From 92aa67306bbc135b922efb2500da7cbfe5801b6e Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Sun, 12 Apr 2026 19:49:03 -0700 Subject: [PATCH 01/85] Initial named pipe server --- Cargo.lock | 943 +++++++++++++++++++++++++++++++-- Cargo.toml | 3 + cuda_check/Cargo.toml | 2 +- xtask/src/main.rs | 24 +- zluda32/Cargo.toml | 33 ++ zluda32/src/ipc.rs | 43 ++ zluda32/src/lib.rs | 354 +++++++++++++ zluda64/Cargo.toml | 16 + zluda64/src/main.rs | 49 ++ zluda_server_common/Cargo.toml | 9 + zluda_server_common/src/lib.rs | 0 11 files changed, 1424 insertions(+), 52 deletions(-) create mode 100644 zluda32/Cargo.toml create mode 100644 zluda32/src/ipc.rs create mode 100644 zluda32/src/lib.rs create mode 100644 zluda64/Cargo.toml create mode 100644 zluda64/src/main.rs create mode 100644 zluda_server_common/Cargo.toml create mode 100644 zluda_server_common/src/lib.rs diff --git a/Cargo.lock b/Cargo.lock index af6f42172..429f8e6cc 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -108,6 +108,12 @@ version = "0.7.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50" +[[package]] +name = "async-task" +version = "4.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de" + [[package]] name = "autocfg" version = "1.4.0" @@ -317,7 +323,7 @@ dependencies = [ "memmap2 0.9.7", "num-traits", "num_cpus", - "rand", + "rand 0.9.2", "rand_distr", "rayon", "safetensors", @@ -376,6 +382,12 @@ version = "1.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" +[[package]] +name = "cfg_aliases" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724" + [[package]] name = "cglue" version = "0.3.5" @@ -414,6 +426,17 @@ dependencies = [ "syn 1.0.109", ] +[[package]] +name = "chacha20" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6f8d983286843e49675a4b7a2d174efe136dc93a18d69130dd18198a6c167601" +dependencies = [ + "cfg-if", + "cpufeatures 0.3.0", + "rand_core 0.10.0", +] + [[package]] name = "clang-sys" version = "1.8.1" @@ -440,6 +463,15 @@ dependencies = [ "cc", ] +[[package]] +name = "cobs" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fa961b519f0b462e3a3b4a34b64d119eeaca1d59af726fe450bbba07a9fc0a1" +dependencies = [ + "thiserror 2.0.12", +] + [[package]] name = "compiler" version = "0.0.0" @@ -453,6 +485,143 @@ dependencies = [ "thiserror 2.0.12", ] +[[package]] +name = "compio" +version = "0.18.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b84ee96a86948d04388f3a0b8c36b9f0a6b40b3528ac0d65737e53632fb37fe" +dependencies = [ + "compio-buf", + "compio-driver", + "compio-fs", + "compio-io", + "compio-log", + "compio-macros", + "compio-runtime", +] + +[[package]] +name = "compio-buf" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a00d719dbd8c602ab0d25d219cbc6b517008858de7a8d6c51b4dc95aefff4dce" +dependencies = [ + "arrayvec", + "bytes", + "libc", +] + +[[package]] +name = "compio-driver" +version = "0.11.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "74d42d98dc890ee4db00c1e68a723391711aab6d67085880d716b72830f7c715" +dependencies = [ + "cfg-if", + "cfg_aliases", + "compio-buf", + "compio-log", + "crossbeam-queue", + "flume", + "futures-util", + "io-uring", + "io_uring_buf_ring", + "libc", + "once_cell", + "paste", + "pin-project-lite", + "polling", + "slab", + "smallvec", + "socket2", + "synchrony", + "thin-cell", + "windows-sys 0.61.2", +] + +[[package]] +name = "compio-fs" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "65ee36e1acf2cec4835efe9a986c012b2462c5ef53580e4ee84ae6d5a3d8e3b3" +dependencies = [ + "cfg-if", + "cfg_aliases", + "compio-buf", + "compio-driver", + "compio-io", + "compio-runtime", + "libc", + "os_pipe", + "pin-project-lite", + "widestring", + "windows-sys 0.61.2", +] + +[[package]] +name = "compio-io" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "637522f28a64fd5f7dcceaa4ddef13fa8d8020025e8c993f7a069e237835580e" +dependencies = [ + "compio-buf", + "futures-util", + "paste", + "synchrony", +] + +[[package]] +name = "compio-log" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc4e560213c1996b618da369b7c9109564b41af9033802ae534465c4ee4e132f" +dependencies = [ + "tracing", +] + +[[package]] +name = "compio-macros" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f05ed201484967dc70de77a8f7a02b29aaa8e6c81cbea2e75492ee0c8d97766b" +dependencies = [ + "proc-macro-crate 3.3.0", + "proc-macro2", + "quote", + "syn 2.0.89", +] + +[[package]] +name = "compio-runtime" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6c1c71f011bdd9c8f30e97d877b606505ee6d241c7782cfaed172f66acbd9cd" +dependencies = [ + "async-task", + "compio-buf", + "compio-driver", + "compio-log", + "core_affinity", + "crossbeam-queue", + "futures-util", + "libc", + "once_cell", + "pin-project-lite", + "scoped-tls", + "slab", + "socket2", + "windows-sys 0.61.2", +] + +[[package]] +name = "concurrent-queue" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4ca0197aee26d1ae37445ee532fefce43251d24cc7c166799f4d46817f1d3973" +dependencies = [ + "crossbeam-utils", +] + [[package]] name = "console" version = "0.16.1" @@ -481,6 +650,17 @@ dependencies = [ "unicode-segmentation", ] +[[package]] +name = "core_affinity" +version = "0.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a034b3a7b624016c6e13f5df875747cc25f884156aad2abd12b6c46797971342" +dependencies = [ + "libc", + "num_cpus", + "winapi", +] + [[package]] name = "cpufeatures" version = "0.2.17" @@ -490,6 +670,15 @@ dependencies = [ "libc", ] +[[package]] +name = "cpufeatures" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b2a41393f66f16b0823bb79094d54ac5fbd34ab292ddafb9a0456ac9f87d201" +dependencies = [ + "libc", +] + [[package]] name = "crc32fast" version = "1.5.0" @@ -499,6 +688,15 @@ dependencies = [ "cfg-if", ] +[[package]] +name = "crossbeam-channel" +version = "0.5.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2" +dependencies = [ + "crossbeam-utils", +] + [[package]] name = "crossbeam-deque" version = "0.8.6" @@ -518,6 +716,15 @@ dependencies = [ "crossbeam-utils", ] +[[package]] +name = "crossbeam-queue" +version = "0.3.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0f58bbc28f91df819d0aa2a2c00cd19754769c2fad90579b3592b1c9ba7a3115" +dependencies = [ + "crossbeam-utils", +] + [[package]] name = "crossbeam-utils" version = "0.8.21" @@ -548,8 +755,8 @@ dependencies = [ "cuda_types", "libloading", "owo-colors", - "rand", - "windows", + "rand 0.10.1", + "windows 0.62.2", "zluda_windows", ] @@ -920,6 +1127,18 @@ dependencies = [ "winreg", ] +[[package]] +name = "embedded-io" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ef1a6892d9eef45c8fa6b9e0086428a2cca8491aca8f787c534a3d6d0bcb3ced" + +[[package]] +name = "embedded-io" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "edd0f118536f44f5ccd48bcb8b111bdc3de888b58c74639dfb034a357d0f206d" + [[package]] name = "encode_unicode" version = "1.0.0" @@ -1031,10 +1250,19 @@ checksum = "719a903cc23e4a89e87962c2a80fdb45cdaad0983a89bd150bb57b4c8571a7d5" dependencies = [ "half", "num-traits", - "rand", + "rand 0.9.2", "rand_distr", ] +[[package]] +name = "flume" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5e139bc46ca777eb5efaf62df0ab8cc5fd400866427e56c68b22e414e53bd3be" +dependencies = [ + "spin", +] + [[package]] name = "fnv" version = "1.0.7" @@ -1070,6 +1298,49 @@ dependencies = [ "uuid", ] +[[package]] +name = "futures-core" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d" + +[[package]] +name = "futures-macro" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e835b70203e41293343137df5c0664546da5745f82ec9b84d40be8336958447b" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.89", +] + +[[package]] +name = "futures-sink" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c39754e157331b013978ec91992bde1ac089843443c49cbc7f46150b0fad0893" + +[[package]] +name = "futures-task" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393" + +[[package]] +name = "futures-util" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6" +dependencies = [ + "futures-core", + "futures-macro", + "futures-sink", + "futures-task", + "pin-project-lite", + "slab", +] + [[package]] name = "gemm" version = "0.19.0" @@ -1189,6 +1460,21 @@ dependencies = [ "seq-macro", ] +[[package]] +name = "generator" +version = "0.8.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52f04ae4152da20c76fe800fa48659201d5cf627c5149ca0b707b69d7eef6cf9" +dependencies = [ + "cc", + "cfg-if", + "libc", + "log", + "rustversion", + "windows-link 0.2.1", + "windows-result 0.4.1", +] + [[package]] name = "generic-array" version = "0.14.7" @@ -1218,10 +1504,24 @@ checksum = "26145e563e54f2cadc477553f1ec5ee650b00862f0a58bcd12cbdc5f0ea2d2f4" dependencies = [ "cfg-if", "libc", - "r-efi", + "r-efi 5.3.0", "wasi 0.14.2+wasi-0.2.4", ] +[[package]] +name = "getrandom" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0de51e6874e94e7bf76d726fc5d13ba782deca734ff60d5bb2fb2607c7406555" +dependencies = [ + "cfg-if", + "libc", + "r-efi 6.0.0", + "rand_core 0.10.0", + "wasip2", + "wasip3", +] + [[package]] name = "gix" version = "0.71.0" @@ -2062,7 +2362,7 @@ dependencies = [ "cfg-if", "crunchy", "num-traits", - "rand", + "rand 0.9.2", "rand_distr", "zerocopy", ] @@ -2255,6 +2555,12 @@ dependencies = [ "zerovec", ] +[[package]] +name = "id-arena" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954" + [[package]] name = "ident_case" version = "1.0.1" @@ -2299,6 +2605,7 @@ checksum = "8c9c992b02b5b4c94ea26e32fe5bccb7aa7d9f390ab5c1221ff895bc7ea8b652" dependencies = [ "equivalent", "hashbrown 0.15.2", + "serde", ] [[package]] @@ -2327,6 +2634,47 @@ dependencies = [ "version_check", ] +[[package]] +name = "io-uring" +version = "0.7.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fdd7bddefd0a8833b88a4b68f90dae22c7450d11b354198baee3874fd811b344" +dependencies = [ + "bitflags 2.9.1", + "cfg-if", + "libc", +] + +[[package]] +name = "io_uring_buf_ring" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1838759bb8c2f24cf05a35429d83145c4aa6af43f8ad38477295e12a7320a80e" +dependencies = [ + "bytes", + "io-uring", + "rustix 1.1.4", +] + +[[package]] +name = "ipc-channel" +version = "0.21.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a441490012d80e9aea75fb27503df8e87e9557dcfc6fe4244dde86bfc12e94e3" +dependencies = [ + "crossbeam-channel", + "libc", + "mio", + "postcard", + "rand 0.9.2", + "rustc-hash 2.1.1", + "serde_core", + "tempfile", + "thiserror 2.0.12", + "uuid", + "windows 0.61.3", +] + [[package]] name = "is-terminal" version = "0.4.17" @@ -2442,11 +2790,17 @@ version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe" +[[package]] +name = "leb128fmt" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2" + [[package]] name = "libc" -version = "0.2.174" +version = "0.2.184" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1171693293099992e19cddea4e8b849964e9846f4acee11b3948bcc337be8776" +checksum = "48f5d2a454e16a5ea0f4ced81bd44e4cfc7bd3a507b61887c99fd3538b28e4af" [[package]] name = "libloading" @@ -2503,9 +2857,9 @@ checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89" [[package]] name = "linux-raw-sys" -version = "0.9.3" +version = "0.12.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fe7db12097d22ec582439daf8618b8fdd1a7bef6270e9af3b1ebcd30893cf413" +checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53" [[package]] name = "litemap" @@ -2593,6 +2947,20 @@ dependencies = [ "logos-codegen", ] +[[package]] +name = "loom" +version = "0.7.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "419e0dc8046cb947daa77eb95ae174acfbddb7673b4151f56d1eed8e93fbfaca" +dependencies = [ + "cfg-if", + "generator", + "pin-utils", + "scoped-tls", + "tracing", + "tracing-subscriber", +] + [[package]] name = "lz4-sys" version = "1.11.1+lz4-1.10.0" @@ -2603,6 +2971,15 @@ dependencies = [ "libc", ] +[[package]] +name = "matchers" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d1525a2a28c7f4fa0fc98bb91ae755d1e2d1505079e05539e35bc876b5d65ae9" +dependencies = [ + "regex-automata", +] + [[package]] name = "maybe-async" version = "0.2.10" @@ -2675,6 +3052,17 @@ dependencies = [ "adler2", ] +[[package]] +name = "mio" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50b7e5b27aa02a74bac8c3f23f448f8d87ff11f92d3aac1a6ed369ee08cc56c1" +dependencies = [ + "libc", + "wasi 0.11.1+wasi-snapshot-preview1", + "windows-sys 0.61.2", +] + [[package]] name = "miopen-sys" version = "0.0.0" @@ -2718,6 +3106,15 @@ dependencies = [ "minimal-lexical", ] +[[package]] +name = "nu-ansi-term" +version = "0.50.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5" +dependencies = [ + "windows-sys 0.61.2", +] + [[package]] name = "num" version = "0.4.3" @@ -2854,6 +3251,16 @@ version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d" +[[package]] +name = "os_pipe" +version = "1.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d8fae84b431384b68627d0f9b3b1245fcf9f46f6c0e3dc902e9dce64edd1967" +dependencies = [ + "libc", + "windows-sys 0.61.2", +] + [[package]] name = "owo-colors" version = "4.2.3" @@ -2916,8 +3323,20 @@ dependencies = [ ] [[package]] -name = "pkg-config" -version = "0.3.32" +name = "pin-project-lite" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd" + +[[package]] +name = "pin-utils" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" + +[[package]] +name = "pkg-config" +version = "0.3.32" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c" @@ -2927,6 +3346,20 @@ version = "0.2.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6" +[[package]] +name = "polling" +version = "3.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d0e4f59085d47d8241c88ead0f274e8a0cb551f3625263c05eb8dd897c34218" +dependencies = [ + "cfg-if", + "concurrent-queue", + "hermit-abi", + "pin-project-lite", + "rustix 1.1.4", + "windows-sys 0.61.2", +] + [[package]] name = "portable-atomic" version = "1.11.1" @@ -2942,6 +3375,18 @@ dependencies = [ "portable-atomic", ] +[[package]] +name = "postcard" +version = "1.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6764c3b5dd454e283a30e6dfe78e9b31096d9e32036b5d1eaac7a6119ccb9a24" +dependencies = [ + "cobs", + "embedded-io 0.4.0", + "embedded-io 0.6.1", + "serde", +] + [[package]] name = "potential_utf" version = "0.1.2" @@ -3201,6 +3646,12 @@ version = "5.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f" +[[package]] +name = "r-efi" +version = "6.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf" + [[package]] name = "rancor" version = "0.1.1" @@ -3217,7 +3668,18 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1" dependencies = [ "rand_chacha", - "rand_core", + "rand_core 0.9.5", +] + +[[package]] +name = "rand" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d2e8e8bcc7961af1fdac401278c6a831614941f6164ee3bf4ce61b7edb162207" +dependencies = [ + "chacha20", + "getrandom 0.4.2", + "rand_core 0.10.0", ] [[package]] @@ -3227,7 +3689,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb" dependencies = [ "ppv-lite86", - "rand_core", + "rand_core 0.9.5", ] [[package]] @@ -3239,6 +3701,12 @@ dependencies = [ "getrandom 0.3.3", ] +[[package]] +name = "rand_core" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c8d0fd677905edcbeedbf2edb6494d676f0e98d54d5cf9bda0b061cb8fb8aba" + [[package]] name = "rand_distr" version = "0.5.1" @@ -3246,7 +3714,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6a8615d50dcf34fa31f7ab52692afec947c4dd0ab803cc87cb3b0b4570ff7463" dependencies = [ "num-traits", - "rand", + "rand 0.9.2", ] [[package]] @@ -3432,15 +3900,15 @@ dependencies = [ [[package]] name = "rustix" -version = "1.0.5" +version = "1.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d97817398dd4bb2e6da002002db259209759911da105da92bec29ccb12cf58bf" +checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190" dependencies = [ "bitflags 2.9.1", "errno", "libc", - "linux-raw-sys 0.9.3", - "windows-sys 0.59.0", + "linux-raw-sys 0.12.1", + "windows-sys 0.61.2", ] [[package]] @@ -3484,6 +3952,12 @@ dependencies = [ "winapi-util", ] +[[package]] +name = "scoped-tls" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294" + [[package]] name = "scopeguard" version = "1.2.0" @@ -3583,7 +4057,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba" dependencies = [ "cfg-if", - "cpufeatures", + "cpufeatures 0.2.17", "digest", ] @@ -3597,6 +4071,15 @@ dependencies = [ "sha1", ] +[[package]] +name = "sharded-slab" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6" +dependencies = [ + "lazy_static", +] + [[package]] name = "shell-words" version = "1.1.0" @@ -3640,12 +4123,37 @@ version = "0.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e" +[[package]] +name = "slab" +version = "0.4.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5" + [[package]] name = "smallvec" version = "1.15.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03" +[[package]] +name = "socket2" +version = "0.6.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3a766e1110788c36f4fa1c2b71b387a7815aa65f88ce0229841826633d93723e" +dependencies = [ + "libc", + "windows-sys 0.61.2", +] + +[[package]] +name = "spin" +version = "0.9.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67" +dependencies = [ + "lock_api", +] + [[package]] name = "stable_deref_trait" version = "1.2.0" @@ -3746,6 +4254,16 @@ dependencies = [ "unicode-ident", ] +[[package]] +name = "synchrony" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c174d82fd56da8214ec095cfe4568e59e5ccb49d060e70c2f98e3ba352b23e45" +dependencies = [ + "futures-util", + "loom", +] + [[package]] name = "synstructure" version = "0.13.2" @@ -3797,10 +4315,16 @@ dependencies = [ "fastrand", "getrandom 0.3.3", "once_cell", - "rustix 1.0.5", + "rustix 1.1.4", "windows-sys 0.59.0", ] +[[package]] +name = "thin-cell" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4164c6c316ba9733b0ab021e7f9852c788a4b991b49c25820f1be48e1d41345b" + [[package]] name = "thiserror" version = "1.0.64" @@ -3841,6 +4365,15 @@ dependencies = [ "syn 2.0.89", ] +[[package]] +name = "thread_local" +version = "1.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f60246a4944f24f6e018aa17cdeffb7818b76356965d03b07d6a9886e8962185" +dependencies = [ + "cfg-if", +] + [[package]] name = "time" version = "0.3.41" @@ -3964,6 +4497,55 @@ version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "fcc842091f2def52017664b53082ecbbeb5c7731092bad69d2c63050401dfd64" +[[package]] +name = "tracing" +version = "0.1.44" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100" +dependencies = [ + "pin-project-lite", + "tracing-core", +] + +[[package]] +name = "tracing-core" +version = "0.1.36" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a" +dependencies = [ + "once_cell", + "valuable", +] + +[[package]] +name = "tracing-log" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3" +dependencies = [ + "log", + "once_cell", + "tracing-core", +] + +[[package]] +name = "tracing-subscriber" +version = "0.3.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cb7f578e5945fb242538965c2d0b04418d38ec25c79d160cd279bf0731c8d319" +dependencies = [ + "matchers", + "nu-ansi-term", + "once_cell", + "regex-automata", + "sharded-slab", + "smallvec", + "thread_local", + "tracing", + "tracing-core", + "tracing-log", +] + [[package]] name = "trie-hard" version = "0.1.0" @@ -4062,10 +4644,17 @@ version = "1.18.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2f87b8aa10b915a06587d0dec516c282ff295b475d94abf425d62b57710070a2" dependencies = [ + "getrandom 0.3.3", "js-sys", "wasm-bindgen", ] +[[package]] +name = "valuable" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65" + [[package]] name = "vcpkg" version = "0.2.15" @@ -4161,6 +4750,24 @@ dependencies = [ "wit-bindgen-rt", ] +[[package]] +name = "wasip2" +version = "1.0.2+wasi-0.2.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9517f9239f02c069db75e65f174b3da828fe5f5b945c4dd26bd25d89c03ebcf5" +dependencies = [ + "wit-bindgen", +] + +[[package]] +name = "wasip3" +version = "0.4.0+wasi-0.3.0-rc-2026-01-06" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5" +dependencies = [ + "wit-bindgen", +] + [[package]] name = "wasm-bindgen" version = "0.2.104" @@ -4220,6 +4827,40 @@ dependencies = [ "unicode-ident", ] +[[package]] +name = "wasm-encoder" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319" +dependencies = [ + "leb128fmt", + "wasmparser", +] + +[[package]] +name = "wasm-metadata" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909" +dependencies = [ + "anyhow", + "indexmap", + "wasm-encoder", + "wasmparser", +] + +[[package]] +name = "wasmparser" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe" +dependencies = [ + "bitflags 2.9.1", + "hashbrown 0.15.2", + "indexmap", + "semver", +] + [[package]] name = "web-time" version = "1.1.0" @@ -4267,16 +4908,38 @@ version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" +[[package]] +name = "windows" +version = "0.61.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9babd3a767a4c1aef6900409f85f5d53ce2544ccdfaa86dad48c91782c6d6893" +dependencies = [ + "windows-collections 0.2.0", + "windows-core 0.61.2", + "windows-future 0.2.1", + "windows-link 0.1.3", + "windows-numerics 0.2.0", +] + [[package]] name = "windows" version = "0.62.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "527fadee13e0c05939a6a05d5bd6eec6cd2e3dbd648b9f8e447c6518133d8580" dependencies = [ - "windows-collections", - "windows-core", - "windows-future", - "windows-numerics", + "windows-collections 0.3.2", + "windows-core 0.62.2", + "windows-future 0.3.2", + "windows-numerics 0.3.1", +] + +[[package]] +name = "windows-collections" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3beeceb5e5cfd9eb1d76b381630e82c4241ccd0d27f1a39ed41b2760b255c5e8" +dependencies = [ + "windows-core 0.61.2", ] [[package]] @@ -4285,7 +4948,20 @@ version = "0.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "23b2d95af1a8a14a3c7367e1ed4fc9c20e0a26e79551b1454d72583c97cc6610" dependencies = [ - "windows-core", + "windows-core 0.62.2", +] + +[[package]] +name = "windows-core" +version = "0.61.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3" +dependencies = [ + "windows-implement", + "windows-interface", + "windows-link 0.1.3", + "windows-result 0.3.4", + "windows-strings 0.4.2", ] [[package]] @@ -4296,9 +4972,20 @@ checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb" dependencies = [ "windows-implement", "windows-interface", - "windows-link", - "windows-result", - "windows-strings", + "windows-link 0.2.1", + "windows-result 0.4.1", + "windows-strings 0.5.1", +] + +[[package]] +name = "windows-future" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc6a41e98427b19fe4b73c550f060b59fa592d7d686537eebf9385621bfbad8e" +dependencies = [ + "windows-core 0.61.2", + "windows-link 0.1.3", + "windows-threading 0.1.0", ] [[package]] @@ -4307,9 +4994,9 @@ version = "0.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e1d6f90251fe18a279739e78025bd6ddc52a7e22f921070ccdc67dde84c605cb" dependencies = [ - "windows-core", - "windows-link", - "windows-threading", + "windows-core 0.62.2", + "windows-link 0.2.1", + "windows-threading 0.2.1", ] [[package]] @@ -4334,20 +5021,45 @@ dependencies = [ "syn 2.0.89", ] +[[package]] +name = "windows-link" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a" + [[package]] name = "windows-link" version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" +[[package]] +name = "windows-numerics" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9150af68066c4c5c07ddc0ce30421554771e528bde427614c61038bc2c92c2b1" +dependencies = [ + "windows-core 0.61.2", + "windows-link 0.1.3", +] + [[package]] name = "windows-numerics" version = "0.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6e2e40844ac143cdb44aead537bbf727de9b044e107a0f1220392177d15b0f26" dependencies = [ - "windows-core", - "windows-link", + "windows-core 0.62.2", + "windows-link 0.2.1", +] + +[[package]] +name = "windows-result" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6" +dependencies = [ + "windows-link 0.1.3", ] [[package]] @@ -4356,7 +5068,16 @@ version = "0.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5" dependencies = [ - "windows-link", + "windows-link 0.2.1", +] + +[[package]] +name = "windows-strings" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57" +dependencies = [ + "windows-link 0.1.3", ] [[package]] @@ -4365,7 +5086,7 @@ version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091" dependencies = [ - "windows-link", + "windows-link 0.2.1", ] [[package]] @@ -4392,7 +5113,7 @@ version = "0.61.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" dependencies = [ - "windows-link", + "windows-link 0.2.1", ] [[package]] @@ -4411,13 +5132,22 @@ dependencies = [ "windows_x86_64_msvc", ] +[[package]] +name = "windows-threading" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b66463ad2e0ea3bbf808b7f1d371311c80e115c0b71d60efc142cafbcfb057a6" +dependencies = [ + "windows-link 0.1.3", +] + [[package]] name = "windows-threading" version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3949bd5b99cafdf1c7ca86b43ca564028dfe27d66958f2470940f73d86d75b37" dependencies = [ - "windows-link", + "windows-link 0.2.1", ] [[package]] @@ -4496,6 +5226,26 @@ dependencies = [ "windows-sys 0.59.0", ] +[[package]] +name = "wit-bindgen" +version = "0.51.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5" +dependencies = [ + "wit-bindgen-rust-macro", +] + +[[package]] +name = "wit-bindgen-core" +version = "0.51.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc" +dependencies = [ + "anyhow", + "heck", + "wit-parser", +] + [[package]] name = "wit-bindgen-rt" version = "0.39.0" @@ -4505,6 +5255,74 @@ dependencies = [ "bitflags 2.9.1", ] +[[package]] +name = "wit-bindgen-rust" +version = "0.51.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21" +dependencies = [ + "anyhow", + "heck", + "indexmap", + "prettyplease", + "syn 2.0.89", + "wasm-metadata", + "wit-bindgen-core", + "wit-component", +] + +[[package]] +name = "wit-bindgen-rust-macro" +version = "0.51.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c0f9bfd77e6a48eccf51359e3ae77140a7f50b1e2ebfe62422d8afdaffab17a" +dependencies = [ + "anyhow", + "prettyplease", + "proc-macro2", + "quote", + "syn 2.0.89", + "wit-bindgen-core", + "wit-bindgen-rust", +] + +[[package]] +name = "wit-component" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2" +dependencies = [ + "anyhow", + "bitflags 2.9.1", + "indexmap", + "log", + "serde", + "serde_derive", + "serde_json", + "wasm-encoder", + "wasm-metadata", + "wasmparser", + "wit-parser", +] + +[[package]] +name = "wit-parser" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736" +dependencies = [ + "anyhow", + "id-arena", + "indexmap", + "log", + "semver", + "serde", + "serde_derive", + "serde_json", + "unicode-xid", + "wasmparser", +] + [[package]] name = "writeable" version = "0.6.1" @@ -4518,7 +5336,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0d65cbf2f12c15564212d48f4e3dfb87923d25d611f2aed18f4cb23f0413d89e" dependencies = [ "libc", - "rustix 1.0.5", + "rustix 1.1.4", ] [[package]] @@ -4698,12 +5516,35 @@ dependencies = [ "serde_json", "tempfile", "vergen-gix", - "windows", + "windows 0.62.2", "zluda_cache", "zluda_common", "zluda_windows", ] +[[package]] +name = "zluda32" +version = "0.0.0" +dependencies = [ + "compio", + "cuda_macros", + "cuda_types", + "ipc-channel", + "paste", + "rand 0.10.1", + "widestring", + "windows 0.62.2", +] + +[[package]] +name = "zluda64" +version = "0.0.0" +dependencies = [ + "compio", + "slab", + "windows-sys 0.61.2", +] + [[package]] name = "zluda_bindgen" version = "0.1.0" @@ -4812,9 +5653,9 @@ dependencies = [ "half", "libloading", "paste", - "rand", + "rand 0.9.2", "rand_chacha", - "windows", + "windows 0.62.2", "zluda_common", "zluda_dnn", "zluda_windows", @@ -4838,8 +5679,8 @@ dependencies = [ "rustc-hash 2.1.1", "tempfile", "widestring", - "windows", - "windows-core", + "windows 0.62.2", + "windows-core 0.62.2", "zluda_ml", "zluda_redirect", "zluda_trace", @@ -4883,12 +5724,20 @@ dependencies = [ "rustc-hash 2.1.1", "unwrap_or", "widestring", - "windows", + "windows 0.62.2", "windows-sys 0.61.2", "winnow 0.6.20", "zluda_windows", ] +[[package]] +name = "zluda_server_common" +version = "0.0.0" +dependencies = [ + "cuda_types", + "rkyv", +] + [[package]] name = "zluda_sparse" version = "0.0.0" @@ -4924,7 +5773,7 @@ dependencies = [ "regex", "rustc-hash 2.1.1", "unwrap_or", - "windows", + "windows 0.62.2", "zluda_common", "zluda_trace_common", "zstd-safe", @@ -5055,7 +5904,7 @@ dependencies = [ "trie-hard", "uuid", "widestring", - "windows", + "windows 0.62.2", ] [[package]] diff --git a/Cargo.toml b/Cargo.toml index d199126eb..570f652eb 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -36,6 +36,7 @@ members = [ "zluda_ml", "zluda_precompile", "zluda_redirect", + "zluda_server_common", "zluda_sparse", "zluda_trace_blas", "zluda_trace_blaslt", @@ -47,6 +48,8 @@ members = [ "zluda_trace_sparse", "zluda_trace", "zluda", + "zluda32", + "zluda64", ] default-members = ["zluda", "zluda_ml", "zluda_inject", "zluda_redirect", "compiler"] diff --git a/cuda_check/Cargo.toml b/cuda_check/Cargo.toml index c0b9c3d4d..baefa150c 100644 --- a/cuda_check/Cargo.toml +++ b/cuda_check/Cargo.toml @@ -13,7 +13,7 @@ cuda_types = { path = "../cuda_types" } zluda_windows = { path = "../zluda_windows" } bpaf = { version = "0.9.19", features = ["derive", "bright-color"] } owo-colors = { version = "4", features = ["supports-colors"] } -rand = "0.9.2" +rand = "0.10.1" libloading = "0.8" [target.'cfg(windows)'.dependencies] diff --git a/xtask/src/main.rs b/xtask/src/main.rs index 270464f7e..1180aa007 100644 --- a/xtask/src/main.rs +++ b/xtask/src/main.rs @@ -37,6 +37,8 @@ struct Cargo { release: Option, #[bpaf(long)] profile: Option, + #[bpaf(long)] + target: Option, #[bpaf(any("", Some), many)] _unused: Vec, } @@ -239,6 +241,8 @@ struct ZludaMetadata { linux_only: bool, #[serde(default)] windows_only: bool, + #[serde(default, rename = "32bit")] + is_32bit: bool, #[serde(default)] debug_only: bool, #[cfg_attr(not(unix), allow(unused))] @@ -272,7 +276,7 @@ fn main() { } fn compile(b: Build) -> (PathBuf, String, Vec) { - let profile = sniff_out_profile_name(&b.cargo_arguments); + let (profile, is_32bit) = sniff_out_profile_name_and_32bit(&b.cargo_arguments); let meta = MetadataCommand::new().no_deps().exec().unwrap(); let target_directory = meta.target_directory.into_std_path_buf(); let projects = meta @@ -286,6 +290,9 @@ fn compile(b: Build) -> (PathBuf, String, Vec) { if project.meta.windows_only && cfg!(not(windows)) { return false; } + if project.meta.is_32bit != is_32bit { + return false; + } if project.meta.debug_only && profile != "debug" { return false; } @@ -306,9 +313,17 @@ fn compile(b: Build) -> (PathBuf, String, Vec) { (target_directory, profile, projects) } -fn sniff_out_profile_name(b: &[OsString]) -> String { +fn sniff_out_profile_name_and_32bit(b: &[OsString]) -> (String, bool) { let parsed_cargo_arguments = cargo().to_options().run_inner(b); - match parsed_cargo_arguments { + let is_32bit = match parsed_cargo_arguments.as_ref() { + Ok(Cargo { + target: Some(target), + .. + }) => target.starts_with("i686"), + Ok(Cargo { target: None, .. }) => cfg!(target_pointer_width = "32"), + _ => false, + }; + let profile = match parsed_cargo_arguments { Ok(Cargo { release: Some(true), .. @@ -318,7 +333,8 @@ fn sniff_out_profile_name(b: &[OsString]) -> String { .. }) => profile, _ => "debug".to_string(), - } + }; + (profile, is_32bit) } fn zip(zip: Build) { diff --git a/zluda32/Cargo.toml b/zluda32/Cargo.toml new file mode 100644 index 000000000..fc956bea1 --- /dev/null +++ b/zluda32/Cargo.toml @@ -0,0 +1,33 @@ +[package] +name = "zluda32" +version = "0.0.0" +authors = ["Andrzej Janik "] +edition = "2021" + +[lib] +name = "nvcuda" +crate-type = ["cdylib"] + +[dependencies] +cuda_types = { path = "../cuda_types" } +cuda_macros = { path = "../cuda_macros" } +paste = "1.0" +ipc-channel = "^0.21.0" +compio = { version = "0.18.0", features = ["fs"] } +windows = { version = "0.62.2", features = [ + "Win32_Foundation", + "Win32_Storage_FileSystem", + "Win32_System_IO", + "Win32_System_Pipes", + "Win32_Security", +] } +# windows-sys = { version = "0.61.2", features = [ +# "Win32_Foundation", +# "Win32_System_Pipes", +# "Win32_Storage_FileSystem", +# ] } +rand = "0.10.1" +widestring = "1.2.1" + +[package.metadata.zluda] +32bit = true diff --git a/zluda32/src/ipc.rs b/zluda32/src/ipc.rs new file mode 100644 index 000000000..0879729e6 --- /dev/null +++ b/zluda32/src/ipc.rs @@ -0,0 +1,43 @@ +use rand::distr::{Alphanumeric, SampleString}; +use std::process::{Command, Stdio}; +use std::ptr; +use widestring::{u16str, U16CString}; +use windows::core::{Error, Owned, PCSTR}; +use windows::Win32::Foundation::*; +use windows::Win32::System::Pipes::*; + +unsafe fn start() -> Result { + let name = Alphanumeric.sample_string(&mut rand::rng(), 32); + let pipe_path = format!(r"\\.\pipe\zluda-{name}\0"); + let pipe = Owned::new(CreateNamedPipeA( + PCSTR(pipe_path.as_ptr()), + windows::Win32::Storage::FileSystem::PIPE_ACCESS_DUPLEX, + PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT | PIPE_REJECT_REMOTE_CLIENTS, + 1, + 128 * 1024, + 16, + 0, + None, + )?); + let child = Command::new("zluda64.exe") + .arg(&pipe_path[..pipe_path.len() - 1]) + .stdin(Stdio::null()) + .stdout(Stdio::null()) + .stderr(Stdio::null()) + .spawn()?; + ConnectNamedPipe(*pipe, None)?; + let in_buffer = [0xffu8; 128 * 1024]; + let mut out_buffer = [0xffu8; 4]; + let mut read = 0; + TransactNamedPipe( + *pipe, + Some(in_buffer.as_ptr().cast()), + in_buffer.len() as u32, + Some(out_buffer.as_mut_ptr().cast()), + out_buffer.len() as u32, + &mut read, + None, + )?; + + todo!() +} diff --git a/zluda32/src/lib.rs b/zluda32/src/lib.rs new file mode 100644 index 000000000..19fdc98b4 --- /dev/null +++ b/zluda32/src/lib.rs @@ -0,0 +1,354 @@ +use std::sync::{Mutex, OnceLock}; +use compio::fs::named_pipe::NamedPipeServer; +use cuda_macros::cuda_function_declarations; +use cuda_types::cuda::*; +use paste::paste; + +mod ipc; + +macro_rules! unimplemented { + ($($abi:literal fn $fn_name:ident( $($arg_id:ident : $arg_type:ty),* ) -> $ret_type:ty;)*) => { + $( + #[cfg_attr(not(test), no_mangle)] + #[allow(improper_ctypes)] + #[allow(improper_ctypes_definitions)] + #[allow(unused_variables)] + pub unsafe extern $abi fn $fn_name ( $( $arg_id : $arg_type),* ) -> $ret_type { + Err(cuda_types::cuda::CUerror::NOT_SUPPORTED) + } + )* + }; +} + +macro_rules! implemented { + ($($abi:literal fn $fn_name:ident( $($arg_id:ident : $arg_type:ty),* ) -> $ret_type:ty;)*) => { + $( + #[cfg_attr(not(test), no_mangle)] + #[allow(improper_ctypes)] + #[allow(improper_ctypes_definitions)] + pub unsafe extern $abi fn $fn_name ( $( $arg_id : $arg_type),* ) -> $ret_type { + use crate::*; + paste! { [< $fn_name:snake:lower >]($($arg_id),*)? }; + Ok(()) + } + )* + }; +} + +cuda_function_declarations! { + unimplemented, + implemented <= [ + cuCtxCreate_v2, + cuCtxDetach, + cuCtxGetApiVersion, + cuCtxGetCurrent, + cuCtxGetDevice, + cuCtxSynchronize, + cuDeviceComputeCapability, + cuDeviceGet, + cuDeviceGetAttribute, + cuDeviceGetCount, + cuDeviceGetName, + cuDeviceGetProperties, + cuDeviceTotalMem_v2, + cuDriverGetVersion, + cuEventCreate, + cuEventDestroy_v2, + cuGetExportTable, + cuInit, + cuLaunchKernel, + cuMemAlloc_v2, + cuMemFreeHost, + cuMemFree_v2, + cuMemGetAddressRange_v2, + cuMemHostAlloc, + cuMemcpyDtoDAsync_v2, + cuMemcpyDtoHAsync_v2, + cuMemcpyHtoDAsync_v2, + cuMemsetD8_v2, + cuModuleGetFunction, + cuModuleGetGlobal_v2, + cuModuleGetTexRef, + cuStreamCreate, + cuStreamDestroy_v2, + cuTexRefSetAddressMode, + cuTexRefSetAddress_v2, + cuTexRefSetFilterMode, + cuTexRefSetFlags, + cuTexRefSetFormat, + cuTexRefSetMaxAnisotropy, + cuTexRefSetMipmapFilterMode, + cuTexRefSetMipmapLevelBias, + cuTexRefSetMipmapLevelClamp, + ] +} + +pub fn cu_init(flags: u32) -> Result<(), CUerror> { + use compio::fs::named_pipe::*; + + todo!() +} + +pub fn cu_ctx_create_v2( + pctx: *mut CUcontext, + flags: ::core::ffi::c_uint, + dev: CUdevice, +) -> Result<(), CUerror> { + todo!() +} + +pub fn cu_ctx_detach(ctx: CUcontext) -> Result<(), CUerror> { + todo!() +} + +pub fn cu_ctx_get_api_version( + ctx: CUcontext, + version: *mut ::core::ffi::c_uint, +) -> Result<(), CUerror> { + todo!() +} + +pub fn cu_ctx_get_current(pctx: *mut CUcontext) -> Result<(), CUerror> { + todo!() +} + +pub fn cu_ctx_get_device(device: *mut CUdevice) -> Result<(), CUerror> { + todo!() +} + +pub fn cu_ctx_synchronize() -> Result<(), CUerror> { + todo!() +} + +pub fn cu_device_compute_capability( + major: *mut ::core::ffi::c_int, + minor: *mut ::core::ffi::c_int, + dev: CUdevice, +) -> Result<(), CUerror> { + todo!() +} + +pub fn cu_device_get(device: *mut CUdevice, ordinal: ::core::ffi::c_int) -> Result<(), CUerror> { + todo!() +} + +pub fn cu_device_get_attribute( + pi: *mut ::core::ffi::c_int, + attrib: CUdevice_attribute, + dev: CUdevice, +) -> Result<(), CUerror> { + todo!() +} + +pub fn cu_device_get_count(count: *mut ::core::ffi::c_int) -> Result<(), CUerror> { + todo!() +} + +pub fn cu_device_get_name( + name: *mut ::core::ffi::c_char, + len: ::core::ffi::c_int, + dev: CUdevice, +) -> Result<(), CUerror> { + todo!() +} + +pub fn cu_device_get_properties(prop: *mut CUdevprop, dev: CUdevice) -> Result<(), CUerror> { + todo!() +} + +pub fn cu_device_total_mem_v2(bytes: *mut usize, dev: CUdevice) -> Result<(), CUerror> { + todo!() +} + +pub fn cu_driver_get_version(driverVersion: *mut ::core::ffi::c_int) -> Result<(), CUerror> { + todo!() +} + +pub fn cu_event_create(phEvent: *mut CUevent, Flags: ::core::ffi::c_uint) -> Result<(), CUerror> { + todo!() +} + +pub fn cu_event_destroy_v2(hEvent: CUevent) -> Result<(), CUerror> { + todo!() +} + +pub fn cu_get_export_table( + ppExportTable: *mut *const ::core::ffi::c_void, + pExportTableId: *const CUuuid, +) -> Result<(), CUerror> { + todo!() +} + +pub fn cu_launch_kernel( + f: CUfunction, + gridDimX: ::core::ffi::c_uint, + gridDimY: ::core::ffi::c_uint, + gridDimZ: ::core::ffi::c_uint, + blockDimX: ::core::ffi::c_uint, + blockDimY: ::core::ffi::c_uint, + blockDimZ: ::core::ffi::c_uint, + sharedMemBytes: ::core::ffi::c_uint, + hStream: CUstream, + kernelParams: *mut *mut ::core::ffi::c_void, + extra: *mut *mut ::core::ffi::c_void, +) -> Result<(), CUerror> { + todo!() +} + +pub fn cu_mem_alloc_v2(dptr: *mut CUdeviceptr, bytesize: usize) -> Result<(), CUerror> { + todo!() +} + +pub fn cu_mem_free_host(p: *mut ::core::ffi::c_void) -> Result<(), CUerror> { + todo!() +} + +pub fn cu_mem_free_v2(dptr: CUdeviceptr) -> Result<(), CUerror> { + todo!() +} + +pub fn cu_mem_get_address_range_v2( + pbase: *mut CUdeviceptr, + psize: *mut usize, + dptr: CUdeviceptr, +) -> Result<(), CUerror> { + todo!() +} + +pub fn cu_mem_host_alloc( + pp: *mut *mut ::core::ffi::c_void, + bytesize: usize, + Flags: ::core::ffi::c_uint, +) -> Result<(), CUerror> { + todo!() +} + +pub fn cu_memcpy_dto_d_async_v2( + dstDevice: CUdeviceptr, + srcDevice: CUdeviceptr, + ByteCount: usize, + hStream: CUstream, +) -> Result<(), CUerror> { + todo!() +} + +pub fn cu_memcpy_dto_h_async_v2( + dstHost: *mut ::core::ffi::c_void, + srcDevice: CUdeviceptr, + ByteCount: usize, + hStream: CUstream, +) -> Result<(), CUerror> { + todo!() +} + +pub fn cu_memcpy_hto_d_async_v2( + dstDevice: CUdeviceptr, + srcHost: *const ::core::ffi::c_void, + ByteCount: usize, + hStream: CUstream, +) -> Result<(), CUerror> { + todo!() +} + +pub fn cu_memset_d8_v2( + dstDevice: CUdeviceptr, + uc: ::core::ffi::c_uchar, + N: usize, +) -> Result<(), CUerror> { + todo!() +} + +pub fn cu_module_get_function( + hfunc: *mut CUfunction, + hmod: CUmodule, + name: *const ::core::ffi::c_char, +) -> Result<(), CUerror> { + todo!() +} + +pub fn cu_module_get_global_v2( + dptr: *mut CUdeviceptr, + bytes: *mut usize, + hmod: CUmodule, + name: *const ::core::ffi::c_char, +) -> Result<(), CUerror> { + todo!() +} + +pub fn cu_module_get_tex_ref( + pTexRef: *mut CUtexref, + hmod: CUmodule, + name: *const ::core::ffi::c_char, +) -> Result<(), CUerror> { + todo!() +} + +pub fn cu_stream_create( + phStream: *mut CUstream, + Flags: ::core::ffi::c_uint, +) -> Result<(), CUerror> { + todo!() +} + +pub fn cu_stream_destroy_v2(hStream: CUstream) -> Result<(), CUerror> { + todo!() +} + +pub fn cu_tex_ref_set_address_mode( + hTexRef: CUtexref, + dim: ::core::ffi::c_int, + am: CUaddress_mode, +) -> Result<(), CUerror> { + todo!() +} + +pub fn cu_tex_ref_set_address_v2( + ByteOffset: *mut usize, + hTexRef: CUtexref, + dptr: CUdeviceptr, + bytes: usize, +) -> Result<(), CUerror> { + todo!() +} + +pub fn cu_tex_ref_set_filter_mode(hTexRef: CUtexref, fm: CUfilter_mode) -> Result<(), CUerror> { + todo!() +} + +pub fn cu_tex_ref_set_flags(hTexRef: CUtexref, Flags: ::core::ffi::c_uint) -> Result<(), CUerror> { + todo!() +} + +pub fn cu_tex_ref_set_format( + hTexRef: CUtexref, + fmt: CUarray_format, + NumPackedComponents: ::core::ffi::c_int, +) -> Result<(), CUerror> { + todo!() +} + +pub fn cu_tex_ref_set_max_anisotropy( + hTexRef: CUtexref, + maxAniso: ::core::ffi::c_uint, +) -> Result<(), CUerror> { + todo!() +} + +pub fn cu_tex_ref_set_mipmap_filter_mode( + hTexRef: CUtexref, + fm: CUfilter_mode, +) -> Result<(), CUerror> { + todo!() +} + +pub fn cu_tex_ref_set_mipmap_level_bias(hTexRef: CUtexref, bias: f32) -> Result<(), CUerror> { + todo!() +} + +pub fn cu_tex_ref_set_mipmap_level_clamp( + hTexRef: CUtexref, + minMipmapLevelClamp: f32, + maxMipmapLevelClamp: f32, +) -> Result<(), CUerror> { + todo!() +} diff --git a/zluda64/Cargo.toml b/zluda64/Cargo.toml new file mode 100644 index 000000000..85e31a029 --- /dev/null +++ b/zluda64/Cargo.toml @@ -0,0 +1,16 @@ +[package] +name = "zluda64" +version = "0.0.0" +authors = ["Andrzej Janik "] +edition = "2021" + +[[bin]] +name = "zluda64" +path = "src/main.rs" + +[dependencies] +windows-sys = { version = "0.61.2", features = ["Win32_Foundation"] } +compio = { version = "0.18.0", features = ["macros", "fs"] } +slab = "0.4.12" + +[package.metadata.zluda] diff --git a/zluda64/src/main.rs b/zluda64/src/main.rs new file mode 100644 index 000000000..accb99f9e --- /dev/null +++ b/zluda64/src/main.rs @@ -0,0 +1,49 @@ +use compio::{ + fs::named_pipe::ClientOptions, + io::{AsyncRead, AsyncReadExt, AsyncWriteExt}, + BufResult, +}; +use slab::Slab; +use windows_sys::Win32::Foundation::ERROR_MORE_DATA; + +struct State { + handles: Slab, +} + +#[compio::main] +async fn main() -> std::io::Result<()> { + let pipe_name = std::env::args_os().nth(1).ok_or(std::io::Error::new( + std::io::ErrorKind::InvalidInput, + "Pipe name not provided", + ))?; + let mut client = ClientOptions::new() + .pipe_mode(compio::fs::named_pipe::PipeMode::Message) + .read(true) + .write(true) + .open(pipe_name) + .await?; + let mut buffer = vec![0u8; 128 * 1024]; + let mut append = false; + loop { + let read_result = if append { + append = false; + client.append(buffer).await + } else { + client.read(buffer).await + }; + match read_result { + BufResult(Ok(0), _) => break, // EOF + BufResult(Ok(n), b) => { + println!("Read {} bytes", n); + client.write_u32_le(0).await?; + buffer = b; + } + BufResult(Err(e), b) if e.raw_os_error() == Some(ERROR_MORE_DATA as i32) => { + append = true; + buffer = b; + } + BufResult(Err(e), _) => return Err(e), + } + } + Ok(()) +} diff --git a/zluda_server_common/Cargo.toml b/zluda_server_common/Cargo.toml new file mode 100644 index 000000000..0eb46d3d0 --- /dev/null +++ b/zluda_server_common/Cargo.toml @@ -0,0 +1,9 @@ +[package] +name = "zluda_server_common" +version = "0.0.0" +authors = ["Andrzej Janik "] +edition = "2021" + +[dependencies] +cuda_types = { path = "../cuda_types" } +rkyv = "0.8.15" diff --git a/zluda_server_common/src/lib.rs b/zluda_server_common/src/lib.rs new file mode 100644 index 000000000..e69de29bb From f38ef457986b70039d39a9a803b60f7f33ad550c Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Sun, 12 Apr 2026 22:16:31 -0700 Subject: [PATCH 02/85] Fix 32bit build issues --- Cargo.lock | 1 - xtask/src/main.rs | 53 ++++++++++++++++++++++++++--------- zluda32/Cargo.toml | 2 ++ zluda32/src/ipc.rs | 10 ++++++- zluda64/Cargo.toml | 3 +- zluda_common/src/constants.rs | 1 + zluda_common/src/lib.rs | 1 + zluda_inject/Cargo.toml | 1 + zluda_redirect/Cargo.toml | 1 + zluda_trace/Cargo.toml | 2 +- zluda_windows/src/lib.rs | 4 +++ 11 files changed, 61 insertions(+), 18 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 429f8e6cc..ea282936c 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -5768,7 +5768,6 @@ dependencies = [ "libloading", "parking_lot", "paste", - "ptx", "ptx_parser", "regex", "rustc-hash 2.1.1", diff --git a/xtask/src/main.rs b/xtask/src/main.rs index 1180aa007..2fd2aa07c 100644 --- a/xtask/src/main.rs +++ b/xtask/src/main.rs @@ -241,6 +241,8 @@ struct ZludaMetadata { linux_only: bool, #[serde(default)] windows_only: bool, + #[serde(default = "always_true", rename = "64bit")] + is_64bit: bool, #[serde(default, rename = "32bit")] is_32bit: bool, #[serde(default)] @@ -256,6 +258,10 @@ struct ZludaMetadata { windows_extra_files: HashMap, } +fn always_true() -> bool { + true +} + fn main() { let options = match options().run_inner(Args::current_args()) { Ok(b) => b, @@ -276,24 +282,33 @@ fn main() { } fn compile(b: Build) -> (PathBuf, String, Vec) { - let (profile, is_32bit) = sniff_out_profile_name_and_32bit(&b.cargo_arguments); + let cargo_flags = sniff_out_cargo_flags(&b.cargo_arguments); let meta = MetadataCommand::new().no_deps().exec().unwrap(); - let target_directory = meta.target_directory.into_std_path_buf(); + let mut target_directory = meta.target_directory.into_std_path_buf(); + if let Some(target) = &cargo_flags.target { + target_directory.push(target); + } let projects = meta .packages .into_iter() .filter_map(Project::try_new) .filter(|project| { + if cargo_flags.is_32bit { + if !project.meta.is_32bit { + return false; + } + } else { + if !project.meta.is_64bit { + return false; + } + } if project.meta.linux_only && cfg!(windows) { return false; } if project.meta.windows_only && cfg!(not(windows)) { return false; } - if project.meta.is_32bit != is_32bit { - return false; - } - if project.meta.debug_only && profile != "debug" { + if project.meta.debug_only && cargo_flags.profile != "debug" { return false; } true @@ -309,19 +324,19 @@ fn compile(b: Build) -> (PathBuf, String, Vec) { } command.args(b.cargo_arguments); assert!(command.status().unwrap().success()); - os::make_symlinks(&target_directory, &*projects, &*profile); - (target_directory, profile, projects) + os::make_symlinks(&target_directory, &*projects, &*cargo_flags.profile); + (target_directory, cargo_flags.profile, projects) } -fn sniff_out_profile_name_and_32bit(b: &[OsString]) -> (String, bool) { +fn sniff_out_cargo_flags(b: &[OsString]) -> CargoFlags { let parsed_cargo_arguments = cargo().to_options().run_inner(b); - let is_32bit = match parsed_cargo_arguments.as_ref() { + let (target, is_32bit) = match parsed_cargo_arguments.as_ref() { Ok(Cargo { target: Some(target), .. - }) => target.starts_with("i686"), - Ok(Cargo { target: None, .. }) => cfg!(target_pointer_width = "32"), - _ => false, + }) => (Some(target.clone()), target.starts_with("i686")), + Ok(Cargo { target: None, .. }) => (None, cfg!(target_pointer_width = "32")), + _ => (None, false), }; let profile = match parsed_cargo_arguments { Ok(Cargo { @@ -334,7 +349,17 @@ fn sniff_out_profile_name_and_32bit(b: &[OsString]) -> (String, bool) { }) => profile, _ => "debug".to_string(), }; - (profile, is_32bit) + CargoFlags { + profile, + target, + is_32bit, + } +} + +struct CargoFlags { + profile: String, + target: Option, + is_32bit: bool, } fn zip(zip: Build) { diff --git a/zluda32/Cargo.toml b/zluda32/Cargo.toml index fc956bea1..0e855fe53 100644 --- a/zluda32/Cargo.toml +++ b/zluda32/Cargo.toml @@ -30,4 +30,6 @@ rand = "0.10.1" widestring = "1.2.1" [package.metadata.zluda] +windows_only = true +64bit = false 32bit = true diff --git a/zluda32/src/ipc.rs b/zluda32/src/ipc.rs index 0879729e6..972ebadff 100644 --- a/zluda32/src/ipc.rs +++ b/zluda32/src/ipc.rs @@ -6,6 +6,14 @@ use windows::core::{Error, Owned, PCSTR}; use windows::Win32::Foundation::*; use windows::Win32::System::Pipes::*; +fn server_path() -> &'static str { + if cfg!(debug_assertions) { + r"C:\dev\ZLUDA\target\debug\zluda64_server.exe" + } else { + "zluda64_server.exe" + } +} + unsafe fn start() -> Result { let name = Alphanumeric.sample_string(&mut rand::rng(), 32); let pipe_path = format!(r"\\.\pipe\zluda-{name}\0"); @@ -19,7 +27,7 @@ unsafe fn start() -> Result { 0, None, )?); - let child = Command::new("zluda64.exe") + let child = Command::new(server_path()) .arg(&pipe_path[..pipe_path.len() - 1]) .stdin(Stdio::null()) .stdout(Stdio::null()) diff --git a/zluda64/Cargo.toml b/zluda64/Cargo.toml index 85e31a029..f8ea2e786 100644 --- a/zluda64/Cargo.toml +++ b/zluda64/Cargo.toml @@ -5,7 +5,7 @@ authors = ["Andrzej Janik "] edition = "2021" [[bin]] -name = "zluda64" +name = "zluda64_server" path = "src/main.rs" [dependencies] @@ -14,3 +14,4 @@ compio = { version = "0.18.0", features = ["macros", "fs"] } slab = "0.4.12" [package.metadata.zluda] +windows_only = true diff --git a/zluda_common/src/constants.rs b/zluda_common/src/constants.rs index 8d316211b..fb468e9bf 100644 --- a/zluda_common/src/constants.rs +++ b/zluda_common/src/constants.rs @@ -2,6 +2,7 @@ pub const PROJECT_SUFFIX: &[u8] = b" [ZLUDA]\0"; const COMPUTE_CAPABILITY_MAJOR: i32 = 8; const COMPUTE_CAPABILITY_MINOR: i32 = 8; +#[cfg(target_pointer_width = "64")] pub const BLAS_HANDLE_COOKIE: usize = 0x57c3fdb0fd72b08e; pub fn compute_capability() -> (i32, i32) { diff --git a/zluda_common/src/lib.rs b/zluda_common/src/lib.rs index 4e3ae784f..4d76b3c93 100644 --- a/zluda_common/src/lib.rs +++ b/zluda_common/src/lib.rs @@ -135,6 +135,7 @@ macro_rules! from_cuda_nop { macro_rules! from_cuda_transmute { ($($from:ty => $to:ty),*) => { $( + #[cfg(target_pointer_width = "64")] impl<'a, E: CudaErrorType> FromCuda<'a, $from, E> for $to { fn from_cuda(x: &'a $from) -> Result { Ok(unsafe { std::mem::transmute(*x) }) diff --git a/zluda_inject/Cargo.toml b/zluda_inject/Cargo.toml index a334ded57..ca4ff1312 100644 --- a/zluda_inject/Cargo.toml +++ b/zluda_inject/Cargo.toml @@ -34,3 +34,4 @@ zluda_ml = { path = "../zluda_ml" } [package.metadata.zluda] windows_only = true +32bit = true diff --git a/zluda_redirect/Cargo.toml b/zluda_redirect/Cargo.toml index e216fd7b2..9133e6567 100644 --- a/zluda_redirect/Cargo.toml +++ b/zluda_redirect/Cargo.toml @@ -36,3 +36,4 @@ rustc-hash = "2.0.0" [package.metadata.zluda] windows_only = true +32bit = true diff --git a/zluda_trace/Cargo.toml b/zluda_trace/Cargo.toml index d36cb1cb1..78ec4fd4e 100644 --- a/zluda_trace/Cargo.toml +++ b/zluda_trace/Cargo.toml @@ -9,7 +9,6 @@ name = "zluda_trace" crate-type = ["cdylib"] [dependencies] -ptx = { path = "../ptx" } ptx_parser = { path = "../ptx_parser" } zluda_trace_common = { path = "../zluda_trace_common" } zluda_common = { path = "../zluda_common" } @@ -52,3 +51,4 @@ linux_symlinks = [ "trace_nvidia/libcuda.so.1", ] windows_paths = ["trace/nvcuda.dll"] +32bit = true diff --git a/zluda_windows/src/lib.rs b/zluda_windows/src/lib.rs index c9d482e70..f48ffa2a2 100644 --- a/zluda_windows/src/lib.rs +++ b/zluda_windows/src/lib.rs @@ -30,6 +30,10 @@ use windows::{ }, }; +#[cfg(target_pointer_width = "32")] +pub static LIBRARIES: [LibraryInfo; 1] = [NVCUDA]; + +#[cfg(target_pointer_width = "64")] pub static LIBRARIES: [LibraryInfo; 16] = [ NVCUDA, NVML, DNN8, DNN9, BLAS13, BLAS12, BLAS11, BLAS_LT13, BLAS_LT12, BLAS_LT11, SPARSE12, SPARSE11, SPARSE10, FFT12, FFT11, FFT10, From 43cbb0d0ec12fb989255279add6208ee38027983 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Sun, 12 Apr 2026 23:46:22 -0700 Subject: [PATCH 03/85] Set up simple cu_init --- zluda32/src/ipc.rs | 100 ++++++++++++++++++++++++++++++--------------- zluda32/src/lib.rs | 5 +-- 2 files changed, 68 insertions(+), 37 deletions(-) diff --git a/zluda32/src/ipc.rs b/zluda32/src/ipc.rs index 972ebadff..9d8b0a9fb 100644 --- a/zluda32/src/ipc.rs +++ b/zluda32/src/ipc.rs @@ -1,6 +1,9 @@ +use cuda_types::cuda::CUerror; use rand::distr::{Alphanumeric, SampleString}; -use std::process::{Command, Stdio}; +use std::num::NonZeroU32; +use std::process::{Child, Command, Stdio}; use std::ptr; +use std::sync::OnceLock; use widestring::{u16str, U16CString}; use windows::core::{Error, Owned, PCSTR}; use windows::Win32::Foundation::*; @@ -14,38 +17,67 @@ fn server_path() -> &'static str { } } -unsafe fn start() -> Result { - let name = Alphanumeric.sample_string(&mut rand::rng(), 32); - let pipe_path = format!(r"\\.\pipe\zluda-{name}\0"); - let pipe = Owned::new(CreateNamedPipeA( - PCSTR(pipe_path.as_ptr()), - windows::Win32::Storage::FileSystem::PIPE_ACCESS_DUPLEX, - PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT | PIPE_REJECT_REMOTE_CLIENTS, - 1, - 128 * 1024, - 16, - 0, - None, - )?); - let child = Command::new(server_path()) - .arg(&pipe_path[..pipe_path.len() - 1]) - .stdin(Stdio::null()) - .stdout(Stdio::null()) - .stderr(Stdio::null()) - .spawn()?; - ConnectNamedPipe(*pipe, None)?; - let in_buffer = [0xffu8; 128 * 1024]; - let mut out_buffer = [0xffu8; 4]; - let mut read = 0; - TransactNamedPipe( - *pipe, - Some(in_buffer.as_ptr().cast()), - in_buffer.len() as u32, - Some(out_buffer.as_mut_ptr().cast()), - out_buffer.len() as u32, - &mut read, - None, - )?; +pub(crate) struct Server { + pipe: Owned, + child: Child, +} + +unsafe impl Sync for Server {} +unsafe impl Send for Server {} + +impl Server { + unsafe fn start() -> Result { + let name = Alphanumeric.sample_string(&mut rand::rng(), 32); + let pipe_path = format!("\\\\.\\pipe\\zluda-{name}\0"); + let pipe = Owned::new(CreateNamedPipeA( + PCSTR(pipe_path.as_ptr()), + windows::Win32::Storage::FileSystem::PIPE_ACCESS_DUPLEX, + PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT | PIPE_REJECT_REMOTE_CLIENTS, + 1, + 128 * 1024, + 1024, + 0, + None, + )?); + let child = Command::new(server_path()) + .arg(&pipe_path[..pipe_path.len() - 1]) + .stdin(Stdio::null()) + .stdout(Stdio::null()) + .stderr(Stdio::null()) + .spawn()?; + match ConnectNamedPipe(*pipe, None) { + Ok(_) => Ok(Server { pipe, child }), + Err(e) if e.code() == ERROR_PIPE_CONNECTED.into() => Ok(Server { pipe, child }), + Err(e) => Err(e), + } + } - todo!() + pub(crate) fn get() -> Result<&'static Server, CUerror> { + static LOCK: OnceLock> = OnceLock::new(); + LOCK.get_or_init(|| unsafe { Server::start() }) + .as_ref() + .map_err(|_| CUerror::UNKNOWN) + } + + pub(crate) fn cu_init(&self, flags: u32) -> Result<(), CUerror> { + let mut in_buffer = [0xffu8; 8]; + in_buffer[..4].copy_from_slice(1u32.to_le_bytes().as_slice()); + in_buffer[4..].copy_from_slice(flags.to_le_bytes().as_slice()); + let mut out_buffer = [0xffu8; 4]; + let mut read = 0; + unsafe { + TransactNamedPipe( + *self.pipe, + Some(in_buffer.as_ptr().cast()), + in_buffer.len() as u32, + Some(out_buffer.as_mut_ptr().cast()), + out_buffer.len() as u32, + &mut read, + None, + ) + .map_err(|_| CUerror::UNKNOWN)?; + } + let result = u32::from_le_bytes(out_buffer); + NonZeroU32::new(result).map_or_else(|| Ok(()), |e| Err(CUerror(e))) + } } diff --git a/zluda32/src/lib.rs b/zluda32/src/lib.rs index 19fdc98b4..56c8872c1 100644 --- a/zluda32/src/lib.rs +++ b/zluda32/src/lib.rs @@ -84,9 +84,8 @@ cuda_function_declarations! { } pub fn cu_init(flags: u32) -> Result<(), CUerror> { - use compio::fs::named_pipe::*; - - todo!() + let server = ipc::Server::get()?; + server.cu_init(flags) } pub fn cu_ctx_create_v2( From 0e62224a6ca3c0dde5679264cbbde043e5e4cff7 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Tue, 14 Apr 2026 18:55:31 -0700 Subject: [PATCH 04/85] Map structs for some functions --- Cargo.lock | 2 + cuda_macros/src/lib.rs | 89 ++++++++++++++++++- zluda_server_common/Cargo.toml | 2 + zluda_server_common/src/lib.rs | 154 +++++++++++++++++++++++++++++++++ 4 files changed, 245 insertions(+), 2 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index ea282936c..ccf78f42e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -5734,7 +5734,9 @@ dependencies = [ name = "zluda_server_common" version = "0.0.0" dependencies = [ + "cuda_macros", "cuda_types", + "paste", "rkyv", ] diff --git a/cuda_macros/src/lib.rs b/cuda_macros/src/lib.rs index 769a672b9..36fb7ba7f 100644 --- a/cuda_macros/src/lib.rs +++ b/cuda_macros/src/lib.rs @@ -4,13 +4,13 @@ use proc_macro::TokenStream; use proc_macro2::Span; use quote::{format_ident, quote, ToTokens}; use rustc_hash::FxHashMap; +use syn::token::Type; use std::iter; use syn::parse::{Parse, ParseStream}; use syn::punctuated::Punctuated; use syn::visit_mut::VisitMut; use syn::{ - bracketed, parse_macro_input, File, ForeignItem, ForeignItemFn, Ident, Item, Path, Signature, - Token + File, ForeignItem, ForeignItemFn, Ident, Item, PatType, Path, Signature, Token, TypeGroup, bracketed, parse_macro_input }; const CUDA_RS: &'static str = include_str! {"cuda.rs"}; @@ -301,6 +301,91 @@ pub fn nvml_normalize_fn(tokens: TokenStream) -> TokenStream { normalize_fn_impl("nvml", None, tokens) } +#[proc_macro] +pub fn generate_input_struct(tokens: TokenStream) -> TokenStream { + let input = parse_macro_input!(tokens as FnWithFields); + let struct_name = format_ident!("{}In", input.fn_name); + let fields = input.fields.iter().filter(|pat| is_input_field(&pat.ty)).map(use_wire_object); + quote! { + #[derive(Archive, Deserialize, Serialize, Debug, PartialEq)] + struct #struct_name { + #(#fields),* + } + }.into() +} + +#[proc_macro] +pub fn generate_output_struct(tokens: TokenStream) -> TokenStream { + let input = parse_macro_input!(tokens as FnWithFields); + let struct_name = format_ident!("{}Out", input.fn_name); + let fields = input.fields.iter().filter(|pat| !is_input_field(&pat.ty)).map(strip_mut_ptr); + quote! { + #[derive(Archive, Deserialize, Serialize, Debug, PartialEq)] + struct #struct_name { + #(#fields),* + } + }.into() +} + +fn is_input_field(ty: &syn::Type) -> bool { + match ty { + syn::Type::Ptr(token) if token.mutability.is_some() => false, + syn::Type::Group(TypeGroup {elem, ..}) => is_input_field(&*elem), + _ => true + } +} + +fn use_wire_object(ty: &syn::PatType) -> proc_macro2::TokenStream { + let pat = &ty.pat; + let type_ = &ty.ty; + quote! { #pat : <#type_ as crate::Encode>::WireObject } +} + +fn strip_mut_ptr(ty: &syn::PatType) -> proc_macro2::TokenStream { + fn strip_mut_ptr_from_type(ty: &syn::Type) -> proc_macro2::TokenStream { + match ty { + syn::Type::Ptr(token) => { + let elem = &token.elem; + quote! { #elem } + }, + _ => unreachable!() + } + } + let pat = &ty.pat; + match &*ty.ty { + syn::Type::Ptr(token) => { + let type_ = strip_mut_ptr_from_type(&*token.elem); + quote! { #pat : <#type_ as crate::Encode>::WireObject } + }, + syn::Type::Group(TypeGroup {elem, ..}) => { + let type_ = strip_mut_ptr_from_type(&*elem); + quote! { #pat : <#type_ as crate::Encode>::WireObject } + }, + _ => unreachable!() + } +} + +struct FnWithFields { + fn_name: Ident, + fields: Punctuated, +} + +impl Parse for FnWithFields { + fn parse(input: ParseStream) -> syn::Result { + let fn_name = input.parse::()?; + let fields = if input.is_empty() { + Punctuated::new() + } else { + input.parse::()?; + input.parse_terminated(PatType::parse, Token![,])? + }; + Ok(Self { + fn_name, + fields, + }) + } +} + fn split(fn_: &str) -> Vec { let mut result = Vec::new(); let mut chars: iter::Peekable<_> = fn_.chars().peekable(); diff --git a/zluda_server_common/Cargo.toml b/zluda_server_common/Cargo.toml index 0eb46d3d0..c57fd0c25 100644 --- a/zluda_server_common/Cargo.toml +++ b/zluda_server_common/Cargo.toml @@ -6,4 +6,6 @@ edition = "2021" [dependencies] cuda_types = { path = "../cuda_types" } +cuda_macros = { path = "../cuda_macros" } rkyv = "0.8.15" +paste = "1" diff --git a/zluda_server_common/src/lib.rs b/zluda_server_common/src/lib.rs index e69de29bb..49d091549 100644 --- a/zluda_server_common/src/lib.rs +++ b/zluda_server_common/src/lib.rs @@ -0,0 +1,154 @@ +use cuda_macros::{cuda_function_declarations, generate_input_struct, generate_output_struct}; +use cuda_types::cuda::*; +use paste::paste; +use rkyv::{rancor::Error, Archive, Deserialize, Serialize}; +use std::ffi::CStr; + +#[repr(C)] +#[derive(Archive, Deserialize, Serialize)] +struct Envelope { + code: u32, + data: T, +} + +macro_rules! noop { + ($($abi:literal fn $fn_name:ident( $($arg_id:ident : $arg_type:ty),* ) -> $ret_type:ty;)*) => {}; +} + +macro_rules! generate_messages { + ($($abi:literal fn $fn_name:ident( $($arg_id:ident : $arg_type:ty),* ) -> $ret_type:ty;)*) => { + $( + generate_input_struct!($fn_name, $($arg_id : $arg_type),*); + generate_output_struct!($fn_name, $($arg_id : $arg_type),*); + )* + }; +} + +cuda_function_declarations! { + noop, + generate_messages <= [ + cuCtxCreate_v2, + cuCtxDetach, + cuCtxGetApiVersion, + cuCtxGetCurrent, + cuCtxGetDevice, + cuCtxSynchronize, + cuDeviceComputeCapability, + cuDeviceGet, + cuDeviceGetAttribute, + cuDeviceGetCount, + cuDeviceGetName, + cuDeviceGetProperties, + cuDeviceTotalMem_v2, + cuDriverGetVersion, + cuEventCreate, + cuEventDestroy_v2, + //cuGetExportTable, + cuInit, + //cuLaunchKernel, + cuMemAlloc_v2, + //cuMemFreeHost, + //cuMemFree_v2, + cuMemGetAddressRange_v2, + //cuMemHostAlloc, + //cuMemcpyDtoDAsync_v2, + //cuMemcpyDtoHAsync_v2, + //cuMemcpyHtoDAsync_v2, + cuMemsetD8_v2, + cuModuleGetFunction, + cuModuleGetGlobal_v2, + cuModuleGetTexRef, + cuStreamCreate, + cuStreamDestroy_v2, + cuTexRefSetAddressMode, + cuTexRefSetAddress_v2, + cuTexRefSetFilterMode, + cuTexRefSetFlags, + cuTexRefSetFormat, + cuTexRefSetMaxAnisotropy, + cuTexRefSetMipmapFilterMode, + cuTexRefSetMipmapLevelBias, + cuTexRefSetMipmapLevelClamp, + ] +} + +pub trait Encode: Copy { + type WireObject; + fn encode(self) -> Self::WireObject; +} + +macro_rules! encode_as_self { + ($type_:ty) => { + impl Encode for $type_ { + type WireObject = Self; + fn encode(self) -> Self { + self + } + } + }; +} + +macro_rules! encode_as_proxy { + ($type_:ty, $proxy_type:ty) => { + impl Encode for $type_ { + type WireObject = $proxy_type; + fn encode(self) -> $proxy_type { + unsafe { std::mem::transmute::(self) } + } + } + }; +} + +macro_rules! encode_as_u32 { + ($type_:ty) => { + impl Encode for $type_ { + type WireObject = u32; + fn encode(self) -> u32 { + unsafe { std::mem::transmute_copy::(&self) } + } + } + }; +} + +impl Encode for *const i8 { + type WireObject = Vec; + fn encode(self) -> Vec { + unsafe { CStr::from_ptr(self) }.to_bytes_with_nul().to_vec() + } +} + +encode_as_self!(u8); +encode_as_self!(i8); +encode_as_self!(u32); +encode_as_self!(f32); + +encode_as_proxy!(CUdevprop_v1, CUdevprop_v1_Wire); +encode_as_proxy!(CUdevice_attribute, u32); +encode_as_proxy!(CUfilter_mode, u32); +encode_as_proxy!(CUaddress_mode, u32); +encode_as_proxy!(CUarray_format, u32); + +encode_as_u32!(usize); +encode_as_u32!(CUcontext); +encode_as_u32!(CUdevice); +encode_as_u32!(CUdeviceptr_v2); +encode_as_u32!(CUevent); +encode_as_u32!(CUfunction); +encode_as_u32!(CUmodule); +encode_as_u32!(CUstream); +encode_as_u32!(CUtexref); + +#[repr(C)] +#[derive(Archive, PartialEq, Debug)] +pub struct CUdevprop_v1_Wire { + pub maxThreadsPerBlock: ::core::ffi::c_int, + pub maxThreadsDim: [::core::ffi::c_int; 3usize], + pub maxGridSize: [::core::ffi::c_int; 3usize], + pub sharedMemPerBlock: ::core::ffi::c_int, + pub totalConstantMemory: ::core::ffi::c_int, + pub SIMDWidth: ::core::ffi::c_int, + pub memPitch: ::core::ffi::c_int, + pub regsPerBlock: ::core::ffi::c_int, + pub clockRate: ::core::ffi::c_int, + pub textureAlign: ::core::ffi::c_int, +} From 4bf87518eb409e07158e422366274d38abed348e Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Thu, 16 Apr 2026 20:51:07 -0700 Subject: [PATCH 05/85] work in progress --- Cargo.lock | 118 ++++++++++++++++- Cargo.toml | 2 +- cuda_macros/src/lib.rs | 15 +-- zluda32/Cargo.toml | 5 +- zluda32/src/ipc.rs | 78 ++++++------ zluda32/src/lib.rs | 170 ++++++++++++++++--------- zluda64/src/main.rs | 49 ------- {zluda64 => zluda64_server}/Cargo.toml | 4 +- zluda64_server/src/main.rs | 41 ++++++ zluda_server_common/Cargo.toml | 4 +- zluda_server_common/src/lib.rs | 66 ++++++++-- 11 files changed, 377 insertions(+), 175 deletions(-) delete mode 100644 zluda64/src/main.rs rename {zluda64 => zluda64_server}/Cargo.toml (77%) create mode 100644 zluda64_server/src/main.rs diff --git a/Cargo.lock b/Cargo.lock index ccf78f42e..096c16632 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -114,6 +114,15 @@ version = "4.7.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de" +[[package]] +name = "atomic-polyfill" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8cf2bce30dfe09ef0bfaef228b9d414faaf7e563035494d7fe092dba54b300f4" +dependencies = [ + "critical-section", +] + [[package]] name = "autocfg" version = "1.4.0" @@ -126,6 +135,26 @@ version = "0.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3a8241f3ebb85c056b509d4327ad0358fbbba6ffb340bf388f26350aeda225b1" +[[package]] +name = "bincode" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "36eaf5d7b090263e8150820482d5d93cd964a81e4019913c972f4edcc6edb740" +dependencies = [ + "bincode_derive", + "serde", + "unty", +] + +[[package]] +name = "bincode_derive" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bf95709a440f45e986983918d0e8a1f30a9b1df04918fc828670606804ac3c09" +dependencies = [ + "virtue", +] + [[package]] name = "bindgen" version = "0.70.1" @@ -172,6 +201,30 @@ version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7" +[[package]] +name = "bitcode" +version = "0.6.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0a6ed1b54d8dc333e7be604d00fa9262f4635485ffea923647b6521a5fff045d" +dependencies = [ + "arrayvec", + "bitcode_derive", + "bytemuck", + "glam", + "serde", +] + +[[package]] +name = "bitcode_derive" +version = "0.6.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "238b90427dfad9da4a9abd60f3ec1cdee6b80454bde49ed37f1781dd8e9dc7f9" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.89", +] + [[package]] name = "bitflags" version = "1.3.2" @@ -688,6 +741,12 @@ dependencies = [ "cfg-if", ] +[[package]] +name = "critical-section" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "790eea4361631c5e7d22598ecd5723ff611904e3344ce8720784c93e3d83d40b" + [[package]] name = "crossbeam-channel" version = "0.5.15" @@ -1197,7 +1256,7 @@ version = "0.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7223ae2d2f179b803433d9c830478527e92b8117eab39460edae7f1614d9fb73" dependencies = [ - "heapless", + "heapless 0.8.0", "serde", ] @@ -2335,6 +2394,12 @@ dependencies = [ "gix-validate 0.9.4", ] +[[package]] +name = "glam" +version = "0.32.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f70749695b063ecbf6b62949ccccde2e733ec3ecbbd71d467dca4e5c6c97cca0" + [[package]] name = "glob" version = "0.3.1" @@ -2367,6 +2432,15 @@ dependencies = [ "zerocopy", ] +[[package]] +name = "hash32" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b0c35f58762feb77d74ebe43bdbc3210f09be9fe6742234d573bacc26ed92b67" +dependencies = [ + "byteorder", +] + [[package]] name = "hash32" version = "0.3.1" @@ -2408,13 +2482,27 @@ dependencies = [ "serde_core", ] +[[package]] +name = "heapless" +version = "0.7.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cdc6457c0eb62c71aac4bc17216026d8410337c4126773b9c5daba343f17964f" +dependencies = [ + "atomic-polyfill", + "hash32 0.2.1", + "rustc_version", + "serde", + "spin", + "stable_deref_trait", +] + [[package]] name = "heapless" version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0bfb9eb618601c89945a70e254898da93b13be0388091d42117462b265bb3fad" dependencies = [ - "hash32", + "hash32 0.3.1", "stable_deref_trait", ] @@ -3384,6 +3472,7 @@ dependencies = [ "cobs", "embedded-io 0.4.0", "embedded-io 0.6.1", + "heapless 0.7.17", "serde", ] @@ -4615,6 +4704,12 @@ version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "323402cff2dd658f39ca17c789b502021b3f18707c91cdf22e3838e1b4023817" +[[package]] +name = "unty" +version = "0.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6d49784317cd0d1ee7ec5c716dd598ec5b4483ea832a2dced265471cc0f690ae" + [[package]] name = "unwrap_or" version = "1.0.1" @@ -4705,6 +4800,12 @@ version = "0.9.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" +[[package]] +name = "virtue" +version = "0.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "051eb1abcf10076295e815102942cc58f9d5e3b4560e46e53c21e8ff6f3af7b1" + [[package]] name = "vswhom" version = "0.1.0" @@ -5526,23 +5627,28 @@ dependencies = [ name = "zluda32" version = "0.0.0" dependencies = [ - "compio", + "bincode", + "bitcode", "cuda_macros", "cuda_types", "ipc-channel", "paste", + "postcard", "rand 0.10.1", "widestring", "windows 0.62.2", + "zluda_server_common", ] [[package]] -name = "zluda64" +name = "zluda64_server" version = "0.0.0" dependencies = [ + "bincode", "compio", "slab", "windows-sys 0.61.2", + "zluda_server_common", ] [[package]] @@ -5734,10 +5840,12 @@ dependencies = [ name = "zluda_server_common" version = "0.0.0" dependencies = [ + "bincode", + "bitcode", "cuda_macros", "cuda_types", "paste", - "rkyv", + "postcard", ] [[package]] diff --git a/Cargo.toml b/Cargo.toml index 570f652eb..5618169c5 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -49,7 +49,7 @@ members = [ "zluda_trace", "zluda", "zluda32", - "zluda64", + "zluda64_server", ] default-members = ["zluda", "zluda_ml", "zluda_inject", "zluda_redirect", "compiler"] diff --git a/cuda_macros/src/lib.rs b/cuda_macros/src/lib.rs index 36fb7ba7f..178a18771 100644 --- a/cuda_macros/src/lib.rs +++ b/cuda_macros/src/lib.rs @@ -4,7 +4,6 @@ use proc_macro::TokenStream; use proc_macro2::Span; use quote::{format_ident, quote, ToTokens}; use rustc_hash::FxHashMap; -use syn::token::Type; use std::iter; use syn::parse::{Parse, ParseStream}; use syn::punctuated::Punctuated; @@ -307,8 +306,8 @@ pub fn generate_input_struct(tokens: TokenStream) -> TokenStream { let struct_name = format_ident!("{}In", input.fn_name); let fields = input.fields.iter().filter(|pat| is_input_field(&pat.ty)).map(use_wire_object); quote! { - #[derive(Archive, Deserialize, Serialize, Debug, PartialEq)] - struct #struct_name { + #[derive(Encode, Decode, PartialEq)] + pub struct #struct_name { #(#fields),* } }.into() @@ -320,8 +319,8 @@ pub fn generate_output_struct(tokens: TokenStream) -> TokenStream { let struct_name = format_ident!("{}Out", input.fn_name); let fields = input.fields.iter().filter(|pat| !is_input_field(&pat.ty)).map(strip_mut_ptr); quote! { - #[derive(Archive, Deserialize, Serialize, Debug, PartialEq)] - struct #struct_name { + #[derive(Encode, Decode, PartialEq)] + pub struct #struct_name { #(#fields),* } }.into() @@ -338,7 +337,7 @@ fn is_input_field(ty: &syn::Type) -> bool { fn use_wire_object(ty: &syn::PatType) -> proc_macro2::TokenStream { let pat = &ty.pat; let type_ = &ty.ty; - quote! { #pat : <#type_ as crate::Encode>::WireObject } + quote! { pub #pat : <#type_ as crate::CudaEncode>::WireObject } } fn strip_mut_ptr(ty: &syn::PatType) -> proc_macro2::TokenStream { @@ -355,11 +354,11 @@ fn strip_mut_ptr(ty: &syn::PatType) -> proc_macro2::TokenStream { match &*ty.ty { syn::Type::Ptr(token) => { let type_ = strip_mut_ptr_from_type(&*token.elem); - quote! { #pat : <#type_ as crate::Encode>::WireObject } + quote! { pub #pat : <#type_ as crate::CudaEncode>::WireObject } }, syn::Type::Group(TypeGroup {elem, ..}) => { let type_ = strip_mut_ptr_from_type(&*elem); - quote! { #pat : <#type_ as crate::Encode>::WireObject } + quote! { pub #pat : <#type_ as crate::CudaEncode>::WireObject } }, _ => unreachable!() } diff --git a/zluda32/Cargo.toml b/zluda32/Cargo.toml index 0e855fe53..3b0310e67 100644 --- a/zluda32/Cargo.toml +++ b/zluda32/Cargo.toml @@ -11,9 +11,9 @@ crate-type = ["cdylib"] [dependencies] cuda_types = { path = "../cuda_types" } cuda_macros = { path = "../cuda_macros" } +zluda_server_common = { path = "../zluda_server_common" } paste = "1.0" ipc-channel = "^0.21.0" -compio = { version = "0.18.0", features = ["fs"] } windows = { version = "0.62.2", features = [ "Win32_Foundation", "Win32_Storage_FileSystem", @@ -28,6 +28,9 @@ windows = { version = "0.62.2", features = [ # ] } rand = "0.10.1" widestring = "1.2.1" +bitcode = "0.6.9" +postcard = "1.1.3" +bincode = "2.0.1" [package.metadata.zluda] windows_only = true diff --git a/zluda32/src/ipc.rs b/zluda32/src/ipc.rs index 9d8b0a9fb..0c89a4a46 100644 --- a/zluda32/src/ipc.rs +++ b/zluda32/src/ipc.rs @@ -1,13 +1,16 @@ use cuda_types::cuda::CUerror; use rand::distr::{Alphanumeric, SampleString}; +use std::os::windows::io::{AsRawHandle, FromRawHandle}; +// use rkyv::util::AlignedVec; use std::num::NonZeroU32; use std::process::{Child, Command, Stdio}; use std::ptr; -use std::sync::OnceLock; +use std::sync::{Mutex, OnceLock}; use widestring::{u16str, U16CString}; use windows::core::{Error, Owned, PCSTR}; use windows::Win32::Foundation::*; use windows::Win32::System::Pipes::*; +use zluda_server_common::{Envelope, Opcode}; fn server_path() -> &'static str { if cfg!(debug_assertions) { @@ -18,7 +21,7 @@ fn server_path() -> &'static str { } pub(crate) struct Server { - pipe: Owned, + pipe: std::fs::File, child: Child, } @@ -26,58 +29,59 @@ unsafe impl Sync for Server {} unsafe impl Send for Server {} impl Server { + const CONFIG: bincode::config::Configuration< + bincode::config::LittleEndian, + bincode::config::Fixint, + > = bincode::config::standard().with_fixed_int_encoding(); + + fn new(pipe: std::fs::File, child: Child) -> Self { + Self { pipe, child } + } + unsafe fn start() -> Result { let name = Alphanumeric.sample_string(&mut rand::rng(), 32); let pipe_path = format!("\\\\.\\pipe\\zluda-{name}\0"); - let pipe = Owned::new(CreateNamedPipeA( - PCSTR(pipe_path.as_ptr()), - windows::Win32::Storage::FileSystem::PIPE_ACCESS_DUPLEX, - PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT | PIPE_REJECT_REMOTE_CLIENTS, - 1, - 128 * 1024, - 1024, - 0, - None, - )?); + let pipe = std::fs::File::from_raw_handle( + CreateNamedPipeA( + PCSTR(pipe_path.as_ptr()), + windows::Win32::Storage::FileSystem::PIPE_ACCESS_DUPLEX, + PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT | PIPE_REJECT_REMOTE_CLIENTS, + 1, + 4 * 1024, + 4 * 1024, + 0, + None, + )? + .0, + ); let child = Command::new(server_path()) .arg(&pipe_path[..pipe_path.len() - 1]) .stdin(Stdio::null()) .stdout(Stdio::null()) .stderr(Stdio::null()) .spawn()?; - match ConnectNamedPipe(*pipe, None) { - Ok(_) => Ok(Server { pipe, child }), - Err(e) if e.code() == ERROR_PIPE_CONNECTED.into() => Ok(Server { pipe, child }), + match ConnectNamedPipe(HANDLE(pipe.as_raw_handle()), None) { + Ok(_) => Ok(Server::new(pipe, child)), + Err(e) if e.code() == ERROR_PIPE_CONNECTED.into() => Ok(Server::new(pipe, child)), Err(e) => Err(e), } } - pub(crate) fn get() -> Result<&'static Server, CUerror> { - static LOCK: OnceLock> = OnceLock::new(); - LOCK.get_or_init(|| unsafe { Server::start() }) + pub(crate) fn get() -> Result<&'static Mutex, CUerror> { + static LOCK: OnceLock, Error>> = OnceLock::new(); + LOCK.get_or_init(|| Ok(Mutex::new(unsafe { Server::start()? }))) .as_ref() .map_err(|_| CUerror::UNKNOWN) } - pub(crate) fn cu_init(&self, flags: u32) -> Result<(), CUerror> { - let mut in_buffer = [0xffu8; 8]; - in_buffer[..4].copy_from_slice(1u32.to_le_bytes().as_slice()); - in_buffer[4..].copy_from_slice(flags.to_le_bytes().as_slice()); - let mut out_buffer = [0xffu8; 4]; - let mut read = 0; - unsafe { - TransactNamedPipe( - *self.pipe, - Some(in_buffer.as_ptr().cast()), - in_buffer.len() as u32, - Some(out_buffer.as_mut_ptr().cast()), - out_buffer.len() as u32, - &mut read, - None, - ) + pub(crate) fn call>( + &mut self, + opcode: Opcode, + input: &impl bincode::Encode, + ) -> Result { + bincode::encode_into_std_write(input, &mut self.pipe, Self::CONFIG) .map_err(|_| CUerror::UNKNOWN)?; - } - let result = u32::from_le_bytes(out_buffer); - NonZeroU32::new(result).map_or_else(|| Ok(()), |e| Err(CUerror(e))) + bincode::decode_from_std_read::(&mut self.pipe, Self::CONFIG) + .map_err(|_| CUerror::UNKNOWN) } } diff --git a/zluda32/src/lib.rs b/zluda32/src/lib.rs index 56c8872c1..fbb4681f5 100644 --- a/zluda32/src/lib.rs +++ b/zluda32/src/lib.rs @@ -1,8 +1,8 @@ -use std::sync::{Mutex, OnceLock}; -use compio::fs::named_pipe::NamedPipeServer; use cuda_macros::cuda_function_declarations; use cuda_types::cuda::*; use paste::paste; +use std::sync::{Mutex, OnceLock}; +use zluda_server_common::*; mod ipc; @@ -27,11 +27,10 @@ macro_rules! implemented { #[allow(improper_ctypes)] #[allow(improper_ctypes_definitions)] pub unsafe extern $abi fn $fn_name ( $( $arg_id : $arg_type),* ) -> $ret_type { - use crate::*; - paste! { [< $fn_name:snake:lower >]($($arg_id),*)? }; - Ok(()) + paste!{ [< $fn_name:snake >] ( $( $arg_id ),* ) } } )* + }; } @@ -83,43 +82,52 @@ cuda_function_declarations! { ] } -pub fn cu_init(flags: u32) -> Result<(), CUerror> { - let server = ipc::Server::get()?; - server.cu_init(flags) +pub(crate) fn cu_init(flags: u32) -> Result<(), CUerror> { + let mut server = ipc::Server::get()?.lock().map_err(|_| CUerror::UNKNOWN)?; + let output = server.call::>(Opcode::cuInit, &cuInitIn { Flags: flags })?; + output.result() } -pub fn cu_ctx_create_v2( +pub(crate) fn cu_ctx_create_v2( pctx: *mut CUcontext, flags: ::core::ffi::c_uint, dev: CUdevice, ) -> Result<(), CUerror> { - todo!() + let ctx = unsafe { pctx.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + let mut server = ipc::Server::get()?.lock().map_err(|_| CUerror::UNKNOWN)?; + let output = server.call::>( + Opcode::cuCtxCreate_v2, + &cuCtxCreate_v2In { flags, dev }, + )?; + output.result()?; + *ctx = CudaEncode::decode(output.data.pctx); + Ok(()) } -pub fn cu_ctx_detach(ctx: CUcontext) -> Result<(), CUerror> { +pub(crate) fn cu_ctx_detach(ctx: CUcontext) -> Result<(), CUerror> { todo!() } -pub fn cu_ctx_get_api_version( +pub(crate) fn cu_ctx_get_api_version( ctx: CUcontext, version: *mut ::core::ffi::c_uint, ) -> Result<(), CUerror> { todo!() } -pub fn cu_ctx_get_current(pctx: *mut CUcontext) -> Result<(), CUerror> { +pub(crate) fn cu_ctx_get_current(pctx: *mut CUcontext) -> Result<(), CUerror> { todo!() } -pub fn cu_ctx_get_device(device: *mut CUdevice) -> Result<(), CUerror> { +pub(crate) fn cu_ctx_get_device(device: *mut CUdevice) -> Result<(), CUerror> { todo!() } -pub fn cu_ctx_synchronize() -> Result<(), CUerror> { +pub(crate) fn cu_ctx_synchronize() -> Result<(), CUerror> { todo!() } -pub fn cu_device_compute_capability( +pub(crate) fn cu_device_compute_capability( major: *mut ::core::ffi::c_int, minor: *mut ::core::ffi::c_int, dev: CUdevice, @@ -127,23 +135,49 @@ pub fn cu_device_compute_capability( todo!() } -pub fn cu_device_get(device: *mut CUdevice, ordinal: ::core::ffi::c_int) -> Result<(), CUerror> { - todo!() +pub(crate) fn cu_device_get( + device: *mut CUdevice, + ordinal: ::core::ffi::c_int, +) -> Result<(), CUerror> { + let device = unsafe { device.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + let mut server = ipc::Server::get()?.lock().map_err(|_| CUerror::UNKNOWN)?; + let output = + server.call::>(Opcode::cuDeviceGet, &cuDeviceGetIn { ordinal })?; + output.result()?; + *device = CudaEncode::decode(output.data.device); + Ok(()) } -pub fn cu_device_get_attribute( +pub(crate) fn cu_device_get_attribute( pi: *mut ::core::ffi::c_int, attrib: CUdevice_attribute, dev: CUdevice, ) -> Result<(), CUerror> { - todo!() -} - -pub fn cu_device_get_count(count: *mut ::core::ffi::c_int) -> Result<(), CUerror> { - todo!() -} - -pub fn cu_device_get_name( + let pi = unsafe { pi.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + let mut server = ipc::Server::get()?.lock().map_err(|_| CUerror::UNKNOWN)?; + let output = server.call::>( + Opcode::cuDeviceGetAttribute, + &cuDeviceGetAttributeIn { + attrib: CudaEncode::encode(attrib), + dev, + }, + )?; + output.result()?; + *pi = CudaEncode::decode(output.data.pi); + Ok(()) +} + +pub(crate) fn cu_device_get_count(count: *mut ::core::ffi::c_int) -> Result<(), CUerror> { + let count = unsafe { count.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + let mut server = ipc::Server::get()?.lock().map_err(|_| CUerror::UNKNOWN)?; + let output = server + .call::>(Opcode::cuDeviceGetCount, &cuDeviceGetCountIn {})?; + output.result()?; + *count = CudaEncode::decode(output.data.count); + Ok(()) +} + +pub(crate) fn cu_device_get_name( name: *mut ::core::ffi::c_char, len: ::core::ffi::c_int, dev: CUdevice, @@ -151,34 +185,45 @@ pub fn cu_device_get_name( todo!() } -pub fn cu_device_get_properties(prop: *mut CUdevprop, dev: CUdevice) -> Result<(), CUerror> { +pub(crate) fn cu_device_get_properties(prop: *mut CUdevprop, dev: CUdevice) -> Result<(), CUerror> { todo!() } -pub fn cu_device_total_mem_v2(bytes: *mut usize, dev: CUdevice) -> Result<(), CUerror> { +pub(crate) fn cu_device_total_mem_v2(bytes: *mut usize, dev: CUdevice) -> Result<(), CUerror> { todo!() } -pub fn cu_driver_get_version(driverVersion: *mut ::core::ffi::c_int) -> Result<(), CUerror> { - todo!() +pub(crate) fn cu_driver_get_version(driverVersion: *mut ::core::ffi::c_int) -> Result<(), CUerror> { + let driverVersion = unsafe { driverVersion.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + let mut server = ipc::Server::get()?.lock().map_err(|_| CUerror::UNKNOWN)?; + let output = server.call::>( + Opcode::cuDriverGetVersion, + &cuDriverGetVersionIn {}, + )?; + output.result()?; + *driverVersion = CudaEncode::decode(output.data.driverVersion); + Ok(()) } -pub fn cu_event_create(phEvent: *mut CUevent, Flags: ::core::ffi::c_uint) -> Result<(), CUerror> { +pub(crate) fn cu_event_create( + phEvent: *mut CUevent, + Flags: ::core::ffi::c_uint, +) -> Result<(), CUerror> { todo!() } -pub fn cu_event_destroy_v2(hEvent: CUevent) -> Result<(), CUerror> { +pub(crate) fn cu_event_destroy_v2(hEvent: CUevent) -> Result<(), CUerror> { todo!() } -pub fn cu_get_export_table( +pub(crate) fn cu_get_export_table( ppExportTable: *mut *const ::core::ffi::c_void, pExportTableId: *const CUuuid, ) -> Result<(), CUerror> { todo!() } -pub fn cu_launch_kernel( +pub(crate) fn cu_launch_kernel( f: CUfunction, gridDimX: ::core::ffi::c_uint, gridDimY: ::core::ffi::c_uint, @@ -194,19 +239,19 @@ pub fn cu_launch_kernel( todo!() } -pub fn cu_mem_alloc_v2(dptr: *mut CUdeviceptr, bytesize: usize) -> Result<(), CUerror> { +pub(crate) fn cu_mem_alloc_v2(dptr: *mut CUdeviceptr, bytesize: usize) -> Result<(), CUerror> { todo!() } -pub fn cu_mem_free_host(p: *mut ::core::ffi::c_void) -> Result<(), CUerror> { +pub(crate) fn cu_mem_free_host(p: *mut ::core::ffi::c_void) -> Result<(), CUerror> { todo!() } -pub fn cu_mem_free_v2(dptr: CUdeviceptr) -> Result<(), CUerror> { +pub(crate) fn cu_mem_free_v2(dptr: CUdeviceptr) -> Result<(), CUerror> { todo!() } -pub fn cu_mem_get_address_range_v2( +pub(crate) fn cu_mem_get_address_range_v2( pbase: *mut CUdeviceptr, psize: *mut usize, dptr: CUdeviceptr, @@ -214,7 +259,7 @@ pub fn cu_mem_get_address_range_v2( todo!() } -pub fn cu_mem_host_alloc( +pub(crate) fn cu_mem_host_alloc( pp: *mut *mut ::core::ffi::c_void, bytesize: usize, Flags: ::core::ffi::c_uint, @@ -222,7 +267,7 @@ pub fn cu_mem_host_alloc( todo!() } -pub fn cu_memcpy_dto_d_async_v2( +pub(crate) fn cu_memcpy_dto_d_async_v2( dstDevice: CUdeviceptr, srcDevice: CUdeviceptr, ByteCount: usize, @@ -231,7 +276,7 @@ pub fn cu_memcpy_dto_d_async_v2( todo!() } -pub fn cu_memcpy_dto_h_async_v2( +pub(crate) fn cu_memcpy_dto_h_async_v2( dstHost: *mut ::core::ffi::c_void, srcDevice: CUdeviceptr, ByteCount: usize, @@ -240,7 +285,7 @@ pub fn cu_memcpy_dto_h_async_v2( todo!() } -pub fn cu_memcpy_hto_d_async_v2( +pub(crate) fn cu_memcpy_hto_d_async_v2( dstDevice: CUdeviceptr, srcHost: *const ::core::ffi::c_void, ByteCount: usize, @@ -249,7 +294,7 @@ pub fn cu_memcpy_hto_d_async_v2( todo!() } -pub fn cu_memset_d8_v2( +pub(crate) fn cu_memset_d8_v2( dstDevice: CUdeviceptr, uc: ::core::ffi::c_uchar, N: usize, @@ -257,7 +302,7 @@ pub fn cu_memset_d8_v2( todo!() } -pub fn cu_module_get_function( +pub(crate) fn cu_module_get_function( hfunc: *mut CUfunction, hmod: CUmodule, name: *const ::core::ffi::c_char, @@ -265,7 +310,7 @@ pub fn cu_module_get_function( todo!() } -pub fn cu_module_get_global_v2( +pub(crate) fn cu_module_get_global_v2( dptr: *mut CUdeviceptr, bytes: *mut usize, hmod: CUmodule, @@ -274,7 +319,7 @@ pub fn cu_module_get_global_v2( todo!() } -pub fn cu_module_get_tex_ref( +pub(crate) fn cu_module_get_tex_ref( pTexRef: *mut CUtexref, hmod: CUmodule, name: *const ::core::ffi::c_char, @@ -282,18 +327,18 @@ pub fn cu_module_get_tex_ref( todo!() } -pub fn cu_stream_create( +pub(crate) fn cu_stream_create( phStream: *mut CUstream, Flags: ::core::ffi::c_uint, ) -> Result<(), CUerror> { todo!() } -pub fn cu_stream_destroy_v2(hStream: CUstream) -> Result<(), CUerror> { +pub(crate) fn cu_stream_destroy_v2(hStream: CUstream) -> Result<(), CUerror> { todo!() } -pub fn cu_tex_ref_set_address_mode( +pub(crate) fn cu_tex_ref_set_address_mode( hTexRef: CUtexref, dim: ::core::ffi::c_int, am: CUaddress_mode, @@ -301,7 +346,7 @@ pub fn cu_tex_ref_set_address_mode( todo!() } -pub fn cu_tex_ref_set_address_v2( +pub(crate) fn cu_tex_ref_set_address_v2( ByteOffset: *mut usize, hTexRef: CUtexref, dptr: CUdeviceptr, @@ -310,15 +355,21 @@ pub fn cu_tex_ref_set_address_v2( todo!() } -pub fn cu_tex_ref_set_filter_mode(hTexRef: CUtexref, fm: CUfilter_mode) -> Result<(), CUerror> { +pub(crate) fn cu_tex_ref_set_filter_mode( + hTexRef: CUtexref, + fm: CUfilter_mode, +) -> Result<(), CUerror> { todo!() } -pub fn cu_tex_ref_set_flags(hTexRef: CUtexref, Flags: ::core::ffi::c_uint) -> Result<(), CUerror> { +pub(crate) fn cu_tex_ref_set_flags( + hTexRef: CUtexref, + Flags: ::core::ffi::c_uint, +) -> Result<(), CUerror> { todo!() } -pub fn cu_tex_ref_set_format( +pub(crate) fn cu_tex_ref_set_format( hTexRef: CUtexref, fmt: CUarray_format, NumPackedComponents: ::core::ffi::c_int, @@ -326,25 +377,28 @@ pub fn cu_tex_ref_set_format( todo!() } -pub fn cu_tex_ref_set_max_anisotropy( +pub(crate) fn cu_tex_ref_set_max_anisotropy( hTexRef: CUtexref, maxAniso: ::core::ffi::c_uint, ) -> Result<(), CUerror> { todo!() } -pub fn cu_tex_ref_set_mipmap_filter_mode( +pub(crate) fn cu_tex_ref_set_mipmap_filter_mode( hTexRef: CUtexref, fm: CUfilter_mode, ) -> Result<(), CUerror> { todo!() } -pub fn cu_tex_ref_set_mipmap_level_bias(hTexRef: CUtexref, bias: f32) -> Result<(), CUerror> { +pub(crate) fn cu_tex_ref_set_mipmap_level_bias( + hTexRef: CUtexref, + bias: f32, +) -> Result<(), CUerror> { todo!() } -pub fn cu_tex_ref_set_mipmap_level_clamp( +pub(crate) fn cu_tex_ref_set_mipmap_level_clamp( hTexRef: CUtexref, minMipmapLevelClamp: f32, maxMipmapLevelClamp: f32, diff --git a/zluda64/src/main.rs b/zluda64/src/main.rs deleted file mode 100644 index accb99f9e..000000000 --- a/zluda64/src/main.rs +++ /dev/null @@ -1,49 +0,0 @@ -use compio::{ - fs::named_pipe::ClientOptions, - io::{AsyncRead, AsyncReadExt, AsyncWriteExt}, - BufResult, -}; -use slab::Slab; -use windows_sys::Win32::Foundation::ERROR_MORE_DATA; - -struct State { - handles: Slab, -} - -#[compio::main] -async fn main() -> std::io::Result<()> { - let pipe_name = std::env::args_os().nth(1).ok_or(std::io::Error::new( - std::io::ErrorKind::InvalidInput, - "Pipe name not provided", - ))?; - let mut client = ClientOptions::new() - .pipe_mode(compio::fs::named_pipe::PipeMode::Message) - .read(true) - .write(true) - .open(pipe_name) - .await?; - let mut buffer = vec![0u8; 128 * 1024]; - let mut append = false; - loop { - let read_result = if append { - append = false; - client.append(buffer).await - } else { - client.read(buffer).await - }; - match read_result { - BufResult(Ok(0), _) => break, // EOF - BufResult(Ok(n), b) => { - println!("Read {} bytes", n); - client.write_u32_le(0).await?; - buffer = b; - } - BufResult(Err(e), b) if e.raw_os_error() == Some(ERROR_MORE_DATA as i32) => { - append = true; - buffer = b; - } - BufResult(Err(e), _) => return Err(e), - } - } - Ok(()) -} diff --git a/zluda64/Cargo.toml b/zluda64_server/Cargo.toml similarity index 77% rename from zluda64/Cargo.toml rename to zluda64_server/Cargo.toml index f8ea2e786..d351226dc 100644 --- a/zluda64/Cargo.toml +++ b/zluda64_server/Cargo.toml @@ -1,5 +1,5 @@ [package] -name = "zluda64" +name = "zluda64_server" version = "0.0.0" authors = ["Andrzej Janik "] edition = "2021" @@ -9,9 +9,11 @@ name = "zluda64_server" path = "src/main.rs" [dependencies] +zluda_server_common = { path = "../zluda_server_common" } windows-sys = { version = "0.61.2", features = ["Win32_Foundation"] } compio = { version = "0.18.0", features = ["macros", "fs"] } slab = "0.4.12" +bincode = "2.0.1" [package.metadata.zluda] windows_only = true diff --git a/zluda64_server/src/main.rs b/zluda64_server/src/main.rs new file mode 100644 index 000000000..182274596 --- /dev/null +++ b/zluda64_server/src/main.rs @@ -0,0 +1,41 @@ +use compio::{ + fs::named_pipe::ClientOptions, + io::{AsyncRead, AsyncReadExt, AsyncWriteExt}, + BufResult, +}; +use slab::Slab; +use windows_sys::Win32::Foundation::ERROR_MORE_DATA; + +struct State { + handles: Slab, +} + +#[compio::main] +async fn main() -> std::io::Result<()> { + let pipe_name = std::env::args_os().nth(1).ok_or(std::io::Error::new( + std::io::ErrorKind::InvalidInput, + "Pipe name not provided", + ))?; + let mut client = ClientOptions::new() + .pipe_mode(compio::fs::named_pipe::PipeMode::Byte) + .read(true) + .write(true) + .open(pipe_name) + .await?; + let mut buffer = vec![0u8; 128 * 1024]; + loop { + let opcode = client.read_u32_le().await?; // Read the length prefix + client.read_managed(buffer_pool, len) + } + Ok(()) +} + +struct PipeReader { + client: compio::fs::named_pipe::NamedPipeClient, +} + +impl bincode::de::read::Reader for PipeReader { + fn read(&mut self, bytes: &mut [u8]) -> Result<(), bincode::error::DecodeError> { + self.client.read_exact(bytes) + } +} diff --git a/zluda_server_common/Cargo.toml b/zluda_server_common/Cargo.toml index c57fd0c25..cf501886d 100644 --- a/zluda_server_common/Cargo.toml +++ b/zluda_server_common/Cargo.toml @@ -7,5 +7,7 @@ edition = "2021" [dependencies] cuda_types = { path = "../cuda_types" } cuda_macros = { path = "../cuda_macros" } -rkyv = "0.8.15" +bitcode = "0.6.9" paste = "1" +postcard = "1.1.3" +bincode = "2.0.1" diff --git a/zluda_server_common/src/lib.rs b/zluda_server_common/src/lib.rs index 49d091549..3e16cf29d 100644 --- a/zluda_server_common/src/lib.rs +++ b/zluda_server_common/src/lib.rs @@ -1,14 +1,24 @@ +use bincode::{Decode, Encode}; use cuda_macros::{cuda_function_declarations, generate_input_struct, generate_output_struct}; use cuda_types::cuda::*; use paste::paste; -use rkyv::{rancor::Error, Archive, Deserialize, Serialize}; -use std::ffi::CStr; +use std::ffi::CString; +use std::num::NonZeroU32; +use std::{ffi::CStr, num::NonZero}; -#[repr(C)] -#[derive(Archive, Deserialize, Serialize)] -struct Envelope { - code: u32, - data: T, +#[derive(Encode, Decode, PartialEq, Debug)] +pub struct Envelope { + pub code: u32, + pub data: T, +} + +impl Envelope { + pub fn result(&self) -> Result<(), CUerror> { + match NonZeroU32::new(self.code) { + Some(code) => Err(CUerror(code)), + None => Ok(()), + } + } } macro_rules! noop { @@ -21,6 +31,14 @@ macro_rules! generate_messages { generate_input_struct!($fn_name, $($arg_id : $arg_type),*); generate_output_struct!($fn_name, $($arg_id : $arg_type),*); )* + + #[repr(u32)] + pub enum Opcode { + System = 0, + $( + $fn_name, + )* + } }; } @@ -72,54 +90,69 @@ cuda_function_declarations! { ] } -pub trait Encode: Copy { +pub trait CudaEncode: Copy { type WireObject; fn encode(self) -> Self::WireObject; + fn decode(o: Self::WireObject) -> Self; } macro_rules! encode_as_self { ($type_:ty) => { - impl Encode for $type_ { + impl CudaEncode for $type_ { type WireObject = Self; fn encode(self) -> Self { self } + fn decode(o: Self::WireObject) -> Self { + o + } } }; } macro_rules! encode_as_proxy { ($type_:ty, $proxy_type:ty) => { - impl Encode for $type_ { + impl CudaEncode for $type_ { type WireObject = $proxy_type; fn encode(self) -> $proxy_type { unsafe { std::mem::transmute::(self) } } + fn decode(o: Self::WireObject) -> Self { + unsafe { std::mem::transmute::<$proxy_type, Self>(o) } + } } }; } macro_rules! encode_as_u32 { ($type_:ty) => { - impl Encode for $type_ { + impl CudaEncode for $type_ { type WireObject = u32; fn encode(self) -> u32 { unsafe { std::mem::transmute_copy::(&self) } } + fn decode(o: Self::WireObject) -> Self { + unsafe { std::mem::transmute_copy::(&o) } + } } }; } -impl Encode for *const i8 { +impl CudaEncode for *const i8 { type WireObject = Vec; fn encode(self) -> Vec { unsafe { CStr::from_ptr(self) }.to_bytes_with_nul().to_vec() } + fn decode(o: Self::WireObject) -> Self { + let c_string = CString::from_vec_with_nul(o).unwrap(); + c_string.into_raw() + } } encode_as_self!(u8); encode_as_self!(i8); encode_as_self!(u32); +encode_as_self!(i32); encode_as_self!(f32); encode_as_proxy!(CUdevprop_v1, CUdevprop_v1_Wire); @@ -130,7 +163,6 @@ encode_as_proxy!(CUarray_format, u32); encode_as_u32!(usize); encode_as_u32!(CUcontext); -encode_as_u32!(CUdevice); encode_as_u32!(CUdeviceptr_v2); encode_as_u32!(CUevent); encode_as_u32!(CUfunction); @@ -139,7 +171,7 @@ encode_as_u32!(CUstream); encode_as_u32!(CUtexref); #[repr(C)] -#[derive(Archive, PartialEq, Debug)] +#[derive(Encode, Decode, PartialEq, Debug)] pub struct CUdevprop_v1_Wire { pub maxThreadsPerBlock: ::core::ffi::c_int, pub maxThreadsDim: [::core::ffi::c_int; 3usize], @@ -152,3 +184,9 @@ pub struct CUdevprop_v1_Wire { pub clockRate: ::core::ffi::c_int, pub textureAlign: ::core::ffi::c_int, } + +#[derive(Encode, Decode, PartialEq)] +pub struct Foobar { + pub text: String, + pub buff: Vec, +} From 6d9ed16b8392c9479ffe0cee4d31cb54fa83428c Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Thu, 16 Apr 2026 23:10:55 -0700 Subject: [PATCH 06/85] Use rkyv after all --- Cargo.lock | 31 +++++++----- cuda_macros/src/lib.rs | 8 ++- ptx/Cargo.toml | 4 +- zluda32/Cargo.toml | 1 + zluda32/src/ipc.rs | 53 ++++++++++++++------ zluda32/src/lib.rs | 57 ++++++++++------------ zluda64_server/Cargo.toml | 2 + zluda64_server/src/main.rs | 89 ++++++++++++++++++++++++++++++---- zluda_server_common/Cargo.toml | 3 ++ zluda_server_common/src/lib.rs | 17 +++++-- 10 files changed, 188 insertions(+), 77 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 096c16632..2726b00a3 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3637,8 +3637,8 @@ dependencies = [ "quick-error", "rustc-hash 2.1.1", "smallvec", - "strum 0.26.3", - "strum_macros 0.26.4", + "strum 0.28.0", + "strum_macros 0.28.0", "tempfile", "thiserror 1.0.64", "unwrap_or", @@ -4261,12 +4261,6 @@ version = "0.11.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f" -[[package]] -name = "strum" -version = "0.26.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8fec0f0aef304996cf250b31b5a10dee7980c85da9d759361292b8bca5a18f06" - [[package]] name = "strum" version = "0.27.1" @@ -4276,11 +4270,17 @@ dependencies = [ "strum_macros 0.27.1", ] +[[package]] +name = "strum" +version = "0.28.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9628de9b8791db39ceda2b119bbe13134770b56c138ec1d3af810d045c04f9bd" + [[package]] name = "strum_macros" -version = "0.26.4" +version = "0.27.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4c6bee85a5a24955dc440386795aa378cd9cf82acd5f764469152d2270e581be" +checksum = "c77a8c5abcaf0f9ce05d62342b7d298c346515365c36b673df4ebe3ced01fde8" dependencies = [ "heck", "proc-macro2", @@ -4291,14 +4291,13 @@ dependencies = [ [[package]] name = "strum_macros" -version = "0.27.1" +version = "0.28.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c77a8c5abcaf0f9ce05d62342b7d298c346515365c36b673df4ebe3ced01fde8" +checksum = "ab85eea0270ee17587ed4156089e10b9e6880ee688791d45a905f5b1ca36f664" dependencies = [ "heck", "proc-macro2", "quote", - "rustversion", "syn 2.0.89", ] @@ -5635,6 +5634,7 @@ dependencies = [ "paste", "postcard", "rand 0.10.1", + "rkyv", "widestring", "windows 0.62.2", "zluda_server_common", @@ -5646,6 +5646,8 @@ version = "0.0.0" dependencies = [ "bincode", "compio", + "cuda_types", + "rkyv", "slab", "windows-sys 0.61.2", "zluda_server_common", @@ -5846,6 +5848,9 @@ dependencies = [ "cuda_types", "paste", "postcard", + "rkyv", + "strum 0.28.0", + "strum_macros 0.28.0", ] [[package]] diff --git a/cuda_macros/src/lib.rs b/cuda_macros/src/lib.rs index 178a18771..1267860b9 100644 --- a/cuda_macros/src/lib.rs +++ b/cuda_macros/src/lib.rs @@ -306,10 +306,12 @@ pub fn generate_input_struct(tokens: TokenStream) -> TokenStream { let struct_name = format_ident!("{}In", input.fn_name); let fields = input.fields.iter().filter(|pat| is_input_field(&pat.ty)).map(use_wire_object); quote! { - #[derive(Encode, Decode, PartialEq)] + #[derive(Archive, Deserialize, Serialize, Debug, PartialEq)] + #[repr(C)] pub struct #struct_name { #(#fields),* } + unsafe impl Portable for #struct_name {} }.into() } @@ -319,10 +321,12 @@ pub fn generate_output_struct(tokens: TokenStream) -> TokenStream { let struct_name = format_ident!("{}Out", input.fn_name); let fields = input.fields.iter().filter(|pat| !is_input_field(&pat.ty)).map(strip_mut_ptr); quote! { - #[derive(Encode, Decode, PartialEq)] + #[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] + #[repr(C)] pub struct #struct_name { #(#fields),* } + unsafe impl Portable for #struct_name {} }.into() } diff --git a/ptx/Cargo.toml b/ptx/Cargo.toml index f732b7708..38dd59b7b 100644 --- a/ptx/Cargo.toml +++ b/ptx/Cargo.toml @@ -16,8 +16,8 @@ bit-vec = "0.8" half = "2.7" bitflags = "1.2" rustc-hash = "2.0.0" -strum = "0.26" -strum_macros = "0.26" +strum = "0.28" +strum_macros = "0.28" petgraph = "0.7.1" highs = "1.12.0" int-enum = "1.1" diff --git a/zluda32/Cargo.toml b/zluda32/Cargo.toml index 3b0310e67..7b49ec111 100644 --- a/zluda32/Cargo.toml +++ b/zluda32/Cargo.toml @@ -31,6 +31,7 @@ widestring = "1.2.1" bitcode = "0.6.9" postcard = "1.1.3" bincode = "2.0.1" +rkyv = "0.8.15" [package.metadata.zluda] windows_only = true diff --git a/zluda32/src/ipc.rs b/zluda32/src/ipc.rs index 0c89a4a46..131beb6e8 100644 --- a/zluda32/src/ipc.rs +++ b/zluda32/src/ipc.rs @@ -1,11 +1,17 @@ use cuda_types::cuda::CUerror; use rand::distr::{Alphanumeric, SampleString}; +use rkyv::api::high::HighSerializer; +use rkyv::rend::u32_le; +use rkyv::ser::allocator::ArenaHandle; +use rkyv::util::AlignedVec; +use rkyv::{rancor, Portable, Serialize}; +use std::io::{Read, Write}; use std::os::windows::io::{AsRawHandle, FromRawHandle}; // use rkyv::util::AlignedVec; use std::num::NonZeroU32; use std::process::{Child, Command, Stdio}; -use std::ptr; use std::sync::{Mutex, OnceLock}; +use std::{mem, ptr}; use widestring::{u16str, U16CString}; use windows::core::{Error, Owned, PCSTR}; use windows::Win32::Foundation::*; @@ -22,20 +28,22 @@ fn server_path() -> &'static str { pub(crate) struct Server { pipe: std::fs::File, - child: Child, + _child: Child, + in_buffer: AlignedVec, + out_buffer: AlignedVec, } unsafe impl Sync for Server {} unsafe impl Send for Server {} impl Server { - const CONFIG: bincode::config::Configuration< - bincode::config::LittleEndian, - bincode::config::Fixint, - > = bincode::config::standard().with_fixed_int_encoding(); - fn new(pipe: std::fs::File, child: Child) -> Self { - Self { pipe, child } + Self { + pipe, + _child: child, + in_buffer: AlignedVec::new(), + out_buffer: AlignedVec::new(), + } } unsafe fn start() -> Result { @@ -67,21 +75,36 @@ impl Server { } } - pub(crate) fn get() -> Result<&'static Mutex, CUerror> { + fn get() -> Result<&'static Mutex, CUerror> { static LOCK: OnceLock, Error>> = OnceLock::new(); LOCK.get_or_init(|| Ok(Mutex::new(unsafe { Server::start()? }))) .as_ref() .map_err(|_| CUerror::UNKNOWN) } - pub(crate) fn call>( - &mut self, + pub(crate) fn remote_call( opcode: Opcode, - input: &impl bincode::Encode, + data: impl for<'a, 'b> Serialize< + HighSerializer<&'a mut AlignedVec, ArenaHandle<'b>, rkyv::rancor::Failure>, + >, ) -> Result { - bincode::encode_into_std_write(input, &mut self.pipe, Self::CONFIG) + let this = &mut *Self::get()?.lock().map_err(|_| CUerror::UNKNOWN)?; + this.in_buffer.clear(); + let slice = rkyv::api::high::to_bytes_in::<_, rkyv::rancor::Failure>( + &Envelope { + code: opcode as u32, + data, + }, + &mut this.in_buffer, + ) + .map_err(|_| CUerror::UNKNOWN)?; + this.pipe.write_all(&slice).map_err(|_| CUerror::UNKNOWN)?; + this.out_buffer.resize(mem::size_of::>(), 0); + this.pipe + .read_exact(&mut this.out_buffer) .map_err(|_| CUerror::UNKNOWN)?; - bincode::decode_from_std_read::(&mut self.pipe, Self::CONFIG) - .map_err(|_| CUerror::UNKNOWN) + let bytes = unsafe { rkyv::access_unchecked::>(&this.out_buffer) }; + bytes.result()?; + Ok(bytes.data.clone()) } } diff --git a/zluda32/src/lib.rs b/zluda32/src/lib.rs index fbb4681f5..e758955b5 100644 --- a/zluda32/src/lib.rs +++ b/zluda32/src/lib.rs @@ -83,9 +83,8 @@ cuda_function_declarations! { } pub(crate) fn cu_init(flags: u32) -> Result<(), CUerror> { - let mut server = ipc::Server::get()?.lock().map_err(|_| CUerror::UNKNOWN)?; - let output = server.call::>(Opcode::cuInit, &cuInitIn { Flags: flags })?; - output.result() + ipc::Server::remote_call::(Opcode::cuInit, cuInitIn { Flags: flags })?; + Ok(()) } pub(crate) fn cu_ctx_create_v2( @@ -94,13 +93,13 @@ pub(crate) fn cu_ctx_create_v2( dev: CUdevice, ) -> Result<(), CUerror> { let ctx = unsafe { pctx.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - let mut server = ipc::Server::get()?.lock().map_err(|_| CUerror::UNKNOWN)?; - let output = server.call::>( - Opcode::cuCtxCreate_v2, - &cuCtxCreate_v2In { flags, dev }, - )?; - output.result()?; - *ctx = CudaEncode::decode(output.data.pctx); + *ctx = CudaEncode::decode( + ipc::Server::remote_call::( + Opcode::cuCtxCreate_v2, + cuCtxCreate_v2In { flags, dev }, + )? + .pctx, + ); Ok(()) } @@ -140,11 +139,9 @@ pub(crate) fn cu_device_get( ordinal: ::core::ffi::c_int, ) -> Result<(), CUerror> { let device = unsafe { device.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - let mut server = ipc::Server::get()?.lock().map_err(|_| CUerror::UNKNOWN)?; - let output = - server.call::>(Opcode::cuDeviceGet, &cuDeviceGetIn { ordinal })?; - output.result()?; - *device = CudaEncode::decode(output.data.device); + *device = + ipc::Server::remote_call::(Opcode::cuDeviceGet, cuDeviceGetIn { ordinal })? + .device; Ok(()) } @@ -154,26 +151,24 @@ pub(crate) fn cu_device_get_attribute( dev: CUdevice, ) -> Result<(), CUerror> { let pi = unsafe { pi.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - let mut server = ipc::Server::get()?.lock().map_err(|_| CUerror::UNKNOWN)?; - let output = server.call::>( + *pi = ipc::Server::remote_call::( Opcode::cuDeviceGetAttribute, - &cuDeviceGetAttributeIn { + cuDeviceGetAttributeIn { attrib: CudaEncode::encode(attrib), dev, }, - )?; - output.result()?; - *pi = CudaEncode::decode(output.data.pi); + )? + .pi; Ok(()) } pub(crate) fn cu_device_get_count(count: *mut ::core::ffi::c_int) -> Result<(), CUerror> { let count = unsafe { count.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - let mut server = ipc::Server::get()?.lock().map_err(|_| CUerror::UNKNOWN)?; - let output = server - .call::>(Opcode::cuDeviceGetCount, &cuDeviceGetCountIn {})?; - output.result()?; - *count = CudaEncode::decode(output.data.count); + *count = ipc::Server::remote_call::( + Opcode::cuDeviceGetCount, + cuDeviceGetCountIn {}, + )? + .count; Ok(()) } @@ -195,13 +190,11 @@ pub(crate) fn cu_device_total_mem_v2(bytes: *mut usize, dev: CUdevice) -> Result pub(crate) fn cu_driver_get_version(driverVersion: *mut ::core::ffi::c_int) -> Result<(), CUerror> { let driverVersion = unsafe { driverVersion.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - let mut server = ipc::Server::get()?.lock().map_err(|_| CUerror::UNKNOWN)?; - let output = server.call::>( + *driverVersion = ipc::Server::remote_call::( Opcode::cuDriverGetVersion, - &cuDriverGetVersionIn {}, - )?; - output.result()?; - *driverVersion = CudaEncode::decode(output.data.driverVersion); + cuDriverGetVersionIn {}, + )? + .driverVersion; Ok(()) } diff --git a/zluda64_server/Cargo.toml b/zluda64_server/Cargo.toml index d351226dc..f47111bdc 100644 --- a/zluda64_server/Cargo.toml +++ b/zluda64_server/Cargo.toml @@ -9,11 +9,13 @@ name = "zluda64_server" path = "src/main.rs" [dependencies] +cuda_types = { path = "../cuda_types" } zluda_server_common = { path = "../zluda_server_common" } windows-sys = { version = "0.61.2", features = ["Win32_Foundation"] } compio = { version = "0.18.0", features = ["macros", "fs"] } slab = "0.4.12" bincode = "2.0.1" +rkyv = "0.8.15" [package.metadata.zluda] windows_only = true diff --git a/zluda64_server/src/main.rs b/zluda64_server/src/main.rs index 182274596..fc90cd477 100644 --- a/zluda64_server/src/main.rs +++ b/zluda64_server/src/main.rs @@ -1,10 +1,16 @@ +use std::mem; + use compio::{ + buf::{IoBuf, IoBufMut, ReserveError, ReserveExactError, SetLen}, fs::named_pipe::ClientOptions, - io::{AsyncRead, AsyncReadExt, AsyncWriteExt}, + io::{AsyncRead, AsyncReadExt, AsyncReadManaged, AsyncWriteExt}, BufResult, }; +use cuda_types::cuda::*; +use rkyv::util::AlignedVec; use slab::Slab; use windows_sys::Win32::Foundation::ERROR_MORE_DATA; +use zluda_server_common::*; struct State { handles: Slab, @@ -22,20 +28,85 @@ async fn main() -> std::io::Result<()> { .write(true) .open(pipe_name) .await?; - let mut buffer = vec![0u8; 128 * 1024]; + let mut buffer = AlignedVecBuffer(AlignedVec::new()); loop { - let opcode = client.read_u32_le().await?; // Read the length prefix - client.read_managed(buffer_pool, len) + let opcode = client.read_u32().await?; // Read the length prefix + buffer.clear(); + match Opcode::from_repr(opcode) { + Some(Opcode::cuInit) => { + let mut remaining_read = mem::size_of::(); + buffer.reserve(remaining_read)?; + while remaining_read > 0 { + let BufResult(read_result, new_buffer) = client.append(buffer).await; + let n = read_result?; + remaining_read = remaining_read.checked_sub(n).ok_or_else(|| { + std::io::Error::new( + std::io::ErrorKind::InvalidData, + "Read more bytes than expected", + ) + })?; + buffer = new_buffer; + } + let input = unsafe { rkyv::access_unchecked::(buffer.as_init()) }; + println!("cuInit({:?})", input.Flags); + } + _ => { + client.write_u32(CUerror::NOT_SUPPORTED.0.get()).await?; + return Err(std::io::Error::new( + std::io::ErrorKind::Other, + "Unsupported operation", + )); + } + } } Ok(()) } -struct PipeReader { - client: compio::fs::named_pipe::NamedPipeClient, +struct AlignedVecBuffer(AlignedVec); + +impl AlignedVecBuffer { + fn clear(&mut self) { + self.0.clear(); + } +} + +impl IoBuf for AlignedVecBuffer { + fn as_init(&self) -> &[u8] { + self.0.as_slice() + } } -impl bincode::de::read::Reader for PipeReader { - fn read(&mut self, bytes: &mut [u8]) -> Result<(), bincode::error::DecodeError> { - self.client.read_exact(bytes) +impl SetLen for AlignedVecBuffer { + unsafe fn set_len(&mut self, len: usize) { + unsafe { self.0.set_len(len) } + } +} + +impl IoBufMut for AlignedVecBuffer { + fn as_uninit(&mut self) -> &mut [std::mem::MaybeUninit] { + let ptr = self.0.as_mut_ptr() as *mut std::mem::MaybeUninit; + let cap = self.0.capacity(); + unsafe { std::slice::from_raw_parts_mut(ptr, cap) } + } + + fn reserve(&mut self, len: usize) -> Result<(), ReserveError> { + self.0.reserve(len); + Ok(()) + } + + fn reserve_exact(&mut self, len: usize) -> Result<(), ReserveExactError> { + if self.0.capacity() - self.0.len() >= len { + return Ok(()); + } + + self.0.reserve_exact(len); + + if self.0.capacity() - self.0.len() != len { + return Err(ReserveExactError::ExactSizeMismatch { + reserved: self.0.capacity() - self.0.len(), + expected: len, + }); + } + Ok(()) } } diff --git a/zluda_server_common/Cargo.toml b/zluda_server_common/Cargo.toml index cf501886d..21d395b4f 100644 --- a/zluda_server_common/Cargo.toml +++ b/zluda_server_common/Cargo.toml @@ -11,3 +11,6 @@ bitcode = "0.6.9" paste = "1" postcard = "1.1.3" bincode = "2.0.1" +rkyv = "0.8.15" +strum = "0.28" +strum_macros = "0.28" diff --git a/zluda_server_common/src/lib.rs b/zluda_server_common/src/lib.rs index 3e16cf29d..f39292522 100644 --- a/zluda_server_common/src/lib.rs +++ b/zluda_server_common/src/lib.rs @@ -2,21 +2,26 @@ use bincode::{Decode, Encode}; use cuda_macros::{cuda_function_declarations, generate_input_struct, generate_output_struct}; use cuda_types::cuda::*; use paste::paste; +use rkyv::{rend, Archive, Deserialize, Portable, Serialize}; use std::ffi::CString; use std::num::NonZeroU32; use std::{ffi::CStr, num::NonZero}; +use strum_macros::FromRepr; -#[derive(Encode, Decode, PartialEq, Debug)] +#[derive(Archive, Deserialize, Serialize, Debug, PartialEq)] +#[repr(C)] pub struct Envelope { pub code: u32, pub data: T, } +unsafe impl Portable for Envelope {} + impl Envelope { pub fn result(&self) -> Result<(), CUerror> { match NonZeroU32::new(self.code) { - Some(code) => Err(CUerror(code)), None => Ok(()), + Some(code) => Err(CUerror(code)), } } } @@ -33,6 +38,7 @@ macro_rules! generate_messages { )* #[repr(u32)] + #[derive(FromRepr)] pub enum Opcode { System = 0, $( @@ -171,7 +177,7 @@ encode_as_u32!(CUstream); encode_as_u32!(CUtexref); #[repr(C)] -#[derive(Encode, Decode, PartialEq, Debug)] +#[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] pub struct CUdevprop_v1_Wire { pub maxThreadsPerBlock: ::core::ffi::c_int, pub maxThreadsDim: [::core::ffi::c_int; 3usize], @@ -185,7 +191,10 @@ pub struct CUdevprop_v1_Wire { pub textureAlign: ::core::ffi::c_int, } -#[derive(Encode, Decode, PartialEq)] +unsafe impl Portable for CUdevprop_v1_Wire {} + +#[derive(Archive, Deserialize, Serialize, Debug, PartialEq)] +#[repr(C)] pub struct Foobar { pub text: String, pub buff: Vec, From a6b66ec4963f98a502924d5c75066d2bbe4f937f Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Sat, 18 Apr 2026 01:20:44 -0700 Subject: [PATCH 07/85] work in progress --- Cargo.lock | 2 + zluda32/Cargo.toml | 1 + zluda32/src/ipc.rs | 35 ++++---- zluda64_server/Cargo.toml | 1 + zluda64_server/src/main.rs | 166 ++++++++++++++++++++++++++++++++----- zluda_inject/Cargo.toml | 1 - zluda_inject/src/bin.rs | 22 +---- zluda_windows/src/lib.rs | 34 ++++++-- 8 files changed, 199 insertions(+), 63 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 2726b00a3..d811d1335 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -5638,6 +5638,7 @@ dependencies = [ "widestring", "windows 0.62.2", "zluda_server_common", + "zluda_windows", ] [[package]] @@ -5646,6 +5647,7 @@ version = "0.0.0" dependencies = [ "bincode", "compio", + "cuda_macros", "cuda_types", "rkyv", "slab", diff --git a/zluda32/Cargo.toml b/zluda32/Cargo.toml index 7b49ec111..be256a5e0 100644 --- a/zluda32/Cargo.toml +++ b/zluda32/Cargo.toml @@ -11,6 +11,7 @@ crate-type = ["cdylib"] [dependencies] cuda_types = { path = "../cuda_types" } cuda_macros = { path = "../cuda_macros" } +zluda_windows = { path = "../zluda_windows" } zluda_server_common = { path = "../zluda_server_common" } paste = "1.0" ipc-channel = "^0.21.0" diff --git a/zluda32/src/ipc.rs b/zluda32/src/ipc.rs index 131beb6e8..c1603b8f1 100644 --- a/zluda32/src/ipc.rs +++ b/zluda32/src/ipc.rs @@ -6,7 +6,7 @@ use rkyv::ser::allocator::ArenaHandle; use rkyv::util::AlignedVec; use rkyv::{rancor, Portable, Serialize}; use std::io::{Read, Write}; -use std::os::windows::io::{AsRawHandle, FromRawHandle}; +use std::os::windows::io::{AsHandle, AsRawHandle, FromRawHandle}; // use rkyv::util::AlignedVec; use std::num::NonZeroU32; use std::process::{Child, Command, Stdio}; @@ -29,8 +29,7 @@ fn server_path() -> &'static str { pub(crate) struct Server { pipe: std::fs::File, _child: Child, - in_buffer: AlignedVec, - out_buffer: AlignedVec, + buffer: AlignedVec, } unsafe impl Sync for Server {} @@ -41,8 +40,7 @@ impl Server { Self { pipe, _child: child, - in_buffer: AlignedVec::new(), - out_buffer: AlignedVec::new(), + buffer: AlignedVec::new(), } } @@ -68,6 +66,7 @@ impl Server { .stdout(Stdio::null()) .stderr(Stdio::null()) .spawn()?; + zluda_windows::kill_child_on_process_exit(child.as_handle().as_raw_handle())?; match ConnectNamedPipe(HANDLE(pipe.as_raw_handle()), None) { Ok(_) => Ok(Server::new(pipe, child)), Err(e) if e.code() == ERROR_PIPE_CONNECTED.into() => Ok(Server::new(pipe, child)), @@ -89,22 +88,30 @@ impl Server { >, ) -> Result { let this = &mut *Self::get()?.lock().map_err(|_| CUerror::UNKNOWN)?; - this.in_buffer.clear(); + this.buffer.clear(); let slice = rkyv::api::high::to_bytes_in::<_, rkyv::rancor::Failure>( &Envelope { code: opcode as u32, data, }, - &mut this.in_buffer, + &mut this.buffer, ) .map_err(|_| CUerror::UNKNOWN)?; this.pipe.write_all(&slice).map_err(|_| CUerror::UNKNOWN)?; - this.out_buffer.resize(mem::size_of::>(), 0); - this.pipe - .read_exact(&mut this.out_buffer) - .map_err(|_| CUerror::UNKNOWN)?; - let bytes = unsafe { rkyv::access_unchecked::>(&this.out_buffer) }; - bytes.result()?; - Ok(bytes.data.clone()) + read_return_code(this)?; + let output = unsafe { rkyv::access_unchecked::(&this.buffer) }; + Ok(output.clone()) + } +} + +fn read_return_code(this: &mut Server) -> Result<(), CUerror> { + let mut code_buffer = [0; 4]; + this.pipe + .read_exact(&mut code_buffer) + .map_err(|_| CUerror::UNKNOWN)?; + let code = u32::from_le_bytes(code_buffer); + match NonZeroU32::new(code) { + None => Ok(()), + Some(code) => Err(CUerror(code)), } } diff --git a/zluda64_server/Cargo.toml b/zluda64_server/Cargo.toml index f47111bdc..04d91290e 100644 --- a/zluda64_server/Cargo.toml +++ b/zluda64_server/Cargo.toml @@ -10,6 +10,7 @@ path = "src/main.rs" [dependencies] cuda_types = { path = "../cuda_types" } +cuda_macros = { path = "../cuda_macros" } zluda_server_common = { path = "../zluda_server_common" } windows-sys = { version = "0.61.2", features = ["Win32_Foundation"] } compio = { version = "0.18.0", features = ["macros", "fs"] } diff --git a/zluda64_server/src/main.rs b/zluda64_server/src/main.rs index fc90cd477..22e21425f 100644 --- a/zluda64_server/src/main.rs +++ b/zluda64_server/src/main.rs @@ -1,14 +1,20 @@ -use std::mem; +// Prevent the console window from appearing when running the server on Windows +#![windows_subsystem = "windows"] use compio::{ buf::{IoBuf, IoBufMut, ReserveError, ReserveExactError, SetLen}, - fs::named_pipe::ClientOptions, - io::{AsyncRead, AsyncReadExt, AsyncReadManaged, AsyncWriteExt}, + fs::named_pipe::{ClientOptions, NamedPipeClient}, + io::{AsyncRead, AsyncReadExt, AsyncReadManaged, AsyncWrite, AsyncWriteExt}, BufResult, }; +use cuda_macros::cuda_function_declarations; use cuda_types::cuda::*; -use rkyv::util::AlignedVec; +use rkyv::{ + api::high::HighSerializer, ser::allocator::ArenaHandle, util::AlignedVec, Archive, Portable, + Serialize, +}; use slab::Slab; +use std::mem; use windows_sys::Win32::Foundation::ERROR_MORE_DATA; use zluda_server_common::*; @@ -30,28 +36,19 @@ async fn main() -> std::io::Result<()> { .await?; let mut buffer = AlignedVecBuffer(AlignedVec::new()); loop { - let opcode = client.read_u32().await?; // Read the length prefix + let opcode = client.read_u32_le().await?; // Read the length prefix buffer.clear(); match Opcode::from_repr(opcode) { Some(Opcode::cuInit) => { - let mut remaining_read = mem::size_of::(); - buffer.reserve(remaining_read)?; - while remaining_read > 0 { - let BufResult(read_result, new_buffer) = client.append(buffer).await; - let n = read_result?; - remaining_read = remaining_read.checked_sub(n).ok_or_else(|| { - std::io::Error::new( - std::io::ErrorKind::InvalidData, - "Read more bytes than expected", - ) - })?; - buffer = new_buffer; - } - let input = unsafe { rkyv::access_unchecked::(buffer.as_init()) }; - println!("cuInit({:?})", input.Flags); + buffer = handle_cuda_function::( + &mut client, + buffer, + cu_init, + ) + .await?; } _ => { - client.write_u32(CUerror::NOT_SUPPORTED.0.get()).await?; + client.write_u32_le(CUerror::NOT_SUPPORTED.0.get()).await?; return Err(std::io::Error::new( std::io::ErrorKind::Other, "Unsupported operation", @@ -59,7 +56,68 @@ async fn main() -> std::io::Result<()> { } } } - Ok(()) +} + +fn cu_init(input: &ArchivedcuInitIn) -> Result { + unsafe { cuInit(input.Flags.to_native()) }?; + Ok(cuInitOut {}) +} + +async fn handle_cuda_function( + client: &mut NamedPipeClient, + mut buffer: AlignedVecBuffer, + handler: impl FnOnce(&In) -> Result, +) -> std::io::Result +where + Out: for<'a, 'b> Serialize< + HighSerializer<&'a mut AlignedVec, ArenaHandle<'b>, rkyv::rancor::Failure>, + >, +{ + buffer = read_all::(buffer, client).await?; + let input = unsafe { rkyv::access_unchecked::(buffer.as_init()) }; + match handler(input) { + Ok(output) => { + buffer.clear(); + rkyv::api::high::to_bytes_in::<_, rkyv::rancor::Failure>( + &Envelope { + code: 0, + data: output, + }, + &mut buffer.0, + ) + .map_err(|_| { + std::io::Error::new(std::io::ErrorKind::Other, "Failed to serialize response") + })?; + let BufResult(result, new_buffer) = client.write_all(buffer).await; + result?; + Ok(new_buffer) + } + Err(e) => { + buffer.clear(); + client.write_u32_le(e.0.get()).await?; + Ok(buffer) + } + } +} + +async fn read_all( + mut buffer: AlignedVecBuffer, + client: &mut NamedPipeClient, +) -> std::io::Result { + let mut remaining_read = mem::size_of::(); + buffer.reserve(remaining_read)?; + while remaining_read > 0 { + let BufResult(read_result, new_buffer) = client.append(buffer).await; + let n = read_result?; + remaining_read = remaining_read.checked_sub(n).ok_or_else(|| { + std::io::Error::new( + std::io::ErrorKind::InvalidData, + "Read more bytes than expected", + ) + })?; + buffer = new_buffer; + } + Ok(buffer) } struct AlignedVecBuffer(AlignedVec); @@ -110,3 +168,67 @@ impl IoBufMut for AlignedVecBuffer { Ok(()) } } + +macro_rules! nop { + ($($abi:literal fn $fn_name:ident( $($arg_id:ident : $arg_type:ty),* ) -> $ret_type:ty;)*) => {}; +} + +macro_rules! implemented { + ($($abi:literal fn $fn_name:ident( $($arg_id:ident : $arg_type:ty),* ) -> $ret_type:ty;)*) => { + $( + #[link(name = "nvcuda", kind = "raw-dylib")] + unsafe extern $abi { + fn $fn_name ( $( $arg_id : $arg_type),* ) -> $ret_type; + } + )* + + }; +} + +cuda_function_declarations! { + nop, + implemented <= [ + // cuCtxCreate_v2, + // cuCtxDetach, + // cuCtxGetApiVersion, + // cuCtxGetCurrent, + // cuCtxGetDevice, + // cuCtxSynchronize, + // cuDeviceComputeCapability, + // cuDeviceGet, + // cuDeviceGetAttribute, + // cuDeviceGetCount, + // cuDeviceGetName, + // cuDeviceGetProperties, + // cuDeviceTotalMem_v2, + // cuDriverGetVersion, + // cuEventCreate, + // cuEventDestroy_v2, + // cuGetExportTable, + cuInit, + // cuLaunchKernel, + // cuMemAlloc_v2, + // cuMemFreeHost, + // cuMemFree_v2, + // cuMemGetAddressRange_v2, + // cuMemHostAlloc, + // cuMemcpyDtoDAsync_v2, + // cuMemcpyDtoHAsync_v2, + // cuMemcpyHtoDAsync_v2, + // cuMemsetD8_v2, + // cuModuleGetFunction, + // cuModuleGetGlobal_v2, + // cuModuleGetTexRef, + // cuStreamCreate, + // cuStreamDestroy_v2, + // cuTexRefSetAddressMode, + // cuTexRefSetAddress_v2, + // cuTexRefSetFilterMode, + // cuTexRefSetFlags, + // cuTexRefSetFormat, + // cuTexRefSetMaxAnisotropy, + // cuTexRefSetMipmapFilterMode, + // cuTexRefSetMipmapLevelBias, + // cuTexRefSetMipmapLevelClamp, + ] +} diff --git a/zluda_inject/Cargo.toml b/zluda_inject/Cargo.toml index ca4ff1312..a8bd44775 100644 --- a/zluda_inject/Cargo.toml +++ b/zluda_inject/Cargo.toml @@ -13,7 +13,6 @@ windows = { version = "0.62.2", features = [ "Win32_Foundation", "Win32_System_Threading", "Win32_Security", - "Win32_System_JobObjects", "Win32_System_Diagnostics_Debug", "Win32_System_LibraryLoader", ] } diff --git a/zluda_inject/src/bin.rs b/zluda_inject/src/bin.rs index a75ee40f6..dd571fbe1 100644 --- a/zluda_inject/src/bin.rs +++ b/zluda_inject/src/bin.rs @@ -7,10 +7,6 @@ use std::ffi::{CString, OsStr}; use std::path::PathBuf; use std::{env, mem, process, ptr}; use windows::Win32::Foundation::{HANDLE, WAIT_FAILED}; -use windows::Win32::System::JobObjects::{ - AssignProcessToJobObject, JobObjectExtendedLimitInformation, SetInformationJobObject, - JOBOBJECT_EXTENDED_LIMIT_INFORMATION, JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE, -}; use windows::Win32::System::Threading::{ self, GetExitCodeProcess, ResumeThread, WaitForSingleObject, CREATE_SUSPENDED, CREATE_UNICODE_ENVIRONMENT, @@ -69,7 +65,7 @@ pub fn main_impl() -> Result<(), Box> { Option::None ) }; - kill_child_on_process_exit(proc_info.hProcess)?; + zluda_windows::kill_child_on_process_exit(proc_info.hProcess)?; injection_env.copy_payloads_to_process(proc_info.hProcess)?; os_call! { ResumeThread(HANDLE(proc_info.hThread)), |x| x == -1i32 as u32 }; os_call! { WaitForSingleObject(HANDLE(proc_info.hProcess), Threading::INFINITE), |x| x == WAIT_FAILED }; @@ -338,19 +334,3 @@ impl InjectionConfig { Ok(result.into_vec()) } } - -fn kill_child_on_process_exit(child: detours_sys::HANDLE) -> Result<(), Box> { - let job_handle = unsafe { windows::Win32::System::JobObjects::CreateJobObjectA(None, None) }?; - let mut info = JOBOBJECT_EXTENDED_LIMIT_INFORMATION::default(); - info.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE; - unsafe { - SetInformationJobObject( - job_handle, - JobObjectExtendedLimitInformation, - &mut info as *mut _ as *mut _, - size_of_val(&info) as u32, - ) - }?; - unsafe { AssignProcessToJobObject(job_handle, HANDLE(child)) }?; - Ok(()) -} diff --git a/zluda_windows/src/lib.rs b/zluda_windows/src/lib.rs index f48ffa2a2..e63001c31 100644 --- a/zluda_windows/src/lib.rs +++ b/zluda_windows/src/lib.rs @@ -13,11 +13,19 @@ use widestring::{u16str, U16Str, U16String}; use windows::{ core::{w, HRESULT, PCWSTR}, Win32::{ - Foundation::{HINSTANCE, HMODULE, HWND, LPARAM, S_OK, WPARAM}, - System::LibraryLoader::{ - GetModuleFileNameA, GetModuleFileNameW, GetModuleHandleExW, LoadLibraryExW, - GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, - LOAD_LIBRARY_SEARCH_DEFAULT_DIRS, LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR, + Foundation::{HANDLE, HINSTANCE, HMODULE, HWND, LPARAM, S_OK, WPARAM}, + System::{ + JobObjects::{ + AssignProcessToJobObject, JobObjectExtendedLimitInformation, + SetInformationJobObject, JOBOBJECT_EXTENDED_LIMIT_INFORMATION, + JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE, + }, + LibraryLoader::{ + GetModuleFileNameA, GetModuleFileNameW, GetModuleHandleExW, LoadLibraryExW, + GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, + GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, LOAD_LIBRARY_SEARCH_DEFAULT_DIRS, + LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR, + }, }, UI::{ Controls::{ @@ -587,6 +595,22 @@ pub fn get_module_path_utf16(hm: HMODULE) -> OsString { OsString::from_wide(&buffer) } +pub fn kill_child_on_process_exit(child: *mut c_void) -> windows::core::Result<()> { + let job_handle = unsafe { windows::Win32::System::JobObjects::CreateJobObjectA(None, None) }?; + let mut info = JOBOBJECT_EXTENDED_LIMIT_INFORMATION::default(); + info.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE; + unsafe { + SetInformationJobObject( + job_handle, + JobObjectExtendedLimitInformation, + &mut info as *mut _ as *mut _, + size_of_val(&info) as u32, + ) + }?; + unsafe { AssignProcessToJobObject(job_handle, HANDLE(child)) }?; + Ok(()) +} + #[cfg(test)] mod tests { use super::*; From fc166b19cc17277080eabc6b4392ae1fc350bbde Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Sun, 19 Apr 2026 21:59:56 -0700 Subject: [PATCH 08/85] Add tracer for nvapi64 --- Cargo.lock | 15 +++++++++++++++ Cargo.toml | 1 + nvapi_trace/Cargo.toml | 23 +++++++++++++++++++++++ nvapi_trace/src/lib.rs | 42 ++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 81 insertions(+) create mode 100644 nvapi_trace/Cargo.toml create mode 100644 nvapi_trace/src/lib.rs diff --git a/Cargo.lock b/Cargo.lock index af6f42172..6830cee5d 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2828,6 +2828,21 @@ dependencies = [ "libc", ] +[[package]] +name = "nvapi_trace" +version = "0.0.0" +dependencies = [ + "cglue", + "cuda_macros", + "cuda_types", + "dark_api", + "format", + "libloading", + "paste", + "unwrap_or", + "zluda_trace_common", +] + [[package]] name = "object" version = "0.38.1" diff --git a/Cargo.toml b/Cargo.toml index d199126eb..482c3f99f 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -16,6 +16,7 @@ members = [ "ext/rocblas-sys", "format", "kernel_metadata", + "nvapi_trace", "ptx_parser_macros_impl", "ptx_parser_macros", "ptx_parser", diff --git a/nvapi_trace/Cargo.toml b/nvapi_trace/Cargo.toml new file mode 100644 index 000000000..2d45caa16 --- /dev/null +++ b/nvapi_trace/Cargo.toml @@ -0,0 +1,23 @@ +[package] +name = "nvapi_trace" +version = "0.0.0" +authors = ["Andrzej Janik "] +edition = "2021" + +[lib] +name = "nvapi_trace" +crate-type = ["cdylib"] + +[dependencies] +format = { path = "../format" } +dark_api = { path = "../dark_api" } +cuda_macros = { path = "../cuda_macros" } +cuda_types = { path = "../cuda_types" } +zluda_trace_common = { path = "../zluda_trace_common" } +libloading = "0.8" +paste = "1.0" +unwrap_or = "1.0.1" +cglue = "0.3.5" + +[package.metadata.zluda] +windows_paths = ["trace/nvapi64.dll"] diff --git a/nvapi_trace/src/lib.rs b/nvapi_trace/src/lib.rs new file mode 100644 index 000000000..978d5c287 --- /dev/null +++ b/nvapi_trace/src/lib.rs @@ -0,0 +1,42 @@ +use libloading::Library; +use std::{ffi::c_void, ptr, sync::LazyLock}; +use zluda_trace_common::ReprUsize; + +static LIBRARY: LazyLock> = LazyLock::new(get_library); + +fn get_library() -> Option { + let cuda_lib = std::env::var("ZLUDA_NVAPI_LIB") + .ok() + .unwrap_or_else(|| r"C:\Windows\System32\nvapi64.dll".to_string()); + zluda_trace_common::dlopen_local_noredirect(cuda_lib).ok() +} + +#[no_mangle] +pub unsafe extern "C" fn nvapi_QueryInterface(interface: u32) -> *mut c_void { + let maybe_fn_ptr = (&*LIBRARY).as_ref().and_then(|lib| { + lib.get:: *mut c_void>(b"nvapi_QueryInterface\0") + .ok() + }); + let fn_ptr = unwrap_or::unwrap_some_or!(maybe_fn_ptr, return ptr::null_mut()); + let export_table = unwrap_or::unwrap_some_or!( + ::zluda_trace_common::get_export_table(), + return ptr::null_mut() + ); + let format_args = dark_api::FnFfiWrapper(|| { + use std::io::Write; + let mut writer = Vec::new(); + write!(&mut writer, "interface: {}", interface).ok(); + dark_api::ByteVecFfi::new(writer) + }); + let underlying_fn = dark_api::FnFfiWrapper(|| { + let result = fn_ptr(interface); + result as usize + }); + ReprUsize::from_usize(export_table.logged_call( + cglue::slice::CSliceRef::from_str("nvapi_QueryInterface"), + cglue::trait_obj!(&format_args as dark_api::FnFfi), + cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), + ptr::null_mut::() as usize, + <*mut c_void as ReprUsize>::format_status, + )) +} From b036dc9a832e92a9345010b2739e9dff8ade9b71 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Sun, 19 Apr 2026 22:41:34 -0700 Subject: [PATCH 09/85] Fix nvapi tracing --- nvapi_trace/Cargo.toml | 3 +++ nvapi_trace/src/lib.rs | 12 ++++++++---- xtask/src/main.rs | 23 +++++++++++++++++++---- zluda_windows/src/lib.rs | 22 +++++++++++++++++++--- 4 files changed, 49 insertions(+), 11 deletions(-) diff --git a/nvapi_trace/Cargo.toml b/nvapi_trace/Cargo.toml index 2d45caa16..6b4a32885 100644 --- a/nvapi_trace/Cargo.toml +++ b/nvapi_trace/Cargo.toml @@ -20,4 +20,7 @@ unwrap_or = "1.0.1" cglue = "0.3.5" [package.metadata.zluda] +windows_only = true windows_paths = ["trace/nvapi64.dll"] +windows32_paths = ["trace/nvapi.dll"] +32bit = true diff --git a/nvapi_trace/src/lib.rs b/nvapi_trace/src/lib.rs index 978d5c287..4e1afb1e4 100644 --- a/nvapi_trace/src/lib.rs +++ b/nvapi_trace/src/lib.rs @@ -5,9 +5,13 @@ use zluda_trace_common::ReprUsize; static LIBRARY: LazyLock> = LazyLock::new(get_library); fn get_library() -> Option { - let cuda_lib = std::env::var("ZLUDA_NVAPI_LIB") - .ok() - .unwrap_or_else(|| r"C:\Windows\System32\nvapi64.dll".to_string()); + let cuda_lib = std::env::var("ZLUDA_NVAPI_LIB").ok().unwrap_or_else(|| { + if cfg!(target_pointer_width = "64") { + r"C:\Windows\System32\nvapi64.dll".to_string() + } else { + r"C:\Windows\System32\nvapi.dll".to_string() + } + }); zluda_trace_common::dlopen_local_noredirect(cuda_lib).ok() } @@ -25,7 +29,7 @@ pub unsafe extern "C" fn nvapi_QueryInterface(interface: u32) -> *mut c_void { let format_args = dark_api::FnFfiWrapper(|| { use std::io::Write; let mut writer = Vec::new(); - write!(&mut writer, "interface: {}", interface).ok(); + write!(&mut writer, "(interface: {:#010x})", interface).ok(); dark_api::ByteVecFfi::new(writer) }); let underlying_fn = dark_api::FnFfiWrapper(|| { diff --git a/xtask/src/main.rs b/xtask/src/main.rs index 2fd2aa07c..012e792b4 100644 --- a/xtask/src/main.rs +++ b/xtask/src/main.rs @@ -44,6 +44,7 @@ struct Cargo { } struct Project { + is_32bit: bool, #[cfg_attr(unix, allow(unused))] manifest_path: PathBuf, name: String, @@ -53,7 +54,7 @@ struct Project { } impl Project { - fn try_new(p: Package) -> Option { + fn try_new(p: Package, is_32bit: bool) -> Option { let name = p.name; let manifest_path = p.manifest_path.into(); serde_json::from_value::>(p.metadata) @@ -78,13 +79,14 @@ impl Project { target_name, target_kind, meta: m.zluda, + is_32bit, } }) } #[cfg(windows)] fn zip_compiler_output(&self) -> bool { - self.meta.windows_paths.is_empty() + self.meta.windows_paths(self.is_32bit).is_empty() } #[cfg(unix)] @@ -148,7 +150,7 @@ impl Project { target_dir, profile, libname, - self.meta.windows_paths.as_slice(), + self.meta.windows_paths(self.is_32bit).as_slice(), ) .map(move |(.., full_path, target)| { let copy_output = full_path.clone(); @@ -255,9 +257,22 @@ struct ZludaMetadata { windows_paths: Vec, #[serde(default)] #[cfg_attr(unix, allow(unused))] + windows32_paths: Vec, + #[serde(default)] + #[cfg_attr(unix, allow(unused))] windows_extra_files: HashMap, } +impl ZludaMetadata { + fn windows_paths(&self, is_32bit: bool) -> &Vec { + if is_32bit && !self.windows32_paths.is_empty() { + &self.windows32_paths + } else { + &self.windows_paths + } + } +} + fn always_true() -> bool { true } @@ -291,7 +306,7 @@ fn compile(b: Build) -> (PathBuf, String, Vec) { let projects = meta .packages .into_iter() - .filter_map(Project::try_new) + .filter_map(|pkg| Project::try_new(pkg, cargo_flags.is_32bit)) .filter(|project| { if cargo_flags.is_32bit { if !project.meta.is_32bit { diff --git a/zluda_windows/src/lib.rs b/zluda_windows/src/lib.rs index e63001c31..26ba82846 100644 --- a/zluda_windows/src/lib.rs +++ b/zluda_windows/src/lib.rs @@ -39,12 +39,12 @@ use windows::{ }; #[cfg(target_pointer_width = "32")] -pub static LIBRARIES: [LibraryInfo; 1] = [NVCUDA]; +pub static LIBRARIES: [LibraryInfo; 2] = [NVCUDA, NVAPI]; #[cfg(target_pointer_width = "64")] -pub static LIBRARIES: [LibraryInfo; 16] = [ +pub static LIBRARIES: [LibraryInfo; 17] = [ NVCUDA, NVML, DNN8, DNN9, BLAS13, BLAS12, BLAS11, BLAS_LT13, BLAS_LT12, BLAS_LT11, SPARSE12, - SPARSE11, SPARSE10, FFT12, FFT11, FFT10, + SPARSE11, SPARSE10, FFT12, FFT11, FFT10, NVAPI, ]; pub const NVCUDA: LibraryInfo = LibraryInfo { @@ -207,6 +207,22 @@ pub const FFT10: LibraryInfo = LibraryInfo { in_system32: false, }; +pub const NVAPI: LibraryInfo = LibraryInfo { + short_name: "nvapi", + is_alias: false, + #[cfg(target_pointer_width = "32")] + ascii_name: "nvapi.dll", + #[cfg(target_pointer_width = "64")] + ascii_name: "nvapi64.dll", + #[cfg(target_pointer_width = "32")] + utf16_name: u16str!("nvapi.dll"), + #[cfg(target_pointer_width = "64")] + utf16_name: u16str!("nvapi64.dll"), + guid: uuid!("f7449ed6-d01c-4376-9fc4-446eb2e4cf70"), + trace_env_var: "ZLUDA_NVAPI_LIB", + in_system32: true, +}; + #[derive(Debug)] pub struct LibraryInfo { pub short_name: &'static str, From 586c1c628b3f5011ed766ba64e3eae3e1fa35a7e Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Sun, 19 Apr 2026 23:11:13 -0700 Subject: [PATCH 10/85] Print nvapi name --- nvapi_trace/src/lib.rs | 537 ++++++++++++++++++++++++++++++++++++++++- 1 file changed, 536 insertions(+), 1 deletion(-) diff --git a/nvapi_trace/src/lib.rs b/nvapi_trace/src/lib.rs index 4e1afb1e4..f264b70b3 100644 --- a/nvapi_trace/src/lib.rs +++ b/nvapi_trace/src/lib.rs @@ -15,6 +15,537 @@ fn get_library() -> Option { zluda_trace_common::dlopen_local_noredirect(cuda_lib).ok() } +macro_rules! interface_to_name { + ($({ $name:literal, $id:literal }),* $(,)?) => { + fn interface_to_name(interface: u32) -> Option<&'static str> { + match interface { + $( + $id => Some($name), + )* + _ => None, + } + } + }; +} + +interface_to_name!( + { "NvAPI_Initialize", 0x0150e828 }, + { "NvAPI_Unload", 0xd22bdd7e }, + { "NvAPI_GetErrorMessage", 0x6c2d048c }, + { "NvAPI_GetInterfaceVersionString", 0x01053fa5 }, + { "NvAPI_GPU_GetEDID", 0x37d32e69 }, + { "NvAPI_SetView", 0x0957d7b6 }, + { "NvAPI_SetViewEx", 0x06b89e68 }, + { "NvAPI_GetDisplayDriverVersion", 0xf951a4d1 }, + { "NvAPI_SYS_GetDriverAndBranchVersion", 0x2926aaad }, + { "NvAPI_GPU_GetMemoryInfo", 0x07f9b368 }, + { "NvAPI_GPU_GetMemoryInfoEx", 0xc0599498 }, + { "NvAPI_OGL_ExpertModeSet", 0x3805ef7a }, + { "NvAPI_OGL_ExpertModeGet", 0x22ed9516 }, + { "NvAPI_OGL_ExpertModeDefaultsSet", 0xb47a657e }, + { "NvAPI_OGL_ExpertModeDefaultsGet", 0xae921f12 }, + { "NvAPI_EnumPhysicalGPUs", 0xe5ac921f }, + { "NvAPI_EnumTCCPhysicalGPUs", 0xd9930b07 }, + { "NvAPI_EnumLogicalGPUs", 0x48b3ea59 }, + { "NvAPI_GetPhysicalGPUsFromDisplay", 0x34ef9506 }, + { "NvAPI_GetPhysicalGPUFromUnAttachedDisplay", 0x5018ed61 }, + { "NvAPI_GetLogicalGPUFromDisplay", 0xee1370cf }, + { "NvAPI_GetLogicalGPUFromPhysicalGPU", 0xadd604d1 }, + { "NvAPI_GetPhysicalGPUsFromLogicalGPU", 0xaea3fa32 }, + { "NvAPI_GetPhysicalGPUFromGPUID", 0x5380ad1a }, + { "NvAPI_GetGPUIDfromPhysicalGPU", 0x6533ea3e }, + { "NvAPI_GPU_GetShaderSubPipeCount", 0x0be17923 }, + { "NvAPI_GPU_GetGpuCoreCount", 0xc7026a87 }, + { "NvAPI_GPU_GetAllOutputs", 0x7d554f8e }, + { "NvAPI_GPU_GetConnectedOutputs", 0x1730bfc9 }, + { "NvAPI_GPU_GetConnectedSLIOutputs", 0x0680de09 }, + { "NvAPI_GPU_GetConnectedDisplayIds", 0x0078dba2 }, + { "NvAPI_GPU_GetAllDisplayIds", 0x785210a2 }, + { "NvAPI_GPU_GetConnectedOutputsWithLidState", 0xcf8caf39 }, + { "NvAPI_GPU_GetConnectedSLIOutputsWithLidState", 0x96043cc7 }, + { "NvAPI_GPU_GetSystemType", 0xbaaabfcc }, + { "NvAPI_GPU_GetActiveOutputs", 0xe3e89b6f }, + { "NvAPI_GPU_SetEDID", 0xe83d6456 }, + { "NvAPI_GPU_GetOutputType", 0x40a505e4 }, + { "NvAPI_GPU_ValidateOutputCombination", 0x34c9c2d4 }, + { "NvAPI_GPU_GetFullName", 0xceee8e9f }, + { "NvAPI_GPU_GetPCIIdentifiers", 0x2ddfb66e }, + { "NvAPI_GPU_GetGPUType", 0xc33baeb1 }, + { "NvAPI_GPU_GetBusType", 0x1bb18724 }, + { "NvAPI_GPU_GetBusId", 0x1be0b8e5 }, + { "NvAPI_GPU_GetBusSlotId", 0x2a0a350f }, + { "NvAPI_GPU_GetIRQ", 0xe4715417 }, + { "NvAPI_GPU_GetVbiosRevision", 0xacc3da0a }, + { "NvAPI_GPU_GetVbiosOEMRevision", 0x2d43fb31 }, + { "NvAPI_GPU_GetVbiosVersionString", 0xa561fd7d }, + { "NvAPI_GPU_GetAGPAperture", 0x6e042794 }, + { "NvAPI_GPU_GetCurrentAGPRate", 0xc74925a0 }, + { "NvAPI_GPU_GetCurrentPCIEDownstreamWidth", 0xd048c3b1 }, + { "NvAPI_GPU_GetPhysicalFrameBufferSize", 0x46fbeb03 }, + { "NvAPI_GPU_GetVirtualFrameBufferSize", 0x5a04b644 }, + { "NvAPI_GPU_GetQuadroStatus", 0xe332fa47 }, + { "NvAPI_GPU_GetBoardInfo", 0x22d54523 }, + { "NvAPI_GPU_GetRamBusWidth", 0x7975c581 }, + { "NvAPI_GPU_GetArchInfo", 0xd8265d24 }, + { "NvAPI_I2CRead", 0x2fde12c5 }, + { "NvAPI_I2CWrite", 0xe812eb07 }, + { "NvAPI_GPU_WorkstationFeatureSetup", 0x6c1f3fe4 }, + { "NvAPI_GPU_WorkstationFeatureQuery", 0x004537df }, + { "NvAPI_GPU_GetHDCPSupportStatus", 0xf089eef5 }, + { "NvAPI_GPU_CudaEnumComputeCapableGpus", 0x5786cc6e }, + { "NvAPI_GPU_GetTachReading", 0x5f608315 }, + { "NvAPI_GPU_GetECCStatusInfo", 0xca1ddaf3 }, + { "NvAPI_GPU_GetECCErrorInfo", 0xc71f85a6 }, + { "NvAPI_GPU_ResetECCErrorInfo", 0xc02eec20 }, + { "NvAPI_GPU_GetECCConfigurationInfo", 0x77a796f3 }, + { "NvAPI_GPU_SetECCConfiguration", 0x1cf639d9 }, + { "NvAPI_GPU_QueryWorkstationFeatureSupport", 0x80b1abb9 }, + { "NvAPI_GPU_SetScanoutIntensity", 0xa57457a4 }, + { "NvAPI_GPU_GetScanoutIntensityState", 0xe81ce836 }, + { "NvAPI_GPU_SetScanoutWarping", 0xb34bab4f }, + { "NvAPI_GPU_GetScanoutWarpingState", 0x6f5435af }, + { "NvAPI_GPU_SetScanoutCompositionParameter", 0xf898247d }, + { "NvAPI_GPU_GetScanoutCompositionParameter", 0x58fe51e6 }, + { "NvAPI_GPU_GetScanoutConfiguration", 0x6a9f5b63 }, + { "NvAPI_GPU_GetScanoutConfigurationEx", 0xe2e1e6f0 }, + { "NvAPI_GPU_GetAdapterIdFromPhysicalGpu", 0x0ff07fde }, + { "NvAPI_GPU_GetVirtualizationInfo", 0x44e022a9 }, + { "NvAPI_GPU_GetLogicalGpuInfo", 0x842b066e }, + { "NvAPI_GPU_GetLicensableFeatures", 0x3fc596aa }, + { "NvAPI_GPU_GetEncoderStatistics", 0xf0a9aeeb }, + { "NvAPI_GPU_GetEncoderSessionsInfo", 0xd8a72ce5 }, + { "NvAPI_GPU_GetGPUInfo", 0xafd1b02c }, + { "NvAPI_GPU_GetVRReadyData", 0x81d629c5 }, + { "NvAPI_GPU_GetGspFeatures", 0x581c4391 }, + { "NvAPI_GPU_GetUUID", 0xdc95673d }, + { "NvAPI_GPU_NVLINK_GetCaps", 0xbef1119d }, + { "NvAPI_GPU_NVLINK_GetStatus", 0xc72a38e3 }, + { "NvAPI_GPU_GetPerfDecreaseInfo", 0x7f7f4600 }, + { "NvAPI_GPU_GetPstatesInfoEx", 0x843c0256 }, + { "NvAPI_GPU_GetPstates20", 0x6ff81213 }, + { "NvAPI_GPU_GetCurrentPstate", 0x927da4f6 }, + { "NvAPI_GPU_GetDynamicPstatesInfoEx", 0x60ded2ed }, + { "NvAPI_GPU_GetThermalSettings", 0xe3640a56 }, + { "NvAPI_GPU_GetAllClockFrequencies", 0xdcb616c3 }, + { "NvAPI_GPU_QueryIlluminationSupport", 0xa629da31 }, + { "NvAPI_GPU_GetIllumination", 0x9a1b9365 }, + { "NvAPI_GPU_SetIllumination", 0x0254a187 }, + { "NvAPI_GPU_ClientIllumDevicesGetInfo", 0xd4100e58 }, + { "NvAPI_GPU_ClientIllumDevicesGetControl", 0x73c01d58 }, + { "NvAPI_GPU_ClientIllumDevicesSetControl", 0x57024c62 }, + { "NvAPI_GPU_ClientIllumZonesGetInfo", 0x4b81241b }, + { "NvAPI_GPU_ClientIllumZonesGetControl", 0x3dbf5764 }, + { "NvAPI_GPU_ClientIllumZonesSetControl", 0x197d065e }, + { "NvAPI_Event_RegisterCallback", 0xe6dbea69 }, + { "NvAPI_Event_UnregisterCallback", 0xde1f9b45 }, + { "NvAPI_EnumNvidiaDisplayHandle", 0x9abdd40d }, + { "NvAPI_EnumNvidiaUnAttachedDisplayHandle", 0x20de9260 }, + { "NvAPI_CreateDisplayFromUnAttachedDisplay", 0x63f9799e }, + { "NvAPI_GetAssociatedNvidiaDisplayHandle", 0x35c29134 }, + { "NvAPI_DISP_GetAssociatedUnAttachedNvidiaDisplayHandle", 0xa70503b2 }, + { "NvAPI_GetAssociatedNvidiaDisplayName", 0x22a78b05 }, + { "NvAPI_GetUnAttachedAssociatedDisplayName", 0x4888d790 }, + { "NvAPI_EnableHWCursor", 0x2863148d }, + { "NvAPI_DisableHWCursor", 0xab163097 }, + { "NvAPI_GetVBlankCounter", 0x67b5db55 }, + { "NvAPI_SetRefreshRateOverride", 0x3092ac32 }, + { "NvAPI_GetAssociatedDisplayOutputId", 0xd995937e }, + { "NvAPI_GetDisplayPortInfo", 0xc64ff367 }, + { "NvAPI_SetDisplayPort", 0xfa13e65a }, + { "NvAPI_GetHDMISupportInfo", 0x6ae16ec3 }, + { "NvAPI_Disp_InfoFrameControl", 0x6067af3f }, + { "NvAPI_Disp_ColorControl", 0x92f9d80d }, + { "NvAPI_Disp_GetHdrCapabilities", 0x84f2a8df }, + { "NvAPI_Disp_HdrColorControl", 0x351da224 }, + { "NvAPI_Disp_SetSourceColorSpace", 0x473b6caf }, + { "NvAPI_Disp_GetSourceColorSpace", 0xceedc85b }, + { "NvAPI_Disp_SetSourceHdrMetadata", 0x905eb63b }, + { "NvAPI_Disp_GetSourceHdrMetadata", 0x0d3f52da }, + { "NvAPI_Disp_SetOutputMode", 0x98e7661a }, + { "NvAPI_Disp_GetOutputMode", 0x81fed88d }, + { "NvAPI_Disp_SetHdrToneMapping", 0xdd6da362 }, + { "NvAPI_Disp_GetHdrToneMapping", 0xfbd36e71 }, + { "NvAPI_Disp_GetColorimetry", 0x00b421ad }, + { "NvAPI_DISP_GetTiming", 0x175167e9 }, + { "NvAPI_DISP_GetMonitorCapabilities", 0x3b05c7e1 }, + { "NvAPI_DISP_GetMonitorColorCapabilities", 0x6ae4cfb5 }, + { "NvAPI_DISP_EnumCustomDisplay", 0xa2072d59 }, + { "NvAPI_DISP_TryCustomDisplay", 0x1f7db630 }, + { "NvAPI_DISP_DeleteCustomDisplay", 0x552e5b9b }, + { "NvAPI_DISP_SaveCustomDisplay", 0x49882876 }, + { "NvAPI_DISP_RevertCustomDisplayTrial", 0xcbbd40f0 }, + { "NvAPI_GetView", 0xd6b99d89 }, + { "NvAPI_GetViewEx", 0xdbbc0af4 }, + { "NvAPI_GetSupportedViews", 0x66fb7fc0 }, + { "NvAPI_DISP_GetDisplayIdByDisplayName", 0xae457190 }, + { "NvAPI_DISP_GetGDIPrimaryDisplayId", 0x1e9d8a31 }, + { "NvAPI_DISP_GetDisplayConfig", 0x11abccf8 }, + { "NvAPI_DISP_SetDisplayConfig", 0x5d8cf8de }, + { "NvAPI_DISP_GetEdidData", 0x436ced76 }, + { "NvAPI_DISP_GetAdaptiveSyncData", 0xb73d1ee9 }, + { "NvAPI_DISP_SetAdaptiveSyncData", 0x3eebba1d }, + { "NvAPI_DISP_GetVirtualRefreshRateData", 0x8c00429a }, + { "NvAPI_DISP_SetVirtualRefreshRateData", 0x5abbe6a3 }, + { "NvAPI_DISP_SetPreferredStereoDisplay", 0xc9d0e25f }, + { "NvAPI_DISP_GetPreferredStereoDisplay", 0x1f6b4666 }, + { "NvAPI_DISP_GetNvManagedDedicatedDisplays", 0xdbdf0cb2 }, + { "NvAPI_DISP_AcquireDedicatedDisplay", 0x47c917ba }, + { "NvAPI_DISP_ReleaseDedicatedDisplay", 0x1247825f }, + { "NvAPI_DISP_GetNvManagedDedicatedDisplayMetadata", 0xd645d80c }, + { "NvAPI_DISP_SetNvManagedDedicatedDisplayMetadata", 0x3d8b129a }, + { "NvAPI_Disp_GetDisplayIdInfo", 0xbae8aa5e }, + { "NvAPI_Disp_GetDisplayIdsFromTarget", 0xe7e5f89e }, + { "NvAPI_Disp_GetVRRInfo", 0xdf8fda57 }, + { "NvAPI_Mosaic_GetSupportedTopoInfo", 0xfdb63c81 }, + { "NvAPI_Mosaic_GetTopoGroup", 0xcb89381d }, + { "NvAPI_Mosaic_GetOverlapLimits", 0x989685f0 }, + { "NvAPI_Mosaic_SetCurrentTopo", 0x9b542831 }, + { "NvAPI_Mosaic_GetCurrentTopo", 0xec32944e }, + { "NvAPI_Mosaic_EnableCurrentTopo", 0x5f1aa66c }, + { "NvAPI_Mosaic_GetDisplayViewportsByResolution", 0xdc6dc8d3 }, + { "NvAPI_Mosaic_SetDisplayGrids", 0x4d959a89 }, + { "NvAPI_Mosaic_ValidateDisplayGrids", 0xcf43903d }, + { "NvAPI_Mosaic_EnumDisplayModes", 0x78db97d7 }, + { "NvAPI_Mosaic_EnumDisplayGrids", 0xdf2887af }, + { "NvAPI_GetSupportedMosaicTopologies", 0x410b5c25 }, + { "NvAPI_GetCurrentMosaicTopology", 0xf60852bd }, + { "NvAPI_SetCurrentMosaicTopology", 0xd54b8989 }, + { "NvAPI_EnableCurrentMosaicTopology", 0x74073cc9 }, + { "NvAPI_GSync_EnumSyncDevices", 0xd9639601 }, + { "NvAPI_GSync_QueryCapabilities", 0x44a3f1d1 }, + { "NvAPI_GSync_GetTopology", 0x4562bc38 }, + { "NvAPI_GSync_SetSyncStateSettings", 0x60acdfdd }, + { "NvAPI_GSync_GetControlParameters", 0x16de1c6a }, + { "NvAPI_GSync_SetControlParameters", 0x8bbff88b }, + { "NvAPI_GSync_AdjustSyncDelay", 0x2d11ff51 }, + { "NvAPI_GSync_GetSyncStatus", 0xf1f5b434 }, + { "NvAPI_GSync_GetStatusParameters", 0x70d404ec }, + { "NvAPI_D3D_GetCurrentSLIState", 0x4b708b54 }, + { "NvAPI_D3D9_RegisterResource", 0xa064bdfc }, + { "NvAPI_D3D9_UnregisterResource", 0xbb2b17aa }, + { "NvAPI_D3D9_AliasSurfaceAsTexture", 0xe5ceae41 }, + { "NvAPI_D3D9_StretchRectEx", 0x22de03aa }, + { "NvAPI_D3D9_ClearRT", 0x332d3942 }, + { "NvAPI_D3D_GetObjectHandleForResource", 0xfceac864 }, + { "NvAPI_D3D_SetResourceHint", 0x6c0ed98c }, + { "NvAPI_D3D_BeginResourceRendering", 0x91123d6a }, + { "NvAPI_D3D_EndResourceRendering", 0x37e7191c }, + { "NvAPI_D3D9_GetSurfaceHandle", 0x0f2dd3f2 }, + { "NvAPI_D3D9_VideoSetStereoInfo", 0xb852f4db }, + { "NvAPI_D3D10_SetDepthBoundsTest", 0x4eadf5d2 }, + { "NvAPI_D3D11_CreateDevice", 0x6a16d3a0 }, + { "NvAPI_D3D11_CreateDeviceAndSwapChain", 0xbb939ee5 }, + { "NvAPI_D3D11_SetDepthBoundsTest", 0x7aaf7a04 }, + { "NvAPI_D3D11_IsNvShaderExtnOpCodeSupported", 0x5f68da40 }, + { "NvAPI_D3D11_SetNvShaderExtnSlot", 0x8e90bb9f }, + { "NvAPI_D3D12_SetNvShaderExtnSlotSpace", 0xac2dfeb5 }, + { "NvAPI_D3D12_SetNvShaderExtnSlotSpaceLocalThread", 0x43d867c0 }, + { "NvAPI_D3D11_SetNvShaderExtnSlotLocalThread", 0x0e6482a0 }, + { "NvAPI_D3D11_BeginUAVOverlapEx", 0xba08208a }, + { "NvAPI_D3D11_BeginUAVOverlap", 0x65b93ca8 }, + { "NvAPI_D3D11_EndUAVOverlap", 0x2216a357 }, + { "NvAPI_D3D11_GetResourceHandle", 0x09d52986 }, + { "NvAPI_D3D_SetFPSIndicatorState", 0xa776e8db }, + { "NvAPI_D3D9_Present", 0x05650beb }, + { "NvAPI_D3D9_QueryFrameCount", 0x9083e53a }, + { "NvAPI_D3D9_ResetFrameCount", 0xfa6a0675 }, + { "NvAPI_D3D9_QueryMaxSwapGroup", 0x5995410d }, + { "NvAPI_D3D9_QuerySwapGroup", 0xeba4d232 }, + { "NvAPI_D3D9_JoinSwapGroup", 0x7d44bb54 }, + { "NvAPI_D3D9_BindSwapBarrier", 0x9c39c246 }, + { "NvAPI_D3D_SetVerticalSyncMode", 0x5526cfd1 }, + { "NvAPI_D3D1x_Present", 0x03b845a1 }, + { "NvAPI_D3D1x_QueryFrameCount", 0x9152e055 }, + { "NvAPI_D3D1x_ResetFrameCount", 0xfbbb031a }, + { "NvAPI_D3D1x_QueryMaxSwapGroup", 0x9bb9d68f }, + { "NvAPI_D3D1x_QuerySwapGroup", 0x407f67aa }, + { "NvAPI_D3D1x_JoinSwapGroup", 0x14610cd7 }, + { "NvAPI_D3D1x_BindSwapBarrier", 0x9de8c729 }, + { "NvAPI_D3D12_QueryPresentBarrierSupport", 0xa15faef7 }, + { "NvAPI_D3D12_CreatePresentBarrierClient", 0x4d815de9 }, + { "NvAPI_D3D12_RegisterPresentBarrierResources", 0xd53c9ef0 }, + { "NvAPI_DestroyPresentBarrierClient", 0x3c5c351b }, + { "NvAPI_JoinPresentBarrier", 0x17f6bf82 }, + { "NvAPI_LeavePresentBarrier", 0xc3ec5a7f }, + { "NvAPI_QueryPresentBarrierFrameStatistics", 0x61b844a1 }, + { "NvAPI_D3D12_CreateDDisplayPresentBarrierClient", 0xb5a21987 }, + { "NvAPI_D3D11_CreateRasterizerState", 0xdb8d28af }, + { "NvAPI_D3D_ConfigureAnsel", 0x341c6c7f }, + { "NvAPI_D3D11_CreateTiledTexture2DArray", 0x7886981a }, + { "NvAPI_D3D11_CheckFeatureSupport", 0x106a487e }, + { "NvAPI_D3D11_CreateImplicitMSAATexture2D", 0xb8f79632 }, + { "NvAPI_D3D12_CreateCommittedImplicitMSAATexture2D", 0x24c6a07b }, + { "NvAPI_D3D11_ResolveSubresourceRegion", 0xe6bfedd6 }, + { "NvAPI_D3D12_ResolveSubresourceRegion", 0xc24a15bf }, + { "NvAPI_D3D11_TiledTexture2DArrayGetDesc", 0xf1a2b9d5 }, + { "NvAPI_D3D11_UpdateTileMappings", 0x9a06ea07 }, + { "NvAPI_D3D11_CopyTileMappings", 0xc09ee6bc }, + { "NvAPI_D3D11_TiledResourceBarrier", 0xd6839099 }, + { "NvAPI_D3D11_AliasMSAATexture2DAsNonMSAA", 0xf1c54fc9 }, + { "NvAPI_D3D11_CreateGeometryShaderEx_2", 0x99ed5c1c }, + { "NvAPI_D3D11_CreateVertexShaderEx", 0x0beaa0b2 }, + { "NvAPI_D3D11_CreateHullShaderEx", 0xb53cab00 }, + { "NvAPI_D3D11_CreateDomainShaderEx", 0xa0d7180d }, + { "NvAPI_D3D11_CreatePixelShaderEx_2", 0x4162822b }, + { "NvAPI_D3D11_CreateFastGeometryShaderExplicit", 0x71ab7c9c }, + { "NvAPI_D3D11_CreateFastGeometryShader", 0x525d43be }, + { "NvAPI_D3D11_DecompressView", 0x3a94e822 }, + { "NvAPI_D3D12_CreateGraphicsPipelineState", 0x2fc28856 }, + { "NvAPI_D3D12_CreateComputePipelineState", 0x2762deac }, + { "NvAPI_D3D12_SetDepthBoundsTestValues", 0xb9333fe9 }, + { "NvAPI_D3D12_CreateReservedResource", 0x2c85f101 }, + { "NvAPI_D3D12_CreateHeap", 0x5cb397cf }, + { "NvAPI_D3D12_CreateHeap2", 0x924be9d6 }, + { "NvAPI_D3D12_QueryCpuVisibleVidmem", 0x26322bc3 }, + { "NvAPI_D3D12_ReservedResourceGetDesc", 0x9aa2aabb }, + { "NvAPI_D3D12_UpdateTileMappings", 0xc6017a7d }, + { "NvAPI_D3D12_CopyTileMappings", 0x47f78194 }, + { "NvAPI_D3D12_ResourceAliasingBarrier", 0xb942bab7 }, + { "NvAPI_D3D12_CaptureUAVInfo", 0x6e5ea9db }, + { "NvAPI_D3D11_GetResourceGPUVirtualAddressEx", 0xaf6d14da }, + { "NvAPI_D3D11_EnumerateMetaCommands", 0xc7453ba8 }, + { "NvAPI_D3D11_CreateMetaCommand", 0xf505fba0 }, + { "NvAPI_D3D11_InitializeMetaCommand", 0xaec629e9 }, + { "NvAPI_D3D11_ExecuteMetaCommand", 0x82236c47 }, + { "NvAPI_D3D12_EnumerateMetaCommands", 0xcd9141d8 }, + { "NvAPI_D3D12_CreateMetaCommand", 0xeb29634b }, + { "NvAPI_D3D12_InitializeMetaCommand", 0xa4125399 }, + { "NvAPI_D3D12_ExecuteMetaCommand", 0xde24fc3d }, + { "NvAPI_D3D12_CreateCommittedResource", 0x027e98ae }, + { "NvAPI_D3D12_GetCopyableFootprints", 0xf6305eb5 }, + { "NvAPI_D3D12_CopyTextureRegion", 0x82b91b25 }, + { "NvAPI_D3D12_IsNvShaderExtnOpCodeSupported", 0x3dfacec8 }, + { "NvAPI_D3D12_GetOptimalThreadCountForMesh", 0xb43995cb }, + { "NvAPI_D3D_IsGSyncCapable", 0x9c1eed78 }, + { "NvAPI_D3D_IsGSyncActive", 0xe942b0ff }, + { "NvAPI_D3D12_SetFlipConfig", 0xf3148c42 }, + { "NvAPI_D3D1x_DisableShaderDiskCache", 0xd0cbca7d }, + { "NvAPI_D3D11_MultiGPU_GetCaps", 0xd2d25687 }, + { "NvAPI_D3D11_MultiGPU_Init", 0x017be49e }, + { "NvAPI_D3D11_CreateMultiGPUDevice", 0xbdb20007 }, + { "NvAPI_D3D_QuerySinglePassStereoSupport", 0x6f5f0a6d }, + { "NvAPI_D3D_SetSinglePassStereoMode", 0xa39e6e6e }, + { "NvAPI_D3D12_QuerySinglePassStereoSupport", 0x3b03791b }, + { "NvAPI_D3D12_SetSinglePassStereoMode", 0x83556d87 }, + { "NvAPI_D3D_QueryMultiViewSupport", 0xb6e0a41c }, + { "NvAPI_D3D_SetMultiViewMode", 0x8285c8da }, + { "NvAPI_D3D_QueryModifiedWSupport", 0xcbf9f4f5 }, + { "NvAPI_D3D_SetModifiedWMode", 0x06ea4bf4 }, + { "NvAPI_D3D12_QueryModifiedWSupport", 0x51235248 }, + { "NvAPI_D3D12_SetModifiedWMode", 0xe1fdaba7 }, + { "NvAPI_D3D_CreateLateLatchObject", 0x2db27d09 }, + { "NvAPI_D3D_QueryLateLatchSupport", 0x8ceca0ec }, + { "NvAPI_D3D_RegisterDevice", 0x8c02c4d0 }, + { "NvAPI_D3D11_MultiDrawInstancedIndirect", 0xd4e26bbf }, + { "NvAPI_D3D11_MultiDrawIndexedInstancedIndirect", 0x59e890f9 }, + { "NvAPI_D3D_ImplicitSLIControl", 0x2aede111 }, + { "NvAPI_D3D12_GetNeedsAppFPBlendClamping", 0x6ef4d2d1 }, + { "NvAPI_D3D12_UseDriverHeapPriorities", 0xf0d978a8 }, + { "NvAPI_D3D12_Mosaic_GetCompanionAllocations", 0xa46022c7 }, + { "NvAPI_D3D12_Mosaic_GetViewportAndGpuPartitions", 0xb092b818 }, + { "NvAPI_D3D1x_GetGraphicsCapabilities", 0x52b1499a }, + { "NvAPI_D3D12_GetGraphicsCapabilities", 0x01e87354 }, + { "NvAPI_D3D11_RSSetExclusiveScissorRects", 0xae4d73ef }, + { "NvAPI_D3D11_RSSetViewportsPixelShadingRates", 0x34f7938f }, + { "NvAPI_D3D11_CreateShadingRateResourceView", 0x99ca2dff }, + { "NvAPI_D3D11_RSSetShadingRateResourceView", 0x1b0c2f83 }, + { "NvAPI_D3D11_RSGetPixelShadingRateSampleOrder", 0x092442a1 }, + { "NvAPI_D3D11_RSSetPixelShadingRateSampleOrder", 0xa942373a }, + { "NvAPI_D3D_InitializeVRSHelper", 0x4780d70b }, + { "NvAPI_D3D_InitializeNvGazeHandler", 0x5b3b7479 }, + { "NvAPI_D3D_InitializeSMPAssist", 0x42763d0c }, + { "NvAPI_D3D_QuerySMPAssistSupport", 0xc57921de }, + { "NvAPI_D3D_GetSleepStatus", 0xaef96ca1 }, + { "NvAPI_D3D_SetSleepMode", 0xac1ca9e0 }, + { "NvAPI_D3D_Sleep", 0x852cd1d2 }, + { "NvAPI_D3D_SetReflexSync", 0xb9f6faff }, + { "NvAPI_D3D_GetLatency", 0x1a587f9c }, + { "NvAPI_D3D_SetLatencyMarker", 0xd9984c05 }, + { "NvAPI_D3D12_SetAsyncFrameMarker", 0x13c98f73 }, + { "NvAPI_D3D11_SetAsyncFrameMarker", 0x59c2c510 }, + { "NvAPI_D3D12_NotifyOutOfBandCommandQueue", 0x03d6e8cb }, + { "NvAPI_D3D12_SetCreateCommandQueueLowLatencyHint", 0x548c224f }, + { "NvAPI_D3D12_CreateCubinComputeShaderExV2", 0x299f5fdc }, + { "NvAPI_D3D12_CreateCubinComputeShader", 0x2a2c79e8 }, + { "NvAPI_D3D12_CreateCubinComputeShaderEx", 0x3151211b }, + { "NvAPI_D3D12_CreateCubinComputeShaderWithName", 0x1dc7261f }, + { "NvAPI_D3D12_LaunchCubinShader", 0x5c52bb86 }, + { "NvAPI_D3D12_DestroyCubinComputeShader", 0x7fb785ba }, + { "NvAPI_D3D12_GetCudaMergedTextureSamplerObject", 0x329fe6e0 }, + { "NvAPI_D3D12_GetCudaIndependentDescriptorObject", 0x0ddac234 }, + { "NvAPI_D3D12_GetCudaTextureObject", 0x80403fc9 }, + { "NvAPI_D3D12_GetCudaSurfaceObject", 0x48f5b2ee }, + { "NvAPI_D3D12_IsFatbinPTXSupported", 0x70c07832 }, + { "NvAPI_D3D12_CreateCuModule", 0xad1a677d }, + { "NvAPI_D3D12_EnumFunctionsInModule", 0x7ab88d88 }, + { "NvAPI_D3D12_CreateCuFunction", 0xe2436e22 }, + { "NvAPI_D3D12_LaunchCuKernelChain", 0x24973538 }, + { "NvAPI_D3D12_LaunchCuKernelChainEx", 0x846a9bf0 }, + { "NvAPI_D3D12_DestroyCuModule", 0x41c65285 }, + { "NvAPI_D3D12_DestroyCuFunction", 0xdf295ea6 }, + { "NvAPI_D3D11_CreateCubinComputeShaderExV2", 0xf2c71d48 }, + { "NvAPI_D3D11_CreateCubinComputeShader", 0x0ed98181 }, + { "NvAPI_D3D11_CreateCubinComputeShaderEx", 0x32c2a0f6 }, + { "NvAPI_D3D11_CreateCubinComputeShaderWithName", 0xb672be19 }, + { "NvAPI_D3D11_LaunchCubinShader", 0x427e236d }, + { "NvAPI_D3D11_DestroyCubinComputeShader", 0x01682c86 }, + { "NvAPI_D3D11_IsFatbinPTXSupported", 0x6086bd93 }, + { "NvAPI_D3D11_GetCudaIndependentViewObject", 0x34d2afa8 }, + { "NvAPI_D3D11_GetCudaMergedTextureSamplerObject", 0x5d637d8f }, + { "NvAPI_D3D11_CreateUnorderedAccessView", 0x74a497a1 }, + { "NvAPI_D3D11_CreateShaderResourceView", 0x65cb431e }, + { "NvAPI_D3D11_CreateSamplerState", 0x89eca416 }, + { "NvAPI_D3D11_GetCudaTextureObject", 0x9006fa68 }, + { "NvAPI_D3D11_GetResourceGPUVirtualAddress", 0x1819b423 }, + { "NvAPI_D3D12_GetRaytracingCaps", 0x85a6c2a0 }, + { "NvAPI_D3D12_EnableRaytracingValidation", 0x1de5991b }, + { "NvAPI_D3D12_RegisterRaytracingValidationMessageCallback", 0x8554eb38 }, + { "NvAPI_D3D12_UnregisterRaytracingValidationMessageCallback", 0x26975da6 }, + { "NvAPI_D3D12_FlushRaytracingValidationMessages", 0xb8fb1fcb }, + { "NvAPI_D3D12_GetRaytracingDisplacementMicromapArrayPrebuildInfo", 0xfa99b6de }, + { "NvAPI_D3D12_GetRaytracingOpacityMicromapArrayPrebuildInfo", 0x4726d180 }, + { "NvAPI_D3D12_SetCreatePipelineStateOptions", 0x5c607a27 }, + { "NvAPI_D3D12_CheckDriverMatchingIdentifierEx", 0xafb237d4 }, + { "NvAPI_D3D12_GetRaytracingAccelerationStructurePrebuildInfoEx", 0x8d025b77 }, + { "NvAPI_D3D12_BuildRaytracingOpacityMicromapArray", 0x814f8d11 }, + { "NvAPI_D3D12_RelocateRaytracingOpacityMicromapArray", 0x0425c538 }, + { "NvAPI_D3D12_BuildRaytracingDisplacementMicromapArray", 0x066f569d }, + { "NvAPI_D3D12_RelocateRaytracingDisplacementMicromapArray", 0x1c142308 }, + { "NvAPI_D3D12_EmitRaytracingDisplacementMicromapArrayPostbuildInfo", 0x68b9a790 }, + { "NvAPI_D3D12_EmitRaytracingOpacityMicromapArrayPostbuildInfo", 0x1d9a39b6 }, + { "NvAPI_D3D12_BuildRaytracingAccelerationStructureEx", 0xe24ead45 }, + { "NvAPI_D3D12_QueryWorkstationFeatureProperties", 0xa92ea23a }, + { "NvAPI_D3D12_CreateCommittedRDMABuffer", 0xe78dcb44 }, + { "NvAPI_D3D12_ConvertCooperativeVectorMatrix", 0x0f252cb3 }, + { "NvAPI_D3D12_ConvertCooperativeVectorMatrixMultiple", 0x96ba5235 }, + { "NvAPI_D3D12_GetPhysicalDeviceCooperativeVectorProperties", 0x8f182aec }, + { "NvAPI_D3D12_GetRaytracingMultiIndirectClusterOperationRequirementsInfo", 0x5c9163f4 }, + { "NvAPI_D3D12_RaytracingExecuteMultiIndirectClusterOperation", 0x67c798af }, + { "NvAPI_D3D12_GetRaytracingPartitionedTlasIndirectPrebuildInfo", 0xcdfdc5f2 }, + { "NvAPI_D3D12_BuildRaytracingPartitionedTlasIndirect", 0x7cfc6fc3 }, + { "NvAPI_NGX_GetNGXOverrideState", 0x3fd96fba }, + { "NvAPI_NGX_SetNGXOverrideState", 0xb60fcb4e }, + { "NvAPI_DirectD3D12GraphicsCommandList_Create", 0x74a4e712 }, + { "NvAPI_DirectD3D12GraphicsCommandList_Release", 0x99da3dde }, + { "NvAPI_DirectD3D12GraphicsCommandList_Reset", 0x999c26d8 }, + { "NvAPI_VIO_GetCapabilities", 0x1dc91303 }, + { "NvAPI_VIO_Open", 0x44ee4841 }, + { "NvAPI_VIO_Close", 0xd01bd237 }, + { "NvAPI_VIO_Status", 0x0e6ce4f1 }, + { "NvAPI_VIO_SyncFormatDetect", 0x118d48a3 }, + { "NvAPI_VIO_GetConfig", 0xd34a789b }, + { "NvAPI_VIO_SetConfig", 0x0e4eec07 }, + { "NvAPI_VIO_SetCSC", 0xa1ec8d74 }, + { "NvAPI_VIO_GetCSC", 0x7b0d72a3 }, + { "NvAPI_VIO_SetGamma", 0x964bf452 }, + { "NvAPI_VIO_GetGamma", 0x51d53d06 }, + { "NvAPI_VIO_SetSyncDelay", 0x2697a8d1 }, + { "NvAPI_VIO_GetSyncDelay", 0x462214a9 }, + { "NvAPI_VIO_GetPCIInfo", 0xb981d935 }, + { "NvAPI_VIO_IsRunning", 0x96bd040e }, + { "NvAPI_VIO_Start", 0xcde8e1a3 }, + { "NvAPI_VIO_Stop", 0x6ba2a5d6 }, + { "NvAPI_VIO_IsFrameLockModeCompatible", 0x7bf0a94d }, + { "NvAPI_VIO_EnumDevices", 0xfd7c5557 }, + { "NvAPI_VIO_QueryTopology", 0x869534e2 }, + { "NvAPI_VIO_EnumSignalFormats", 0xead72fe4 }, + { "NvAPI_VIO_EnumDataFormats", 0x221fa8e8 }, + { "NvAPI_Stereo_CreateConfigurationProfileRegistryKey", 0xbe7692ec }, + { "NvAPI_Stereo_DeleteConfigurationProfileRegistryKey", 0xf117b834 }, + { "NvAPI_Stereo_SetConfigurationProfileValue", 0x24409f48 }, + { "NvAPI_Stereo_DeleteConfigurationProfileValue", 0x49bceecf }, + { "NvAPI_Stereo_Enable", 0x239c4545 }, + { "NvAPI_Stereo_Disable", 0x2ec50c2b }, + { "NvAPI_Stereo_IsEnabled", 0x348ff8e1 }, + { "NvAPI_Stereo_GetStereoSupport", 0x296c434d }, + { "NvAPI_Stereo_CreateHandleFromIUnknown", 0xac7e37f4 }, + { "NvAPI_Stereo_DestroyHandle", 0x3a153134 }, + { "NvAPI_Stereo_Activate", 0xf6a1ad68 }, + { "NvAPI_Stereo_Deactivate", 0x2d68de96 }, + { "NvAPI_Stereo_IsActivated", 0x1fb0bc30 }, + { "NvAPI_Stereo_GetSeparation", 0x451f2134 }, + { "NvAPI_Stereo_SetSeparation", 0x5c069fa3 }, + { "NvAPI_Stereo_DecreaseSeparation", 0xda044458 }, + { "NvAPI_Stereo_IncreaseSeparation", 0xc9a8ecec }, + { "NvAPI_Stereo_GetConvergence", 0x4ab00934 }, + { "NvAPI_Stereo_SetConvergence", 0x3dd6b54b }, + { "NvAPI_Stereo_DecreaseConvergence", 0x4c87e317 }, + { "NvAPI_Stereo_IncreaseConvergence", 0xa17daabe }, + { "NvAPI_Stereo_GetFrustumAdjustMode", 0xe6839b43 }, + { "NvAPI_Stereo_SetFrustumAdjustMode", 0x7be27fa2 }, + { "NvAPI_Stereo_CaptureJpegImage", 0x932cb140 }, + { "NvAPI_Stereo_InitActivation", 0xc7177702 }, + { "NvAPI_Stereo_Trigger_Activation", 0x0d6c6cd2 }, + { "NvAPI_Stereo_CapturePngImage", 0x8b7e99b5 }, + { "NvAPI_Stereo_ReverseStereoBlitControl", 0x3cd58f89 }, + { "NvAPI_Stereo_SetNotificationMessage", 0x6b9b409e }, + { "NvAPI_Stereo_SetActiveEye", 0x96eea9f8 }, + { "NvAPI_Stereo_SetDriverMode", 0x5e8f0bec }, + { "NvAPI_Stereo_GetEyeSeparation", 0xce653127 }, + { "NvAPI_Stereo_IsWindowedModeSupported", 0x40c8ed5e }, + { "NvAPI_Stereo_SetSurfaceCreationMode", 0xf5dcfcba }, + { "NvAPI_Stereo_GetSurfaceCreationMode", 0x36f1c736 }, + { "NvAPI_Stereo_Debug_WasLastDrawStereoized", 0xed4416c5 }, + { "NvAPI_Stereo_SetDefaultProfile", 0x44f0ecd1 }, + { "NvAPI_Stereo_GetDefaultProfile", 0x624e21c2 }, + { "NvAPI_D3D1x_CreateSwapChain", 0x1bc21b66 }, + { "NvAPI_D3D9_CreateSwapChain", 0x1a131e09 }, + { "NvAPI_Vulkan_InitLowLatencyDevice", 0x5c1696b6 }, + { "NvAPI_Vulkan_DestroyLowLatencyDevice", 0x11a5932b }, + { "NvAPI_Vulkan_GetSleepStatus", 0xadf966af }, + { "NvAPI_Vulkan_SetSleepMode", 0x2acfd162 }, + { "NvAPI_Vulkan_Sleep", 0x36732b1e }, + { "NvAPI_Vulkan_GetLatency", 0x3233d44a }, + { "NvAPI_Vulkan_SetLatencyMarker", 0xa17d13d6 }, + { "NvAPI_Vulkan_NotifyOutOfBandVkQueue", 0x5d6d3840 }, + { "NvAPI_DRS_CreateSession", 0x0694d52e }, + { "NvAPI_DRS_DestroySession", 0xdad9cff8 }, + { "NvAPI_DRS_LoadSettings", 0x375dbd6b }, + { "NvAPI_DRS_SaveSettings", 0xfcbc7e14 }, + { "NvAPI_DRS_LoadSettingsFromFile", 0xd3ede889 }, + { "NvAPI_DRS_SaveSettingsToFile", 0x2be25df8 }, + { "NvAPI_DRS_CreateProfile", 0xcc176068 }, + { "NvAPI_DRS_DeleteProfile", 0x17093206 }, + { "NvAPI_DRS_SetCurrentGlobalProfile", 0x1c89c5df }, + { "NvAPI_DRS_GetCurrentGlobalProfile", 0x617bff9f }, + { "NvAPI_DRS_GetProfileInfo", 0x61cd6fd6 }, + { "NvAPI_DRS_SetProfileInfo", 0x16abd3a9 }, + { "NvAPI_DRS_FindProfileByName", 0x7e4a9a0b }, + { "NvAPI_DRS_EnumProfiles", 0xbc371ee0 }, + { "NvAPI_DRS_GetNumProfiles", 0x1dae4fbc }, + { "NvAPI_DRS_CreateApplication", 0x4347a9de }, + { "NvAPI_DRS_DeleteApplicationEx", 0xc5ea85a1 }, + { "NvAPI_DRS_DeleteApplication", 0x2c694bc6 }, + { "NvAPI_DRS_GetApplicationInfo", 0xed1f8c69 }, + { "NvAPI_DRS_EnumApplications", 0x7fa2173a }, + { "NvAPI_DRS_FindApplicationByName", 0xeee566b2 }, + { "NvAPI_DRS_SetSetting", 0x577dd202 }, + { "NvAPI_DRS_GetSetting", 0x73bf8338 }, + { "NvAPI_DRS_EnumSettings", 0xae3039da }, + { "NvAPI_DRS_EnumAvailableSettingIds", 0xf020614a }, + { "NvAPI_DRS_EnumAvailableSettingValues", 0x2ec39f90 }, + { "NvAPI_DRS_GetSettingIdFromName", 0xcb7309cd }, + { "NvAPI_DRS_GetSettingNameFromId", 0xd61cbe6e }, + { "NvAPI_DRS_DeleteProfileSetting", 0xe4a26362 }, + { "NvAPI_DRS_RestoreAllDefaults", 0x5927b094 }, + { "NvAPI_DRS_RestoreProfileDefault", 0xfa5f6134 }, + { "NvAPI_DRS_RestoreProfileDefaultSetting", 0x53f0381e }, + { "NvAPI_DRS_GetBaseProfile", 0xda8466a0 }, + { "NvAPI_SYS_GetChipSetInfo", 0x53dabbca }, + { "NvAPI_SYS_GetLidAndDockInfo", 0xcda14d8a }, + { "NvAPI_SYS_GetDisplayIdFromGpuAndOutputId", 0x08f2bab4 }, + { "NvAPI_SYS_GetGpuAndOutputIdFromDisplayId", 0x112ba1a5 }, + { "NvAPI_SYS_GetPhysicalGpuFromDisplayId", 0x9ea74659 }, + { "NvAPI_SYS_GetDisplayDriverInfo", 0x721faceb }, + { "NvAPI_SYS_GetPhysicalGPUs", 0xd3b24d2d }, + { "NvAPI_SYS_GetLogicalGPUs", 0xccfffc10 }, + { "NvAPI_NGX_GetDriverFeatureSupport", 0x6194b19d }, + { "NvAPI_GPU_ClientRegisterForUtilizationSampleUpdates", 0xadeeaf67 }, + { "NvAPI_RegisterRiseCallback", 0x9cfe8f94 }, + { "NvAPI_RequestRise", 0x5047de98 }, + { "NvAPI_UninstallRise", 0xab8d09f6 }, +); + #[no_mangle] pub unsafe extern "C" fn nvapi_QueryInterface(interface: u32) -> *mut c_void { let maybe_fn_ptr = (&*LIBRARY).as_ref().and_then(|lib| { @@ -29,7 +560,11 @@ pub unsafe extern "C" fn nvapi_QueryInterface(interface: u32) -> *mut c_void { let format_args = dark_api::FnFfiWrapper(|| { use std::io::Write; let mut writer = Vec::new(); - write!(&mut writer, "(interface: {:#010x})", interface).ok(); + let name = interface_to_name(interface); + match name { + Some(name) => write!(&mut writer, "(interface: {})", name).ok(), + None => write!(&mut writer, "(interface: {:#010x})", interface).ok(), + }; dark_api::ByteVecFfi::new(writer) }); let underlying_fn = dark_api::FnFfiWrapper(|| { From d2bc39da873bc42e7edac77ce913847101592af0 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Sun, 19 Apr 2026 23:40:19 -0700 Subject: [PATCH 11/85] Log functions called by nvapi --- Cargo.lock | 214 ++++++++++++++++------------------ nvapi_trace/Cargo.toml | 2 + nvapi_trace/src/lib.rs | 65 ++++++++++- zluda_trace/Cargo.toml | 4 +- zluda_trace_common/src/lib.rs | 18 +++ 5 files changed, 187 insertions(+), 116 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 0c309deda..e72996776 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -84,7 +84,7 @@ dependencies = [ "argh_shared", "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -161,7 +161,7 @@ version = "0.70.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f49d8fed880d473ea71efb9bf597651e77201bdd4893efe54c9e5d65ae04ce6f" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", "cexpr", "clang-sys", "itertools 0.13.0", @@ -172,7 +172,7 @@ dependencies = [ "regex", "rustc-hash 1.1.0", "shlex", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -181,7 +181,7 @@ version = "0.71.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5f58bf3d7db68cfbac37cfc485a8d711e87e064c3d0fe0435b92f7a407f9d6b3" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", "cexpr", "clang-sys", "itertools 0.13.0", @@ -192,7 +192,7 @@ dependencies = [ "regex", "rustc-hash 2.1.1", "shlex", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -222,7 +222,7 @@ checksum = "238b90427dfad9da4a9abd60f3ec1cdee6b80454bde49ed37f1781dd8e9dc7f9" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -233,9 +233,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" [[package]] name = "bitflags" -version = "2.9.1" +version = "2.11.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1b8e56985ec62d17e9c1001dc89c88ecd7dc08e47eba5ec7c29c7b5eeecde967" +checksum = "c4512299f36f043ab09a583e57bceb5a5aab7a73db1805848e8fef3c9e8c78b3" [[package]] name = "blake3" @@ -278,7 +278,7 @@ checksum = "fefb4feeec9a091705938922f26081aad77c64cd2e76cd1c4a9ece8e42e1618a" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -318,7 +318,7 @@ checksum = "89385e82b5d1821d2219e0b095efa2cc1f246cbf99080f3be46a1a85c0d392d9" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -338,7 +338,7 @@ checksum = "f9abbd1bc6865053c427f7198e6af43bfdedc55ab791faed4fbd361d789575ff" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -373,7 +373,7 @@ dependencies = [ "gemm", "half", "libm", - "memmap2 0.9.7", + "memmap2", "num-traits", "num_cpus", "rand 0.9.2", @@ -641,7 +641,7 @@ dependencies = [ "proc-macro-crate 3.3.0", "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -826,14 +826,14 @@ dependencies = [ "proc-macro2", "quote", "rustc-hash 2.1.1", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] name = "cuda_types" version = "0.0.0" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", "cuda_macros", "hip_runtime-sys", "hipblaslt-sys", @@ -878,7 +878,7 @@ dependencies = [ "proc-macro2", "quote", "strsim", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -889,7 +889,7 @@ checksum = "fc34b93ccb385b40dc71c6fceac4b2ad23662c7eeb248cf10d529b7e055b6ead" dependencies = [ "darling_core", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -934,7 +934,7 @@ checksum = "30542c1ad912e0e3d22a1935c290e12e8a29d704a420177a31faad4a601a0800" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -955,7 +955,7 @@ dependencies = [ "darling", "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -965,7 +965,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ab63b0e2bf4d5928aff72e83a7dace85d7bba5fe12dcc3c5a572d78caffd3f3c" dependencies = [ "derive_builder_core", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -985,7 +985,7 @@ checksum = "cb7330aeadfbe296029522e6c40f315320aba36fc43a5b3632f3795348f3bd22" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", "unicode-xid", ] @@ -1018,7 +1018,7 @@ dependencies = [ "dsl_auto_type", "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -1038,7 +1038,7 @@ version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "209c735641a413bc68c4923a9d6ad4bcb3ca306b794edaa7eb0b3228a99ffb25" dependencies = [ - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -1086,7 +1086,7 @@ checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -1100,7 +1100,7 @@ dependencies = [ "heck", "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -1142,28 +1142,29 @@ checksum = "e1d926b4d407d372f141f93bb444696142c29d32962ccbd3531117cf3aa0bfa9" [[package]] name = "dynasm" -version = "1.2.3" +version = "5.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "add9a102807b524ec050363f09e06f1504214b0e1c7797f64261c891022dce8b" +checksum = "df4bf11ba8aecc00489b7ec4e8963cd3860651c3ea2a114394f8ba7e92a0e94a" dependencies = [ - "bitflags 1.3.2", + "bitflags 2.11.1", "byteorder", "lazy_static", - "proc-macro-error", + "proc-macro-error2", "proc-macro2", "quote", - "syn 1.0.109", + "syn 2.0.117", ] [[package]] name = "dynasmrt" -version = "1.2.3" +version = "5.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "64fba5a42bd76a17cad4bfa00de168ee1cbfa06a5e8ce992ae880218c05641a9" +checksum = "b38e5331d851567729d892ed28d898d22f49a96940b29e23b5c3e681bd30ffb3" dependencies = [ "byteorder", "dynasm", - "memmap2 0.5.10", + "fnv", + "memmap2", ] [[package]] @@ -1222,7 +1223,7 @@ dependencies = [ "heck", "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -1371,7 +1372,7 @@ checksum = "e835b70203e41293343137df5c0664546da5745f82ec9b84d40be8336958447b" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -1704,7 +1705,7 @@ dependencies = [ "bstr", "gix-chunk", "gix-hash 0.17.0", - "memmap2 0.9.7", + "memmap2", "thiserror 2.0.12", ] @@ -1735,7 +1736,7 @@ version = "0.14.12" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8dc2c844c4cf141884678cabef736fd91dd73068b9146e6f004ba1a0457944b6" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", "bstr", "gix-path", "libc", @@ -1899,7 +1900,7 @@ version = "0.19.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "20972499c03473e773a2099e5fd0c695b9b72465837797a51a43391a1635a030" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", "bstr", "gix-features 0.41.1", "gix-path", @@ -1959,7 +1960,7 @@ version = "0.39.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "855bece2d4153453aa5d0a80d51deea1ce8cd6a3b4cf213da85ac344ccb908a7" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", "bstr", "filetime", "fnv", @@ -1975,7 +1976,7 @@ dependencies = [ "hashbrown 0.14.5", "itoa", "libc", - "memmap2 0.9.7", + "memmap2", "rustix 0.38.37", "smallvec", "thiserror 2.0.12", @@ -2047,7 +2048,7 @@ dependencies = [ "gix-hashtable", "gix-object", "gix-path", - "memmap2 0.9.7", + "memmap2", "smallvec", "thiserror 2.0.12", ] @@ -2096,7 +2097,7 @@ version = "0.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "fef8422c3c9066d649074b24025125963f85232bfad32d6d16aea9453b82ec14" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", "bstr", "gix-attributes", "gix-config-value", @@ -2151,7 +2152,7 @@ dependencies = [ "gix-tempfile", "gix-utils 0.2.0", "gix-validate 0.9.4", - "memmap2 0.9.7", + "memmap2", "thiserror 2.0.12", "winnow 0.7.10", ] @@ -2176,7 +2177,7 @@ version = "0.33.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "342caa4e158df3020cadf62f656307c3948fe4eacfdf67171d7212811860c3e9" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", "bstr", "gix-commitgraph", "gix-date", @@ -2209,7 +2210,7 @@ version = "0.10.12" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "47aeb0f13de9ef2f3033f5ff218de30f44db827ac9f1286f9ef050aacddd5888" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", "gix-path", "libc", "windows-sys 0.52.0", @@ -2309,7 +2310,7 @@ version = "0.45.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "36c0b049f8bdb61b20016694102f7b507f2e1727e83e9c5e6dad4f7d84ff7384" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", "gix-commitgraph", "gix-date", "gix-hash 0.17.0", @@ -2718,7 +2719,7 @@ dependencies = [ "proc-macro2", "proc-macro2-diagnostics", "quote", - "syn 2.0.89", + "syn 2.0.117", "version_check", ] @@ -2728,7 +2729,7 @@ version = "0.7.11" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "fdd7bddefd0a8833b88a4b68f90dae22c7450d11b354198baee3874fd811b344" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", "cfg-if", "libc", ] @@ -2912,7 +2913,7 @@ version = "0.1.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", "libc", "redox_syscall", ] @@ -3023,7 +3024,7 @@ dependencies = [ "proc-macro2", "quote", "regex-syntax", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -3076,7 +3077,7 @@ checksum = "5cf92c10c7e361d6b99666ec1c6f9805b0bea2c3bd8c78dc6fe98ac5bd78db11" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -3087,18 +3088,9 @@ checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3" [[package]] name = "memmap2" -version = "0.5.10" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "83faa42c0a078c393f6b29d5db232d8be22776a891f8f56e5284faee4a20b327" -dependencies = [ - "libc", -] - -[[package]] -name = "memmap2" -version = "0.9.7" +version = "0.9.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "483758ad303d734cec05e5c12b41d7e93e6a6390c5e9dae6bdeb7c1259012d28" +checksum = "714098028fe011992e1c3962653c96b2d578c4b4bce9036e15ff220319b1e0e3" dependencies = [ "libc", "stable_deref_trait", @@ -3175,7 +3167,7 @@ checksum = "4568f25ccbd45ab5d5603dc34318c1ec56b117531781260002151b8530a9f931" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -3321,6 +3313,8 @@ dependencies = [ "cuda_macros", "cuda_types", "dark_api", + "dynasm", + "dynasmrt", "format", "libloading", "paste", @@ -3532,7 +3526,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "64d1ec885c64d0457d564db4ec299b2dae3f9c02808b8ad9c3a089c591b18033" dependencies = [ "proc-macro2", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -3554,34 +3548,32 @@ dependencies = [ ] [[package]] -name = "proc-macro-error" -version = "1.0.4" +name = "proc-macro-error-attr2" +version = "2.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c" +checksum = "96de42df36bb9bba5542fe9f1a054b8cc87e172759a1868aa05c1f3acc89dfc5" dependencies = [ - "proc-macro-error-attr", "proc-macro2", "quote", - "syn 1.0.109", - "version_check", ] [[package]] -name = "proc-macro-error-attr" -version = "1.0.4" +name = "proc-macro-error2" +version = "2.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869" +checksum = "11ec05c52be0a07b08061f7dd003e7d7092e0472bc731b4af7bb1ef876109802" dependencies = [ + "proc-macro-error-attr2", "proc-macro2", "quote", - "version_check", + "syn 2.0.117", ] [[package]] name = "proc-macro2" -version = "1.0.92" +version = "1.0.106" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "37d3544b3f2748c54e147655edb5025752e2303145b5aefb3c3ea2c78b973bb0" +checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934" dependencies = [ "unicode-ident", ] @@ -3594,7 +3586,7 @@ checksum = "af066a9c399a26e020ada66a034357a868728e72cd426f3adcd35f80d88d88c8" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", "version_check", "yansi", ] @@ -3626,7 +3618,7 @@ checksum = "7347867d0a7e1208d93b46767be83e2b8f978c3dad35f775ac8d8847551d6fe1" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -3683,7 +3675,7 @@ dependencies = [ "ptx_parser_macros_impl", "quote", "rustc-hash 2.1.1", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -3693,7 +3685,7 @@ dependencies = [ "proc-macro2", "quote", "rustc-hash 2.1.1", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -3737,9 +3729,9 @@ checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0" [[package]] name = "quote" -version = "1.0.37" +version = "1.0.45" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af" +checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924" dependencies = [ "proc-macro2", ] @@ -3827,7 +3819,7 @@ version = "11.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "498cd0dc59d73224351ee52a95fee0f1a617a2eae0e7d9d720cc622c73a54186" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", ] [[package]] @@ -3862,7 +3854,7 @@ version = "0.5.11" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d2f103c6d277498fbceb16e84d317e2a400f160f46904d5f5410848c829511a3" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", ] [[package]] @@ -3947,7 +3939,7 @@ checksum = "8100bb34c0a1d0f907143db3149e6b4eea3c33b9ee8b189720168e818303986f" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -3995,7 +3987,7 @@ version = "0.38.37" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8acb788b847c24f28525660c4d7758620a7210875711f79e7f663cc152726811" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", "errno", "libc", "linux-raw-sys 0.4.14", @@ -4008,7 +4000,7 @@ version = "1.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", "errno", "libc", "linux-raw-sys 0.12.1", @@ -4085,7 +4077,7 @@ checksum = "1783eabc414609e28a5ba76aee5ddd52199f7107a0b24c2e9746a1ecc34a683d" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -4130,7 +4122,7 @@ checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -4301,7 +4293,7 @@ dependencies = [ "proc-macro2", "quote", "rustversion", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -4313,7 +4305,7 @@ dependencies = [ "heck", "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -4348,9 +4340,9 @@ dependencies = [ [[package]] name = "syn" -version = "2.0.89" +version = "2.0.117" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "44d46482f1c1c87acd84dea20c1bf5ebff4c757009ed6bf19cfd36fb10e92c4e" +checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99" dependencies = [ "proc-macro2", "quote", @@ -4375,7 +4367,7 @@ checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -4384,7 +4376,7 @@ version = "0.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "01198a2debb237c62b6826ec7081082d951f46dbb64b0e8c7649a452230d1dfc" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", "byteorder", "enum-as-inner", "libc", @@ -4454,7 +4446,7 @@ checksum = "08904e7672f5eb876eaaf87e0ce17857500934f4981c4a0ab2b4aa98baac7fc3" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -4465,7 +4457,7 @@ checksum = "7f7cf42b4507d8ea322120659672cf1b9dbb93f8f2d4ecfd6e51350ff5b17a1d" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -4906,7 +4898,7 @@ dependencies = [ "log", "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", "wasm-bindgen-shared", ] @@ -4928,7 +4920,7 @@ checksum = "9f07d2f20d4da7b26400c9f4a0511e6e0345b040694e8a75bd41d578fa4421d7" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", "wasm-bindgen-backend", "wasm-bindgen-shared", ] @@ -4970,7 +4962,7 @@ version = "0.244.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", "hashbrown 0.15.2", "indexmap", "semver", @@ -5122,7 +5114,7 @@ checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -5133,7 +5125,7 @@ checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -5367,7 +5359,7 @@ version = "0.39.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6f42320e61fe2cfd34354ecb597f86f413484a798ba44a8ca1165c58d42da6c1" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", ] [[package]] @@ -5380,7 +5372,7 @@ dependencies = [ "heck", "indexmap", "prettyplease", - "syn 2.0.89", + "syn 2.0.117", "wasm-metadata", "wit-bindgen-core", "wit-component", @@ -5396,7 +5388,7 @@ dependencies = [ "prettyplease", "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", "wit-bindgen-core", "wit-bindgen-rust", ] @@ -5408,7 +5400,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2" dependencies = [ "anyhow", - "bitflags 2.9.1", + "bitflags 2.11.1", "indexmap", "log", "serde", @@ -5494,7 +5486,7 @@ checksum = "38da3c9736e16c5d3c8c597a9aaa5d1fa565d0532ae05e27c24aa62fb32c0ab6" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", "synstructure", ] @@ -5515,7 +5507,7 @@ checksum = "9ecf5b4cc5364572d7f4c329661bcc82724222973f2cab6f050a4e5c22f75181" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -5535,7 +5527,7 @@ checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", "synstructure", ] @@ -5569,7 +5561,7 @@ checksum = "5b96237efa0c878c64bd89c436f661be4e46b2f3eff1ebb976f7ef2321d2f58f" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -5681,7 +5673,7 @@ dependencies = [ "proc-macro2", "quote", "rustc-hash 2.1.1", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] diff --git a/nvapi_trace/Cargo.toml b/nvapi_trace/Cargo.toml index 6b4a32885..0f769536f 100644 --- a/nvapi_trace/Cargo.toml +++ b/nvapi_trace/Cargo.toml @@ -18,6 +18,8 @@ libloading = "0.8" paste = "1.0" unwrap_or = "1.0.1" cglue = "0.3.5" +dynasm = "5.0" +dynasmrt = "5.0" [package.metadata.zluda] windows_only = true diff --git a/nvapi_trace/src/lib.rs b/nvapi_trace/src/lib.rs index f264b70b3..a03079b75 100644 --- a/nvapi_trace/src/lib.rs +++ b/nvapi_trace/src/lib.rs @@ -1,5 +1,5 @@ use libloading::Library; -use std::{ffi::c_void, ptr, sync::LazyLock}; +use std::{ffi::c_void, mem, ptr, sync::LazyLock}; use zluda_trace_common::ReprUsize; static LIBRARY: LazyLock> = LazyLock::new(get_library); @@ -571,11 +571,70 @@ pub unsafe extern "C" fn nvapi_QueryInterface(interface: u32) -> *mut c_void { let result = fn_ptr(interface); result as usize }); - ReprUsize::from_usize(export_table.logged_call( + let original = ReprUsize::from_usize(export_table.logged_call( cglue::slice::CSliceRef::from_str("nvapi_QueryInterface"), cglue::trait_obj!(&format_args as dark_api::FnFfi), cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), ptr::null_mut::() as usize, <*mut c_void as ReprUsize>::format_status, - )) + )); + if cfg!(target_pointer_width = "32") { + get_thunk(original, report_fn, interface) + } else { + original + } +} + +unsafe extern "system" fn report_fn(interface: u32) { + use zluda_trace_common::Unknown; + let export_table = unwrap_or::unwrap_some_or!(::zluda_trace_common::get_export_table(), return); + let format_args = + dark_api::FnFfiWrapper(|| dark_api::ByteVecFfi::new("(...)".as_bytes().to_vec())); + let underlying_fn = dark_api::FnFfiWrapper(|| 0); + let fn_name = match interface_to_name(interface) { + Some(name) => name.to_string(), + None => { + format!("{{nvapi:{:#010x}}}", interface) + } + }; + export_table.logged_call( + cglue::slice::CSliceRef::from_str(mem::transmute(&*fn_name)), + cglue::trait_obj!(&format_args as dark_api::FnFfi), + cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), + ::INTERNAL_ERROR, + ::format_status, + ); +} + +#[cfg(target_arch = "x86")] +pub fn get_thunk( + original_fn: *mut c_void, + report_fn: unsafe extern "system" fn(u32), + interface: u32, +) -> *mut c_void { + use dynasmrt::{dynasm, DynasmApi}; + let mut ops = dynasmrt::x86::Assembler::new().unwrap(); + let start = ops.offset(); + dynasm!(ops + ; .arch x86 + ; push interface as i32 + ; mov eax, report_fn as i32 + ; call eax + ; mov eax, original_fn as i32 + ; jmp eax + ; int 3 + ); + let exe_buf = ops.finalize().unwrap(); + let result_fn = exe_buf.ptr(start); + std::mem::forget(exe_buf); + result_fn as *mut _ +} + +#[cfg(target_arch = "x86_64")] +pub fn get_thunk( + _original_fn: *mut c_void, + _report_fn: unsafe extern "system" fn(u32), + _interface: u32, +) -> *mut c_void { + todo!() } diff --git a/zluda_trace/Cargo.toml b/zluda_trace/Cargo.toml index 78ec4fd4e..decfa48f7 100644 --- a/zluda_trace/Cargo.toml +++ b/zluda_trace/Cargo.toml @@ -15,8 +15,8 @@ zluda_common = { path = "../zluda_common" } format = { path = "../format" } dark_api = { path = "../dark_api" } regex = "1.4" -dynasm = "1.2" -dynasmrt = "1.2" +dynasm = "5.0" +dynasmrt = "5.0" # we don't need elf32, but goblin has a bug where elf64 does not build without elf32 goblin = { version = "0.9", default-features = false, features = [ "elf64", diff --git a/zluda_trace_common/src/lib.rs b/zluda_trace_common/src/lib.rs index 1646db0f5..2bccda0bb 100644 --- a/zluda_trace_common/src/lib.rs +++ b/zluda_trace_common/src/lib.rs @@ -472,3 +472,21 @@ impl ReprUsize for cuda_types::nvml::nvmlReturn_t { ByteVecFfi::new(writer) } } + +pub struct Unknown; + +impl ReprUsize for Unknown { + fn to_usize(self) -> usize { + 0 + } + + fn from_usize(_: usize) -> Self { + Self + } + + const INTERNAL_ERROR: usize = usize::MAX; + + extern "C" fn format_status(_: usize) -> ByteVecFfi { + ByteVecFfi::new(b"UNKNOWN".to_vec()) + } +} From 6c96cef3d5d54a403894391875a4bd274e227d21 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Sun, 19 Apr 2026 23:54:54 -0700 Subject: [PATCH 12/85] Stop regenerating thunks for no reason --- Cargo.lock | 1 + nvapi_trace/Cargo.toml | 1 + nvapi_trace/src/lib.rs | 61 +++++++++++++++++++++++++++++++++++------- 3 files changed, 54 insertions(+), 9 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index e72996776..355b46c90 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3318,6 +3318,7 @@ dependencies = [ "format", "libloading", "paste", + "rustc-hash 2.1.1", "unwrap_or", "zluda_trace_common", ] diff --git a/nvapi_trace/Cargo.toml b/nvapi_trace/Cargo.toml index 0f769536f..ed86c5453 100644 --- a/nvapi_trace/Cargo.toml +++ b/nvapi_trace/Cargo.toml @@ -20,6 +20,7 @@ unwrap_or = "1.0.1" cglue = "0.3.5" dynasm = "5.0" dynasmrt = "5.0" +rustc-hash = "2.0.0" [package.metadata.zluda] windows_only = true diff --git a/nvapi_trace/src/lib.rs b/nvapi_trace/src/lib.rs index a03079b75..cf630929f 100644 --- a/nvapi_trace/src/lib.rs +++ b/nvapi_trace/src/lib.rs @@ -1,10 +1,17 @@ use libloading::Library; -use std::{ffi::c_void, mem, ptr, sync::LazyLock}; +use rustc_hash::FxHashMap; +use std::{ + collections::hash_map, + ffi::c_void, + mem, ptr, + sync::{LazyLock, Mutex}, +}; use zluda_trace_common::ReprUsize; -static LIBRARY: LazyLock> = LazyLock::new(get_library); +static GLOBAL_STATE: LazyLock)>> = + LazyLock::new(get_global_state); -fn get_library() -> Option { +fn get_global_state() -> Option<(Library, Mutex)> { let cuda_lib = std::env::var("ZLUDA_NVAPI_LIB").ok().unwrap_or_else(|| { if cfg!(target_pointer_width = "64") { r"C:\Windows\System32\nvapi64.dll".to_string() @@ -12,7 +19,36 @@ fn get_library() -> Option { r"C:\Windows\System32\nvapi.dll".to_string() } }); - zluda_trace_common::dlopen_local_noredirect(cuda_lib).ok() + let lib = zluda_trace_common::dlopen_local_noredirect(cuda_lib).ok()?; + Some((Library::from(lib), Mutex::new(GlobalState::new()))) +} + +struct GlobalState { + thunks: FxHashMap, +} + +impl GlobalState { + fn new() -> Self { + GlobalState { + thunks: FxHashMap::default(), + } + } + + fn get_thunk( + &mut self, + original: *mut c_void, + report_fn: unsafe extern "system" fn(u32), + interface: u32, + ) -> *mut c_void { + match self.thunks.entry(interface) { + hash_map::Entry::Occupied(entry) => *entry.get() as *mut c_void, + hash_map::Entry::Vacant(entry) => { + let thunk = get_thunk(original, report_fn, interface); + entry.insert(thunk as usize); + thunk + } + } + } } macro_rules! interface_to_name { @@ -548,11 +584,14 @@ interface_to_name!( #[no_mangle] pub unsafe extern "C" fn nvapi_QueryInterface(interface: u32) -> *mut c_void { - let maybe_fn_ptr = (&*LIBRARY).as_ref().and_then(|lib| { - lib.get:: *mut c_void>(b"nvapi_QueryInterface\0") - .ok() + let maybe_fn_ptr_global = (&*GLOBAL_STATE).as_ref().and_then(|(lib, state)| { + let fn_ptr = lib + .get:: *mut c_void>(b"nvapi_QueryInterface\0") + .ok()?; + Some((fn_ptr, state)) }); - let fn_ptr = unwrap_or::unwrap_some_or!(maybe_fn_ptr, return ptr::null_mut()); + let (fn_ptr, global_state) = + unwrap_or::unwrap_some_or!(maybe_fn_ptr_global, return ptr::null_mut()); let export_table = unwrap_or::unwrap_some_or!( ::zluda_trace_common::get_export_table(), return ptr::null_mut() @@ -579,7 +618,11 @@ pub unsafe extern "C" fn nvapi_QueryInterface(interface: u32) -> *mut c_void { <*mut c_void as ReprUsize>::format_status, )); if cfg!(target_pointer_width = "32") { - get_thunk(original, report_fn, interface) + global_state + .lock() + .ok() + .map(|mut state| state.get_thunk(original, report_fn, interface)) + .unwrap_or_else(|| get_thunk(original, report_fn, interface)) } else { original } From 8663a9c990cb3ee01e6b138c03e2ccd4c62e6ab7 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Mon, 20 Apr 2026 01:58:21 -0700 Subject: [PATCH 13/85] Fix thunk jump into NULL --- dark_api/src/lib.rs | 1 + nvapi_trace/src/lib.rs | 1368 +++++++++++++++++---------------- zluda_trace/src/lib.rs | 8 +- zluda_trace/src/log.rs | 4 + zluda_trace_blas/src/lib.rs | 1 + zluda_trace_blaslt/src/lib.rs | 1 + zluda_trace_dnn8/src/lib.rs | 1 + zluda_trace_dnn9/src/lib.rs | 1 + zluda_trace_fft/src/lib.rs | 1 + zluda_trace_nvml/src/lib.rs | 1 + zluda_trace_sparse/src/lib.rs | 1 + 11 files changed, 704 insertions(+), 684 deletions(-) diff --git a/dark_api/src/lib.rs b/dark_api/src/lib.rs index cfd8c928e..6b2d452e9 100644 --- a/dark_api/src/lib.rs +++ b/dark_api/src/lib.rs @@ -354,6 +354,7 @@ dark_api! { #[noformat] [0] = logged_call( fn_name: cglue::slice::CSliceRef<'static, u8>, + nvapi_interface: u32, args: crate::FnFfiRef, fn_: crate::FnFfiRef, internal_error: usize, diff --git a/nvapi_trace/src/lib.rs b/nvapi_trace/src/lib.rs index cf630929f..9b5d2cea4 100644 --- a/nvapi_trace/src/lib.rs +++ b/nvapi_trace/src/lib.rs @@ -1,683 +1,685 @@ -use libloading::Library; -use rustc_hash::FxHashMap; -use std::{ - collections::hash_map, - ffi::c_void, - mem, ptr, - sync::{LazyLock, Mutex}, -}; -use zluda_trace_common::ReprUsize; - -static GLOBAL_STATE: LazyLock)>> = - LazyLock::new(get_global_state); - -fn get_global_state() -> Option<(Library, Mutex)> { - let cuda_lib = std::env::var("ZLUDA_NVAPI_LIB").ok().unwrap_or_else(|| { - if cfg!(target_pointer_width = "64") { - r"C:\Windows\System32\nvapi64.dll".to_string() - } else { - r"C:\Windows\System32\nvapi.dll".to_string() - } - }); - let lib = zluda_trace_common::dlopen_local_noredirect(cuda_lib).ok()?; - Some((Library::from(lib), Mutex::new(GlobalState::new()))) -} - -struct GlobalState { - thunks: FxHashMap, -} - -impl GlobalState { - fn new() -> Self { - GlobalState { - thunks: FxHashMap::default(), - } - } - - fn get_thunk( - &mut self, - original: *mut c_void, - report_fn: unsafe extern "system" fn(u32), - interface: u32, - ) -> *mut c_void { - match self.thunks.entry(interface) { - hash_map::Entry::Occupied(entry) => *entry.get() as *mut c_void, - hash_map::Entry::Vacant(entry) => { - let thunk = get_thunk(original, report_fn, interface); - entry.insert(thunk as usize); - thunk - } - } - } -} - -macro_rules! interface_to_name { - ($({ $name:literal, $id:literal }),* $(,)?) => { - fn interface_to_name(interface: u32) -> Option<&'static str> { - match interface { - $( - $id => Some($name), - )* - _ => None, - } - } - }; -} - -interface_to_name!( - { "NvAPI_Initialize", 0x0150e828 }, - { "NvAPI_Unload", 0xd22bdd7e }, - { "NvAPI_GetErrorMessage", 0x6c2d048c }, - { "NvAPI_GetInterfaceVersionString", 0x01053fa5 }, - { "NvAPI_GPU_GetEDID", 0x37d32e69 }, - { "NvAPI_SetView", 0x0957d7b6 }, - { "NvAPI_SetViewEx", 0x06b89e68 }, - { "NvAPI_GetDisplayDriverVersion", 0xf951a4d1 }, - { "NvAPI_SYS_GetDriverAndBranchVersion", 0x2926aaad }, - { "NvAPI_GPU_GetMemoryInfo", 0x07f9b368 }, - { "NvAPI_GPU_GetMemoryInfoEx", 0xc0599498 }, - { "NvAPI_OGL_ExpertModeSet", 0x3805ef7a }, - { "NvAPI_OGL_ExpertModeGet", 0x22ed9516 }, - { "NvAPI_OGL_ExpertModeDefaultsSet", 0xb47a657e }, - { "NvAPI_OGL_ExpertModeDefaultsGet", 0xae921f12 }, - { "NvAPI_EnumPhysicalGPUs", 0xe5ac921f }, - { "NvAPI_EnumTCCPhysicalGPUs", 0xd9930b07 }, - { "NvAPI_EnumLogicalGPUs", 0x48b3ea59 }, - { "NvAPI_GetPhysicalGPUsFromDisplay", 0x34ef9506 }, - { "NvAPI_GetPhysicalGPUFromUnAttachedDisplay", 0x5018ed61 }, - { "NvAPI_GetLogicalGPUFromDisplay", 0xee1370cf }, - { "NvAPI_GetLogicalGPUFromPhysicalGPU", 0xadd604d1 }, - { "NvAPI_GetPhysicalGPUsFromLogicalGPU", 0xaea3fa32 }, - { "NvAPI_GetPhysicalGPUFromGPUID", 0x5380ad1a }, - { "NvAPI_GetGPUIDfromPhysicalGPU", 0x6533ea3e }, - { "NvAPI_GPU_GetShaderSubPipeCount", 0x0be17923 }, - { "NvAPI_GPU_GetGpuCoreCount", 0xc7026a87 }, - { "NvAPI_GPU_GetAllOutputs", 0x7d554f8e }, - { "NvAPI_GPU_GetConnectedOutputs", 0x1730bfc9 }, - { "NvAPI_GPU_GetConnectedSLIOutputs", 0x0680de09 }, - { "NvAPI_GPU_GetConnectedDisplayIds", 0x0078dba2 }, - { "NvAPI_GPU_GetAllDisplayIds", 0x785210a2 }, - { "NvAPI_GPU_GetConnectedOutputsWithLidState", 0xcf8caf39 }, - { "NvAPI_GPU_GetConnectedSLIOutputsWithLidState", 0x96043cc7 }, - { "NvAPI_GPU_GetSystemType", 0xbaaabfcc }, - { "NvAPI_GPU_GetActiveOutputs", 0xe3e89b6f }, - { "NvAPI_GPU_SetEDID", 0xe83d6456 }, - { "NvAPI_GPU_GetOutputType", 0x40a505e4 }, - { "NvAPI_GPU_ValidateOutputCombination", 0x34c9c2d4 }, - { "NvAPI_GPU_GetFullName", 0xceee8e9f }, - { "NvAPI_GPU_GetPCIIdentifiers", 0x2ddfb66e }, - { "NvAPI_GPU_GetGPUType", 0xc33baeb1 }, - { "NvAPI_GPU_GetBusType", 0x1bb18724 }, - { "NvAPI_GPU_GetBusId", 0x1be0b8e5 }, - { "NvAPI_GPU_GetBusSlotId", 0x2a0a350f }, - { "NvAPI_GPU_GetIRQ", 0xe4715417 }, - { "NvAPI_GPU_GetVbiosRevision", 0xacc3da0a }, - { "NvAPI_GPU_GetVbiosOEMRevision", 0x2d43fb31 }, - { "NvAPI_GPU_GetVbiosVersionString", 0xa561fd7d }, - { "NvAPI_GPU_GetAGPAperture", 0x6e042794 }, - { "NvAPI_GPU_GetCurrentAGPRate", 0xc74925a0 }, - { "NvAPI_GPU_GetCurrentPCIEDownstreamWidth", 0xd048c3b1 }, - { "NvAPI_GPU_GetPhysicalFrameBufferSize", 0x46fbeb03 }, - { "NvAPI_GPU_GetVirtualFrameBufferSize", 0x5a04b644 }, - { "NvAPI_GPU_GetQuadroStatus", 0xe332fa47 }, - { "NvAPI_GPU_GetBoardInfo", 0x22d54523 }, - { "NvAPI_GPU_GetRamBusWidth", 0x7975c581 }, - { "NvAPI_GPU_GetArchInfo", 0xd8265d24 }, - { "NvAPI_I2CRead", 0x2fde12c5 }, - { "NvAPI_I2CWrite", 0xe812eb07 }, - { "NvAPI_GPU_WorkstationFeatureSetup", 0x6c1f3fe4 }, - { "NvAPI_GPU_WorkstationFeatureQuery", 0x004537df }, - { "NvAPI_GPU_GetHDCPSupportStatus", 0xf089eef5 }, - { "NvAPI_GPU_CudaEnumComputeCapableGpus", 0x5786cc6e }, - { "NvAPI_GPU_GetTachReading", 0x5f608315 }, - { "NvAPI_GPU_GetECCStatusInfo", 0xca1ddaf3 }, - { "NvAPI_GPU_GetECCErrorInfo", 0xc71f85a6 }, - { "NvAPI_GPU_ResetECCErrorInfo", 0xc02eec20 }, - { "NvAPI_GPU_GetECCConfigurationInfo", 0x77a796f3 }, - { "NvAPI_GPU_SetECCConfiguration", 0x1cf639d9 }, - { "NvAPI_GPU_QueryWorkstationFeatureSupport", 0x80b1abb9 }, - { "NvAPI_GPU_SetScanoutIntensity", 0xa57457a4 }, - { "NvAPI_GPU_GetScanoutIntensityState", 0xe81ce836 }, - { "NvAPI_GPU_SetScanoutWarping", 0xb34bab4f }, - { "NvAPI_GPU_GetScanoutWarpingState", 0x6f5435af }, - { "NvAPI_GPU_SetScanoutCompositionParameter", 0xf898247d }, - { "NvAPI_GPU_GetScanoutCompositionParameter", 0x58fe51e6 }, - { "NvAPI_GPU_GetScanoutConfiguration", 0x6a9f5b63 }, - { "NvAPI_GPU_GetScanoutConfigurationEx", 0xe2e1e6f0 }, - { "NvAPI_GPU_GetAdapterIdFromPhysicalGpu", 0x0ff07fde }, - { "NvAPI_GPU_GetVirtualizationInfo", 0x44e022a9 }, - { "NvAPI_GPU_GetLogicalGpuInfo", 0x842b066e }, - { "NvAPI_GPU_GetLicensableFeatures", 0x3fc596aa }, - { "NvAPI_GPU_GetEncoderStatistics", 0xf0a9aeeb }, - { "NvAPI_GPU_GetEncoderSessionsInfo", 0xd8a72ce5 }, - { "NvAPI_GPU_GetGPUInfo", 0xafd1b02c }, - { "NvAPI_GPU_GetVRReadyData", 0x81d629c5 }, - { "NvAPI_GPU_GetGspFeatures", 0x581c4391 }, - { "NvAPI_GPU_GetUUID", 0xdc95673d }, - { "NvAPI_GPU_NVLINK_GetCaps", 0xbef1119d }, - { "NvAPI_GPU_NVLINK_GetStatus", 0xc72a38e3 }, - { "NvAPI_GPU_GetPerfDecreaseInfo", 0x7f7f4600 }, - { "NvAPI_GPU_GetPstatesInfoEx", 0x843c0256 }, - { "NvAPI_GPU_GetPstates20", 0x6ff81213 }, - { "NvAPI_GPU_GetCurrentPstate", 0x927da4f6 }, - { "NvAPI_GPU_GetDynamicPstatesInfoEx", 0x60ded2ed }, - { "NvAPI_GPU_GetThermalSettings", 0xe3640a56 }, - { "NvAPI_GPU_GetAllClockFrequencies", 0xdcb616c3 }, - { "NvAPI_GPU_QueryIlluminationSupport", 0xa629da31 }, - { "NvAPI_GPU_GetIllumination", 0x9a1b9365 }, - { "NvAPI_GPU_SetIllumination", 0x0254a187 }, - { "NvAPI_GPU_ClientIllumDevicesGetInfo", 0xd4100e58 }, - { "NvAPI_GPU_ClientIllumDevicesGetControl", 0x73c01d58 }, - { "NvAPI_GPU_ClientIllumDevicesSetControl", 0x57024c62 }, - { "NvAPI_GPU_ClientIllumZonesGetInfo", 0x4b81241b }, - { "NvAPI_GPU_ClientIllumZonesGetControl", 0x3dbf5764 }, - { "NvAPI_GPU_ClientIllumZonesSetControl", 0x197d065e }, - { "NvAPI_Event_RegisterCallback", 0xe6dbea69 }, - { "NvAPI_Event_UnregisterCallback", 0xde1f9b45 }, - { "NvAPI_EnumNvidiaDisplayHandle", 0x9abdd40d }, - { "NvAPI_EnumNvidiaUnAttachedDisplayHandle", 0x20de9260 }, - { "NvAPI_CreateDisplayFromUnAttachedDisplay", 0x63f9799e }, - { "NvAPI_GetAssociatedNvidiaDisplayHandle", 0x35c29134 }, - { "NvAPI_DISP_GetAssociatedUnAttachedNvidiaDisplayHandle", 0xa70503b2 }, - { "NvAPI_GetAssociatedNvidiaDisplayName", 0x22a78b05 }, - { "NvAPI_GetUnAttachedAssociatedDisplayName", 0x4888d790 }, - { "NvAPI_EnableHWCursor", 0x2863148d }, - { "NvAPI_DisableHWCursor", 0xab163097 }, - { "NvAPI_GetVBlankCounter", 0x67b5db55 }, - { "NvAPI_SetRefreshRateOverride", 0x3092ac32 }, - { "NvAPI_GetAssociatedDisplayOutputId", 0xd995937e }, - { "NvAPI_GetDisplayPortInfo", 0xc64ff367 }, - { "NvAPI_SetDisplayPort", 0xfa13e65a }, - { "NvAPI_GetHDMISupportInfo", 0x6ae16ec3 }, - { "NvAPI_Disp_InfoFrameControl", 0x6067af3f }, - { "NvAPI_Disp_ColorControl", 0x92f9d80d }, - { "NvAPI_Disp_GetHdrCapabilities", 0x84f2a8df }, - { "NvAPI_Disp_HdrColorControl", 0x351da224 }, - { "NvAPI_Disp_SetSourceColorSpace", 0x473b6caf }, - { "NvAPI_Disp_GetSourceColorSpace", 0xceedc85b }, - { "NvAPI_Disp_SetSourceHdrMetadata", 0x905eb63b }, - { "NvAPI_Disp_GetSourceHdrMetadata", 0x0d3f52da }, - { "NvAPI_Disp_SetOutputMode", 0x98e7661a }, - { "NvAPI_Disp_GetOutputMode", 0x81fed88d }, - { "NvAPI_Disp_SetHdrToneMapping", 0xdd6da362 }, - { "NvAPI_Disp_GetHdrToneMapping", 0xfbd36e71 }, - { "NvAPI_Disp_GetColorimetry", 0x00b421ad }, - { "NvAPI_DISP_GetTiming", 0x175167e9 }, - { "NvAPI_DISP_GetMonitorCapabilities", 0x3b05c7e1 }, - { "NvAPI_DISP_GetMonitorColorCapabilities", 0x6ae4cfb5 }, - { "NvAPI_DISP_EnumCustomDisplay", 0xa2072d59 }, - { "NvAPI_DISP_TryCustomDisplay", 0x1f7db630 }, - { "NvAPI_DISP_DeleteCustomDisplay", 0x552e5b9b }, - { "NvAPI_DISP_SaveCustomDisplay", 0x49882876 }, - { "NvAPI_DISP_RevertCustomDisplayTrial", 0xcbbd40f0 }, - { "NvAPI_GetView", 0xd6b99d89 }, - { "NvAPI_GetViewEx", 0xdbbc0af4 }, - { "NvAPI_GetSupportedViews", 0x66fb7fc0 }, - { "NvAPI_DISP_GetDisplayIdByDisplayName", 0xae457190 }, - { "NvAPI_DISP_GetGDIPrimaryDisplayId", 0x1e9d8a31 }, - { "NvAPI_DISP_GetDisplayConfig", 0x11abccf8 }, - { "NvAPI_DISP_SetDisplayConfig", 0x5d8cf8de }, - { "NvAPI_DISP_GetEdidData", 0x436ced76 }, - { "NvAPI_DISP_GetAdaptiveSyncData", 0xb73d1ee9 }, - { "NvAPI_DISP_SetAdaptiveSyncData", 0x3eebba1d }, - { "NvAPI_DISP_GetVirtualRefreshRateData", 0x8c00429a }, - { "NvAPI_DISP_SetVirtualRefreshRateData", 0x5abbe6a3 }, - { "NvAPI_DISP_SetPreferredStereoDisplay", 0xc9d0e25f }, - { "NvAPI_DISP_GetPreferredStereoDisplay", 0x1f6b4666 }, - { "NvAPI_DISP_GetNvManagedDedicatedDisplays", 0xdbdf0cb2 }, - { "NvAPI_DISP_AcquireDedicatedDisplay", 0x47c917ba }, - { "NvAPI_DISP_ReleaseDedicatedDisplay", 0x1247825f }, - { "NvAPI_DISP_GetNvManagedDedicatedDisplayMetadata", 0xd645d80c }, - { "NvAPI_DISP_SetNvManagedDedicatedDisplayMetadata", 0x3d8b129a }, - { "NvAPI_Disp_GetDisplayIdInfo", 0xbae8aa5e }, - { "NvAPI_Disp_GetDisplayIdsFromTarget", 0xe7e5f89e }, - { "NvAPI_Disp_GetVRRInfo", 0xdf8fda57 }, - { "NvAPI_Mosaic_GetSupportedTopoInfo", 0xfdb63c81 }, - { "NvAPI_Mosaic_GetTopoGroup", 0xcb89381d }, - { "NvAPI_Mosaic_GetOverlapLimits", 0x989685f0 }, - { "NvAPI_Mosaic_SetCurrentTopo", 0x9b542831 }, - { "NvAPI_Mosaic_GetCurrentTopo", 0xec32944e }, - { "NvAPI_Mosaic_EnableCurrentTopo", 0x5f1aa66c }, - { "NvAPI_Mosaic_GetDisplayViewportsByResolution", 0xdc6dc8d3 }, - { "NvAPI_Mosaic_SetDisplayGrids", 0x4d959a89 }, - { "NvAPI_Mosaic_ValidateDisplayGrids", 0xcf43903d }, - { "NvAPI_Mosaic_EnumDisplayModes", 0x78db97d7 }, - { "NvAPI_Mosaic_EnumDisplayGrids", 0xdf2887af }, - { "NvAPI_GetSupportedMosaicTopologies", 0x410b5c25 }, - { "NvAPI_GetCurrentMosaicTopology", 0xf60852bd }, - { "NvAPI_SetCurrentMosaicTopology", 0xd54b8989 }, - { "NvAPI_EnableCurrentMosaicTopology", 0x74073cc9 }, - { "NvAPI_GSync_EnumSyncDevices", 0xd9639601 }, - { "NvAPI_GSync_QueryCapabilities", 0x44a3f1d1 }, - { "NvAPI_GSync_GetTopology", 0x4562bc38 }, - { "NvAPI_GSync_SetSyncStateSettings", 0x60acdfdd }, - { "NvAPI_GSync_GetControlParameters", 0x16de1c6a }, - { "NvAPI_GSync_SetControlParameters", 0x8bbff88b }, - { "NvAPI_GSync_AdjustSyncDelay", 0x2d11ff51 }, - { "NvAPI_GSync_GetSyncStatus", 0xf1f5b434 }, - { "NvAPI_GSync_GetStatusParameters", 0x70d404ec }, - { "NvAPI_D3D_GetCurrentSLIState", 0x4b708b54 }, - { "NvAPI_D3D9_RegisterResource", 0xa064bdfc }, - { "NvAPI_D3D9_UnregisterResource", 0xbb2b17aa }, - { "NvAPI_D3D9_AliasSurfaceAsTexture", 0xe5ceae41 }, - { "NvAPI_D3D9_StretchRectEx", 0x22de03aa }, - { "NvAPI_D3D9_ClearRT", 0x332d3942 }, - { "NvAPI_D3D_GetObjectHandleForResource", 0xfceac864 }, - { "NvAPI_D3D_SetResourceHint", 0x6c0ed98c }, - { "NvAPI_D3D_BeginResourceRendering", 0x91123d6a }, - { "NvAPI_D3D_EndResourceRendering", 0x37e7191c }, - { "NvAPI_D3D9_GetSurfaceHandle", 0x0f2dd3f2 }, - { "NvAPI_D3D9_VideoSetStereoInfo", 0xb852f4db }, - { "NvAPI_D3D10_SetDepthBoundsTest", 0x4eadf5d2 }, - { "NvAPI_D3D11_CreateDevice", 0x6a16d3a0 }, - { "NvAPI_D3D11_CreateDeviceAndSwapChain", 0xbb939ee5 }, - { "NvAPI_D3D11_SetDepthBoundsTest", 0x7aaf7a04 }, - { "NvAPI_D3D11_IsNvShaderExtnOpCodeSupported", 0x5f68da40 }, - { "NvAPI_D3D11_SetNvShaderExtnSlot", 0x8e90bb9f }, - { "NvAPI_D3D12_SetNvShaderExtnSlotSpace", 0xac2dfeb5 }, - { "NvAPI_D3D12_SetNvShaderExtnSlotSpaceLocalThread", 0x43d867c0 }, - { "NvAPI_D3D11_SetNvShaderExtnSlotLocalThread", 0x0e6482a0 }, - { "NvAPI_D3D11_BeginUAVOverlapEx", 0xba08208a }, - { "NvAPI_D3D11_BeginUAVOverlap", 0x65b93ca8 }, - { "NvAPI_D3D11_EndUAVOverlap", 0x2216a357 }, - { "NvAPI_D3D11_GetResourceHandle", 0x09d52986 }, - { "NvAPI_D3D_SetFPSIndicatorState", 0xa776e8db }, - { "NvAPI_D3D9_Present", 0x05650beb }, - { "NvAPI_D3D9_QueryFrameCount", 0x9083e53a }, - { "NvAPI_D3D9_ResetFrameCount", 0xfa6a0675 }, - { "NvAPI_D3D9_QueryMaxSwapGroup", 0x5995410d }, - { "NvAPI_D3D9_QuerySwapGroup", 0xeba4d232 }, - { "NvAPI_D3D9_JoinSwapGroup", 0x7d44bb54 }, - { "NvAPI_D3D9_BindSwapBarrier", 0x9c39c246 }, - { "NvAPI_D3D_SetVerticalSyncMode", 0x5526cfd1 }, - { "NvAPI_D3D1x_Present", 0x03b845a1 }, - { "NvAPI_D3D1x_QueryFrameCount", 0x9152e055 }, - { "NvAPI_D3D1x_ResetFrameCount", 0xfbbb031a }, - { "NvAPI_D3D1x_QueryMaxSwapGroup", 0x9bb9d68f }, - { "NvAPI_D3D1x_QuerySwapGroup", 0x407f67aa }, - { "NvAPI_D3D1x_JoinSwapGroup", 0x14610cd7 }, - { "NvAPI_D3D1x_BindSwapBarrier", 0x9de8c729 }, - { "NvAPI_D3D12_QueryPresentBarrierSupport", 0xa15faef7 }, - { "NvAPI_D3D12_CreatePresentBarrierClient", 0x4d815de9 }, - { "NvAPI_D3D12_RegisterPresentBarrierResources", 0xd53c9ef0 }, - { "NvAPI_DestroyPresentBarrierClient", 0x3c5c351b }, - { "NvAPI_JoinPresentBarrier", 0x17f6bf82 }, - { "NvAPI_LeavePresentBarrier", 0xc3ec5a7f }, - { "NvAPI_QueryPresentBarrierFrameStatistics", 0x61b844a1 }, - { "NvAPI_D3D12_CreateDDisplayPresentBarrierClient", 0xb5a21987 }, - { "NvAPI_D3D11_CreateRasterizerState", 0xdb8d28af }, - { "NvAPI_D3D_ConfigureAnsel", 0x341c6c7f }, - { "NvAPI_D3D11_CreateTiledTexture2DArray", 0x7886981a }, - { "NvAPI_D3D11_CheckFeatureSupport", 0x106a487e }, - { "NvAPI_D3D11_CreateImplicitMSAATexture2D", 0xb8f79632 }, - { "NvAPI_D3D12_CreateCommittedImplicitMSAATexture2D", 0x24c6a07b }, - { "NvAPI_D3D11_ResolveSubresourceRegion", 0xe6bfedd6 }, - { "NvAPI_D3D12_ResolveSubresourceRegion", 0xc24a15bf }, - { "NvAPI_D3D11_TiledTexture2DArrayGetDesc", 0xf1a2b9d5 }, - { "NvAPI_D3D11_UpdateTileMappings", 0x9a06ea07 }, - { "NvAPI_D3D11_CopyTileMappings", 0xc09ee6bc }, - { "NvAPI_D3D11_TiledResourceBarrier", 0xd6839099 }, - { "NvAPI_D3D11_AliasMSAATexture2DAsNonMSAA", 0xf1c54fc9 }, - { "NvAPI_D3D11_CreateGeometryShaderEx_2", 0x99ed5c1c }, - { "NvAPI_D3D11_CreateVertexShaderEx", 0x0beaa0b2 }, - { "NvAPI_D3D11_CreateHullShaderEx", 0xb53cab00 }, - { "NvAPI_D3D11_CreateDomainShaderEx", 0xa0d7180d }, - { "NvAPI_D3D11_CreatePixelShaderEx_2", 0x4162822b }, - { "NvAPI_D3D11_CreateFastGeometryShaderExplicit", 0x71ab7c9c }, - { "NvAPI_D3D11_CreateFastGeometryShader", 0x525d43be }, - { "NvAPI_D3D11_DecompressView", 0x3a94e822 }, - { "NvAPI_D3D12_CreateGraphicsPipelineState", 0x2fc28856 }, - { "NvAPI_D3D12_CreateComputePipelineState", 0x2762deac }, - { "NvAPI_D3D12_SetDepthBoundsTestValues", 0xb9333fe9 }, - { "NvAPI_D3D12_CreateReservedResource", 0x2c85f101 }, - { "NvAPI_D3D12_CreateHeap", 0x5cb397cf }, - { "NvAPI_D3D12_CreateHeap2", 0x924be9d6 }, - { "NvAPI_D3D12_QueryCpuVisibleVidmem", 0x26322bc3 }, - { "NvAPI_D3D12_ReservedResourceGetDesc", 0x9aa2aabb }, - { "NvAPI_D3D12_UpdateTileMappings", 0xc6017a7d }, - { "NvAPI_D3D12_CopyTileMappings", 0x47f78194 }, - { "NvAPI_D3D12_ResourceAliasingBarrier", 0xb942bab7 }, - { "NvAPI_D3D12_CaptureUAVInfo", 0x6e5ea9db }, - { "NvAPI_D3D11_GetResourceGPUVirtualAddressEx", 0xaf6d14da }, - { "NvAPI_D3D11_EnumerateMetaCommands", 0xc7453ba8 }, - { "NvAPI_D3D11_CreateMetaCommand", 0xf505fba0 }, - { "NvAPI_D3D11_InitializeMetaCommand", 0xaec629e9 }, - { "NvAPI_D3D11_ExecuteMetaCommand", 0x82236c47 }, - { "NvAPI_D3D12_EnumerateMetaCommands", 0xcd9141d8 }, - { "NvAPI_D3D12_CreateMetaCommand", 0xeb29634b }, - { "NvAPI_D3D12_InitializeMetaCommand", 0xa4125399 }, - { "NvAPI_D3D12_ExecuteMetaCommand", 0xde24fc3d }, - { "NvAPI_D3D12_CreateCommittedResource", 0x027e98ae }, - { "NvAPI_D3D12_GetCopyableFootprints", 0xf6305eb5 }, - { "NvAPI_D3D12_CopyTextureRegion", 0x82b91b25 }, - { "NvAPI_D3D12_IsNvShaderExtnOpCodeSupported", 0x3dfacec8 }, - { "NvAPI_D3D12_GetOptimalThreadCountForMesh", 0xb43995cb }, - { "NvAPI_D3D_IsGSyncCapable", 0x9c1eed78 }, - { "NvAPI_D3D_IsGSyncActive", 0xe942b0ff }, - { "NvAPI_D3D12_SetFlipConfig", 0xf3148c42 }, - { "NvAPI_D3D1x_DisableShaderDiskCache", 0xd0cbca7d }, - { "NvAPI_D3D11_MultiGPU_GetCaps", 0xd2d25687 }, - { "NvAPI_D3D11_MultiGPU_Init", 0x017be49e }, - { "NvAPI_D3D11_CreateMultiGPUDevice", 0xbdb20007 }, - { "NvAPI_D3D_QuerySinglePassStereoSupport", 0x6f5f0a6d }, - { "NvAPI_D3D_SetSinglePassStereoMode", 0xa39e6e6e }, - { "NvAPI_D3D12_QuerySinglePassStereoSupport", 0x3b03791b }, - { "NvAPI_D3D12_SetSinglePassStereoMode", 0x83556d87 }, - { "NvAPI_D3D_QueryMultiViewSupport", 0xb6e0a41c }, - { "NvAPI_D3D_SetMultiViewMode", 0x8285c8da }, - { "NvAPI_D3D_QueryModifiedWSupport", 0xcbf9f4f5 }, - { "NvAPI_D3D_SetModifiedWMode", 0x06ea4bf4 }, - { "NvAPI_D3D12_QueryModifiedWSupport", 0x51235248 }, - { "NvAPI_D3D12_SetModifiedWMode", 0xe1fdaba7 }, - { "NvAPI_D3D_CreateLateLatchObject", 0x2db27d09 }, - { "NvAPI_D3D_QueryLateLatchSupport", 0x8ceca0ec }, - { "NvAPI_D3D_RegisterDevice", 0x8c02c4d0 }, - { "NvAPI_D3D11_MultiDrawInstancedIndirect", 0xd4e26bbf }, - { "NvAPI_D3D11_MultiDrawIndexedInstancedIndirect", 0x59e890f9 }, - { "NvAPI_D3D_ImplicitSLIControl", 0x2aede111 }, - { "NvAPI_D3D12_GetNeedsAppFPBlendClamping", 0x6ef4d2d1 }, - { "NvAPI_D3D12_UseDriverHeapPriorities", 0xf0d978a8 }, - { "NvAPI_D3D12_Mosaic_GetCompanionAllocations", 0xa46022c7 }, - { "NvAPI_D3D12_Mosaic_GetViewportAndGpuPartitions", 0xb092b818 }, - { "NvAPI_D3D1x_GetGraphicsCapabilities", 0x52b1499a }, - { "NvAPI_D3D12_GetGraphicsCapabilities", 0x01e87354 }, - { "NvAPI_D3D11_RSSetExclusiveScissorRects", 0xae4d73ef }, - { "NvAPI_D3D11_RSSetViewportsPixelShadingRates", 0x34f7938f }, - { "NvAPI_D3D11_CreateShadingRateResourceView", 0x99ca2dff }, - { "NvAPI_D3D11_RSSetShadingRateResourceView", 0x1b0c2f83 }, - { "NvAPI_D3D11_RSGetPixelShadingRateSampleOrder", 0x092442a1 }, - { "NvAPI_D3D11_RSSetPixelShadingRateSampleOrder", 0xa942373a }, - { "NvAPI_D3D_InitializeVRSHelper", 0x4780d70b }, - { "NvAPI_D3D_InitializeNvGazeHandler", 0x5b3b7479 }, - { "NvAPI_D3D_InitializeSMPAssist", 0x42763d0c }, - { "NvAPI_D3D_QuerySMPAssistSupport", 0xc57921de }, - { "NvAPI_D3D_GetSleepStatus", 0xaef96ca1 }, - { "NvAPI_D3D_SetSleepMode", 0xac1ca9e0 }, - { "NvAPI_D3D_Sleep", 0x852cd1d2 }, - { "NvAPI_D3D_SetReflexSync", 0xb9f6faff }, - { "NvAPI_D3D_GetLatency", 0x1a587f9c }, - { "NvAPI_D3D_SetLatencyMarker", 0xd9984c05 }, - { "NvAPI_D3D12_SetAsyncFrameMarker", 0x13c98f73 }, - { "NvAPI_D3D11_SetAsyncFrameMarker", 0x59c2c510 }, - { "NvAPI_D3D12_NotifyOutOfBandCommandQueue", 0x03d6e8cb }, - { "NvAPI_D3D12_SetCreateCommandQueueLowLatencyHint", 0x548c224f }, - { "NvAPI_D3D12_CreateCubinComputeShaderExV2", 0x299f5fdc }, - { "NvAPI_D3D12_CreateCubinComputeShader", 0x2a2c79e8 }, - { "NvAPI_D3D12_CreateCubinComputeShaderEx", 0x3151211b }, - { "NvAPI_D3D12_CreateCubinComputeShaderWithName", 0x1dc7261f }, - { "NvAPI_D3D12_LaunchCubinShader", 0x5c52bb86 }, - { "NvAPI_D3D12_DestroyCubinComputeShader", 0x7fb785ba }, - { "NvAPI_D3D12_GetCudaMergedTextureSamplerObject", 0x329fe6e0 }, - { "NvAPI_D3D12_GetCudaIndependentDescriptorObject", 0x0ddac234 }, - { "NvAPI_D3D12_GetCudaTextureObject", 0x80403fc9 }, - { "NvAPI_D3D12_GetCudaSurfaceObject", 0x48f5b2ee }, - { "NvAPI_D3D12_IsFatbinPTXSupported", 0x70c07832 }, - { "NvAPI_D3D12_CreateCuModule", 0xad1a677d }, - { "NvAPI_D3D12_EnumFunctionsInModule", 0x7ab88d88 }, - { "NvAPI_D3D12_CreateCuFunction", 0xe2436e22 }, - { "NvAPI_D3D12_LaunchCuKernelChain", 0x24973538 }, - { "NvAPI_D3D12_LaunchCuKernelChainEx", 0x846a9bf0 }, - { "NvAPI_D3D12_DestroyCuModule", 0x41c65285 }, - { "NvAPI_D3D12_DestroyCuFunction", 0xdf295ea6 }, - { "NvAPI_D3D11_CreateCubinComputeShaderExV2", 0xf2c71d48 }, - { "NvAPI_D3D11_CreateCubinComputeShader", 0x0ed98181 }, - { "NvAPI_D3D11_CreateCubinComputeShaderEx", 0x32c2a0f6 }, - { "NvAPI_D3D11_CreateCubinComputeShaderWithName", 0xb672be19 }, - { "NvAPI_D3D11_LaunchCubinShader", 0x427e236d }, - { "NvAPI_D3D11_DestroyCubinComputeShader", 0x01682c86 }, - { "NvAPI_D3D11_IsFatbinPTXSupported", 0x6086bd93 }, - { "NvAPI_D3D11_GetCudaIndependentViewObject", 0x34d2afa8 }, - { "NvAPI_D3D11_GetCudaMergedTextureSamplerObject", 0x5d637d8f }, - { "NvAPI_D3D11_CreateUnorderedAccessView", 0x74a497a1 }, - { "NvAPI_D3D11_CreateShaderResourceView", 0x65cb431e }, - { "NvAPI_D3D11_CreateSamplerState", 0x89eca416 }, - { "NvAPI_D3D11_GetCudaTextureObject", 0x9006fa68 }, - { "NvAPI_D3D11_GetResourceGPUVirtualAddress", 0x1819b423 }, - { "NvAPI_D3D12_GetRaytracingCaps", 0x85a6c2a0 }, - { "NvAPI_D3D12_EnableRaytracingValidation", 0x1de5991b }, - { "NvAPI_D3D12_RegisterRaytracingValidationMessageCallback", 0x8554eb38 }, - { "NvAPI_D3D12_UnregisterRaytracingValidationMessageCallback", 0x26975da6 }, - { "NvAPI_D3D12_FlushRaytracingValidationMessages", 0xb8fb1fcb }, - { "NvAPI_D3D12_GetRaytracingDisplacementMicromapArrayPrebuildInfo", 0xfa99b6de }, - { "NvAPI_D3D12_GetRaytracingOpacityMicromapArrayPrebuildInfo", 0x4726d180 }, - { "NvAPI_D3D12_SetCreatePipelineStateOptions", 0x5c607a27 }, - { "NvAPI_D3D12_CheckDriverMatchingIdentifierEx", 0xafb237d4 }, - { "NvAPI_D3D12_GetRaytracingAccelerationStructurePrebuildInfoEx", 0x8d025b77 }, - { "NvAPI_D3D12_BuildRaytracingOpacityMicromapArray", 0x814f8d11 }, - { "NvAPI_D3D12_RelocateRaytracingOpacityMicromapArray", 0x0425c538 }, - { "NvAPI_D3D12_BuildRaytracingDisplacementMicromapArray", 0x066f569d }, - { "NvAPI_D3D12_RelocateRaytracingDisplacementMicromapArray", 0x1c142308 }, - { "NvAPI_D3D12_EmitRaytracingDisplacementMicromapArrayPostbuildInfo", 0x68b9a790 }, - { "NvAPI_D3D12_EmitRaytracingOpacityMicromapArrayPostbuildInfo", 0x1d9a39b6 }, - { "NvAPI_D3D12_BuildRaytracingAccelerationStructureEx", 0xe24ead45 }, - { "NvAPI_D3D12_QueryWorkstationFeatureProperties", 0xa92ea23a }, - { "NvAPI_D3D12_CreateCommittedRDMABuffer", 0xe78dcb44 }, - { "NvAPI_D3D12_ConvertCooperativeVectorMatrix", 0x0f252cb3 }, - { "NvAPI_D3D12_ConvertCooperativeVectorMatrixMultiple", 0x96ba5235 }, - { "NvAPI_D3D12_GetPhysicalDeviceCooperativeVectorProperties", 0x8f182aec }, - { "NvAPI_D3D12_GetRaytracingMultiIndirectClusterOperationRequirementsInfo", 0x5c9163f4 }, - { "NvAPI_D3D12_RaytracingExecuteMultiIndirectClusterOperation", 0x67c798af }, - { "NvAPI_D3D12_GetRaytracingPartitionedTlasIndirectPrebuildInfo", 0xcdfdc5f2 }, - { "NvAPI_D3D12_BuildRaytracingPartitionedTlasIndirect", 0x7cfc6fc3 }, - { "NvAPI_NGX_GetNGXOverrideState", 0x3fd96fba }, - { "NvAPI_NGX_SetNGXOverrideState", 0xb60fcb4e }, - { "NvAPI_DirectD3D12GraphicsCommandList_Create", 0x74a4e712 }, - { "NvAPI_DirectD3D12GraphicsCommandList_Release", 0x99da3dde }, - { "NvAPI_DirectD3D12GraphicsCommandList_Reset", 0x999c26d8 }, - { "NvAPI_VIO_GetCapabilities", 0x1dc91303 }, - { "NvAPI_VIO_Open", 0x44ee4841 }, - { "NvAPI_VIO_Close", 0xd01bd237 }, - { "NvAPI_VIO_Status", 0x0e6ce4f1 }, - { "NvAPI_VIO_SyncFormatDetect", 0x118d48a3 }, - { "NvAPI_VIO_GetConfig", 0xd34a789b }, - { "NvAPI_VIO_SetConfig", 0x0e4eec07 }, - { "NvAPI_VIO_SetCSC", 0xa1ec8d74 }, - { "NvAPI_VIO_GetCSC", 0x7b0d72a3 }, - { "NvAPI_VIO_SetGamma", 0x964bf452 }, - { "NvAPI_VIO_GetGamma", 0x51d53d06 }, - { "NvAPI_VIO_SetSyncDelay", 0x2697a8d1 }, - { "NvAPI_VIO_GetSyncDelay", 0x462214a9 }, - { "NvAPI_VIO_GetPCIInfo", 0xb981d935 }, - { "NvAPI_VIO_IsRunning", 0x96bd040e }, - { "NvAPI_VIO_Start", 0xcde8e1a3 }, - { "NvAPI_VIO_Stop", 0x6ba2a5d6 }, - { "NvAPI_VIO_IsFrameLockModeCompatible", 0x7bf0a94d }, - { "NvAPI_VIO_EnumDevices", 0xfd7c5557 }, - { "NvAPI_VIO_QueryTopology", 0x869534e2 }, - { "NvAPI_VIO_EnumSignalFormats", 0xead72fe4 }, - { "NvAPI_VIO_EnumDataFormats", 0x221fa8e8 }, - { "NvAPI_Stereo_CreateConfigurationProfileRegistryKey", 0xbe7692ec }, - { "NvAPI_Stereo_DeleteConfigurationProfileRegistryKey", 0xf117b834 }, - { "NvAPI_Stereo_SetConfigurationProfileValue", 0x24409f48 }, - { "NvAPI_Stereo_DeleteConfigurationProfileValue", 0x49bceecf }, - { "NvAPI_Stereo_Enable", 0x239c4545 }, - { "NvAPI_Stereo_Disable", 0x2ec50c2b }, - { "NvAPI_Stereo_IsEnabled", 0x348ff8e1 }, - { "NvAPI_Stereo_GetStereoSupport", 0x296c434d }, - { "NvAPI_Stereo_CreateHandleFromIUnknown", 0xac7e37f4 }, - { "NvAPI_Stereo_DestroyHandle", 0x3a153134 }, - { "NvAPI_Stereo_Activate", 0xf6a1ad68 }, - { "NvAPI_Stereo_Deactivate", 0x2d68de96 }, - { "NvAPI_Stereo_IsActivated", 0x1fb0bc30 }, - { "NvAPI_Stereo_GetSeparation", 0x451f2134 }, - { "NvAPI_Stereo_SetSeparation", 0x5c069fa3 }, - { "NvAPI_Stereo_DecreaseSeparation", 0xda044458 }, - { "NvAPI_Stereo_IncreaseSeparation", 0xc9a8ecec }, - { "NvAPI_Stereo_GetConvergence", 0x4ab00934 }, - { "NvAPI_Stereo_SetConvergence", 0x3dd6b54b }, - { "NvAPI_Stereo_DecreaseConvergence", 0x4c87e317 }, - { "NvAPI_Stereo_IncreaseConvergence", 0xa17daabe }, - { "NvAPI_Stereo_GetFrustumAdjustMode", 0xe6839b43 }, - { "NvAPI_Stereo_SetFrustumAdjustMode", 0x7be27fa2 }, - { "NvAPI_Stereo_CaptureJpegImage", 0x932cb140 }, - { "NvAPI_Stereo_InitActivation", 0xc7177702 }, - { "NvAPI_Stereo_Trigger_Activation", 0x0d6c6cd2 }, - { "NvAPI_Stereo_CapturePngImage", 0x8b7e99b5 }, - { "NvAPI_Stereo_ReverseStereoBlitControl", 0x3cd58f89 }, - { "NvAPI_Stereo_SetNotificationMessage", 0x6b9b409e }, - { "NvAPI_Stereo_SetActiveEye", 0x96eea9f8 }, - { "NvAPI_Stereo_SetDriverMode", 0x5e8f0bec }, - { "NvAPI_Stereo_GetEyeSeparation", 0xce653127 }, - { "NvAPI_Stereo_IsWindowedModeSupported", 0x40c8ed5e }, - { "NvAPI_Stereo_SetSurfaceCreationMode", 0xf5dcfcba }, - { "NvAPI_Stereo_GetSurfaceCreationMode", 0x36f1c736 }, - { "NvAPI_Stereo_Debug_WasLastDrawStereoized", 0xed4416c5 }, - { "NvAPI_Stereo_SetDefaultProfile", 0x44f0ecd1 }, - { "NvAPI_Stereo_GetDefaultProfile", 0x624e21c2 }, - { "NvAPI_D3D1x_CreateSwapChain", 0x1bc21b66 }, - { "NvAPI_D3D9_CreateSwapChain", 0x1a131e09 }, - { "NvAPI_Vulkan_InitLowLatencyDevice", 0x5c1696b6 }, - { "NvAPI_Vulkan_DestroyLowLatencyDevice", 0x11a5932b }, - { "NvAPI_Vulkan_GetSleepStatus", 0xadf966af }, - { "NvAPI_Vulkan_SetSleepMode", 0x2acfd162 }, - { "NvAPI_Vulkan_Sleep", 0x36732b1e }, - { "NvAPI_Vulkan_GetLatency", 0x3233d44a }, - { "NvAPI_Vulkan_SetLatencyMarker", 0xa17d13d6 }, - { "NvAPI_Vulkan_NotifyOutOfBandVkQueue", 0x5d6d3840 }, - { "NvAPI_DRS_CreateSession", 0x0694d52e }, - { "NvAPI_DRS_DestroySession", 0xdad9cff8 }, - { "NvAPI_DRS_LoadSettings", 0x375dbd6b }, - { "NvAPI_DRS_SaveSettings", 0xfcbc7e14 }, - { "NvAPI_DRS_LoadSettingsFromFile", 0xd3ede889 }, - { "NvAPI_DRS_SaveSettingsToFile", 0x2be25df8 }, - { "NvAPI_DRS_CreateProfile", 0xcc176068 }, - { "NvAPI_DRS_DeleteProfile", 0x17093206 }, - { "NvAPI_DRS_SetCurrentGlobalProfile", 0x1c89c5df }, - { "NvAPI_DRS_GetCurrentGlobalProfile", 0x617bff9f }, - { "NvAPI_DRS_GetProfileInfo", 0x61cd6fd6 }, - { "NvAPI_DRS_SetProfileInfo", 0x16abd3a9 }, - { "NvAPI_DRS_FindProfileByName", 0x7e4a9a0b }, - { "NvAPI_DRS_EnumProfiles", 0xbc371ee0 }, - { "NvAPI_DRS_GetNumProfiles", 0x1dae4fbc }, - { "NvAPI_DRS_CreateApplication", 0x4347a9de }, - { "NvAPI_DRS_DeleteApplicationEx", 0xc5ea85a1 }, - { "NvAPI_DRS_DeleteApplication", 0x2c694bc6 }, - { "NvAPI_DRS_GetApplicationInfo", 0xed1f8c69 }, - { "NvAPI_DRS_EnumApplications", 0x7fa2173a }, - { "NvAPI_DRS_FindApplicationByName", 0xeee566b2 }, - { "NvAPI_DRS_SetSetting", 0x577dd202 }, - { "NvAPI_DRS_GetSetting", 0x73bf8338 }, - { "NvAPI_DRS_EnumSettings", 0xae3039da }, - { "NvAPI_DRS_EnumAvailableSettingIds", 0xf020614a }, - { "NvAPI_DRS_EnumAvailableSettingValues", 0x2ec39f90 }, - { "NvAPI_DRS_GetSettingIdFromName", 0xcb7309cd }, - { "NvAPI_DRS_GetSettingNameFromId", 0xd61cbe6e }, - { "NvAPI_DRS_DeleteProfileSetting", 0xe4a26362 }, - { "NvAPI_DRS_RestoreAllDefaults", 0x5927b094 }, - { "NvAPI_DRS_RestoreProfileDefault", 0xfa5f6134 }, - { "NvAPI_DRS_RestoreProfileDefaultSetting", 0x53f0381e }, - { "NvAPI_DRS_GetBaseProfile", 0xda8466a0 }, - { "NvAPI_SYS_GetChipSetInfo", 0x53dabbca }, - { "NvAPI_SYS_GetLidAndDockInfo", 0xcda14d8a }, - { "NvAPI_SYS_GetDisplayIdFromGpuAndOutputId", 0x08f2bab4 }, - { "NvAPI_SYS_GetGpuAndOutputIdFromDisplayId", 0x112ba1a5 }, - { "NvAPI_SYS_GetPhysicalGpuFromDisplayId", 0x9ea74659 }, - { "NvAPI_SYS_GetDisplayDriverInfo", 0x721faceb }, - { "NvAPI_SYS_GetPhysicalGPUs", 0xd3b24d2d }, - { "NvAPI_SYS_GetLogicalGPUs", 0xccfffc10 }, - { "NvAPI_NGX_GetDriverFeatureSupport", 0x6194b19d }, - { "NvAPI_GPU_ClientRegisterForUtilizationSampleUpdates", 0xadeeaf67 }, - { "NvAPI_RegisterRiseCallback", 0x9cfe8f94 }, - { "NvAPI_RequestRise", 0x5047de98 }, - { "NvAPI_UninstallRise", 0xab8d09f6 }, -); - -#[no_mangle] -pub unsafe extern "C" fn nvapi_QueryInterface(interface: u32) -> *mut c_void { - let maybe_fn_ptr_global = (&*GLOBAL_STATE).as_ref().and_then(|(lib, state)| { - let fn_ptr = lib - .get:: *mut c_void>(b"nvapi_QueryInterface\0") - .ok()?; - Some((fn_ptr, state)) - }); - let (fn_ptr, global_state) = - unwrap_or::unwrap_some_or!(maybe_fn_ptr_global, return ptr::null_mut()); - let export_table = unwrap_or::unwrap_some_or!( - ::zluda_trace_common::get_export_table(), - return ptr::null_mut() - ); - let format_args = dark_api::FnFfiWrapper(|| { - use std::io::Write; - let mut writer = Vec::new(); - let name = interface_to_name(interface); - match name { - Some(name) => write!(&mut writer, "(interface: {})", name).ok(), - None => write!(&mut writer, "(interface: {:#010x})", interface).ok(), - }; - dark_api::ByteVecFfi::new(writer) - }); - let underlying_fn = dark_api::FnFfiWrapper(|| { - let result = fn_ptr(interface); - result as usize - }); - let original = ReprUsize::from_usize(export_table.logged_call( - cglue::slice::CSliceRef::from_str("nvapi_QueryInterface"), - cglue::trait_obj!(&format_args as dark_api::FnFfi), - cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), - ptr::null_mut::() as usize, - <*mut c_void as ReprUsize>::format_status, - )); - if cfg!(target_pointer_width = "32") { - global_state - .lock() - .ok() - .map(|mut state| state.get_thunk(original, report_fn, interface)) - .unwrap_or_else(|| get_thunk(original, report_fn, interface)) - } else { - original - } -} - -unsafe extern "system" fn report_fn(interface: u32) { - use zluda_trace_common::Unknown; - let export_table = unwrap_or::unwrap_some_or!(::zluda_trace_common::get_export_table(), return); - let format_args = - dark_api::FnFfiWrapper(|| dark_api::ByteVecFfi::new("(...)".as_bytes().to_vec())); - let underlying_fn = dark_api::FnFfiWrapper(|| 0); - let fn_name = match interface_to_name(interface) { - Some(name) => name.to_string(), - None => { - format!("{{nvapi:{:#010x}}}", interface) - } - }; - export_table.logged_call( - cglue::slice::CSliceRef::from_str(mem::transmute(&*fn_name)), - cglue::trait_obj!(&format_args as dark_api::FnFfi), - cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), - ::INTERNAL_ERROR, - ::format_status, - ); -} - -#[cfg(target_arch = "x86")] -pub fn get_thunk( - original_fn: *mut c_void, - report_fn: unsafe extern "system" fn(u32), - interface: u32, -) -> *mut c_void { - use dynasmrt::{dynasm, DynasmApi}; - let mut ops = dynasmrt::x86::Assembler::new().unwrap(); - let start = ops.offset(); - dynasm!(ops - ; .arch x86 - ; push interface as i32 - ; mov eax, report_fn as i32 - ; call eax - ; mov eax, original_fn as i32 - ; jmp eax - ; int 3 - ); - let exe_buf = ops.finalize().unwrap(); - let result_fn = exe_buf.ptr(start); - std::mem::forget(exe_buf); - result_fn as *mut _ -} - -#[cfg(target_arch = "x86_64")] -pub fn get_thunk( - _original_fn: *mut c_void, - _report_fn: unsafe extern "system" fn(u32), - _interface: u32, -) -> *mut c_void { - todo!() -} +use libloading::Library; +use rustc_hash::FxHashMap; +use std::{ + collections::hash_map, + ffi::c_void, + mem, ptr, + sync::{LazyLock, Mutex}, +}; +use zluda_trace_common::ReprUsize; + +static GLOBAL_STATE: LazyLock)>> = + LazyLock::new(get_global_state); + +fn get_global_state() -> Option<(Library, Mutex)> { + let cuda_lib = std::env::var("ZLUDA_NVAPI_LIB").ok().unwrap_or_else(|| { + if cfg!(target_pointer_width = "64") { + r"C:\Windows\System32\nvapi64.dll".to_string() + } else { + r"C:\Windows\System32\nvapi.dll".to_string() + } + }); + let lib = zluda_trace_common::dlopen_local_noredirect(cuda_lib).ok()?; + Some((Library::from(lib), Mutex::new(GlobalState::new()))) +} + +struct GlobalState { + thunks: FxHashMap, +} + +impl GlobalState { + fn new() -> Self { + GlobalState { + thunks: FxHashMap::default(), + } + } + + fn get_thunk( + &mut self, + original: *mut c_void, + report_fn: unsafe extern "system" fn(u32), + interface: u32, + ) -> *mut c_void { + match self.thunks.entry(interface) { + hash_map::Entry::Occupied(entry) => *entry.get() as *mut c_void, + hash_map::Entry::Vacant(entry) => { + let thunk = get_thunk(original, report_fn, interface); + entry.insert(thunk as usize); + thunk + } + } + } +} + +macro_rules! interface_to_name { + ($({ $name:literal, $id:literal }),* $(,)?) => { + fn interface_to_name(interface: u32) -> Option<&'static str> { + match interface { + $( + $id => Some($name), + )* + _ => None, + } + } + }; +} + +interface_to_name!( + { "NvAPI_Initialize", 0x0150e828 }, + { "NvAPI_Unload", 0xd22bdd7e }, + { "NvAPI_GetErrorMessage", 0x6c2d048c }, + { "NvAPI_GetInterfaceVersionString", 0x01053fa5 }, + { "NvAPI_GPU_GetEDID", 0x37d32e69 }, + { "NvAPI_SetView", 0x0957d7b6 }, + { "NvAPI_SetViewEx", 0x06b89e68 }, + { "NvAPI_GetDisplayDriverVersion", 0xf951a4d1 }, + { "NvAPI_SYS_GetDriverAndBranchVersion", 0x2926aaad }, + { "NvAPI_GPU_GetMemoryInfo", 0x07f9b368 }, + { "NvAPI_GPU_GetMemoryInfoEx", 0xc0599498 }, + { "NvAPI_OGL_ExpertModeSet", 0x3805ef7a }, + { "NvAPI_OGL_ExpertModeGet", 0x22ed9516 }, + { "NvAPI_OGL_ExpertModeDefaultsSet", 0xb47a657e }, + { "NvAPI_OGL_ExpertModeDefaultsGet", 0xae921f12 }, + { "NvAPI_EnumPhysicalGPUs", 0xe5ac921f }, + { "NvAPI_EnumTCCPhysicalGPUs", 0xd9930b07 }, + { "NvAPI_EnumLogicalGPUs", 0x48b3ea59 }, + { "NvAPI_GetPhysicalGPUsFromDisplay", 0x34ef9506 }, + { "NvAPI_GetPhysicalGPUFromUnAttachedDisplay", 0x5018ed61 }, + { "NvAPI_GetLogicalGPUFromDisplay", 0xee1370cf }, + { "NvAPI_GetLogicalGPUFromPhysicalGPU", 0xadd604d1 }, + { "NvAPI_GetPhysicalGPUsFromLogicalGPU", 0xaea3fa32 }, + { "NvAPI_GetPhysicalGPUFromGPUID", 0x5380ad1a }, + { "NvAPI_GetGPUIDfromPhysicalGPU", 0x6533ea3e }, + { "NvAPI_GPU_GetShaderSubPipeCount", 0x0be17923 }, + { "NvAPI_GPU_GetGpuCoreCount", 0xc7026a87 }, + { "NvAPI_GPU_GetAllOutputs", 0x7d554f8e }, + { "NvAPI_GPU_GetConnectedOutputs", 0x1730bfc9 }, + { "NvAPI_GPU_GetConnectedSLIOutputs", 0x0680de09 }, + { "NvAPI_GPU_GetConnectedDisplayIds", 0x0078dba2 }, + { "NvAPI_GPU_GetAllDisplayIds", 0x785210a2 }, + { "NvAPI_GPU_GetConnectedOutputsWithLidState", 0xcf8caf39 }, + { "NvAPI_GPU_GetConnectedSLIOutputsWithLidState", 0x96043cc7 }, + { "NvAPI_GPU_GetSystemType", 0xbaaabfcc }, + { "NvAPI_GPU_GetActiveOutputs", 0xe3e89b6f }, + { "NvAPI_GPU_SetEDID", 0xe83d6456 }, + { "NvAPI_GPU_GetOutputType", 0x40a505e4 }, + { "NvAPI_GPU_ValidateOutputCombination", 0x34c9c2d4 }, + { "NvAPI_GPU_GetFullName", 0xceee8e9f }, + { "NvAPI_GPU_GetPCIIdentifiers", 0x2ddfb66e }, + { "NvAPI_GPU_GetGPUType", 0xc33baeb1 }, + { "NvAPI_GPU_GetBusType", 0x1bb18724 }, + { "NvAPI_GPU_GetBusId", 0x1be0b8e5 }, + { "NvAPI_GPU_GetBusSlotId", 0x2a0a350f }, + { "NvAPI_GPU_GetIRQ", 0xe4715417 }, + { "NvAPI_GPU_GetVbiosRevision", 0xacc3da0a }, + { "NvAPI_GPU_GetVbiosOEMRevision", 0x2d43fb31 }, + { "NvAPI_GPU_GetVbiosVersionString", 0xa561fd7d }, + { "NvAPI_GPU_GetAGPAperture", 0x6e042794 }, + { "NvAPI_GPU_GetCurrentAGPRate", 0xc74925a0 }, + { "NvAPI_GPU_GetCurrentPCIEDownstreamWidth", 0xd048c3b1 }, + { "NvAPI_GPU_GetPhysicalFrameBufferSize", 0x46fbeb03 }, + { "NvAPI_GPU_GetVirtualFrameBufferSize", 0x5a04b644 }, + { "NvAPI_GPU_GetQuadroStatus", 0xe332fa47 }, + { "NvAPI_GPU_GetBoardInfo", 0x22d54523 }, + { "NvAPI_GPU_GetRamBusWidth", 0x7975c581 }, + { "NvAPI_GPU_GetArchInfo", 0xd8265d24 }, + { "NvAPI_I2CRead", 0x2fde12c5 }, + { "NvAPI_I2CWrite", 0xe812eb07 }, + { "NvAPI_GPU_WorkstationFeatureSetup", 0x6c1f3fe4 }, + { "NvAPI_GPU_WorkstationFeatureQuery", 0x004537df }, + { "NvAPI_GPU_GetHDCPSupportStatus", 0xf089eef5 }, + { "NvAPI_GPU_CudaEnumComputeCapableGpus", 0x5786cc6e }, + { "NvAPI_GPU_GetTachReading", 0x5f608315 }, + { "NvAPI_GPU_GetECCStatusInfo", 0xca1ddaf3 }, + { "NvAPI_GPU_GetECCErrorInfo", 0xc71f85a6 }, + { "NvAPI_GPU_ResetECCErrorInfo", 0xc02eec20 }, + { "NvAPI_GPU_GetECCConfigurationInfo", 0x77a796f3 }, + { "NvAPI_GPU_SetECCConfiguration", 0x1cf639d9 }, + { "NvAPI_GPU_QueryWorkstationFeatureSupport", 0x80b1abb9 }, + { "NvAPI_GPU_SetScanoutIntensity", 0xa57457a4 }, + { "NvAPI_GPU_GetScanoutIntensityState", 0xe81ce836 }, + { "NvAPI_GPU_SetScanoutWarping", 0xb34bab4f }, + { "NvAPI_GPU_GetScanoutWarpingState", 0x6f5435af }, + { "NvAPI_GPU_SetScanoutCompositionParameter", 0xf898247d }, + { "NvAPI_GPU_GetScanoutCompositionParameter", 0x58fe51e6 }, + { "NvAPI_GPU_GetScanoutConfiguration", 0x6a9f5b63 }, + { "NvAPI_GPU_GetScanoutConfigurationEx", 0xe2e1e6f0 }, + { "NvAPI_GPU_GetAdapterIdFromPhysicalGpu", 0x0ff07fde }, + { "NvAPI_GPU_GetVirtualizationInfo", 0x44e022a9 }, + { "NvAPI_GPU_GetLogicalGpuInfo", 0x842b066e }, + { "NvAPI_GPU_GetLicensableFeatures", 0x3fc596aa }, + { "NvAPI_GPU_GetEncoderStatistics", 0xf0a9aeeb }, + { "NvAPI_GPU_GetEncoderSessionsInfo", 0xd8a72ce5 }, + { "NvAPI_GPU_GetGPUInfo", 0xafd1b02c }, + { "NvAPI_GPU_GetVRReadyData", 0x81d629c5 }, + { "NvAPI_GPU_GetGspFeatures", 0x581c4391 }, + { "NvAPI_GPU_GetUUID", 0xdc95673d }, + { "NvAPI_GPU_NVLINK_GetCaps", 0xbef1119d }, + { "NvAPI_GPU_NVLINK_GetStatus", 0xc72a38e3 }, + { "NvAPI_GPU_GetPerfDecreaseInfo", 0x7f7f4600 }, + { "NvAPI_GPU_GetPstatesInfoEx", 0x843c0256 }, + { "NvAPI_GPU_GetPstates20", 0x6ff81213 }, + { "NvAPI_GPU_GetCurrentPstate", 0x927da4f6 }, + { "NvAPI_GPU_GetDynamicPstatesInfoEx", 0x60ded2ed }, + { "NvAPI_GPU_GetThermalSettings", 0xe3640a56 }, + { "NvAPI_GPU_GetAllClockFrequencies", 0xdcb616c3 }, + { "NvAPI_GPU_QueryIlluminationSupport", 0xa629da31 }, + { "NvAPI_GPU_GetIllumination", 0x9a1b9365 }, + { "NvAPI_GPU_SetIllumination", 0x0254a187 }, + { "NvAPI_GPU_ClientIllumDevicesGetInfo", 0xd4100e58 }, + { "NvAPI_GPU_ClientIllumDevicesGetControl", 0x73c01d58 }, + { "NvAPI_GPU_ClientIllumDevicesSetControl", 0x57024c62 }, + { "NvAPI_GPU_ClientIllumZonesGetInfo", 0x4b81241b }, + { "NvAPI_GPU_ClientIllumZonesGetControl", 0x3dbf5764 }, + { "NvAPI_GPU_ClientIllumZonesSetControl", 0x197d065e }, + { "NvAPI_Event_RegisterCallback", 0xe6dbea69 }, + { "NvAPI_Event_UnregisterCallback", 0xde1f9b45 }, + { "NvAPI_EnumNvidiaDisplayHandle", 0x9abdd40d }, + { "NvAPI_EnumNvidiaUnAttachedDisplayHandle", 0x20de9260 }, + { "NvAPI_CreateDisplayFromUnAttachedDisplay", 0x63f9799e }, + { "NvAPI_GetAssociatedNvidiaDisplayHandle", 0x35c29134 }, + { "NvAPI_DISP_GetAssociatedUnAttachedNvidiaDisplayHandle", 0xa70503b2 }, + { "NvAPI_GetAssociatedNvidiaDisplayName", 0x22a78b05 }, + { "NvAPI_GetUnAttachedAssociatedDisplayName", 0x4888d790 }, + { "NvAPI_EnableHWCursor", 0x2863148d }, + { "NvAPI_DisableHWCursor", 0xab163097 }, + { "NvAPI_GetVBlankCounter", 0x67b5db55 }, + { "NvAPI_SetRefreshRateOverride", 0x3092ac32 }, + { "NvAPI_GetAssociatedDisplayOutputId", 0xd995937e }, + { "NvAPI_GetDisplayPortInfo", 0xc64ff367 }, + { "NvAPI_SetDisplayPort", 0xfa13e65a }, + { "NvAPI_GetHDMISupportInfo", 0x6ae16ec3 }, + { "NvAPI_Disp_InfoFrameControl", 0x6067af3f }, + { "NvAPI_Disp_ColorControl", 0x92f9d80d }, + { "NvAPI_Disp_GetHdrCapabilities", 0x84f2a8df }, + { "NvAPI_Disp_HdrColorControl", 0x351da224 }, + { "NvAPI_Disp_SetSourceColorSpace", 0x473b6caf }, + { "NvAPI_Disp_GetSourceColorSpace", 0xceedc85b }, + { "NvAPI_Disp_SetSourceHdrMetadata", 0x905eb63b }, + { "NvAPI_Disp_GetSourceHdrMetadata", 0x0d3f52da }, + { "NvAPI_Disp_SetOutputMode", 0x98e7661a }, + { "NvAPI_Disp_GetOutputMode", 0x81fed88d }, + { "NvAPI_Disp_SetHdrToneMapping", 0xdd6da362 }, + { "NvAPI_Disp_GetHdrToneMapping", 0xfbd36e71 }, + { "NvAPI_Disp_GetColorimetry", 0x00b421ad }, + { "NvAPI_DISP_GetTiming", 0x175167e9 }, + { "NvAPI_DISP_GetMonitorCapabilities", 0x3b05c7e1 }, + { "NvAPI_DISP_GetMonitorColorCapabilities", 0x6ae4cfb5 }, + { "NvAPI_DISP_EnumCustomDisplay", 0xa2072d59 }, + { "NvAPI_DISP_TryCustomDisplay", 0x1f7db630 }, + { "NvAPI_DISP_DeleteCustomDisplay", 0x552e5b9b }, + { "NvAPI_DISP_SaveCustomDisplay", 0x49882876 }, + { "NvAPI_DISP_RevertCustomDisplayTrial", 0xcbbd40f0 }, + { "NvAPI_GetView", 0xd6b99d89 }, + { "NvAPI_GetViewEx", 0xdbbc0af4 }, + { "NvAPI_GetSupportedViews", 0x66fb7fc0 }, + { "NvAPI_DISP_GetDisplayIdByDisplayName", 0xae457190 }, + { "NvAPI_DISP_GetGDIPrimaryDisplayId", 0x1e9d8a31 }, + { "NvAPI_DISP_GetDisplayConfig", 0x11abccf8 }, + { "NvAPI_DISP_SetDisplayConfig", 0x5d8cf8de }, + { "NvAPI_DISP_GetEdidData", 0x436ced76 }, + { "NvAPI_DISP_GetAdaptiveSyncData", 0xb73d1ee9 }, + { "NvAPI_DISP_SetAdaptiveSyncData", 0x3eebba1d }, + { "NvAPI_DISP_GetVirtualRefreshRateData", 0x8c00429a }, + { "NvAPI_DISP_SetVirtualRefreshRateData", 0x5abbe6a3 }, + { "NvAPI_DISP_SetPreferredStereoDisplay", 0xc9d0e25f }, + { "NvAPI_DISP_GetPreferredStereoDisplay", 0x1f6b4666 }, + { "NvAPI_DISP_GetNvManagedDedicatedDisplays", 0xdbdf0cb2 }, + { "NvAPI_DISP_AcquireDedicatedDisplay", 0x47c917ba }, + { "NvAPI_DISP_ReleaseDedicatedDisplay", 0x1247825f }, + { "NvAPI_DISP_GetNvManagedDedicatedDisplayMetadata", 0xd645d80c }, + { "NvAPI_DISP_SetNvManagedDedicatedDisplayMetadata", 0x3d8b129a }, + { "NvAPI_Disp_GetDisplayIdInfo", 0xbae8aa5e }, + { "NvAPI_Disp_GetDisplayIdsFromTarget", 0xe7e5f89e }, + { "NvAPI_Disp_GetVRRInfo", 0xdf8fda57 }, + { "NvAPI_Mosaic_GetSupportedTopoInfo", 0xfdb63c81 }, + { "NvAPI_Mosaic_GetTopoGroup", 0xcb89381d }, + { "NvAPI_Mosaic_GetOverlapLimits", 0x989685f0 }, + { "NvAPI_Mosaic_SetCurrentTopo", 0x9b542831 }, + { "NvAPI_Mosaic_GetCurrentTopo", 0xec32944e }, + { "NvAPI_Mosaic_EnableCurrentTopo", 0x5f1aa66c }, + { "NvAPI_Mosaic_GetDisplayViewportsByResolution", 0xdc6dc8d3 }, + { "NvAPI_Mosaic_SetDisplayGrids", 0x4d959a89 }, + { "NvAPI_Mosaic_ValidateDisplayGrids", 0xcf43903d }, + { "NvAPI_Mosaic_EnumDisplayModes", 0x78db97d7 }, + { "NvAPI_Mosaic_EnumDisplayGrids", 0xdf2887af }, + { "NvAPI_GetSupportedMosaicTopologies", 0x410b5c25 }, + { "NvAPI_GetCurrentMosaicTopology", 0xf60852bd }, + { "NvAPI_SetCurrentMosaicTopology", 0xd54b8989 }, + { "NvAPI_EnableCurrentMosaicTopology", 0x74073cc9 }, + { "NvAPI_GSync_EnumSyncDevices", 0xd9639601 }, + { "NvAPI_GSync_QueryCapabilities", 0x44a3f1d1 }, + { "NvAPI_GSync_GetTopology", 0x4562bc38 }, + { "NvAPI_GSync_SetSyncStateSettings", 0x60acdfdd }, + { "NvAPI_GSync_GetControlParameters", 0x16de1c6a }, + { "NvAPI_GSync_SetControlParameters", 0x8bbff88b }, + { "NvAPI_GSync_AdjustSyncDelay", 0x2d11ff51 }, + { "NvAPI_GSync_GetSyncStatus", 0xf1f5b434 }, + { "NvAPI_GSync_GetStatusParameters", 0x70d404ec }, + { "NvAPI_D3D_GetCurrentSLIState", 0x4b708b54 }, + { "NvAPI_D3D9_RegisterResource", 0xa064bdfc }, + { "NvAPI_D3D9_UnregisterResource", 0xbb2b17aa }, + { "NvAPI_D3D9_AliasSurfaceAsTexture", 0xe5ceae41 }, + { "NvAPI_D3D9_StretchRectEx", 0x22de03aa }, + { "NvAPI_D3D9_ClearRT", 0x332d3942 }, + { "NvAPI_D3D_GetObjectHandleForResource", 0xfceac864 }, + { "NvAPI_D3D_SetResourceHint", 0x6c0ed98c }, + { "NvAPI_D3D_BeginResourceRendering", 0x91123d6a }, + { "NvAPI_D3D_EndResourceRendering", 0x37e7191c }, + { "NvAPI_D3D9_GetSurfaceHandle", 0x0f2dd3f2 }, + { "NvAPI_D3D9_VideoSetStereoInfo", 0xb852f4db }, + { "NvAPI_D3D10_SetDepthBoundsTest", 0x4eadf5d2 }, + { "NvAPI_D3D11_CreateDevice", 0x6a16d3a0 }, + { "NvAPI_D3D11_CreateDeviceAndSwapChain", 0xbb939ee5 }, + { "NvAPI_D3D11_SetDepthBoundsTest", 0x7aaf7a04 }, + { "NvAPI_D3D11_IsNvShaderExtnOpCodeSupported", 0x5f68da40 }, + { "NvAPI_D3D11_SetNvShaderExtnSlot", 0x8e90bb9f }, + { "NvAPI_D3D12_SetNvShaderExtnSlotSpace", 0xac2dfeb5 }, + { "NvAPI_D3D12_SetNvShaderExtnSlotSpaceLocalThread", 0x43d867c0 }, + { "NvAPI_D3D11_SetNvShaderExtnSlotLocalThread", 0x0e6482a0 }, + { "NvAPI_D3D11_BeginUAVOverlapEx", 0xba08208a }, + { "NvAPI_D3D11_BeginUAVOverlap", 0x65b93ca8 }, + { "NvAPI_D3D11_EndUAVOverlap", 0x2216a357 }, + { "NvAPI_D3D11_GetResourceHandle", 0x09d52986 }, + { "NvAPI_D3D_SetFPSIndicatorState", 0xa776e8db }, + { "NvAPI_D3D9_Present", 0x05650beb }, + { "NvAPI_D3D9_QueryFrameCount", 0x9083e53a }, + { "NvAPI_D3D9_ResetFrameCount", 0xfa6a0675 }, + { "NvAPI_D3D9_QueryMaxSwapGroup", 0x5995410d }, + { "NvAPI_D3D9_QuerySwapGroup", 0xeba4d232 }, + { "NvAPI_D3D9_JoinSwapGroup", 0x7d44bb54 }, + { "NvAPI_D3D9_BindSwapBarrier", 0x9c39c246 }, + { "NvAPI_D3D_SetVerticalSyncMode", 0x5526cfd1 }, + { "NvAPI_D3D1x_Present", 0x03b845a1 }, + { "NvAPI_D3D1x_QueryFrameCount", 0x9152e055 }, + { "NvAPI_D3D1x_ResetFrameCount", 0xfbbb031a }, + { "NvAPI_D3D1x_QueryMaxSwapGroup", 0x9bb9d68f }, + { "NvAPI_D3D1x_QuerySwapGroup", 0x407f67aa }, + { "NvAPI_D3D1x_JoinSwapGroup", 0x14610cd7 }, + { "NvAPI_D3D1x_BindSwapBarrier", 0x9de8c729 }, + { "NvAPI_D3D12_QueryPresentBarrierSupport", 0xa15faef7 }, + { "NvAPI_D3D12_CreatePresentBarrierClient", 0x4d815de9 }, + { "NvAPI_D3D12_RegisterPresentBarrierResources", 0xd53c9ef0 }, + { "NvAPI_DestroyPresentBarrierClient", 0x3c5c351b }, + { "NvAPI_JoinPresentBarrier", 0x17f6bf82 }, + { "NvAPI_LeavePresentBarrier", 0xc3ec5a7f }, + { "NvAPI_QueryPresentBarrierFrameStatistics", 0x61b844a1 }, + { "NvAPI_D3D12_CreateDDisplayPresentBarrierClient", 0xb5a21987 }, + { "NvAPI_D3D11_CreateRasterizerState", 0xdb8d28af }, + { "NvAPI_D3D_ConfigureAnsel", 0x341c6c7f }, + { "NvAPI_D3D11_CreateTiledTexture2DArray", 0x7886981a }, + { "NvAPI_D3D11_CheckFeatureSupport", 0x106a487e }, + { "NvAPI_D3D11_CreateImplicitMSAATexture2D", 0xb8f79632 }, + { "NvAPI_D3D12_CreateCommittedImplicitMSAATexture2D", 0x24c6a07b }, + { "NvAPI_D3D11_ResolveSubresourceRegion", 0xe6bfedd6 }, + { "NvAPI_D3D12_ResolveSubresourceRegion", 0xc24a15bf }, + { "NvAPI_D3D11_TiledTexture2DArrayGetDesc", 0xf1a2b9d5 }, + { "NvAPI_D3D11_UpdateTileMappings", 0x9a06ea07 }, + { "NvAPI_D3D11_CopyTileMappings", 0xc09ee6bc }, + { "NvAPI_D3D11_TiledResourceBarrier", 0xd6839099 }, + { "NvAPI_D3D11_AliasMSAATexture2DAsNonMSAA", 0xf1c54fc9 }, + { "NvAPI_D3D11_CreateGeometryShaderEx_2", 0x99ed5c1c }, + { "NvAPI_D3D11_CreateVertexShaderEx", 0x0beaa0b2 }, + { "NvAPI_D3D11_CreateHullShaderEx", 0xb53cab00 }, + { "NvAPI_D3D11_CreateDomainShaderEx", 0xa0d7180d }, + { "NvAPI_D3D11_CreatePixelShaderEx_2", 0x4162822b }, + { "NvAPI_D3D11_CreateFastGeometryShaderExplicit", 0x71ab7c9c }, + { "NvAPI_D3D11_CreateFastGeometryShader", 0x525d43be }, + { "NvAPI_D3D11_DecompressView", 0x3a94e822 }, + { "NvAPI_D3D12_CreateGraphicsPipelineState", 0x2fc28856 }, + { "NvAPI_D3D12_CreateComputePipelineState", 0x2762deac }, + { "NvAPI_D3D12_SetDepthBoundsTestValues", 0xb9333fe9 }, + { "NvAPI_D3D12_CreateReservedResource", 0x2c85f101 }, + { "NvAPI_D3D12_CreateHeap", 0x5cb397cf }, + { "NvAPI_D3D12_CreateHeap2", 0x924be9d6 }, + { "NvAPI_D3D12_QueryCpuVisibleVidmem", 0x26322bc3 }, + { "NvAPI_D3D12_ReservedResourceGetDesc", 0x9aa2aabb }, + { "NvAPI_D3D12_UpdateTileMappings", 0xc6017a7d }, + { "NvAPI_D3D12_CopyTileMappings", 0x47f78194 }, + { "NvAPI_D3D12_ResourceAliasingBarrier", 0xb942bab7 }, + { "NvAPI_D3D12_CaptureUAVInfo", 0x6e5ea9db }, + { "NvAPI_D3D11_GetResourceGPUVirtualAddressEx", 0xaf6d14da }, + { "NvAPI_D3D11_EnumerateMetaCommands", 0xc7453ba8 }, + { "NvAPI_D3D11_CreateMetaCommand", 0xf505fba0 }, + { "NvAPI_D3D11_InitializeMetaCommand", 0xaec629e9 }, + { "NvAPI_D3D11_ExecuteMetaCommand", 0x82236c47 }, + { "NvAPI_D3D12_EnumerateMetaCommands", 0xcd9141d8 }, + { "NvAPI_D3D12_CreateMetaCommand", 0xeb29634b }, + { "NvAPI_D3D12_InitializeMetaCommand", 0xa4125399 }, + { "NvAPI_D3D12_ExecuteMetaCommand", 0xde24fc3d }, + { "NvAPI_D3D12_CreateCommittedResource", 0x027e98ae }, + { "NvAPI_D3D12_GetCopyableFootprints", 0xf6305eb5 }, + { "NvAPI_D3D12_CopyTextureRegion", 0x82b91b25 }, + { "NvAPI_D3D12_IsNvShaderExtnOpCodeSupported", 0x3dfacec8 }, + { "NvAPI_D3D12_GetOptimalThreadCountForMesh", 0xb43995cb }, + { "NvAPI_D3D_IsGSyncCapable", 0x9c1eed78 }, + { "NvAPI_D3D_IsGSyncActive", 0xe942b0ff }, + { "NvAPI_D3D12_SetFlipConfig", 0xf3148c42 }, + { "NvAPI_D3D1x_DisableShaderDiskCache", 0xd0cbca7d }, + { "NvAPI_D3D11_MultiGPU_GetCaps", 0xd2d25687 }, + { "NvAPI_D3D11_MultiGPU_Init", 0x017be49e }, + { "NvAPI_D3D11_CreateMultiGPUDevice", 0xbdb20007 }, + { "NvAPI_D3D_QuerySinglePassStereoSupport", 0x6f5f0a6d }, + { "NvAPI_D3D_SetSinglePassStereoMode", 0xa39e6e6e }, + { "NvAPI_D3D12_QuerySinglePassStereoSupport", 0x3b03791b }, + { "NvAPI_D3D12_SetSinglePassStereoMode", 0x83556d87 }, + { "NvAPI_D3D_QueryMultiViewSupport", 0xb6e0a41c }, + { "NvAPI_D3D_SetMultiViewMode", 0x8285c8da }, + { "NvAPI_D3D_QueryModifiedWSupport", 0xcbf9f4f5 }, + { "NvAPI_D3D_SetModifiedWMode", 0x06ea4bf4 }, + { "NvAPI_D3D12_QueryModifiedWSupport", 0x51235248 }, + { "NvAPI_D3D12_SetModifiedWMode", 0xe1fdaba7 }, + { "NvAPI_D3D_CreateLateLatchObject", 0x2db27d09 }, + { "NvAPI_D3D_QueryLateLatchSupport", 0x8ceca0ec }, + { "NvAPI_D3D_RegisterDevice", 0x8c02c4d0 }, + { "NvAPI_D3D11_MultiDrawInstancedIndirect", 0xd4e26bbf }, + { "NvAPI_D3D11_MultiDrawIndexedInstancedIndirect", 0x59e890f9 }, + { "NvAPI_D3D_ImplicitSLIControl", 0x2aede111 }, + { "NvAPI_D3D12_GetNeedsAppFPBlendClamping", 0x6ef4d2d1 }, + { "NvAPI_D3D12_UseDriverHeapPriorities", 0xf0d978a8 }, + { "NvAPI_D3D12_Mosaic_GetCompanionAllocations", 0xa46022c7 }, + { "NvAPI_D3D12_Mosaic_GetViewportAndGpuPartitions", 0xb092b818 }, + { "NvAPI_D3D1x_GetGraphicsCapabilities", 0x52b1499a }, + { "NvAPI_D3D12_GetGraphicsCapabilities", 0x01e87354 }, + { "NvAPI_D3D11_RSSetExclusiveScissorRects", 0xae4d73ef }, + { "NvAPI_D3D11_RSSetViewportsPixelShadingRates", 0x34f7938f }, + { "NvAPI_D3D11_CreateShadingRateResourceView", 0x99ca2dff }, + { "NvAPI_D3D11_RSSetShadingRateResourceView", 0x1b0c2f83 }, + { "NvAPI_D3D11_RSGetPixelShadingRateSampleOrder", 0x092442a1 }, + { "NvAPI_D3D11_RSSetPixelShadingRateSampleOrder", 0xa942373a }, + { "NvAPI_D3D_InitializeVRSHelper", 0x4780d70b }, + { "NvAPI_D3D_InitializeNvGazeHandler", 0x5b3b7479 }, + { "NvAPI_D3D_InitializeSMPAssist", 0x42763d0c }, + { "NvAPI_D3D_QuerySMPAssistSupport", 0xc57921de }, + { "NvAPI_D3D_GetSleepStatus", 0xaef96ca1 }, + { "NvAPI_D3D_SetSleepMode", 0xac1ca9e0 }, + { "NvAPI_D3D_Sleep", 0x852cd1d2 }, + { "NvAPI_D3D_SetReflexSync", 0xb9f6faff }, + { "NvAPI_D3D_GetLatency", 0x1a587f9c }, + { "NvAPI_D3D_SetLatencyMarker", 0xd9984c05 }, + { "NvAPI_D3D12_SetAsyncFrameMarker", 0x13c98f73 }, + { "NvAPI_D3D11_SetAsyncFrameMarker", 0x59c2c510 }, + { "NvAPI_D3D12_NotifyOutOfBandCommandQueue", 0x03d6e8cb }, + { "NvAPI_D3D12_SetCreateCommandQueueLowLatencyHint", 0x548c224f }, + { "NvAPI_D3D12_CreateCubinComputeShaderExV2", 0x299f5fdc }, + { "NvAPI_D3D12_CreateCubinComputeShader", 0x2a2c79e8 }, + { "NvAPI_D3D12_CreateCubinComputeShaderEx", 0x3151211b }, + { "NvAPI_D3D12_CreateCubinComputeShaderWithName", 0x1dc7261f }, + { "NvAPI_D3D12_LaunchCubinShader", 0x5c52bb86 }, + { "NvAPI_D3D12_DestroyCubinComputeShader", 0x7fb785ba }, + { "NvAPI_D3D12_GetCudaMergedTextureSamplerObject", 0x329fe6e0 }, + { "NvAPI_D3D12_GetCudaIndependentDescriptorObject", 0x0ddac234 }, + { "NvAPI_D3D12_GetCudaTextureObject", 0x80403fc9 }, + { "NvAPI_D3D12_GetCudaSurfaceObject", 0x48f5b2ee }, + { "NvAPI_D3D12_IsFatbinPTXSupported", 0x70c07832 }, + { "NvAPI_D3D12_CreateCuModule", 0xad1a677d }, + { "NvAPI_D3D12_EnumFunctionsInModule", 0x7ab88d88 }, + { "NvAPI_D3D12_CreateCuFunction", 0xe2436e22 }, + { "NvAPI_D3D12_LaunchCuKernelChain", 0x24973538 }, + { "NvAPI_D3D12_LaunchCuKernelChainEx", 0x846a9bf0 }, + { "NvAPI_D3D12_DestroyCuModule", 0x41c65285 }, + { "NvAPI_D3D12_DestroyCuFunction", 0xdf295ea6 }, + { "NvAPI_D3D11_CreateCubinComputeShaderExV2", 0xf2c71d48 }, + { "NvAPI_D3D11_CreateCubinComputeShader", 0x0ed98181 }, + { "NvAPI_D3D11_CreateCubinComputeShaderEx", 0x32c2a0f6 }, + { "NvAPI_D3D11_CreateCubinComputeShaderWithName", 0xb672be19 }, + { "NvAPI_D3D11_LaunchCubinShader", 0x427e236d }, + { "NvAPI_D3D11_DestroyCubinComputeShader", 0x01682c86 }, + { "NvAPI_D3D11_IsFatbinPTXSupported", 0x6086bd93 }, + { "NvAPI_D3D11_GetCudaIndependentViewObject", 0x34d2afa8 }, + { "NvAPI_D3D11_GetCudaMergedTextureSamplerObject", 0x5d637d8f }, + { "NvAPI_D3D11_CreateUnorderedAccessView", 0x74a497a1 }, + { "NvAPI_D3D11_CreateShaderResourceView", 0x65cb431e }, + { "NvAPI_D3D11_CreateSamplerState", 0x89eca416 }, + { "NvAPI_D3D11_GetCudaTextureObject", 0x9006fa68 }, + { "NvAPI_D3D11_GetResourceGPUVirtualAddress", 0x1819b423 }, + { "NvAPI_D3D12_GetRaytracingCaps", 0x85a6c2a0 }, + { "NvAPI_D3D12_EnableRaytracingValidation", 0x1de5991b }, + { "NvAPI_D3D12_RegisterRaytracingValidationMessageCallback", 0x8554eb38 }, + { "NvAPI_D3D12_UnregisterRaytracingValidationMessageCallback", 0x26975da6 }, + { "NvAPI_D3D12_FlushRaytracingValidationMessages", 0xb8fb1fcb }, + { "NvAPI_D3D12_GetRaytracingDisplacementMicromapArrayPrebuildInfo", 0xfa99b6de }, + { "NvAPI_D3D12_GetRaytracingOpacityMicromapArrayPrebuildInfo", 0x4726d180 }, + { "NvAPI_D3D12_SetCreatePipelineStateOptions", 0x5c607a27 }, + { "NvAPI_D3D12_CheckDriverMatchingIdentifierEx", 0xafb237d4 }, + { "NvAPI_D3D12_GetRaytracingAccelerationStructurePrebuildInfoEx", 0x8d025b77 }, + { "NvAPI_D3D12_BuildRaytracingOpacityMicromapArray", 0x814f8d11 }, + { "NvAPI_D3D12_RelocateRaytracingOpacityMicromapArray", 0x0425c538 }, + { "NvAPI_D3D12_BuildRaytracingDisplacementMicromapArray", 0x066f569d }, + { "NvAPI_D3D12_RelocateRaytracingDisplacementMicromapArray", 0x1c142308 }, + { "NvAPI_D3D12_EmitRaytracingDisplacementMicromapArrayPostbuildInfo", 0x68b9a790 }, + { "NvAPI_D3D12_EmitRaytracingOpacityMicromapArrayPostbuildInfo", 0x1d9a39b6 }, + { "NvAPI_D3D12_BuildRaytracingAccelerationStructureEx", 0xe24ead45 }, + { "NvAPI_D3D12_QueryWorkstationFeatureProperties", 0xa92ea23a }, + { "NvAPI_D3D12_CreateCommittedRDMABuffer", 0xe78dcb44 }, + { "NvAPI_D3D12_ConvertCooperativeVectorMatrix", 0x0f252cb3 }, + { "NvAPI_D3D12_ConvertCooperativeVectorMatrixMultiple", 0x96ba5235 }, + { "NvAPI_D3D12_GetPhysicalDeviceCooperativeVectorProperties", 0x8f182aec }, + { "NvAPI_D3D12_GetRaytracingMultiIndirectClusterOperationRequirementsInfo", 0x5c9163f4 }, + { "NvAPI_D3D12_RaytracingExecuteMultiIndirectClusterOperation", 0x67c798af }, + { "NvAPI_D3D12_GetRaytracingPartitionedTlasIndirectPrebuildInfo", 0xcdfdc5f2 }, + { "NvAPI_D3D12_BuildRaytracingPartitionedTlasIndirect", 0x7cfc6fc3 }, + { "NvAPI_NGX_GetNGXOverrideState", 0x3fd96fba }, + { "NvAPI_NGX_SetNGXOverrideState", 0xb60fcb4e }, + { "NvAPI_DirectD3D12GraphicsCommandList_Create", 0x74a4e712 }, + { "NvAPI_DirectD3D12GraphicsCommandList_Release", 0x99da3dde }, + { "NvAPI_DirectD3D12GraphicsCommandList_Reset", 0x999c26d8 }, + { "NvAPI_VIO_GetCapabilities", 0x1dc91303 }, + { "NvAPI_VIO_Open", 0x44ee4841 }, + { "NvAPI_VIO_Close", 0xd01bd237 }, + { "NvAPI_VIO_Status", 0x0e6ce4f1 }, + { "NvAPI_VIO_SyncFormatDetect", 0x118d48a3 }, + { "NvAPI_VIO_GetConfig", 0xd34a789b }, + { "NvAPI_VIO_SetConfig", 0x0e4eec07 }, + { "NvAPI_VIO_SetCSC", 0xa1ec8d74 }, + { "NvAPI_VIO_GetCSC", 0x7b0d72a3 }, + { "NvAPI_VIO_SetGamma", 0x964bf452 }, + { "NvAPI_VIO_GetGamma", 0x51d53d06 }, + { "NvAPI_VIO_SetSyncDelay", 0x2697a8d1 }, + { "NvAPI_VIO_GetSyncDelay", 0x462214a9 }, + { "NvAPI_VIO_GetPCIInfo", 0xb981d935 }, + { "NvAPI_VIO_IsRunning", 0x96bd040e }, + { "NvAPI_VIO_Start", 0xcde8e1a3 }, + { "NvAPI_VIO_Stop", 0x6ba2a5d6 }, + { "NvAPI_VIO_IsFrameLockModeCompatible", 0x7bf0a94d }, + { "NvAPI_VIO_EnumDevices", 0xfd7c5557 }, + { "NvAPI_VIO_QueryTopology", 0x869534e2 }, + { "NvAPI_VIO_EnumSignalFormats", 0xead72fe4 }, + { "NvAPI_VIO_EnumDataFormats", 0x221fa8e8 }, + { "NvAPI_Stereo_CreateConfigurationProfileRegistryKey", 0xbe7692ec }, + { "NvAPI_Stereo_DeleteConfigurationProfileRegistryKey", 0xf117b834 }, + { "NvAPI_Stereo_SetConfigurationProfileValue", 0x24409f48 }, + { "NvAPI_Stereo_DeleteConfigurationProfileValue", 0x49bceecf }, + { "NvAPI_Stereo_Enable", 0x239c4545 }, + { "NvAPI_Stereo_Disable", 0x2ec50c2b }, + { "NvAPI_Stereo_IsEnabled", 0x348ff8e1 }, + { "NvAPI_Stereo_GetStereoSupport", 0x296c434d }, + { "NvAPI_Stereo_CreateHandleFromIUnknown", 0xac7e37f4 }, + { "NvAPI_Stereo_DestroyHandle", 0x3a153134 }, + { "NvAPI_Stereo_Activate", 0xf6a1ad68 }, + { "NvAPI_Stereo_Deactivate", 0x2d68de96 }, + { "NvAPI_Stereo_IsActivated", 0x1fb0bc30 }, + { "NvAPI_Stereo_GetSeparation", 0x451f2134 }, + { "NvAPI_Stereo_SetSeparation", 0x5c069fa3 }, + { "NvAPI_Stereo_DecreaseSeparation", 0xda044458 }, + { "NvAPI_Stereo_IncreaseSeparation", 0xc9a8ecec }, + { "NvAPI_Stereo_GetConvergence", 0x4ab00934 }, + { "NvAPI_Stereo_SetConvergence", 0x3dd6b54b }, + { "NvAPI_Stereo_DecreaseConvergence", 0x4c87e317 }, + { "NvAPI_Stereo_IncreaseConvergence", 0xa17daabe }, + { "NvAPI_Stereo_GetFrustumAdjustMode", 0xe6839b43 }, + { "NvAPI_Stereo_SetFrustumAdjustMode", 0x7be27fa2 }, + { "NvAPI_Stereo_CaptureJpegImage", 0x932cb140 }, + { "NvAPI_Stereo_InitActivation", 0xc7177702 }, + { "NvAPI_Stereo_Trigger_Activation", 0x0d6c6cd2 }, + { "NvAPI_Stereo_CapturePngImage", 0x8b7e99b5 }, + { "NvAPI_Stereo_ReverseStereoBlitControl", 0x3cd58f89 }, + { "NvAPI_Stereo_SetNotificationMessage", 0x6b9b409e }, + { "NvAPI_Stereo_SetActiveEye", 0x96eea9f8 }, + { "NvAPI_Stereo_SetDriverMode", 0x5e8f0bec }, + { "NvAPI_Stereo_GetEyeSeparation", 0xce653127 }, + { "NvAPI_Stereo_IsWindowedModeSupported", 0x40c8ed5e }, + { "NvAPI_Stereo_SetSurfaceCreationMode", 0xf5dcfcba }, + { "NvAPI_Stereo_GetSurfaceCreationMode", 0x36f1c736 }, + { "NvAPI_Stereo_Debug_WasLastDrawStereoized", 0xed4416c5 }, + { "NvAPI_Stereo_SetDefaultProfile", 0x44f0ecd1 }, + { "NvAPI_Stereo_GetDefaultProfile", 0x624e21c2 }, + { "NvAPI_D3D1x_CreateSwapChain", 0x1bc21b66 }, + { "NvAPI_D3D9_CreateSwapChain", 0x1a131e09 }, + { "NvAPI_Vulkan_InitLowLatencyDevice", 0x5c1696b6 }, + { "NvAPI_Vulkan_DestroyLowLatencyDevice", 0x11a5932b }, + { "NvAPI_Vulkan_GetSleepStatus", 0xadf966af }, + { "NvAPI_Vulkan_SetSleepMode", 0x2acfd162 }, + { "NvAPI_Vulkan_Sleep", 0x36732b1e }, + { "NvAPI_Vulkan_GetLatency", 0x3233d44a }, + { "NvAPI_Vulkan_SetLatencyMarker", 0xa17d13d6 }, + { "NvAPI_Vulkan_NotifyOutOfBandVkQueue", 0x5d6d3840 }, + { "NvAPI_DRS_CreateSession", 0x0694d52e }, + { "NvAPI_DRS_DestroySession", 0xdad9cff8 }, + { "NvAPI_DRS_LoadSettings", 0x375dbd6b }, + { "NvAPI_DRS_SaveSettings", 0xfcbc7e14 }, + { "NvAPI_DRS_LoadSettingsFromFile", 0xd3ede889 }, + { "NvAPI_DRS_SaveSettingsToFile", 0x2be25df8 }, + { "NvAPI_DRS_CreateProfile", 0xcc176068 }, + { "NvAPI_DRS_DeleteProfile", 0x17093206 }, + { "NvAPI_DRS_SetCurrentGlobalProfile", 0x1c89c5df }, + { "NvAPI_DRS_GetCurrentGlobalProfile", 0x617bff9f }, + { "NvAPI_DRS_GetProfileInfo", 0x61cd6fd6 }, + { "NvAPI_DRS_SetProfileInfo", 0x16abd3a9 }, + { "NvAPI_DRS_FindProfileByName", 0x7e4a9a0b }, + { "NvAPI_DRS_EnumProfiles", 0xbc371ee0 }, + { "NvAPI_DRS_GetNumProfiles", 0x1dae4fbc }, + { "NvAPI_DRS_CreateApplication", 0x4347a9de }, + { "NvAPI_DRS_DeleteApplicationEx", 0xc5ea85a1 }, + { "NvAPI_DRS_DeleteApplication", 0x2c694bc6 }, + { "NvAPI_DRS_GetApplicationInfo", 0xed1f8c69 }, + { "NvAPI_DRS_EnumApplications", 0x7fa2173a }, + { "NvAPI_DRS_FindApplicationByName", 0xeee566b2 }, + { "NvAPI_DRS_SetSetting", 0x577dd202 }, + { "NvAPI_DRS_GetSetting", 0x73bf8338 }, + { "NvAPI_DRS_EnumSettings", 0xae3039da }, + { "NvAPI_DRS_EnumAvailableSettingIds", 0xf020614a }, + { "NvAPI_DRS_EnumAvailableSettingValues", 0x2ec39f90 }, + { "NvAPI_DRS_GetSettingIdFromName", 0xcb7309cd }, + { "NvAPI_DRS_GetSettingNameFromId", 0xd61cbe6e }, + { "NvAPI_DRS_DeleteProfileSetting", 0xe4a26362 }, + { "NvAPI_DRS_RestoreAllDefaults", 0x5927b094 }, + { "NvAPI_DRS_RestoreProfileDefault", 0xfa5f6134 }, + { "NvAPI_DRS_RestoreProfileDefaultSetting", 0x53f0381e }, + { "NvAPI_DRS_GetBaseProfile", 0xda8466a0 }, + { "NvAPI_SYS_GetChipSetInfo", 0x53dabbca }, + { "NvAPI_SYS_GetLidAndDockInfo", 0xcda14d8a }, + { "NvAPI_SYS_GetDisplayIdFromGpuAndOutputId", 0x08f2bab4 }, + { "NvAPI_SYS_GetGpuAndOutputIdFromDisplayId", 0x112ba1a5 }, + { "NvAPI_SYS_GetPhysicalGpuFromDisplayId", 0x9ea74659 }, + { "NvAPI_SYS_GetDisplayDriverInfo", 0x721faceb }, + { "NvAPI_SYS_GetPhysicalGPUs", 0xd3b24d2d }, + { "NvAPI_SYS_GetLogicalGPUs", 0xccfffc10 }, + { "NvAPI_NGX_GetDriverFeatureSupport", 0x6194b19d }, + { "NvAPI_GPU_ClientRegisterForUtilizationSampleUpdates", 0xadeeaf67 }, + { "NvAPI_RegisterRiseCallback", 0x9cfe8f94 }, + { "NvAPI_RequestRise", 0x5047de98 }, + { "NvAPI_UninstallRise", 0xab8d09f6 }, +); + +#[no_mangle] +pub unsafe extern "C" fn nvapi_QueryInterface(interface: u32) -> *mut c_void { + let maybe_fn_ptr_global = (&*GLOBAL_STATE).as_ref().and_then(|(lib, state)| { + let fn_ptr = lib + .get:: *mut c_void>(b"nvapi_QueryInterface\0") + .ok()?; + Some((fn_ptr, state)) + }); + let (fn_ptr, global_state) = + unwrap_or::unwrap_some_or!(maybe_fn_ptr_global, return ptr::null_mut()); + let export_table = unwrap_or::unwrap_some_or!( + ::zluda_trace_common::get_export_table(), + return ptr::null_mut() + ); + let format_args = dark_api::FnFfiWrapper(|| { + use std::io::Write; + let mut writer = Vec::new(); + let name = interface_to_name(interface); + match name { + Some(name) => write!(&mut writer, "(interface: {})", name).ok(), + None => write!(&mut writer, "(interface: {:#010x})", interface).ok(), + }; + dark_api::ByteVecFfi::new(writer) + }); + let underlying_fn = dark_api::FnFfiWrapper(|| { + let result = fn_ptr(interface); + result as usize + }); + let original: *mut c_void = ReprUsize::from_usize(export_table.logged_call( + cglue::slice::CSliceRef::from_str("nvapi_QueryInterface"), + 0, + cglue::trait_obj!(&format_args as dark_api::FnFfi), + cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), + ptr::null_mut::() as usize, + <*mut c_void as ReprUsize>::format_status, + )); + if cfg!(target_pointer_width = "32") && !original.is_null() { + global_state + .lock() + .ok() + .map(|mut state| state.get_thunk(original, report_fn, interface)) + .unwrap_or_else(|| get_thunk(original, report_fn, interface)) + } else { + original + } +} + +unsafe extern "system" fn report_fn(interface: u32) { + use zluda_trace_common::Unknown; + let export_table = unwrap_or::unwrap_some_or!(::zluda_trace_common::get_export_table(), return); + let format_args = + dark_api::FnFfiWrapper(|| dark_api::ByteVecFfi::new("(...)".as_bytes().to_vec())); + let underlying_fn = dark_api::FnFfiWrapper(|| 0); + let (fn_name, interface) = match interface_to_name(interface) { + Some(name) => (name, 0), + None => { + ("", interface) + } + }; + export_table.logged_call( + cglue::slice::CSliceRef::from_str(fn_name), + interface, + cglue::trait_obj!(&format_args as dark_api::FnFfi), + cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), + ::INTERNAL_ERROR, + ::format_status, + ); +} + +#[cfg(target_arch = "x86")] +pub fn get_thunk( + original_fn: *mut c_void, + report_fn: unsafe extern "system" fn(u32), + interface: u32, +) -> *mut c_void { + use dynasmrt::{dynasm, DynasmApi}; + let mut ops = dynasmrt::x86::Assembler::new().unwrap(); + let start = ops.offset(); + dynasm!(ops + ; .arch x86 + ; push interface as i32 + ; mov eax, report_fn as i32 + ; call eax + ; mov eax, original_fn as i32 + ; jmp eax + ; int 3 + ); + let exe_buf = ops.finalize().unwrap(); + let result_fn = exe_buf.ptr(start); + std::mem::forget(exe_buf); + result_fn as *mut _ +} + +#[cfg(target_arch = "x86_64")] +pub fn get_thunk( + _original_fn: *mut c_void, + _report_fn: unsafe extern "system" fn(u32), + _interface: u32, +) -> *mut c_void { + todo!() +} diff --git a/zluda_trace/src/lib.rs b/zluda_trace/src/lib.rs index b813f631e..967387497 100644 --- a/zluda_trace/src/lib.rs +++ b/zluda_trace/src/lib.rs @@ -147,13 +147,19 @@ struct InternalTableImpl; impl ::dark_api::zluda_trace::CudaDarkApi for InternalTableImpl { unsafe extern "system" fn logged_call( fn_name: cglue::slice::CSliceRef<'static, u8>, + nvapi_interface: u32, args: ::dark_api::FnFfiRef<::dark_api::ByteVecFfi>, fn_: ::dark_api::FnFfiRef, internal_error: usize, format_status: extern "C" fn(usize) -> ::dark_api::ByteVecFfi, ) -> usize { + let fn_name = if nvapi_interface == 0 { + CudaFunctionName::Normal(unsafe { fn_name.into_str() }) + } else { + CudaFunctionName::Nvapi(nvapi_interface) + }; GlobalState2::under_lock( - CudaFunctionName::Normal(unsafe { fn_name.into_str() }), + fn_name, Some(|| args.call().to_vec()), internal_error, |status| format_status(status).to_vec(), diff --git a/zluda_trace/src/log.rs b/zluda_trace/src/log.rs index 5915f1938..023d7979d 100644 --- a/zluda_trace/src/log.rs +++ b/zluda_trace/src/log.rs @@ -236,6 +236,7 @@ impl Write for WriteBuffer { pub(crate) enum CudaFunctionName { Normal(&'static str), Dark { guid: CUuuid, index: usize }, + Nvapi(u32) } impl Display for CudaFunctionName { @@ -257,6 +258,9 @@ impl Display for CudaFunctionName { } } } + CudaFunctionName::Nvapi(interface) => { + write!(f, "{{nvapi:{:#010x}}}", interface) + } } } } diff --git a/zluda_trace_blas/src/lib.rs b/zluda_trace_blas/src/lib.rs index b1bc28fdc..0ef7600eb 100644 --- a/zluda_trace_blas/src/lib.rs +++ b/zluda_trace_blas/src/lib.rs @@ -35,6 +35,7 @@ macro_rules! unimplemented { }); ReprUsize::from_usize(export_table.logged_call( cglue::slice::CSliceRef::from_str(stringify!($fn_name)), + 0, cglue::trait_obj!(&format_args as dark_api::FnFfi), cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), internal_error_untyped, diff --git a/zluda_trace_blaslt/src/lib.rs b/zluda_trace_blaslt/src/lib.rs index 5202a79dc..e1c4b1f1a 100644 --- a/zluda_trace_blaslt/src/lib.rs +++ b/zluda_trace_blaslt/src/lib.rs @@ -35,6 +35,7 @@ macro_rules! unimplemented { }); ReprUsize::from_usize(export_table.logged_call( cglue::slice::CSliceRef::from_str(stringify!($fn_name)), + 0, cglue::trait_obj!(&format_args as dark_api::FnFfi), cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), internal_error_untyped, diff --git a/zluda_trace_dnn8/src/lib.rs b/zluda_trace_dnn8/src/lib.rs index 6e98a384b..f0ebd0402 100644 --- a/zluda_trace_dnn8/src/lib.rs +++ b/zluda_trace_dnn8/src/lib.rs @@ -35,6 +35,7 @@ macro_rules! unimplemented { }); ReprUsize::from_usize(export_table.logged_call( cglue::slice::CSliceRef::from_str(stringify!($fn_name)), + 0, cglue::trait_obj!(&format_args as dark_api::FnFfi), cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), internal_error_untyped, diff --git a/zluda_trace_dnn9/src/lib.rs b/zluda_trace_dnn9/src/lib.rs index 5989ccb3a..96e1a7536 100644 --- a/zluda_trace_dnn9/src/lib.rs +++ b/zluda_trace_dnn9/src/lib.rs @@ -35,6 +35,7 @@ macro_rules! unimplemented { }); ReprUsize::from_usize(export_table.logged_call( cglue::slice::CSliceRef::from_str(stringify!($fn_name)), + 0, cglue::trait_obj!(&format_args as dark_api::FnFfi), cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), internal_error_untyped, diff --git a/zluda_trace_fft/src/lib.rs b/zluda_trace_fft/src/lib.rs index dbedc29fd..ca1f83881 100644 --- a/zluda_trace_fft/src/lib.rs +++ b/zluda_trace_fft/src/lib.rs @@ -35,6 +35,7 @@ macro_rules! unimplemented { }); ReprUsize::from_usize(export_table.logged_call( cglue::slice::CSliceRef::from_str(stringify!($fn_name)), + 0, cglue::trait_obj!(&format_args as dark_api::FnFfi), cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), internal_error_untyped, diff --git a/zluda_trace_nvml/src/lib.rs b/zluda_trace_nvml/src/lib.rs index 4eed6940f..8fe8b5b51 100644 --- a/zluda_trace_nvml/src/lib.rs +++ b/zluda_trace_nvml/src/lib.rs @@ -35,6 +35,7 @@ macro_rules! unimplemented { }); ReprUsize::from_usize(export_table.logged_call( cglue::slice::CSliceRef::from_str(stringify!($fn_name)), + 0, cglue::trait_obj!(&format_args as dark_api::FnFfi), cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), internal_error_untyped, diff --git a/zluda_trace_sparse/src/lib.rs b/zluda_trace_sparse/src/lib.rs index 44a286d0c..2e2d7683a 100644 --- a/zluda_trace_sparse/src/lib.rs +++ b/zluda_trace_sparse/src/lib.rs @@ -35,6 +35,7 @@ macro_rules! unimplemented { }); ReprUsize::from_usize(export_table.logged_call( cglue::slice::CSliceRef::from_str(stringify!($fn_name)), + 0, cglue::trait_obj!(&format_args as dark_api::FnFfi), cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), internal_error_untyped, From 0f06b7a43311ec9dd06dfa2a1e52ba2344947207 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Mon, 20 Apr 2026 20:44:36 -0700 Subject: [PATCH 14/85] Show return value of nvapi functions --- nvapi_trace/src/lib.rs | 25 ++++++++++++------------- zluda_trace_common/src/lib.rs | 18 ------------------ 2 files changed, 12 insertions(+), 31 deletions(-) diff --git a/nvapi_trace/src/lib.rs b/nvapi_trace/src/lib.rs index 9b5d2cea4..5dfd87568 100644 --- a/nvapi_trace/src/lib.rs +++ b/nvapi_trace/src/lib.rs @@ -37,7 +37,7 @@ impl GlobalState { fn get_thunk( &mut self, original: *mut c_void, - report_fn: unsafe extern "system" fn(u32), + report_fn: unsafe extern "system" fn(u32, i32), interface: u32, ) -> *mut c_void { match self.thunks.entry(interface) { @@ -629,32 +629,29 @@ pub unsafe extern "C" fn nvapi_QueryInterface(interface: u32) -> *mut c_void { } } -unsafe extern "system" fn report_fn(interface: u32) { - use zluda_trace_common::Unknown; +unsafe extern "system" fn report_fn(interface: u32, result: i32) { let export_table = unwrap_or::unwrap_some_or!(::zluda_trace_common::get_export_table(), return); let format_args = dark_api::FnFfiWrapper(|| dark_api::ByteVecFfi::new("(...)".as_bytes().to_vec())); - let underlying_fn = dark_api::FnFfiWrapper(|| 0); + let underlying_fn = dark_api::FnFfiWrapper(|| ReprUsize::to_usize(result)); let (fn_name, interface) = match interface_to_name(interface) { Some(name) => (name, 0), - None => { - ("", interface) - } + None => ("", interface), }; export_table.logged_call( cglue::slice::CSliceRef::from_str(fn_name), interface, cglue::trait_obj!(&format_args as dark_api::FnFfi), cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), - ::INTERNAL_ERROR, - ::format_status, + ::INTERNAL_ERROR, + ::format_status, ); } #[cfg(target_arch = "x86")] pub fn get_thunk( original_fn: *mut c_void, - report_fn: unsafe extern "system" fn(u32), + report_fn: unsafe extern "system" fn(u32, i32), interface: u32, ) -> *mut c_void { use dynasmrt::{dynasm, DynasmApi}; @@ -662,11 +659,13 @@ pub fn get_thunk( let start = ops.offset(); dynasm!(ops ; .arch x86 + ; mov eax, original_fn as i32 + ; call eax + ; push eax ; push interface as i32 ; mov eax, report_fn as i32 ; call eax - ; mov eax, original_fn as i32 - ; jmp eax + ; ret ; int 3 ); let exe_buf = ops.finalize().unwrap(); @@ -678,7 +677,7 @@ pub fn get_thunk( #[cfg(target_arch = "x86_64")] pub fn get_thunk( _original_fn: *mut c_void, - _report_fn: unsafe extern "system" fn(u32), + _report_fn: unsafe extern "system" fn(u32, i32), _interface: u32, ) -> *mut c_void { todo!() diff --git a/zluda_trace_common/src/lib.rs b/zluda_trace_common/src/lib.rs index 2bccda0bb..1646db0f5 100644 --- a/zluda_trace_common/src/lib.rs +++ b/zluda_trace_common/src/lib.rs @@ -472,21 +472,3 @@ impl ReprUsize for cuda_types::nvml::nvmlReturn_t { ByteVecFfi::new(writer) } } - -pub struct Unknown; - -impl ReprUsize for Unknown { - fn to_usize(self) -> usize { - 0 - } - - fn from_usize(_: usize) -> Self { - Self - } - - const INTERNAL_ERROR: usize = usize::MAX; - - extern "C" fn format_status(_: usize) -> ByteVecFfi { - ByteVecFfi::new(b"UNKNOWN".to_vec()) - } -} From e898b236efeb20e89ecf3a1d09dfd313cce9895a Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Mon, 20 Apr 2026 22:36:11 -0700 Subject: [PATCH 15/85] Add initial nvapi --- Cargo.lock | 16 + Cargo.toml | 1 + nvapi/Cargo.toml | 26 + nvapi/src/lib.rs | 573 ++ nvapi/src/nvapi.rs | 19879 +++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 20495 insertions(+) create mode 100644 nvapi/Cargo.toml create mode 100644 nvapi/src/lib.rs create mode 100644 nvapi/src/nvapi.rs diff --git a/Cargo.lock b/Cargo.lock index 355b46c90..14e03dfec 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3305,6 +3305,22 @@ dependencies = [ "libc", ] +[[package]] +name = "nvapi" +version = "0.0.0" +dependencies = [ + "cglue", + "cuda_macros", + "cuda_types", + "dark_api", + "format", + "libloading", + "paste", + "rustc-hash 2.1.1", + "unwrap_or", + "zluda_trace_common", +] + [[package]] name = "nvapi_trace" version = "0.0.0" diff --git a/Cargo.toml b/Cargo.toml index 9051bab6a..066ca9602 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -16,6 +16,7 @@ members = [ "ext/rocblas-sys", "format", "kernel_metadata", + "nvapi", "nvapi_trace", "ptx_parser_macros_impl", "ptx_parser_macros", diff --git a/nvapi/Cargo.toml b/nvapi/Cargo.toml new file mode 100644 index 000000000..a3699b162 --- /dev/null +++ b/nvapi/Cargo.toml @@ -0,0 +1,26 @@ +[package] +name = "nvapi" +version = "0.0.0" +authors = ["Andrzej Janik "] +edition = "2021" + +[lib] +name = "nvapi64" +crate-type = ["cdylib"] + +[dependencies] +format = { path = "../format" } +dark_api = { path = "../dark_api" } +cuda_macros = { path = "../cuda_macros" } +cuda_types = { path = "../cuda_types" } +zluda_trace_common = { path = "../zluda_trace_common" } +libloading = "0.8" +paste = "1.0" +unwrap_or = "1.0.1" +cglue = "0.3.5" +rustc-hash = "2.0.0" + +[package.metadata.zluda] +windows_only = true +windows32_paths = ["nvapi.dll"] +32bit = true diff --git a/nvapi/src/lib.rs b/nvapi/src/lib.rs new file mode 100644 index 000000000..4d2491fb3 --- /dev/null +++ b/nvapi/src/lib.rs @@ -0,0 +1,573 @@ +use crate::nvapi::*; +use libloading::Library; +use rustc_hash::FxHashMap; +use std::{ + collections::hash_map, + ffi::c_void, + mem, ptr, + sync::{LazyLock, Mutex}, +}; + +#[allow(warnings)] +mod nvapi; + +macro_rules! interface_to_name { + ($({ $name:ident, $id:literal }),* $(,)?) => { + fn interface_to_fn(interface: u32) -> Option<*mut c_void> { + match interface { + $( + $id => Some($name as *mut c_void), + )* + _ => None, + } + } + }; +} + +interface_to_name!( + { NvAPI_Initialize, 0x0150e828 }, + { NvAPI_Unload, 0xd22bdd7e }, + // { NvAPI_GetErrorMessage, 0x6c2d048c }, + // { NvAPI_GetInterfaceVersionString, 0x01053fa5 }, + // { NvAPI_GPU_GetEDID, 0x37d32e69 }, + // { NvAPI_SetView, 0x0957d7b6 }, + // { NvAPI_SetViewEx, 0x06b89e68 }, + { NvAPI_GetDisplayDriverVersion, 0xf951a4d1 }, + // { NvAPI_SYS_GetDriverAndBranchVersion, 0x2926aaad }, + // { NvAPI_GPU_GetMemoryInfo, 0x07f9b368 }, + // { NvAPI_GPU_GetMemoryInfoEx, 0xc0599498 }, + // { NvAPI_OGL_ExpertModeSet, 0x3805ef7a }, + // { NvAPI_OGL_ExpertModeGet, 0x22ed9516 }, + // { NvAPI_OGL_ExpertModeDefaultsSet, 0xb47a657e }, + // { NvAPI_OGL_ExpertModeDefaultsGet, 0xae921f12 }, + // { NvAPI_EnumPhysicalGPUs, 0xe5ac921f }, + // { NvAPI_EnumTCCPhysicalGPUs, 0xd9930b07 }, + // { NvAPI_EnumLogicalGPUs, 0x48b3ea59 }, + // { NvAPI_GetPhysicalGPUsFromDisplay, 0x34ef9506 }, + // { NvAPI_GetPhysicalGPUFromUnAttachedDisplay, 0x5018ed61 }, + // { NvAPI_GetLogicalGPUFromDisplay, 0xee1370cf }, + // { NvAPI_GetLogicalGPUFromPhysicalGPU, 0xadd604d1 }, + // { NvAPI_GetPhysicalGPUsFromLogicalGPU, 0xaea3fa32 }, + // { NvAPI_GetPhysicalGPUFromGPUID, 0x5380ad1a }, + // { NvAPI_GetGPUIDfromPhysicalGPU, 0x6533ea3e }, + // { NvAPI_GPU_GetShaderSubPipeCount, 0x0be17923 }, + // { NvAPI_GPU_GetGpuCoreCount, 0xc7026a87 }, + // { NvAPI_GPU_GetAllOutputs, 0x7d554f8e }, + // { NvAPI_GPU_GetConnectedOutputs, 0x1730bfc9 }, + // { NvAPI_GPU_GetConnectedSLIOutputs, 0x0680de09 }, + // { NvAPI_GPU_GetConnectedDisplayIds, 0x0078dba2 }, + // { NvAPI_GPU_GetAllDisplayIds, 0x785210a2 }, + // { NvAPI_GPU_GetConnectedOutputsWithLidState, 0xcf8caf39 }, + // { NvAPI_GPU_GetConnectedSLIOutputsWithLidState, 0x96043cc7 }, + // { NvAPI_GPU_GetSystemType, 0xbaaabfcc }, + // { NvAPI_GPU_GetActiveOutputs, 0xe3e89b6f }, + // { NvAPI_GPU_SetEDID, 0xe83d6456 }, + // { NvAPI_GPU_GetOutputType, 0x40a505e4 }, + // { NvAPI_GPU_ValidateOutputCombination, 0x34c9c2d4 }, + // { NvAPI_GPU_GetFullName, 0xceee8e9f }, + // { NvAPI_GPU_GetPCIIdentifiers, 0x2ddfb66e }, + // { NvAPI_GPU_GetGPUType, 0xc33baeb1 }, + // { NvAPI_GPU_GetBusType, 0x1bb18724 }, + // { NvAPI_GPU_GetBusId, 0x1be0b8e5 }, + // { NvAPI_GPU_GetBusSlotId, 0x2a0a350f }, + // { NvAPI_GPU_GetIRQ, 0xe4715417 }, + // { NvAPI_GPU_GetVbiosRevision, 0xacc3da0a }, + // { NvAPI_GPU_GetVbiosOEMRevision, 0x2d43fb31 }, + // { NvAPI_GPU_GetVbiosVersionString, 0xa561fd7d }, + // { NvAPI_GPU_GetAGPAperture, 0x6e042794 }, + // { NvAPI_GPU_GetCurrentAGPRate, 0xc74925a0 }, + // { NvAPI_GPU_GetCurrentPCIEDownstreamWidth, 0xd048c3b1 }, + // { NvAPI_GPU_GetPhysicalFrameBufferSize, 0x46fbeb03 }, + // { NvAPI_GPU_GetVirtualFrameBufferSize, 0x5a04b644 }, + // { NvAPI_GPU_GetQuadroStatus, 0xe332fa47 }, + // { NvAPI_GPU_GetBoardInfo, 0x22d54523 }, + // { NvAPI_GPU_GetRamBusWidth, 0x7975c581 }, + // { NvAPI_GPU_GetArchInfo, 0xd8265d24 }, + // { NvAPI_I2CRead, 0x2fde12c5 }, + // { NvAPI_I2CWrite, 0xe812eb07 }, + // { NvAPI_GPU_WorkstationFeatureSetup, 0x6c1f3fe4 }, + // { NvAPI_GPU_WorkstationFeatureQuery, 0x004537df }, + // { NvAPI_GPU_GetHDCPSupportStatus, 0xf089eef5 }, + // { NvAPI_GPU_CudaEnumComputeCapableGpus, 0x5786cc6e }, + // { NvAPI_GPU_GetTachReading, 0x5f608315 }, + // { NvAPI_GPU_GetECCStatusInfo, 0xca1ddaf3 }, + // { NvAPI_GPU_GetECCErrorInfo, 0xc71f85a6 }, + // { NvAPI_GPU_ResetECCErrorInfo, 0xc02eec20 }, + // { NvAPI_GPU_GetECCConfigurationInfo, 0x77a796f3 }, + // { NvAPI_GPU_SetECCConfiguration, 0x1cf639d9 }, + // { NvAPI_GPU_QueryWorkstationFeatureSupport, 0x80b1abb9 }, + // { NvAPI_GPU_SetScanoutIntensity, 0xa57457a4 }, + // { NvAPI_GPU_GetScanoutIntensityState, 0xe81ce836 }, + // { NvAPI_GPU_SetScanoutWarping, 0xb34bab4f }, + // { NvAPI_GPU_GetScanoutWarpingState, 0x6f5435af }, + // { NvAPI_GPU_SetScanoutCompositionParameter, 0xf898247d }, + // { NvAPI_GPU_GetScanoutCompositionParameter, 0x58fe51e6 }, + // { NvAPI_GPU_GetScanoutConfiguration, 0x6a9f5b63 }, + // { NvAPI_GPU_GetScanoutConfigurationEx, 0xe2e1e6f0 }, + // { NvAPI_GPU_GetAdapterIdFromPhysicalGpu, 0x0ff07fde }, + // { NvAPI_GPU_GetVirtualizationInfo, 0x44e022a9 }, + // { NvAPI_GPU_GetLogicalGpuInfo, 0x842b066e }, + // { NvAPI_GPU_GetLicensableFeatures, 0x3fc596aa }, + // { NvAPI_GPU_GetEncoderStatistics, 0xf0a9aeeb }, + // { NvAPI_GPU_GetEncoderSessionsInfo, 0xd8a72ce5 }, + // { NvAPI_GPU_GetGPUInfo, 0xafd1b02c }, + // { NvAPI_GPU_GetVRReadyData, 0x81d629c5 }, + // { NvAPI_GPU_GetGspFeatures, 0x581c4391 }, + // { NvAPI_GPU_GetUUID, 0xdc95673d }, + // { NvAPI_GPU_NVLINK_GetCaps, 0xbef1119d }, + // { NvAPI_GPU_NVLINK_GetStatus, 0xc72a38e3 }, + // { NvAPI_GPU_GetPerfDecreaseInfo, 0x7f7f4600 }, + // { NvAPI_GPU_GetPstatesInfoEx, 0x843c0256 }, + // { NvAPI_GPU_GetPstates20, 0x6ff81213 }, + // { NvAPI_GPU_GetCurrentPstate, 0x927da4f6 }, + // { NvAPI_GPU_GetDynamicPstatesInfoEx, 0x60ded2ed }, + // { NvAPI_GPU_GetThermalSettings, 0xe3640a56 }, + // { NvAPI_GPU_GetAllClockFrequencies, 0xdcb616c3 }, + // { NvAPI_GPU_QueryIlluminationSupport, 0xa629da31 }, + // { NvAPI_GPU_GetIllumination, 0x9a1b9365 }, + // { NvAPI_GPU_SetIllumination, 0x0254a187 }, + // { NvAPI_GPU_ClientIllumDevicesGetInfo, 0xd4100e58 }, + // { NvAPI_GPU_ClientIllumDevicesGetControl, 0x73c01d58 }, + // { NvAPI_GPU_ClientIllumDevicesSetControl, 0x57024c62 }, + // { NvAPI_GPU_ClientIllumZonesGetInfo, 0x4b81241b }, + // { NvAPI_GPU_ClientIllumZonesGetControl, 0x3dbf5764 }, + // { NvAPI_GPU_ClientIllumZonesSetControl, 0x197d065e }, + // { NvAPI_Event_RegisterCallback, 0xe6dbea69 }, + // { NvAPI_Event_UnregisterCallback, 0xde1f9b45 }, + // { NvAPI_EnumNvidiaDisplayHandle, 0x9abdd40d }, + // { NvAPI_EnumNvidiaUnAttachedDisplayHandle, 0x20de9260 }, + // { NvAPI_CreateDisplayFromUnAttachedDisplay, 0x63f9799e }, + // { NvAPI_GetAssociatedNvidiaDisplayHandle, 0x35c29134 }, + // { NvAPI_DISP_GetAssociatedUnAttachedNvidiaDisplayHandle, 0xa70503b2 }, + // { NvAPI_GetAssociatedNvidiaDisplayName, 0x22a78b05 }, + // { NvAPI_GetUnAttachedAssociatedDisplayName, 0x4888d790 }, + // { NvAPI_EnableHWCursor, 0x2863148d }, + // { NvAPI_DisableHWCursor, 0xab163097 }, + // { NvAPI_GetVBlankCounter, 0x67b5db55 }, + // { NvAPI_SetRefreshRateOverride, 0x3092ac32 }, + // { NvAPI_GetAssociatedDisplayOutputId, 0xd995937e }, + // { NvAPI_GetDisplayPortInfo, 0xc64ff367 }, + // { NvAPI_SetDisplayPort, 0xfa13e65a }, + // { NvAPI_GetHDMISupportInfo, 0x6ae16ec3 }, + // { NvAPI_Disp_InfoFrameControl, 0x6067af3f }, + // { NvAPI_Disp_ColorControl, 0x92f9d80d }, + // { NvAPI_Disp_GetHdrCapabilities, 0x84f2a8df }, + // { NvAPI_Disp_HdrColorControl, 0x351da224 }, + // { NvAPI_Disp_SetSourceColorSpace, 0x473b6caf }, + // { NvAPI_Disp_GetSourceColorSpace, 0xceedc85b }, + // { NvAPI_Disp_SetSourceHdrMetadata, 0x905eb63b }, + // { NvAPI_Disp_GetSourceHdrMetadata, 0x0d3f52da }, + // { NvAPI_Disp_SetOutputMode, 0x98e7661a }, + // { NvAPI_Disp_GetOutputMode, 0x81fed88d }, + // { NvAPI_Disp_SetHdrToneMapping, 0xdd6da362 }, + // { NvAPI_Disp_GetHdrToneMapping, 0xfbd36e71 }, + // { NvAPI_Disp_GetColorimetry, 0x00b421ad }, + // { NvAPI_DISP_GetTiming, 0x175167e9 }, + // { NvAPI_DISP_GetMonitorCapabilities, 0x3b05c7e1 }, + // { NvAPI_DISP_GetMonitorColorCapabilities, 0x6ae4cfb5 }, + // { NvAPI_DISP_EnumCustomDisplay, 0xa2072d59 }, + // { NvAPI_DISP_TryCustomDisplay, 0x1f7db630 }, + // { NvAPI_DISP_DeleteCustomDisplay, 0x552e5b9b }, + // { NvAPI_DISP_SaveCustomDisplay, 0x49882876 }, + // { NvAPI_DISP_RevertCustomDisplayTrial, 0xcbbd40f0 }, + // { NvAPI_GetView, 0xd6b99d89 }, + // { NvAPI_GetViewEx, 0xdbbc0af4 }, + // { NvAPI_GetSupportedViews, 0x66fb7fc0 }, + // { NvAPI_DISP_GetDisplayIdByDisplayName, 0xae457190 }, + // { NvAPI_DISP_GetGDIPrimaryDisplayId, 0x1e9d8a31 }, + // { NvAPI_DISP_GetDisplayConfig, 0x11abccf8 }, + // { NvAPI_DISP_SetDisplayConfig, 0x5d8cf8de }, + // { NvAPI_DISP_GetEdidData, 0x436ced76 }, + // { NvAPI_DISP_GetAdaptiveSyncData, 0xb73d1ee9 }, + // { NvAPI_DISP_SetAdaptiveSyncData, 0x3eebba1d }, + // { NvAPI_DISP_GetVirtualRefreshRateData, 0x8c00429a }, + // { NvAPI_DISP_SetVirtualRefreshRateData, 0x5abbe6a3 }, + // { NvAPI_DISP_SetPreferredStereoDisplay, 0xc9d0e25f }, + // { NvAPI_DISP_GetPreferredStereoDisplay, 0x1f6b4666 }, + // { NvAPI_DISP_GetNvManagedDedicatedDisplays, 0xdbdf0cb2 }, + // { NvAPI_DISP_AcquireDedicatedDisplay, 0x47c917ba }, + // { NvAPI_DISP_ReleaseDedicatedDisplay, 0x1247825f }, + // { NvAPI_DISP_GetNvManagedDedicatedDisplayMetadata, 0xd645d80c }, + // { NvAPI_DISP_SetNvManagedDedicatedDisplayMetadata, 0x3d8b129a }, + // { NvAPI_Disp_GetDisplayIdInfo, 0xbae8aa5e }, + // { NvAPI_Disp_GetDisplayIdsFromTarget, 0xe7e5f89e }, + // { NvAPI_Disp_GetVRRInfo, 0xdf8fda57 }, + // { NvAPI_Mosaic_GetSupportedTopoInfo, 0xfdb63c81 }, + // { NvAPI_Mosaic_GetTopoGroup, 0xcb89381d }, + // { NvAPI_Mosaic_GetOverlapLimits, 0x989685f0 }, + // { NvAPI_Mosaic_SetCurrentTopo, 0x9b542831 }, + // { NvAPI_Mosaic_GetCurrentTopo, 0xec32944e }, + // { NvAPI_Mosaic_EnableCurrentTopo, 0x5f1aa66c }, + // { NvAPI_Mosaic_GetDisplayViewportsByResolution, 0xdc6dc8d3 }, + // { NvAPI_Mosaic_SetDisplayGrids, 0x4d959a89 }, + // { NvAPI_Mosaic_ValidateDisplayGrids, 0xcf43903d }, + // { NvAPI_Mosaic_EnumDisplayModes, 0x78db97d7 }, + // { NvAPI_Mosaic_EnumDisplayGrids, 0xdf2887af }, + // { NvAPI_GetSupportedMosaicTopologies, 0x410b5c25 }, + // { NvAPI_GetCurrentMosaicTopology, 0xf60852bd }, + // { NvAPI_SetCurrentMosaicTopology, 0xd54b8989 }, + // { NvAPI_EnableCurrentMosaicTopology, 0x74073cc9 }, + // { NvAPI_GSync_EnumSyncDevices, 0xd9639601 }, + // { NvAPI_GSync_QueryCapabilities, 0x44a3f1d1 }, + // { NvAPI_GSync_GetTopology, 0x4562bc38 }, + // { NvAPI_GSync_SetSyncStateSettings, 0x60acdfdd }, + // { NvAPI_GSync_GetControlParameters, 0x16de1c6a }, + // { NvAPI_GSync_SetControlParameters, 0x8bbff88b }, + // { NvAPI_GSync_AdjustSyncDelay, 0x2d11ff51 }, + // { NvAPI_GSync_GetSyncStatus, 0xf1f5b434 }, + // { NvAPI_GSync_GetStatusParameters, 0x70d404ec }, + // { NvAPI_D3D_GetCurrentSLIState, 0x4b708b54 }, + // { NvAPI_D3D9_RegisterResource, 0xa064bdfc }, + // { NvAPI_D3D9_UnregisterResource, 0xbb2b17aa }, + // { NvAPI_D3D9_AliasSurfaceAsTexture, 0xe5ceae41 }, + // { NvAPI_D3D9_StretchRectEx, 0x22de03aa }, + // { NvAPI_D3D9_ClearRT, 0x332d3942 }, + // { NvAPI_D3D_GetObjectHandleForResource, 0xfceac864 }, + // { NvAPI_D3D_SetResourceHint, 0x6c0ed98c }, + // { NvAPI_D3D_BeginResourceRendering, 0x91123d6a }, + // { NvAPI_D3D_EndResourceRendering, 0x37e7191c }, + // { NvAPI_D3D9_GetSurfaceHandle, 0x0f2dd3f2 }, + // { NvAPI_D3D9_VideoSetStereoInfo, 0xb852f4db }, + // { NvAPI_D3D10_SetDepthBoundsTest, 0x4eadf5d2 }, + // { NvAPI_D3D11_CreateDevice, 0x6a16d3a0 }, + // { NvAPI_D3D11_CreateDeviceAndSwapChain, 0xbb939ee5 }, + // { NvAPI_D3D11_SetDepthBoundsTest, 0x7aaf7a04 }, + // { NvAPI_D3D11_IsNvShaderExtnOpCodeSupported, 0x5f68da40 }, + // { NvAPI_D3D11_SetNvShaderExtnSlot, 0x8e90bb9f }, + // { NvAPI_D3D12_SetNvShaderExtnSlotSpace, 0xac2dfeb5 }, + // { NvAPI_D3D12_SetNvShaderExtnSlotSpaceLocalThread, 0x43d867c0 }, + // { NvAPI_D3D11_SetNvShaderExtnSlotLocalThread, 0x0e6482a0 }, + // { NvAPI_D3D11_BeginUAVOverlapEx, 0xba08208a }, + // { NvAPI_D3D11_BeginUAVOverlap, 0x65b93ca8 }, + // { NvAPI_D3D11_EndUAVOverlap, 0x2216a357 }, + // { NvAPI_D3D11_GetResourceHandle, 0x09d52986 }, + // { NvAPI_D3D_SetFPSIndicatorState, 0xa776e8db }, + // { NvAPI_D3D9_Present, 0x05650beb }, + // { NvAPI_D3D9_QueryFrameCount, 0x9083e53a }, + // { NvAPI_D3D9_ResetFrameCount, 0xfa6a0675 }, + // { NvAPI_D3D9_QueryMaxSwapGroup, 0x5995410d }, + // { NvAPI_D3D9_QuerySwapGroup, 0xeba4d232 }, + // { NvAPI_D3D9_JoinSwapGroup, 0x7d44bb54 }, + // { NvAPI_D3D9_BindSwapBarrier, 0x9c39c246 }, + // { NvAPI_D3D_SetVerticalSyncMode, 0x5526cfd1 }, + // { NvAPI_D3D1x_Present, 0x03b845a1 }, + // { NvAPI_D3D1x_QueryFrameCount, 0x9152e055 }, + // { NvAPI_D3D1x_ResetFrameCount, 0xfbbb031a }, + // { NvAPI_D3D1x_QueryMaxSwapGroup, 0x9bb9d68f }, + // { NvAPI_D3D1x_QuerySwapGroup, 0x407f67aa }, + // { NvAPI_D3D1x_JoinSwapGroup, 0x14610cd7 }, + // { NvAPI_D3D1x_BindSwapBarrier, 0x9de8c729 }, + // { NvAPI_D3D12_QueryPresentBarrierSupport, 0xa15faef7 }, + // { NvAPI_D3D12_CreatePresentBarrierClient, 0x4d815de9 }, + // { NvAPI_D3D12_RegisterPresentBarrierResources, 0xd53c9ef0 }, + // { NvAPI_DestroyPresentBarrierClient, 0x3c5c351b }, + // { NvAPI_JoinPresentBarrier, 0x17f6bf82 }, + // { NvAPI_LeavePresentBarrier, 0xc3ec5a7f }, + // { NvAPI_QueryPresentBarrierFrameStatistics, 0x61b844a1 }, + // { NvAPI_D3D12_CreateDDisplayPresentBarrierClient, 0xb5a21987 }, + // { NvAPI_D3D11_CreateRasterizerState, 0xdb8d28af }, + // { NvAPI_D3D_ConfigureAnsel, 0x341c6c7f }, + // { NvAPI_D3D11_CreateTiledTexture2DArray, 0x7886981a }, + // { NvAPI_D3D11_CheckFeatureSupport, 0x106a487e }, + // { NvAPI_D3D11_CreateImplicitMSAATexture2D, 0xb8f79632 }, + // { NvAPI_D3D12_CreateCommittedImplicitMSAATexture2D, 0x24c6a07b }, + // { NvAPI_D3D11_ResolveSubresourceRegion, 0xe6bfedd6 }, + // { NvAPI_D3D12_ResolveSubresourceRegion, 0xc24a15bf }, + // { NvAPI_D3D11_TiledTexture2DArrayGetDesc, 0xf1a2b9d5 }, + // { NvAPI_D3D11_UpdateTileMappings, 0x9a06ea07 }, + // { NvAPI_D3D11_CopyTileMappings, 0xc09ee6bc }, + // { NvAPI_D3D11_TiledResourceBarrier, 0xd6839099 }, + // { NvAPI_D3D11_AliasMSAATexture2DAsNonMSAA, 0xf1c54fc9 }, + // { NvAPI_D3D11_CreateGeometryShaderEx_2, 0x99ed5c1c }, + // { NvAPI_D3D11_CreateVertexShaderEx, 0x0beaa0b2 }, + // { NvAPI_D3D11_CreateHullShaderEx, 0xb53cab00 }, + // { NvAPI_D3D11_CreateDomainShaderEx, 0xa0d7180d }, + // { NvAPI_D3D11_CreatePixelShaderEx_2, 0x4162822b }, + // { NvAPI_D3D11_CreateFastGeometryShaderExplicit, 0x71ab7c9c }, + // { NvAPI_D3D11_CreateFastGeometryShader, 0x525d43be }, + // { NvAPI_D3D11_DecompressView, 0x3a94e822 }, + // { NvAPI_D3D12_CreateGraphicsPipelineState, 0x2fc28856 }, + // { NvAPI_D3D12_CreateComputePipelineState, 0x2762deac }, + // { NvAPI_D3D12_SetDepthBoundsTestValues, 0xb9333fe9 }, + // { NvAPI_D3D12_CreateReservedResource, 0x2c85f101 }, + // { NvAPI_D3D12_CreateHeap, 0x5cb397cf }, + // { NvAPI_D3D12_CreateHeap2, 0x924be9d6 }, + // { NvAPI_D3D12_QueryCpuVisibleVidmem, 0x26322bc3 }, + // { NvAPI_D3D12_ReservedResourceGetDesc, 0x9aa2aabb }, + // { NvAPI_D3D12_UpdateTileMappings, 0xc6017a7d }, + // { NvAPI_D3D12_CopyTileMappings, 0x47f78194 }, + // { NvAPI_D3D12_ResourceAliasingBarrier, 0xb942bab7 }, + // { NvAPI_D3D12_CaptureUAVInfo, 0x6e5ea9db }, + // { NvAPI_D3D11_GetResourceGPUVirtualAddressEx, 0xaf6d14da }, + // { NvAPI_D3D11_EnumerateMetaCommands, 0xc7453ba8 }, + // { NvAPI_D3D11_CreateMetaCommand, 0xf505fba0 }, + // { NvAPI_D3D11_InitializeMetaCommand, 0xaec629e9 }, + // { NvAPI_D3D11_ExecuteMetaCommand, 0x82236c47 }, + // { NvAPI_D3D12_EnumerateMetaCommands, 0xcd9141d8 }, + // { NvAPI_D3D12_CreateMetaCommand, 0xeb29634b }, + // { NvAPI_D3D12_InitializeMetaCommand, 0xa4125399 }, + // { NvAPI_D3D12_ExecuteMetaCommand, 0xde24fc3d }, + // { NvAPI_D3D12_CreateCommittedResource, 0x027e98ae }, + // { NvAPI_D3D12_GetCopyableFootprints, 0xf6305eb5 }, + // { NvAPI_D3D12_CopyTextureRegion, 0x82b91b25 }, + // { NvAPI_D3D12_IsNvShaderExtnOpCodeSupported, 0x3dfacec8 }, + // { NvAPI_D3D12_GetOptimalThreadCountForMesh, 0xb43995cb }, + // { NvAPI_D3D_IsGSyncCapable, 0x9c1eed78 }, + // { NvAPI_D3D_IsGSyncActive, 0xe942b0ff }, + // { NvAPI_D3D12_SetFlipConfig, 0xf3148c42 }, + // { NvAPI_D3D1x_DisableShaderDiskCache, 0xd0cbca7d }, + // { NvAPI_D3D11_MultiGPU_GetCaps, 0xd2d25687 }, + // { NvAPI_D3D11_MultiGPU_Init, 0x017be49e }, + // { NvAPI_D3D11_CreateMultiGPUDevice, 0xbdb20007 }, + // { NvAPI_D3D_QuerySinglePassStereoSupport, 0x6f5f0a6d }, + // { NvAPI_D3D_SetSinglePassStereoMode, 0xa39e6e6e }, + // { NvAPI_D3D12_QuerySinglePassStereoSupport, 0x3b03791b }, + // { NvAPI_D3D12_SetSinglePassStereoMode, 0x83556d87 }, + // { NvAPI_D3D_QueryMultiViewSupport, 0xb6e0a41c }, + // { NvAPI_D3D_SetMultiViewMode, 0x8285c8da }, + // { NvAPI_D3D_QueryModifiedWSupport, 0xcbf9f4f5 }, + // { NvAPI_D3D_SetModifiedWMode, 0x06ea4bf4 }, + // { NvAPI_D3D12_QueryModifiedWSupport, 0x51235248 }, + // { NvAPI_D3D12_SetModifiedWMode, 0xe1fdaba7 }, + // { NvAPI_D3D_CreateLateLatchObject, 0x2db27d09 }, + // { NvAPI_D3D_QueryLateLatchSupport, 0x8ceca0ec }, + // { NvAPI_D3D_RegisterDevice, 0x8c02c4d0 }, + // { NvAPI_D3D11_MultiDrawInstancedIndirect, 0xd4e26bbf }, + // { NvAPI_D3D11_MultiDrawIndexedInstancedIndirect, 0x59e890f9 }, + // { NvAPI_D3D_ImplicitSLIControl, 0x2aede111 }, + // { NvAPI_D3D12_GetNeedsAppFPBlendClamping, 0x6ef4d2d1 }, + // { NvAPI_D3D12_UseDriverHeapPriorities, 0xf0d978a8 }, + // { NvAPI_D3D12_Mosaic_GetCompanionAllocations, 0xa46022c7 }, + // { NvAPI_D3D12_Mosaic_GetViewportAndGpuPartitions, 0xb092b818 }, + // { NvAPI_D3D1x_GetGraphicsCapabilities, 0x52b1499a }, + // { NvAPI_D3D12_GetGraphicsCapabilities, 0x01e87354 }, + // { NvAPI_D3D11_RSSetExclusiveScissorRects, 0xae4d73ef }, + // { NvAPI_D3D11_RSSetViewportsPixelShadingRates, 0x34f7938f }, + // { NvAPI_D3D11_CreateShadingRateResourceView, 0x99ca2dff }, + // { NvAPI_D3D11_RSSetShadingRateResourceView, 0x1b0c2f83 }, + // { NvAPI_D3D11_RSGetPixelShadingRateSampleOrder, 0x092442a1 }, + // { NvAPI_D3D11_RSSetPixelShadingRateSampleOrder, 0xa942373a }, + // { NvAPI_D3D_InitializeVRSHelper, 0x4780d70b }, + // { NvAPI_D3D_InitializeNvGazeHandler, 0x5b3b7479 }, + // { NvAPI_D3D_InitializeSMPAssist, 0x42763d0c }, + // { NvAPI_D3D_QuerySMPAssistSupport, 0xc57921de }, + // { NvAPI_D3D_GetSleepStatus, 0xaef96ca1 }, + // { NvAPI_D3D_SetSleepMode, 0xac1ca9e0 }, + // { NvAPI_D3D_Sleep, 0x852cd1d2 }, + // { NvAPI_D3D_SetReflexSync, 0xb9f6faff }, + // { NvAPI_D3D_GetLatency, 0x1a587f9c }, + // { NvAPI_D3D_SetLatencyMarker, 0xd9984c05 }, + // { NvAPI_D3D12_SetAsyncFrameMarker, 0x13c98f73 }, + // { NvAPI_D3D11_SetAsyncFrameMarker, 0x59c2c510 }, + // { NvAPI_D3D12_NotifyOutOfBandCommandQueue, 0x03d6e8cb }, + // { NvAPI_D3D12_SetCreateCommandQueueLowLatencyHint, 0x548c224f }, + // { NvAPI_D3D12_CreateCubinComputeShaderExV2, 0x299f5fdc }, + // { NvAPI_D3D12_CreateCubinComputeShader, 0x2a2c79e8 }, + // { NvAPI_D3D12_CreateCubinComputeShaderEx, 0x3151211b }, + // { NvAPI_D3D12_CreateCubinComputeShaderWithName, 0x1dc7261f }, + // { NvAPI_D3D12_LaunchCubinShader, 0x5c52bb86 }, + // { NvAPI_D3D12_DestroyCubinComputeShader, 0x7fb785ba }, + // { NvAPI_D3D12_GetCudaMergedTextureSamplerObject, 0x329fe6e0 }, + // { NvAPI_D3D12_GetCudaIndependentDescriptorObject, 0x0ddac234 }, + // { NvAPI_D3D12_GetCudaTextureObject, 0x80403fc9 }, + // { NvAPI_D3D12_GetCudaSurfaceObject, 0x48f5b2ee }, + // { NvAPI_D3D12_IsFatbinPTXSupported, 0x70c07832 }, + // { NvAPI_D3D12_CreateCuModule, 0xad1a677d }, + // { NvAPI_D3D12_EnumFunctionsInModule, 0x7ab88d88 }, + // { NvAPI_D3D12_CreateCuFunction, 0xe2436e22 }, + // { NvAPI_D3D12_LaunchCuKernelChain, 0x24973538 }, + // { NvAPI_D3D12_LaunchCuKernelChainEx, 0x846a9bf0 }, + // { NvAPI_D3D12_DestroyCuModule, 0x41c65285 }, + // { NvAPI_D3D12_DestroyCuFunction, 0xdf295ea6 }, + // { NvAPI_D3D11_CreateCubinComputeShaderExV2, 0xf2c71d48 }, + // { NvAPI_D3D11_CreateCubinComputeShader, 0x0ed98181 }, + // { NvAPI_D3D11_CreateCubinComputeShaderEx, 0x32c2a0f6 }, + // { NvAPI_D3D11_CreateCubinComputeShaderWithName, 0xb672be19 }, + // { NvAPI_D3D11_LaunchCubinShader, 0x427e236d }, + // { NvAPI_D3D11_DestroyCubinComputeShader, 0x01682c86 }, + // { NvAPI_D3D11_IsFatbinPTXSupported, 0x6086bd93 }, + // { NvAPI_D3D11_GetCudaIndependentViewObject, 0x34d2afa8 }, + // { NvAPI_D3D11_GetCudaMergedTextureSamplerObject, 0x5d637d8f }, + // { NvAPI_D3D11_CreateUnorderedAccessView, 0x74a497a1 }, + // { NvAPI_D3D11_CreateShaderResourceView, 0x65cb431e }, + // { NvAPI_D3D11_CreateSamplerState, 0x89eca416 }, + // { NvAPI_D3D11_GetCudaTextureObject, 0x9006fa68 }, + // { NvAPI_D3D11_GetResourceGPUVirtualAddress, 0x1819b423 }, + // { NvAPI_D3D12_GetRaytracingCaps, 0x85a6c2a0 }, + // { NvAPI_D3D12_EnableRaytracingValidation, 0x1de5991b }, + // { NvAPI_D3D12_RegisterRaytracingValidationMessageCallback, 0x8554eb38 }, + // { NvAPI_D3D12_UnregisterRaytracingValidationMessageCallback, 0x26975da6 }, + // { NvAPI_D3D12_FlushRaytracingValidationMessages, 0xb8fb1fcb }, + // { NvAPI_D3D12_GetRaytracingDisplacementMicromapArrayPrebuildInfo, 0xfa99b6de }, + // { NvAPI_D3D12_GetRaytracingOpacityMicromapArrayPrebuildInfo, 0x4726d180 }, + // { NvAPI_D3D12_SetCreatePipelineStateOptions, 0x5c607a27 }, + // { NvAPI_D3D12_CheckDriverMatchingIdentifierEx, 0xafb237d4 }, + // { NvAPI_D3D12_GetRaytracingAccelerationStructurePrebuildInfoEx, 0x8d025b77 }, + // { NvAPI_D3D12_BuildRaytracingOpacityMicromapArray, 0x814f8d11 }, + // { NvAPI_D3D12_RelocateRaytracingOpacityMicromapArray, 0x0425c538 }, + // { NvAPI_D3D12_BuildRaytracingDisplacementMicromapArray, 0x066f569d }, + // { NvAPI_D3D12_RelocateRaytracingDisplacementMicromapArray, 0x1c142308 }, + // { NvAPI_D3D12_EmitRaytracingDisplacementMicromapArrayPostbuildInfo, 0x68b9a790 }, + // { NvAPI_D3D12_EmitRaytracingOpacityMicromapArrayPostbuildInfo, 0x1d9a39b6 }, + // { NvAPI_D3D12_BuildRaytracingAccelerationStructureEx, 0xe24ead45 }, + // { NvAPI_D3D12_QueryWorkstationFeatureProperties, 0xa92ea23a }, + // { NvAPI_D3D12_CreateCommittedRDMABuffer, 0xe78dcb44 }, + // { NvAPI_D3D12_ConvertCooperativeVectorMatrix, 0x0f252cb3 }, + // { NvAPI_D3D12_ConvertCooperativeVectorMatrixMultiple, 0x96ba5235 }, + // { NvAPI_D3D12_GetPhysicalDeviceCooperativeVectorProperties, 0x8f182aec }, + // { NvAPI_D3D12_GetRaytracingMultiIndirectClusterOperationRequirementsInfo, 0x5c9163f4 }, + // { NvAPI_D3D12_RaytracingExecuteMultiIndirectClusterOperation, 0x67c798af }, + // { NvAPI_D3D12_GetRaytracingPartitionedTlasIndirectPrebuildInfo, 0xcdfdc5f2 }, + // { NvAPI_D3D12_BuildRaytracingPartitionedTlasIndirect, 0x7cfc6fc3 }, + // { NvAPI_NGX_GetNGXOverrideState, 0x3fd96fba }, + // { NvAPI_NGX_SetNGXOverrideState, 0xb60fcb4e }, + // { NvAPI_DirectD3D12GraphicsCommandList_Create, 0x74a4e712 }, + // { NvAPI_DirectD3D12GraphicsCommandList_Release, 0x99da3dde }, + // { NvAPI_DirectD3D12GraphicsCommandList_Reset, 0x999c26d8 }, + // { NvAPI_VIO_GetCapabilities, 0x1dc91303 }, + // { NvAPI_VIO_Open, 0x44ee4841 }, + // { NvAPI_VIO_Close, 0xd01bd237 }, + // { NvAPI_VIO_Status, 0x0e6ce4f1 }, + // { NvAPI_VIO_SyncFormatDetect, 0x118d48a3 }, + // { NvAPI_VIO_GetConfig, 0xd34a789b }, + // { NvAPI_VIO_SetConfig, 0x0e4eec07 }, + // { NvAPI_VIO_SetCSC, 0xa1ec8d74 }, + // { NvAPI_VIO_GetCSC, 0x7b0d72a3 }, + // { NvAPI_VIO_SetGamma, 0x964bf452 }, + // { NvAPI_VIO_GetGamma, 0x51d53d06 }, + // { NvAPI_VIO_SetSyncDelay, 0x2697a8d1 }, + // { NvAPI_VIO_GetSyncDelay, 0x462214a9 }, + // { NvAPI_VIO_GetPCIInfo, 0xb981d935 }, + // { NvAPI_VIO_IsRunning, 0x96bd040e }, + // { NvAPI_VIO_Start, 0xcde8e1a3 }, + // { NvAPI_VIO_Stop, 0x6ba2a5d6 }, + // { NvAPI_VIO_IsFrameLockModeCompatible, 0x7bf0a94d }, + // { NvAPI_VIO_EnumDevices, 0xfd7c5557 }, + // { NvAPI_VIO_QueryTopology, 0x869534e2 }, + // { NvAPI_VIO_EnumSignalFormats, 0xead72fe4 }, + // { NvAPI_VIO_EnumDataFormats, 0x221fa8e8 }, + // { NvAPI_Stereo_CreateConfigurationProfileRegistryKey, 0xbe7692ec }, + // { NvAPI_Stereo_DeleteConfigurationProfileRegistryKey, 0xf117b834 }, + // { NvAPI_Stereo_SetConfigurationProfileValue, 0x24409f48 }, + // { NvAPI_Stereo_DeleteConfigurationProfileValue, 0x49bceecf }, + // { NvAPI_Stereo_Enable, 0x239c4545 }, + // { NvAPI_Stereo_Disable, 0x2ec50c2b }, + // { NvAPI_Stereo_IsEnabled, 0x348ff8e1 }, + // { NvAPI_Stereo_GetStereoSupport, 0x296c434d }, + // { NvAPI_Stereo_CreateHandleFromIUnknown, 0xac7e37f4 }, + // { NvAPI_Stereo_DestroyHandle, 0x3a153134 }, + // { NvAPI_Stereo_Activate, 0xf6a1ad68 }, + // { NvAPI_Stereo_Deactivate, 0x2d68de96 }, + // { NvAPI_Stereo_IsActivated, 0x1fb0bc30 }, + // { NvAPI_Stereo_GetSeparation, 0x451f2134 }, + // { NvAPI_Stereo_SetSeparation, 0x5c069fa3 }, + // { NvAPI_Stereo_DecreaseSeparation, 0xda044458 }, + // { NvAPI_Stereo_IncreaseSeparation, 0xc9a8ecec }, + // { NvAPI_Stereo_GetConvergence, 0x4ab00934 }, + // { NvAPI_Stereo_SetConvergence, 0x3dd6b54b }, + // { NvAPI_Stereo_DecreaseConvergence, 0x4c87e317 }, + // { NvAPI_Stereo_IncreaseConvergence, 0xa17daabe }, + // { NvAPI_Stereo_GetFrustumAdjustMode, 0xe6839b43 }, + // { NvAPI_Stereo_SetFrustumAdjustMode, 0x7be27fa2 }, + // { NvAPI_Stereo_CaptureJpegImage, 0x932cb140 }, + // { NvAPI_Stereo_InitActivation, 0xc7177702 }, + // { NvAPI_Stereo_Trigger_Activation, 0x0d6c6cd2 }, + // { NvAPI_Stereo_CapturePngImage, 0x8b7e99b5 }, + // { NvAPI_Stereo_ReverseStereoBlitControl, 0x3cd58f89 }, + // { NvAPI_Stereo_SetNotificationMessage, 0x6b9b409e }, + // { NvAPI_Stereo_SetActiveEye, 0x96eea9f8 }, + // { NvAPI_Stereo_SetDriverMode, 0x5e8f0bec }, + // { NvAPI_Stereo_GetEyeSeparation, 0xce653127 }, + // { NvAPI_Stereo_IsWindowedModeSupported, 0x40c8ed5e }, + // { NvAPI_Stereo_SetSurfaceCreationMode, 0xf5dcfcba }, + // { NvAPI_Stereo_GetSurfaceCreationMode, 0x36f1c736 }, + // { NvAPI_Stereo_Debug_WasLastDrawStereoized, 0xed4416c5 }, + // { NvAPI_Stereo_SetDefaultProfile, 0x44f0ecd1 }, + // { NvAPI_Stereo_GetDefaultProfile, 0x624e21c2 }, + // { NvAPI_D3D1x_CreateSwapChain, 0x1bc21b66 }, + // { NvAPI_D3D9_CreateSwapChain, 0x1a131e09 }, + // { NvAPI_Vulkan_InitLowLatencyDevice, 0x5c1696b6 }, + // { NvAPI_Vulkan_DestroyLowLatencyDevice, 0x11a5932b }, + // { NvAPI_Vulkan_GetSleepStatus, 0xadf966af }, + // { NvAPI_Vulkan_SetSleepMode, 0x2acfd162 }, + // { NvAPI_Vulkan_Sleep, 0x36732b1e }, + // { NvAPI_Vulkan_GetLatency, 0x3233d44a }, + // { NvAPI_Vulkan_SetLatencyMarker, 0xa17d13d6 }, + // { NvAPI_Vulkan_NotifyOutOfBandVkQueue, 0x5d6d3840 }, + // { NvAPI_DRS_CreateSession, 0x0694d52e }, + // { NvAPI_DRS_DestroySession, 0xdad9cff8 }, + // { NvAPI_DRS_LoadSettings, 0x375dbd6b }, + // { NvAPI_DRS_SaveSettings, 0xfcbc7e14 }, + // { NvAPI_DRS_LoadSettingsFromFile, 0xd3ede889 }, + // { NvAPI_DRS_SaveSettingsToFile, 0x2be25df8 }, + // { NvAPI_DRS_CreateProfile, 0xcc176068 }, + // { NvAPI_DRS_DeleteProfile, 0x17093206 }, + // { NvAPI_DRS_SetCurrentGlobalProfile, 0x1c89c5df }, + // { NvAPI_DRS_GetCurrentGlobalProfile, 0x617bff9f }, + // { NvAPI_DRS_GetProfileInfo, 0x61cd6fd6 }, + // { NvAPI_DRS_SetProfileInfo, 0x16abd3a9 }, + // { NvAPI_DRS_FindProfileByName, 0x7e4a9a0b }, + // { NvAPI_DRS_EnumProfiles, 0xbc371ee0 }, + // { NvAPI_DRS_GetNumProfiles, 0x1dae4fbc }, + // { NvAPI_DRS_CreateApplication, 0x4347a9de }, + // { NvAPI_DRS_DeleteApplicationEx, 0xc5ea85a1 }, + // { NvAPI_DRS_DeleteApplication, 0x2c694bc6 }, + // { NvAPI_DRS_GetApplicationInfo, 0xed1f8c69 }, + // { NvAPI_DRS_EnumApplications, 0x7fa2173a }, + // { NvAPI_DRS_FindApplicationByName, 0xeee566b2 }, + // { NvAPI_DRS_SetSetting, 0x577dd202 }, + // { NvAPI_DRS_GetSetting, 0x73bf8338 }, + // { NvAPI_DRS_EnumSettings, 0xae3039da }, + // { NvAPI_DRS_EnumAvailableSettingIds, 0xf020614a }, + // { NvAPI_DRS_EnumAvailableSettingValues, 0x2ec39f90 }, + // { NvAPI_DRS_GetSettingIdFromName, 0xcb7309cd }, + // { NvAPI_DRS_GetSettingNameFromId, 0xd61cbe6e }, + // { NvAPI_DRS_DeleteProfileSetting, 0xe4a26362 }, + // { NvAPI_DRS_RestoreAllDefaults, 0x5927b094 }, + // { NvAPI_DRS_RestoreProfileDefault, 0xfa5f6134 }, + // { NvAPI_DRS_RestoreProfileDefaultSetting, 0x53f0381e }, + // { NvAPI_DRS_GetBaseProfile, 0xda8466a0 }, + // { NvAPI_SYS_GetChipSetInfo, 0x53dabbca }, + // { NvAPI_SYS_GetLidAndDockInfo, 0xcda14d8a }, + // { NvAPI_SYS_GetDisplayIdFromGpuAndOutputId, 0x08f2bab4 }, + // { NvAPI_SYS_GetGpuAndOutputIdFromDisplayId, 0x112ba1a5 }, + // { NvAPI_SYS_GetPhysicalGpuFromDisplayId, 0x9ea74659 }, + // { NvAPI_SYS_GetDisplayDriverInfo, 0x721faceb }, + // { NvAPI_SYS_GetPhysicalGPUs, 0xd3b24d2d }, + // { NvAPI_SYS_GetLogicalGPUs, 0xccfffc10 }, + // { NvAPI_NGX_GetDriverFeatureSupport, 0x6194b19d }, + // { NvAPI_GPU_ClientRegisterForUtilizationSampleUpdates, 0xadeeaf67 }, + // { NvAPI_RegisterRiseCallback, 0x9cfe8f94 }, + // { NvAPI_RequestRise, 0x5047de98 }, + // { NvAPI_UninstallRise, 0xab8d09f6 }, +); + +fn make_nvapi_version(ver: u32) -> u32 { + let size = std::mem::size_of::() as u32; + (size << 16) | ver +} + +#[no_mangle] +pub unsafe extern "C" fn nvapi_QueryInterface(interface: u32) -> *mut c_void { + interface_to_fn(interface).unwrap_or(std::ptr::null_mut()) +} + +unsafe extern "C" fn NvAPI_Initialize() -> i32 { + 0 +} + +unsafe extern "C" fn NvAPI_Unload() -> i32 { + 0 +} + +unsafe extern "C" fn NvAPI_GetDisplayDriverVersion( + display: NvDisplayHandle, + pVersion: *mut NV_DISPLAY_DRIVER_VERSION, +) -> i32 { + let version = pVersion.as_mut(); + let version = unwrap_or::unwrap_some_or!(version, return _NvAPI_Status_NVAPI_INVALID_ARGUMENT); + if version.version != make_nvapi_version::(1) { + return _NvAPI_Status_NVAPI_INVALID_ARGUMENT; + } + _NvAPI_Status_NVAPI_NO_IMPLEMENTATION +} diff --git a/nvapi/src/nvapi.rs b/nvapi/src/nvapi.rs new file mode 100644 index 000000000..718bd0a38 --- /dev/null +++ b/nvapi/src/nvapi.rs @@ -0,0 +1,19879 @@ +// bindgen nvapi.h -o nvapi.rs --no-layout-tests --allowlist-type "Nv.*" --allowlist-type "NV_.*" +/* automatically generated by rust-bindgen 0.72.1 */ + +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8).offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { + byte | mask + } else { + byte & !mask + } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8).offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::()); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::()); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +pub type DWORD = ::std::os::raw::c_ulong; +pub type ULONG_PTR = ::std::os::raw::c_ulonglong; +pub type SIZE_T = ULONG_PTR; +pub type LONG = ::std::os::raw::c_long; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _LUID { + pub LowPart: DWORD, + pub HighPart: LONG, +} +pub type LUID = _LUID; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MEMORY_RANGE { + pub BaseAddress: *mut ::std::os::raw::c_void, + pub Length: SIZE_T, +} +pub type NV_MEMORY_RANGE = _NV_MEMORY_RANGE; +pub type NvU64 = ::std::os::raw::c_ulonglong; +pub type NvS64 = ::std::os::raw::c_longlong; +pub type NvS32 = ::std::os::raw::c_int; +pub type NvU32 = ::std::os::raw::c_uint; +pub type NvS16 = ::std::os::raw::c_short; +pub type NvU16 = ::std::os::raw::c_ushort; +pub type NvU8 = ::std::os::raw::c_uchar; +pub type NvS8 = ::std::os::raw::c_schar; +pub type NvF32 = f32; +pub type NvF64 = f64; +pub type NvBool = NvU8; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_RECT { + pub left: NvU32, + pub top: NvU32, + pub right: NvU32, + pub bottom: NvU32, +} +pub type NV_RECT = _NV_RECT; +#[doc = "! \\addtogroup nvapihandles\n! NVAPI Handles - These handles are retrieved from various calls and passed in to others in NvAPI\n! These are meant to be opaque types. Do not assume they correspond to indices, HDCs,\n! display indexes or anything else.\n!\n! Most handles remain valid until a display re-configuration (display mode set) or GPU\n! reconfiguration (going into or out of SLI modes) occurs. If NVAPI_HANDLE_INVALIDATED\n! is received by an app, it should discard all handles, and re-enumerate them.\n! @{"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvLogicalGpuHandle__ { + pub unused: ::std::os::raw::c_int, +} +#[doc = "! \\addtogroup nvapihandles\n! NVAPI Handles - These handles are retrieved from various calls and passed in to others in NvAPI\n! These are meant to be opaque types. Do not assume they correspond to indices, HDCs,\n! display indexes or anything else.\n!\n! Most handles remain valid until a display re-configuration (display mode set) or GPU\n! reconfiguration (going into or out of SLI modes) occurs. If NVAPI_HANDLE_INVALIDATED\n! is received by an app, it should discard all handles, and re-enumerate them.\n! @{"] +pub type NvLogicalGpuHandle = *mut NvLogicalGpuHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvPhysicalGpuHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvPhysicalGpuHandle = *mut NvPhysicalGpuHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvDisplayHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvDisplayHandle = *mut NvDisplayHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvMonitorHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvMonitorHandle = *mut NvMonitorHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvUnAttachedDisplayHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvUnAttachedDisplayHandle = *mut NvUnAttachedDisplayHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvVisualComputingDeviceHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvVisualComputingDeviceHandle = *mut NvVisualComputingDeviceHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvEventHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvEventHandle = *mut NvEventHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvHICHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvHICHandle = *mut NvHICHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvGSyncDeviceHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvGSyncDeviceHandle = *mut NvGSyncDeviceHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvVioHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvVioHandle = *mut NvVioHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvTransitionHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvTransitionHandle = *mut NvTransitionHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvAudioHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvAudioHandle = *mut NvAudioHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Nv3DVPContextHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type Nv3DVPContextHandle = *mut Nv3DVPContextHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Nv3DVPTransceiverHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type Nv3DVPTransceiverHandle = *mut Nv3DVPTransceiverHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Nv3DVPGlassesHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type Nv3DVPGlassesHandle = *mut Nv3DVPGlassesHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvPcfClientHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvPcfClientHandle = *mut NvPcfClientHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvSourceHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvSourceHandle = *mut NvSourceHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvTargetHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvTargetHandle = *mut NvTargetHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvPresentBarrierClientHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvPresentBarrierClientHandle = *mut NvPresentBarrierClientHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvSBox { + pub sX: NvS32, + pub sY: NvS32, + pub sWidth: NvS32, + pub sHeight: NvS32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvGUID { + pub data1: NvU32, + pub data2: NvU16, + pub data3: NvU16, + pub data4: [NvU8; 8usize], +} +pub type NvLUID = NvGUID; +pub type NvAPI_String = [::std::os::raw::c_char; 4096usize]; +pub type NvAPI_LongString = [::std::os::raw::c_char; 256usize]; +pub type NvAPI_ShortString = [::std::os::raw::c_char; 64usize]; +pub type NvAPI_UnicodeShortString = [NvU16; 64usize]; +#[doc = "!< Success. Request is completed."] +pub const _NvAPI_Status_NVAPI_OK: _NvAPI_Status = 0; +#[doc = "!< Generic error"] +pub const _NvAPI_Status_NVAPI_ERROR: _NvAPI_Status = -1; +#[doc = "!< NVAPI support library cannot be loaded."] +pub const _NvAPI_Status_NVAPI_LIBRARY_NOT_FOUND: _NvAPI_Status = -2; +#[doc = "!< not implemented in current driver installation"] +pub const _NvAPI_Status_NVAPI_NO_IMPLEMENTATION: _NvAPI_Status = -3; +#[doc = "!< NvAPI_Initialize has not been called (successfully)"] +pub const _NvAPI_Status_NVAPI_API_NOT_INITIALIZED: _NvAPI_Status = -4; +#[doc = "!< The argument/parameter value is not valid or NULL."] +pub const _NvAPI_Status_NVAPI_INVALID_ARGUMENT: _NvAPI_Status = -5; +#[doc = "!< No NVIDIA display driver, or NVIDIA GPU driving a display, was found."] +pub const _NvAPI_Status_NVAPI_NVIDIA_DEVICE_NOT_FOUND: _NvAPI_Status = -6; +#[doc = "!< No more items to enumerate"] +pub const _NvAPI_Status_NVAPI_END_ENUMERATION: _NvAPI_Status = -7; +#[doc = "!< Invalid handle"] +pub const _NvAPI_Status_NVAPI_INVALID_HANDLE: _NvAPI_Status = -8; +#[doc = "!< An argument's structure version is not supported"] +pub const _NvAPI_Status_NVAPI_INCOMPATIBLE_STRUCT_VERSION: _NvAPI_Status = -9; +#[doc = "!< The handle is no longer valid (likely due to GPU or display re-configuration)"] +pub const _NvAPI_Status_NVAPI_HANDLE_INVALIDATED: _NvAPI_Status = -10; +#[doc = "!< No NVIDIA OpenGL context is current (but needs to be)"] +pub const _NvAPI_Status_NVAPI_OPENGL_CONTEXT_NOT_CURRENT: _NvAPI_Status = -11; +#[doc = "!< An invalid pointer, usually NULL, was passed as a parameter"] +pub const _NvAPI_Status_NVAPI_INVALID_POINTER: _NvAPI_Status = -14; +#[doc = "!< OpenGL Expert is not supported by the current drivers"] +pub const _NvAPI_Status_NVAPI_NO_GL_EXPERT: _NvAPI_Status = -12; +#[doc = "!< OpenGL Expert is supported, but driver instrumentation is currently disabled"] +pub const _NvAPI_Status_NVAPI_INSTRUMENTATION_DISABLED: _NvAPI_Status = -13; +#[doc = "!< OpenGL does not support Nsight"] +pub const _NvAPI_Status_NVAPI_NO_GL_NSIGHT: _NvAPI_Status = -15; +#[doc = "!< Expected a logical GPU handle for one or more parameters"] +pub const _NvAPI_Status_NVAPI_EXPECTED_LOGICAL_GPU_HANDLE: _NvAPI_Status = -100; +#[doc = "!< Expected a physical GPU handle for one or more parameters"] +pub const _NvAPI_Status_NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE: _NvAPI_Status = -101; +#[doc = "!< Expected an NV display handle for one or more parameters"] +pub const _NvAPI_Status_NVAPI_EXPECTED_DISPLAY_HANDLE: _NvAPI_Status = -102; +#[doc = "!< The combination of parameters is not valid."] +pub const _NvAPI_Status_NVAPI_INVALID_COMBINATION: _NvAPI_Status = -103; +#[doc = "!< Requested feature is not supported in the selected GPU"] +pub const _NvAPI_Status_NVAPI_NOT_SUPPORTED: _NvAPI_Status = -104; +#[doc = "!< No port ID was found for the I2C transaction"] +pub const _NvAPI_Status_NVAPI_PORTID_NOT_FOUND: _NvAPI_Status = -105; +#[doc = "!< Expected an unattached display handle as one of the input parameters."] +pub const _NvAPI_Status_NVAPI_EXPECTED_UNATTACHED_DISPLAY_HANDLE: _NvAPI_Status = -106; +#[doc = "!< Invalid perf level"] +pub const _NvAPI_Status_NVAPI_INVALID_PERF_LEVEL: _NvAPI_Status = -107; +#[doc = "!< Device is busy; request not fulfilled"] +pub const _NvAPI_Status_NVAPI_DEVICE_BUSY: _NvAPI_Status = -108; +#[doc = "!< NV persist file is not found"] +pub const _NvAPI_Status_NVAPI_NV_PERSIST_FILE_NOT_FOUND: _NvAPI_Status = -109; +#[doc = "!< NV persist data is not found"] +pub const _NvAPI_Status_NVAPI_PERSIST_DATA_NOT_FOUND: _NvAPI_Status = -110; +#[doc = "!< Expected a TV output display"] +pub const _NvAPI_Status_NVAPI_EXPECTED_TV_DISPLAY: _NvAPI_Status = -111; +#[doc = "!< Expected a TV output on the D Connector - HDTV_EIAJ4120."] +pub const _NvAPI_Status_NVAPI_EXPECTED_TV_DISPLAY_ON_DCONNECTOR: _NvAPI_Status = -112; +#[doc = "!< SLI is not active on this device."] +pub const _NvAPI_Status_NVAPI_NO_ACTIVE_SLI_TOPOLOGY: _NvAPI_Status = -113; +#[doc = "!< Setup of SLI rendering mode is not possible right now."] +pub const _NvAPI_Status_NVAPI_SLI_RENDERING_MODE_NOTALLOWED: _NvAPI_Status = -114; +#[doc = "!< Expected a digital flat panel."] +pub const _NvAPI_Status_NVAPI_EXPECTED_DIGITAL_FLAT_PANEL: _NvAPI_Status = -115; +#[doc = "!< Argument exceeds the expected size."] +pub const _NvAPI_Status_NVAPI_ARGUMENT_EXCEED_MAX_SIZE: _NvAPI_Status = -116; +#[doc = "!< Inhibit is ON due to one of the flags in NV_GPU_DISPLAY_CHANGE_INHIBIT or SLI active."] +pub const _NvAPI_Status_NVAPI_DEVICE_SWITCHING_NOT_ALLOWED: _NvAPI_Status = -117; +#[doc = "!< Testing of clocks is not supported."] +pub const _NvAPI_Status_NVAPI_TESTING_CLOCKS_NOT_SUPPORTED: _NvAPI_Status = -118; +#[doc = "!< The specified underscan config is from an unknown source (e.g. INF)"] +pub const _NvAPI_Status_NVAPI_UNKNOWN_UNDERSCAN_CONFIG: _NvAPI_Status = -119; +#[doc = "!< Timeout while reconfiguring GPUs"] +pub const _NvAPI_Status_NVAPI_TIMEOUT_RECONFIGURING_GPU_TOPO: _NvAPI_Status = -120; +#[doc = "!< Requested data was not found"] +pub const _NvAPI_Status_NVAPI_DATA_NOT_FOUND: _NvAPI_Status = -121; +#[doc = "!< Expected an analog display"] +pub const _NvAPI_Status_NVAPI_EXPECTED_ANALOG_DISPLAY: _NvAPI_Status = -122; +#[doc = "!< No SLI video bridge is present"] +pub const _NvAPI_Status_NVAPI_NO_VIDLINK: _NvAPI_Status = -123; +#[doc = "!< NVAPI requires a reboot for the settings to take effect"] +pub const _NvAPI_Status_NVAPI_REQUIRES_REBOOT: _NvAPI_Status = -124; +#[doc = "!< The function is not supported with the current Hybrid mode."] +pub const _NvAPI_Status_NVAPI_INVALID_HYBRID_MODE: _NvAPI_Status = -125; +#[doc = "!< The target types are not all the same"] +pub const _NvAPI_Status_NVAPI_MIXED_TARGET_TYPES: _NvAPI_Status = -126; +#[doc = "!< The function is not supported from 32-bit on a 64-bit system."] +pub const _NvAPI_Status_NVAPI_SYSWOW64_NOT_SUPPORTED: _NvAPI_Status = -127; +#[doc = "!< There is no implicit GPU topology active. Use NVAPI_SetHybridMode to change topology."] +pub const _NvAPI_Status_NVAPI_IMPLICIT_SET_GPU_TOPOLOGY_CHANGE_NOT_ALLOWED: _NvAPI_Status = -128; +#[doc = "!< Prompt the user to close all non-migratable applications."] +pub const _NvAPI_Status_NVAPI_REQUEST_USER_TO_CLOSE_NON_MIGRATABLE_APPS: _NvAPI_Status = -129; +#[doc = "!< Could not allocate sufficient memory to complete the call."] +pub const _NvAPI_Status_NVAPI_OUT_OF_MEMORY: _NvAPI_Status = -130; +#[doc = "!< The previous operation that is transferring information to or from this surface is incomplete."] +pub const _NvAPI_Status_NVAPI_WAS_STILL_DRAWING: _NvAPI_Status = -131; +#[doc = "!< The file was not found."] +pub const _NvAPI_Status_NVAPI_FILE_NOT_FOUND: _NvAPI_Status = -132; +#[doc = "!< There are too many unique instances of a particular type of state object."] +pub const _NvAPI_Status_NVAPI_TOO_MANY_UNIQUE_STATE_OBJECTS: _NvAPI_Status = -133; +#[doc = "!< The method call is invalid. For example, a method's parameter may not be a valid pointer."] +pub const _NvAPI_Status_NVAPI_INVALID_CALL: _NvAPI_Status = -134; +#[doc = "!< d3d10_1.dll cannot be loaded."] +pub const _NvAPI_Status_NVAPI_D3D10_1_LIBRARY_NOT_FOUND: _NvAPI_Status = -135; +#[doc = "!< Couldn't find the function in the loaded DLL."] +pub const _NvAPI_Status_NVAPI_FUNCTION_NOT_FOUND: _NvAPI_Status = -136; +#[doc = "!< The application will require Administrator privileges to access this API.\n!< The application can be elevated to a higher permission level by selecting \"Run as Administrator\"."] +pub const _NvAPI_Status_NVAPI_INVALID_USER_PRIVILEGE: _NvAPI_Status = -137; +#[doc = "!< The handle corresponds to GDIPrimary."] +pub const _NvAPI_Status_NVAPI_EXPECTED_NON_PRIMARY_DISPLAY_HANDLE: _NvAPI_Status = -138; +#[doc = "!< Setting Physx GPU requires that the GPU is compute-capable."] +pub const _NvAPI_Status_NVAPI_EXPECTED_COMPUTE_GPU_HANDLE: _NvAPI_Status = -139; +#[doc = "!< The Stereo part of NVAPI failed to initialize completely. Check if the stereo driver is installed."] +pub const _NvAPI_Status_NVAPI_STEREO_NOT_INITIALIZED: _NvAPI_Status = -140; +#[doc = "!< Access to stereo-related registry keys or values has failed."] +pub const _NvAPI_Status_NVAPI_STEREO_REGISTRY_ACCESS_FAILED: _NvAPI_Status = -141; +#[doc = "!< The given registry profile type is not supported."] +pub const _NvAPI_Status_NVAPI_STEREO_REGISTRY_PROFILE_TYPE_NOT_SUPPORTED: _NvAPI_Status = -142; +#[doc = "!< The given registry value is not supported."] +pub const _NvAPI_Status_NVAPI_STEREO_REGISTRY_VALUE_NOT_SUPPORTED: _NvAPI_Status = -143; +#[doc = "!< Stereo is not enabled and the function needed it to execute completely."] +pub const _NvAPI_Status_NVAPI_STEREO_NOT_ENABLED: _NvAPI_Status = -144; +#[doc = "!< Stereo is not turned on and the function needed it to execute completely."] +pub const _NvAPI_Status_NVAPI_STEREO_NOT_TURNED_ON: _NvAPI_Status = -145; +#[doc = "!< Invalid device interface."] +pub const _NvAPI_Status_NVAPI_STEREO_INVALID_DEVICE_INTERFACE: _NvAPI_Status = -146; +#[doc = "!< Separation percentage or JPEG image capture quality is out of [0-100] range."] +pub const _NvAPI_Status_NVAPI_STEREO_PARAMETER_OUT_OF_RANGE: _NvAPI_Status = -147; +#[doc = "!< The given frustum adjust mode is not supported."] +pub const _NvAPI_Status_NVAPI_STEREO_FRUSTUM_ADJUST_MODE_NOT_SUPPORTED: _NvAPI_Status = -148; +#[doc = "!< The mosaic topology is not possible given the current state of the hardware."] +pub const _NvAPI_Status_NVAPI_TOPO_NOT_POSSIBLE: _NvAPI_Status = -149; +#[doc = "!< An attempt to do a display resolution mode change has failed."] +pub const _NvAPI_Status_NVAPI_MODE_CHANGE_FAILED: _NvAPI_Status = -150; +#[doc = "!< d3d11.dll/d3d11_beta.dll cannot be loaded."] +pub const _NvAPI_Status_NVAPI_D3D11_LIBRARY_NOT_FOUND: _NvAPI_Status = -151; +#[doc = "!< Address is outside of valid range."] +pub const _NvAPI_Status_NVAPI_INVALID_ADDRESS: _NvAPI_Status = -152; +#[doc = "!< The pre-allocated string is too small to hold the result."] +pub const _NvAPI_Status_NVAPI_STRING_TOO_SMALL: _NvAPI_Status = -153; +#[doc = "!< The input does not match any of the available devices."] +pub const _NvAPI_Status_NVAPI_MATCHING_DEVICE_NOT_FOUND: _NvAPI_Status = -154; +#[doc = "!< Driver is running."] +pub const _NvAPI_Status_NVAPI_DRIVER_RUNNING: _NvAPI_Status = -155; +#[doc = "!< Driver is not running."] +pub const _NvAPI_Status_NVAPI_DRIVER_NOTRUNNING: _NvAPI_Status = -156; +#[doc = "!< A driver reload is required to apply these settings."] +pub const _NvAPI_Status_NVAPI_ERROR_DRIVER_RELOAD_REQUIRED: _NvAPI_Status = -157; +#[doc = "!< Intended setting is not allowed."] +pub const _NvAPI_Status_NVAPI_SET_NOT_ALLOWED: _NvAPI_Status = -158; +#[doc = "!< Information can't be returned due to \"advanced display topology\"."] +pub const _NvAPI_Status_NVAPI_ADVANCED_DISPLAY_TOPOLOGY_REQUIRED: _NvAPI_Status = -159; +#[doc = "!< Setting is not found."] +pub const _NvAPI_Status_NVAPI_SETTING_NOT_FOUND: _NvAPI_Status = -160; +#[doc = "!< Setting size is too large."] +pub const _NvAPI_Status_NVAPI_SETTING_SIZE_TOO_LARGE: _NvAPI_Status = -161; +#[doc = "!< There are too many settings for a profile."] +pub const _NvAPI_Status_NVAPI_TOO_MANY_SETTINGS_IN_PROFILE: _NvAPI_Status = -162; +#[doc = "!< Profile is not found."] +pub const _NvAPI_Status_NVAPI_PROFILE_NOT_FOUND: _NvAPI_Status = -163; +#[doc = "!< Profile name is duplicated."] +pub const _NvAPI_Status_NVAPI_PROFILE_NAME_IN_USE: _NvAPI_Status = -164; +#[doc = "!< Profile name is empty."] +pub const _NvAPI_Status_NVAPI_PROFILE_NAME_EMPTY: _NvAPI_Status = -165; +#[doc = "!< Application not found in the Profile."] +pub const _NvAPI_Status_NVAPI_EXECUTABLE_NOT_FOUND: _NvAPI_Status = -166; +#[doc = "!< Application already exists in the other profile."] +pub const _NvAPI_Status_NVAPI_EXECUTABLE_ALREADY_IN_USE: _NvAPI_Status = -167; +#[doc = "!< Data Type mismatch"] +pub const _NvAPI_Status_NVAPI_DATATYPE_MISMATCH: _NvAPI_Status = -168; +#[doc = "!< The profile passed as parameter has been removed and is no longer valid."] +pub const _NvAPI_Status_NVAPI_PROFILE_REMOVED: _NvAPI_Status = -169; +#[doc = "!< An unregistered resource was passed as a parameter."] +pub const _NvAPI_Status_NVAPI_UNREGISTERED_RESOURCE: _NvAPI_Status = -170; +#[doc = "!< The DisplayId corresponds to a display which is not within the normal outputId range."] +pub const _NvAPI_Status_NVAPI_ID_OUT_OF_RANGE: _NvAPI_Status = -171; +#[doc = "!< Display topology is not valid so the driver cannot do a mode set on this configuration."] +pub const _NvAPI_Status_NVAPI_DISPLAYCONFIG_VALIDATION_FAILED: _NvAPI_Status = -172; +#[doc = "!< Display Port Multi-Stream topology has been changed."] +pub const _NvAPI_Status_NVAPI_DPMST_CHANGED: _NvAPI_Status = -173; +#[doc = "!< Input buffer is insufficient to hold the contents."] +pub const _NvAPI_Status_NVAPI_INSUFFICIENT_BUFFER: _NvAPI_Status = -174; +#[doc = "!< No access to the caller."] +pub const _NvAPI_Status_NVAPI_ACCESS_DENIED: _NvAPI_Status = -175; +#[doc = "!< The requested action cannot be performed without Mosaic being enabled."] +pub const _NvAPI_Status_NVAPI_MOSAIC_NOT_ACTIVE: _NvAPI_Status = -176; +#[doc = "!< The surface is relocated away from video memory."] +pub const _NvAPI_Status_NVAPI_SHARE_RESOURCE_RELOCATED: _NvAPI_Status = -177; +#[doc = "!< The user should disable DWM before calling NvAPI."] +pub const _NvAPI_Status_NVAPI_REQUEST_USER_TO_DISABLE_DWM: _NvAPI_Status = -178; +#[doc = "!< D3D device status is D3DERR_DEVICELOST or D3DERR_DEVICENOTRESET - the user has to reset the device."] +pub const _NvAPI_Status_NVAPI_D3D_DEVICE_LOST: _NvAPI_Status = -179; +#[doc = "!< The requested action cannot be performed in the current state."] +pub const _NvAPI_Status_NVAPI_INVALID_CONFIGURATION: _NvAPI_Status = -180; +#[doc = "!< Call failed as stereo handshake not completed."] +pub const _NvAPI_Status_NVAPI_STEREO_HANDSHAKE_NOT_DONE: _NvAPI_Status = -181; +#[doc = "!< The path provided was too short to determine the correct NVDRS_APPLICATION"] +pub const _NvAPI_Status_NVAPI_EXECUTABLE_PATH_IS_AMBIGUOUS: _NvAPI_Status = -182; +#[doc = "!< Default stereo profile is not currently defined"] +pub const _NvAPI_Status_NVAPI_DEFAULT_STEREO_PROFILE_IS_NOT_DEFINED: _NvAPI_Status = -183; +#[doc = "!< Default stereo profile does not exist"] +pub const _NvAPI_Status_NVAPI_DEFAULT_STEREO_PROFILE_DOES_NOT_EXIST: _NvAPI_Status = -184; +#[doc = "!< A cluster is already defined with the given configuration."] +pub const _NvAPI_Status_NVAPI_CLUSTER_ALREADY_EXISTS: _NvAPI_Status = -185; +#[doc = "!< The input display id is not that of a multi stream enabled connector or a display device in a multi stream topology"] +pub const _NvAPI_Status_NVAPI_DPMST_DISPLAY_ID_EXPECTED: _NvAPI_Status = -186; +#[doc = "!< The input display id is not valid or the monitor associated to it does not support the current operation"] +pub const _NvAPI_Status_NVAPI_INVALID_DISPLAY_ID: _NvAPI_Status = -187; +#[doc = "!< While playing secure audio stream, stream goes out of sync"] +pub const _NvAPI_Status_NVAPI_STREAM_IS_OUT_OF_SYNC: _NvAPI_Status = -188; +#[doc = "!< Older audio driver version than required"] +pub const _NvAPI_Status_NVAPI_INCOMPATIBLE_AUDIO_DRIVER: _NvAPI_Status = -189; +#[doc = "!< Value already set, setting again not allowed."] +pub const _NvAPI_Status_NVAPI_VALUE_ALREADY_SET: _NvAPI_Status = -190; +#[doc = "!< Requested operation timed out"] +pub const _NvAPI_Status_NVAPI_TIMEOUT: _NvAPI_Status = -191; +#[doc = "!< The requested workstation feature set has incomplete driver internal allocation resources"] +pub const _NvAPI_Status_NVAPI_GPU_WORKSTATION_FEATURE_INCOMPLETE: _NvAPI_Status = -192; +#[doc = "!< Call failed because InitActivation was not called."] +pub const _NvAPI_Status_NVAPI_STEREO_INIT_ACTIVATION_NOT_DONE: _NvAPI_Status = -193; +#[doc = "!< The requested action cannot be performed without Sync being enabled."] +pub const _NvAPI_Status_NVAPI_SYNC_NOT_ACTIVE: _NvAPI_Status = -194; +#[doc = "!< The requested action cannot be performed without Sync Master being enabled."] +pub const _NvAPI_Status_NVAPI_SYNC_MASTER_NOT_FOUND: _NvAPI_Status = -195; +#[doc = "!< Invalid displays passed in the NV_GSYNC_DISPLAY pointer."] +pub const _NvAPI_Status_NVAPI_INVALID_SYNC_TOPOLOGY: _NvAPI_Status = -196; +#[doc = "!< The specified signing algorithm is not supported. Either an incorrect value was entered or the current installed driver/hardware does not support the input value."] +pub const _NvAPI_Status_NVAPI_ECID_SIGN_ALGO_UNSUPPORTED: _NvAPI_Status = -197; +#[doc = "!< The encrypted public key verification has failed."] +pub const _NvAPI_Status_NVAPI_ECID_KEY_VERIFICATION_FAILED: _NvAPI_Status = -198; +#[doc = "!< The device's firmware is out of date."] +pub const _NvAPI_Status_NVAPI_FIRMWARE_OUT_OF_DATE: _NvAPI_Status = -199; +#[doc = "!< The device's firmware is not supported."] +pub const _NvAPI_Status_NVAPI_FIRMWARE_REVISION_NOT_SUPPORTED: _NvAPI_Status = -200; +#[doc = "!< The caller is not authorized to modify the License."] +pub const _NvAPI_Status_NVAPI_LICENSE_CALLER_AUTHENTICATION_FAILED: _NvAPI_Status = -201; +#[doc = "!< The user tried to use a deferred context without registering the device first"] +pub const _NvAPI_Status_NVAPI_D3D_DEVICE_NOT_REGISTERED: _NvAPI_Status = -202; +#[doc = "!< Head or SourceId was not reserved for the VR Display before doing the Modeset or the dedicated display."] +pub const _NvAPI_Status_NVAPI_RESOURCE_NOT_ACQUIRED: _NvAPI_Status = -203; +#[doc = "!< Provided timing is not supported."] +pub const _NvAPI_Status_NVAPI_TIMING_NOT_SUPPORTED: _NvAPI_Status = -204; +#[doc = "!< HDCP Encryption Failed for the device. Would be applicable when the device is HDCP Capable."] +pub const _NvAPI_Status_NVAPI_HDCP_ENCRYPTION_FAILED: _NvAPI_Status = -205; +#[doc = "!< Provided mode is over sink device pclk limitation."] +pub const _NvAPI_Status_NVAPI_PCLK_LIMITATION_FAILED: _NvAPI_Status = -206; +#[doc = "!< No connector on GPU found."] +pub const _NvAPI_Status_NVAPI_NO_CONNECTOR_FOUND: _NvAPI_Status = -207; +#[doc = "!< When a non-HDCP capable HMD is connected, we would inform user by this code."] +pub const _NvAPI_Status_NVAPI_HDCP_DISABLED: _NvAPI_Status = -208; +#[doc = "!< Atleast an API is still being called"] +pub const _NvAPI_Status_NVAPI_API_IN_USE: _NvAPI_Status = -209; +#[doc = "!< No display found on Nvidia GPU(s)."] +pub const _NvAPI_Status_NVAPI_NVIDIA_DISPLAY_NOT_FOUND: _NvAPI_Status = -210; +#[doc = "!< Priv security violation, improper access to a secured register."] +pub const _NvAPI_Status_NVAPI_PRIV_SEC_VIOLATION: _NvAPI_Status = -211; +#[doc = "!< NVAPI cannot be called by this vendor"] +pub const _NvAPI_Status_NVAPI_INCORRECT_VENDOR: _NvAPI_Status = -212; +#[doc = "!< DirectMode Display is already in use"] +pub const _NvAPI_Status_NVAPI_DISPLAY_IN_USE: _NvAPI_Status = -213; +#[doc = "!< The Config is having Non-NVidia GPU with Non-HDCP HMD connected"] +pub const _NvAPI_Status_NVAPI_UNSUPPORTED_CONFIG_NON_HDCP_HMD: _NvAPI_Status = -214; +#[doc = "!< GPU's Max Display Limit has Reached"] +pub const _NvAPI_Status_NVAPI_MAX_DISPLAY_LIMIT_REACHED: _NvAPI_Status = -215; +#[doc = "!< DirectMode not Enabled on the Display"] +pub const _NvAPI_Status_NVAPI_INVALID_DIRECT_MODE_DISPLAY: _NvAPI_Status = -216; +#[doc = "!< GPU is in debug mode, OC is NOT allowed."] +pub const _NvAPI_Status_NVAPI_GPU_IN_DEBUG_MODE: _NvAPI_Status = -217; +#[doc = "!< No NvAPI context was found for this D3D object"] +pub const _NvAPI_Status_NVAPI_D3D_CONTEXT_NOT_FOUND: _NvAPI_Status = -218; +#[doc = "!< there is version mismatch between stereo driver and dx driver"] +pub const _NvAPI_Status_NVAPI_STEREO_VERSION_MISMATCH: _NvAPI_Status = -219; +#[doc = "!< GPU is not powered and so the request cannot be completed."] +pub const _NvAPI_Status_NVAPI_GPU_NOT_POWERED: _NvAPI_Status = -220; +#[doc = "!< The display driver update in progress."] +pub const _NvAPI_Status_NVAPI_ERROR_DRIVER_RELOAD_IN_PROGRESS: _NvAPI_Status = -221; +#[doc = "!< Wait for HW resources allocation"] +pub const _NvAPI_Status_NVAPI_WAIT_FOR_HW_RESOURCE: _NvAPI_Status = -222; +#[doc = "!< operation requires further HDCP action"] +pub const _NvAPI_Status_NVAPI_REQUIRE_FURTHER_HDCP_ACTION: _NvAPI_Status = -223; +#[doc = "!< Dynamic Mux transition failure"] +pub const _NvAPI_Status_NVAPI_DISPLAY_MUX_TRANSITION_FAILED: _NvAPI_Status = -224; +#[doc = "!< Invalid DSC version"] +pub const _NvAPI_Status_NVAPI_INVALID_DSC_VERSION: _NvAPI_Status = -225; +#[doc = "!< Invalid DSC slice count"] +pub const _NvAPI_Status_NVAPI_INVALID_DSC_SLICECOUNT: _NvAPI_Status = -226; +#[doc = "!< Invalid DSC output BPP"] +pub const _NvAPI_Status_NVAPI_INVALID_DSC_OUTPUT_BPP: _NvAPI_Status = -227; +#[doc = "!< There was an error while loading nvapi.dll from the driver store."] +pub const _NvAPI_Status_NVAPI_FAILED_TO_LOAD_FROM_DRIVER_STORE: _NvAPI_Status = -228; +#[doc = "!< OpenGL does not export Vulkan fake extensions"] +pub const _NvAPI_Status_NVAPI_NO_VULKAN: _NvAPI_Status = -229; +#[doc = "!< A request for NvTOPPs telemetry CData has already been made and is pending a response."] +pub const _NvAPI_Status_NVAPI_REQUEST_PENDING: _NvAPI_Status = -230; +#[doc = "!< Operation cannot be performed because the resource is in use."] +pub const _NvAPI_Status_NVAPI_RESOURCE_IN_USE: _NvAPI_Status = -231; +#[doc = "!< Device kernel image is invalid"] +pub const _NvAPI_Status_NVAPI_INVALID_IMAGE: _NvAPI_Status = -232; +#[doc = "!< PTX JIT compilation failed"] +pub const _NvAPI_Status_NVAPI_INVALID_PTX: _NvAPI_Status = -233; +#[doc = "!< Uncorrectable NVLink error was detected during the execution"] +pub const _NvAPI_Status_NVAPI_NVLINK_UNCORRECTABLE: _NvAPI_Status = -234; +#[doc = "!< PTX JIT compiler library was not found."] +pub const _NvAPI_Status_NVAPI_JIT_COMPILER_NOT_FOUND: _NvAPI_Status = -235; +#[doc = "!< Device kernel source is invalid."] +pub const _NvAPI_Status_NVAPI_INVALID_SOURCE: _NvAPI_Status = -236; +#[doc = "!< While executing a kernel, the device encountered an illegal instruction."] +pub const _NvAPI_Status_NVAPI_ILLEGAL_INSTRUCTION: _NvAPI_Status = -237; +#[doc = "!< While executing a kernel, the device program counter wrapped its address space"] +pub const _NvAPI_Status_NVAPI_INVALID_PC: _NvAPI_Status = -238; +#[doc = "!< An exception occurred on the device while executing a kernel"] +pub const _NvAPI_Status_NVAPI_LAUNCH_FAILED: _NvAPI_Status = -239; +#[doc = "!< Attempted operation is not permitted."] +pub const _NvAPI_Status_NVAPI_NOT_PERMITTED: _NvAPI_Status = -240; +#[doc = "!< The callback function has already been registered."] +pub const _NvAPI_Status_NVAPI_CALLBACK_ALREADY_REGISTERED: _NvAPI_Status = -241; +#[doc = "!< The callback function is not found or not registered."] +pub const _NvAPI_Status_NVAPI_CALLBACK_NOT_FOUND: _NvAPI_Status = -242; +#[doc = "!< Invalid Wire Format for the VR HMD"] +pub const _NvAPI_Status_NVAPI_INVALID_OUTPUT_WIRE_FORMAT: _NvAPI_Status = -243; +#[doc = "! NvAPI Status Values\n! All NvAPI functions return one of these codes.\n! \\ingroup nvapistatus"] +pub type _NvAPI_Status = ::std::os::raw::c_int; +#[doc = "! NvAPI Status Values\n! All NvAPI functions return one of these codes.\n! \\ingroup nvapistatus"] +pub use self::_NvAPI_Status as NvAPI_Status; +#[doc = "! \\ingroup driverapi\n! Used in NvAPI_GPU_GetMemoryInfo()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_DISPLAY_DRIVER_MEMORY_INFO_V1 { + #[doc = "!< Version info"] + pub version: NvU32, + #[doc = "!< Size(in kb) of the physical framebuffer."] + pub dedicatedVideoMemory: NvU32, + #[doc = "!< Size(in kb) of the available physical framebuffer for allocating video memory surfaces."] + pub availableDedicatedVideoMemory: NvU32, + #[doc = "!< Size(in kb) of system memory the driver allocates at load time."] + pub systemVideoMemory: NvU32, + #[doc = "!< Size(in kb) of shared system memory that driver is allowed to commit for surfaces across all allocations."] + pub sharedSystemMemory: NvU32, +} +#[doc = "! \\ingroup driverapi\n! Used in NvAPI_GPU_GetMemoryInfo()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_DISPLAY_DRIVER_MEMORY_INFO_V2 { + #[doc = "!< Version info"] + pub version: NvU32, + #[doc = "!< Size(in kb) of the physical framebuffer."] + pub dedicatedVideoMemory: NvU32, + #[doc = "!< Size(in kb) of the available physical framebuffer for allocating video memory surfaces."] + pub availableDedicatedVideoMemory: NvU32, + #[doc = "!< Size(in kb) of system memory the driver allocates at load time."] + pub systemVideoMemory: NvU32, + #[doc = "!< Size(in kb) of shared system memory that driver is allowed to commit for surfaces across all allocations."] + pub sharedSystemMemory: NvU32, + #[doc = "!< Size(in kb) of the current available physical framebuffer for allocating video memory surfaces."] + pub curAvailableDedicatedVideoMemory: NvU32, +} +#[doc = "! \\ingroup driverapi\n! Used in NvAPI_GPU_GetMemoryInfo()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_DISPLAY_DRIVER_MEMORY_INFO_V3 { + #[doc = "!< Version info"] + pub version: NvU32, + #[doc = "!< Size(in kb) of the physical framebuffer."] + pub dedicatedVideoMemory: NvU32, + #[doc = "!< Size(in kb) of the available physical framebuffer for allocating video memory surfaces."] + pub availableDedicatedVideoMemory: NvU32, + #[doc = "!< Size(in kb) of system memory the driver allocates at load time."] + pub systemVideoMemory: NvU32, + #[doc = "!< Size(in kb) of shared system memory that driver is allowed to commit for surfaces across all allocations."] + pub sharedSystemMemory: NvU32, + #[doc = "!< Size(in kb) of the current available physical framebuffer for allocating video memory surfaces."] + pub curAvailableDedicatedVideoMemory: NvU32, + #[doc = "!< Size(in kb) of the total size of memory released as a result of the evictions."] + pub dedicatedVideoMemoryEvictionsSize: NvU32, + #[doc = "!< Indicates the number of eviction events that caused an allocation to be removed from dedicated video memory to free GPU\n!< video memory to make room for other allocations."] + pub dedicatedVideoMemoryEvictionCount: NvU32, +} +#[doc = "! \\ingroup driverapi"] +pub type NV_DISPLAY_DRIVER_MEMORY_INFO = NV_DISPLAY_DRIVER_MEMORY_INFO_V3; +#[doc = "! \\ingroup driverapi\n! Used in NvAPI_GPU_GetMemoryInfoEx()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_MEMORY_INFO_EX_V1 { + #[doc = "!< Structure version"] + pub version: NvU32, + #[doc = "!< Size(in bytes) of the physical framebuffer. Refers to the dedicated video memory on discrete GPUs."] + pub dedicatedVideoMemory: NvU64, + #[doc = "!< Size(in bytes) of the available physical framebuffer for allocating video memory surfaces."] + pub availableDedicatedVideoMemory: NvU64, + #[doc = "!< Size(in bytes) of system memory the driver allocates at load time. It is a substitute for dedicated video memory.\n!< Typically used with integrated GPUs that do not have dedicated video memory."] + pub systemVideoMemory: NvU64, + #[doc = "!< Size(in bytes) of shared system memory that driver is allowed to commit for surfaces across all allocations.\n!< On discrete GPUs, it is used to utilize system memory for various operations. It does not need to be reserved during boot.\n!< It may be used by both GPU and CPU, and has an \"on-demand\" type of usage."] + pub sharedSystemMemory: NvU64, + #[doc = "!< Size(in bytes) of the current available physical framebuffer for allocating video memory surfaces."] + pub curAvailableDedicatedVideoMemory: NvU64, + #[doc = "!< Size(in bytes) of the total size of memory released as a result of the evictions."] + pub dedicatedVideoMemoryEvictionsSize: NvU64, + #[doc = "!< Indicates the number of eviction events that caused an allocation to be removed from dedicated video memory to free GPU\n!< video memory to make room for other allocations."] + pub dedicatedVideoMemoryEvictionCount: NvU64, + #[doc = "!< Size(in bytes) of the total size of memory allocated as a result of the promotions."] + pub dedicatedVideoMemoryPromotionsSize: NvU64, + #[doc = "!< Indicates the number of promotion events that caused an allocation to be promoted to dedicated video memory"] + pub dedicatedVideoMemoryPromotionCount: NvU64, +} +#[doc = "! \\ingroup driverapi"] +pub type NV_GPU_MEMORY_INFO_EX = NV_GPU_MEMORY_INFO_EX_V1; +#[doc = "! \\ingroup dx\n! Used in NvAPI_D3D10_GetCurrentSLIState(), and NvAPI_D3D_GetCurrentSLIState()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GET_CURRENT_SLI_STATE_V1 { + #[doc = "!< Structure version"] + pub version: NvU32, + #[doc = "!< [OUT] The maximum possible value of numAFRGroups"] + pub maxNumAFRGroups: NvU32, + #[doc = "!< [OUT] The number of AFR groups enabled in the system"] + pub numAFRGroups: NvU32, + #[doc = "!< [OUT] The AFR group index for the frame currently being rendered"] + pub currentAFRIndex: NvU32, + #[doc = "!< [OUT] What the AFR group index will be for the next frame (i.e. after calling Present)"] + pub nextFrameAFRIndex: NvU32, + #[doc = "!< [OUT] The AFR group index that was used for the previous frame (~0 if more than one frame has not been rendered yet)"] + pub previousFrameAFRIndex: NvU32, + #[doc = "!< [OUT] Boolean: Is this frame the first time running on the current AFR group"] + pub bIsCurAFRGroupNew: NvU32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GET_CURRENT_SLI_STATE_V2 { + #[doc = "!< Structure version"] + pub version: NvU32, + #[doc = "!< [OUT] The maximum possible value of numAFRGroups"] + pub maxNumAFRGroups: NvU32, + #[doc = "!< [OUT] The number of AFR groups enabled in the system"] + pub numAFRGroups: NvU32, + #[doc = "!< [OUT] The AFR group index for the frame currently being rendered"] + pub currentAFRIndex: NvU32, + #[doc = "!< [OUT] What the AFR group index will be for the next frame (i.e. after calling Present)"] + pub nextFrameAFRIndex: NvU32, + #[doc = "!< [OUT] The AFR group index that was used for the previous frame (~0 if more than one frame has not been rendered yet)"] + pub previousFrameAFRIndex: NvU32, + #[doc = "!< [OUT] Boolean: Is this frame the first time running on the current AFR group"] + pub bIsCurAFRGroupNew: NvU32, + #[doc = "!< [OUT] The number of GPUs used in VR-SLI. If it is 0 VR-SLI is not active"] + pub numVRSLIGpus: NvU32, +} +pub const _NV_StereoActiveEye_NVAPI_STEREO_EYE_RIGHT: _NV_StereoActiveEye = 1; +pub const _NV_StereoActiveEye_NVAPI_STEREO_EYE_LEFT: _NV_StereoActiveEye = 2; +pub const _NV_StereoActiveEye_NVAPI_STEREO_EYE_MONO: _NV_StereoActiveEye = 3; +#[doc = "! \\ingroup stereoapi"] +pub type _NV_StereoActiveEye = ::std::os::raw::c_int; +#[doc = "! \\ingroup stereoapi"] +pub use self::_NV_StereoActiveEye as NV_STEREO_ACTIVE_EYE; +pub const _NV_StereoDriverMode_NVAPI_STEREO_DRIVER_MODE_AUTOMATIC: _NV_StereoDriverMode = 0; +pub const _NV_StereoDriverMode_NVAPI_STEREO_DRIVER_MODE_DIRECT: _NV_StereoDriverMode = 2; +#[doc = "! \\ingroup stereoapi"] +pub type _NV_StereoDriverMode = ::std::os::raw::c_int; +#[doc = "! \\ingroup stereoapi"] +pub use self::_NV_StereoDriverMode as NV_STEREO_DRIVER_MODE; +pub const _NV_DP_LINK_RATE_NV_DP_1_62GBPS: _NV_DP_LINK_RATE = 6; +pub const _NV_DP_LINK_RATE_NV_DP_2_70GBPS: _NV_DP_LINK_RATE = 10; +pub const _NV_DP_LINK_RATE_NV_DP_5_40GBPS: _NV_DP_LINK_RATE = 20; +pub const _NV_DP_LINK_RATE_NV_DP_8_10GBPS: _NV_DP_LINK_RATE = 30; +pub const _NV_DP_LINK_RATE_NV_EDP_2_16GBPS: _NV_DP_LINK_RATE = 8; +pub const _NV_DP_LINK_RATE_NV_EDP_2_43GBPS: _NV_DP_LINK_RATE = 9; +pub const _NV_DP_LINK_RATE_NV_EDP_3_24GBPS: _NV_DP_LINK_RATE = 12; +pub const _NV_DP_LINK_RATE_NV_EDP_4_32GBPS: _NV_DP_LINK_RATE = 16; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub type _NV_DP_LINK_RATE = ::std::os::raw::c_int; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub use self::_NV_DP_LINK_RATE as NV_DP_LINK_RATE; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_1_62Gbps: _NV_DP2X_LINK_RATE = 162; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_2_16Gbps: _NV_DP2X_LINK_RATE = 216; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_2_43Gbps: _NV_DP2X_LINK_RATE = 243; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_2_50Gbps: _NV_DP2X_LINK_RATE = 250; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_2_70Gbps: _NV_DP2X_LINK_RATE = 270; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_3_24Gbps: _NV_DP2X_LINK_RATE = 324; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_4_32Gbps: _NV_DP2X_LINK_RATE = 432; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_5_40Gbps: _NV_DP2X_LINK_RATE = 540; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_6_75Gbps: _NV_DP2X_LINK_RATE = 675; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_8_10Gbps: _NV_DP2X_LINK_RATE = 810; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_10_0Gbps: _NV_DP2X_LINK_RATE = 1000; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_13_5Gbps: _NV_DP2X_LINK_RATE = 1350; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_20_0Gbps: _NV_DP2X_LINK_RATE = 2000; +pub type _NV_DP2X_LINK_RATE = ::std::os::raw::c_int; +pub use self::_NV_DP2X_LINK_RATE as NV_DP2X_LINK_RATE; +pub const _NV_DP_LANE_COUNT_NV_DP_1_LANE: _NV_DP_LANE_COUNT = 1; +pub const _NV_DP_LANE_COUNT_NV_DP_2_LANE: _NV_DP_LANE_COUNT = 2; +pub const _NV_DP_LANE_COUNT_NV_DP_4_LANE: _NV_DP_LANE_COUNT = 4; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub type _NV_DP_LANE_COUNT = ::std::os::raw::c_int; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub use self::_NV_DP_LANE_COUNT as NV_DP_LANE_COUNT; +pub const _NV_DP_COLOR_FORMAT_NV_DP_COLOR_FORMAT_RGB: _NV_DP_COLOR_FORMAT = 0; +pub const _NV_DP_COLOR_FORMAT_NV_DP_COLOR_FORMAT_YCbCr422: _NV_DP_COLOR_FORMAT = 1; +pub const _NV_DP_COLOR_FORMAT_NV_DP_COLOR_FORMAT_YCbCr444: _NV_DP_COLOR_FORMAT = 2; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub type _NV_DP_COLOR_FORMAT = ::std::os::raw::c_int; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub use self::_NV_DP_COLOR_FORMAT as NV_DP_COLOR_FORMAT; +pub const _NV_DP_COLORIMETRY_NV_DP_COLORIMETRY_RGB: _NV_DP_COLORIMETRY = 0; +pub const _NV_DP_COLORIMETRY_NV_DP_COLORIMETRY_YCbCr_ITU601: _NV_DP_COLORIMETRY = 1; +pub const _NV_DP_COLORIMETRY_NV_DP_COLORIMETRY_YCbCr_ITU709: _NV_DP_COLORIMETRY = 2; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub type _NV_DP_COLORIMETRY = ::std::os::raw::c_int; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub use self::_NV_DP_COLORIMETRY as NV_DP_COLORIMETRY; +pub const _NV_DP_DYNAMIC_RANGE_NV_DP_DYNAMIC_RANGE_VESA: _NV_DP_DYNAMIC_RANGE = 0; +pub const _NV_DP_DYNAMIC_RANGE_NV_DP_DYNAMIC_RANGE_CEA: _NV_DP_DYNAMIC_RANGE = 1; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub type _NV_DP_DYNAMIC_RANGE = ::std::os::raw::c_int; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub use self::_NV_DP_DYNAMIC_RANGE as NV_DP_DYNAMIC_RANGE; +pub const _NV_DP_BPC_NV_DP_BPC_DEFAULT: _NV_DP_BPC = 0; +pub const _NV_DP_BPC_NV_DP_BPC_6: _NV_DP_BPC = 1; +pub const _NV_DP_BPC_NV_DP_BPC_8: _NV_DP_BPC = 2; +pub const _NV_DP_BPC_NV_DP_BPC_10: _NV_DP_BPC = 3; +pub const _NV_DP_BPC_NV_DP_BPC_12: _NV_DP_BPC = 4; +pub const _NV_DP_BPC_NV_DP_BPC_16: _NV_DP_BPC = 5; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub type _NV_DP_BPC = ::std::os::raw::c_int; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub use self::_NV_DP_BPC as NV_DP_BPC; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_EDID_V1 { + pub version: NvU32, + pub EDID_Data: [NvU8; 256usize], +} +#[doc = "! Used in NvAPI_GPU_GetEDID()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_EDID_V2 { + #[doc = "!< Structure version"] + pub version: NvU32, + pub EDID_Data: [NvU8; 256usize], + pub sizeofEDID: NvU32, +} +#[doc = "! Used in NvAPI_GPU_GetEDID()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_EDID_V3 { + #[doc = "!< Structure version"] + pub version: NvU32, + pub EDID_Data: [NvU8; 256usize], + pub sizeofEDID: NvU32, + #[doc = "!< ID which always returned in a monotonically increasing counter.\n!< Across a split-EDID read we need to verify that all calls returned the same edidId.\n!< This counter is incremented if we get the updated EDID."] + pub edidId: NvU32, + #[doc = "!< Which 256-byte page of the EDID we want to read. Start at 0.\n!< If the read succeeds with edidSize > NV_EDID_DATA_SIZE,\n!< call back again with offset+256 until we have read the entire buffer"] + pub offset: NvU32, +} +#[doc = "! Used in NvAPI_GPU_GetEDID()"] +pub type NV_EDID = NV_EDID_V3; +#[doc = "!< the EDID which is actively used by the driver, it could be _RAW/_COOKED/_FORCED/_INF."] +pub const NV_EDID_FLAG_NV_EDID_FLAG_DEFAULT: NV_EDID_FLAG = 0; +#[doc = "!< the EDID which is not modified by the driver. If there's no _FORCED edid engaged, it\n!< will be the unmodified monitor EDID from the I2C bus. Otherwise it is original _FORCED edid."] +pub const NV_EDID_FLAG_NV_EDID_FLAG_RAW: NV_EDID_FLAG = 1; +#[doc = "!< the EDID has been modified by the driver for compatibility"] +pub const NV_EDID_FLAG_NV_EDID_FLAG_COOKED: NV_EDID_FLAG = 2; +#[doc = "!< the EDID is forced by the end-user over s/w interface,"] +pub const NV_EDID_FLAG_NV_EDID_FLAG_FORCED: NV_EDID_FLAG = 3; +#[doc = "!< the EDID is from monitor INF"] +pub const NV_EDID_FLAG_NV_EDID_FLAG_INF: NV_EDID_FLAG = 4; +#[doc = "!< the EDID is from the monitor over I2C bus without any modification."] +pub const NV_EDID_FLAG_NV_EDID_FLAG_HW: NV_EDID_FLAG = 5; +pub type NV_EDID_FLAG = ::std::os::raw::c_int; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_VGA_15_PIN: _NV_GPU_CONNECTOR_TYPE = 0; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_TV_COMPOSITE: _NV_GPU_CONNECTOR_TYPE = 16; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_TV_SVIDEO: _NV_GPU_CONNECTOR_TYPE = 17; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_TV_HDTV_COMPONENT: _NV_GPU_CONNECTOR_TYPE = 19; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_TV_SCART: _NV_GPU_CONNECTOR_TYPE = 20; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_TV_COMPOSITE_SCART_ON_EIAJ4120: + _NV_GPU_CONNECTOR_TYPE = 22; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_TV_HDTV_EIAJ4120: _NV_GPU_CONNECTOR_TYPE = 23; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_PC_POD_HDTV_YPRPB: _NV_GPU_CONNECTOR_TYPE = 24; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_PC_POD_SVIDEO: _NV_GPU_CONNECTOR_TYPE = 25; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_PC_POD_COMPOSITE: _NV_GPU_CONNECTOR_TYPE = 26; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DVI_I_TV_SVIDEO: _NV_GPU_CONNECTOR_TYPE = 32; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DVI_I_TV_COMPOSITE: _NV_GPU_CONNECTOR_TYPE = + 33; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DVI_I: _NV_GPU_CONNECTOR_TYPE = 48; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DVI_D: _NV_GPU_CONNECTOR_TYPE = 49; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_ADC: _NV_GPU_CONNECTOR_TYPE = 50; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_LFH_DVI_I_1: _NV_GPU_CONNECTOR_TYPE = 56; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_LFH_DVI_I_2: _NV_GPU_CONNECTOR_TYPE = 57; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_SPWG: _NV_GPU_CONNECTOR_TYPE = 64; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_OEM: _NV_GPU_CONNECTOR_TYPE = 65; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DISPLAYPORT_EXTERNAL: _NV_GPU_CONNECTOR_TYPE = + 70; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DISPLAYPORT_INTERNAL: _NV_GPU_CONNECTOR_TYPE = + 71; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DISPLAYPORT_MINI_EXT: _NV_GPU_CONNECTOR_TYPE = + 72; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_HDMI_A: _NV_GPU_CONNECTOR_TYPE = 97; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_HDMI_C_MINI: _NV_GPU_CONNECTOR_TYPE = 99; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_LFH_DISPLAYPORT_1: _NV_GPU_CONNECTOR_TYPE = + 100; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_LFH_DISPLAYPORT_2: _NV_GPU_CONNECTOR_TYPE = + 101; +#[doc = "!< Deprecated."] +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_VIRTUAL_WFD: _NV_GPU_CONNECTOR_TYPE = 112; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_USB_C: _NV_GPU_CONNECTOR_TYPE = 113; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_UNKNOWN: _NV_GPU_CONNECTOR_TYPE = -1; +#[doc = "! \\ingroup gpu\n! Used in NV_GPU_CONNECTOR_DATA"] +pub type _NV_GPU_CONNECTOR_TYPE = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpu\n! Used in NV_GPU_CONNECTOR_DATA"] +pub use self::_NV_GPU_CONNECTOR_TYPE as NV_GPU_CONNECTOR_TYPE; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_NONE: _NV_DISPLAY_TV_FORMAT = 0; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_NTSCM: _NV_DISPLAY_TV_FORMAT = 1; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_NTSCJ: _NV_DISPLAY_TV_FORMAT = 2; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_PALM: _NV_DISPLAY_TV_FORMAT = 4; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_PALBDGH: _NV_DISPLAY_TV_FORMAT = 8; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_PALN: _NV_DISPLAY_TV_FORMAT = 16; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_PALNC: _NV_DISPLAY_TV_FORMAT = 32; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_576i: _NV_DISPLAY_TV_FORMAT = 256; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_480i: _NV_DISPLAY_TV_FORMAT = 512; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_ED_480p: _NV_DISPLAY_TV_FORMAT = 1024; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_ED_576p: _NV_DISPLAY_TV_FORMAT = 2048; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_720p: _NV_DISPLAY_TV_FORMAT = 4096; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_1080i: _NV_DISPLAY_TV_FORMAT = 8192; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_1080p: _NV_DISPLAY_TV_FORMAT = 16384; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_720p50: _NV_DISPLAY_TV_FORMAT = 32768; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_1080p24: _NV_DISPLAY_TV_FORMAT = 65536; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_1080i50: _NV_DISPLAY_TV_FORMAT = 131072; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_1080p50: _NV_DISPLAY_TV_FORMAT = 262144; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp30: _NV_DISPLAY_TV_FORMAT = 524288; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp30_3840: _NV_DISPLAY_TV_FORMAT = 524288; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp25: _NV_DISPLAY_TV_FORMAT = 1048576; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp25_3840: _NV_DISPLAY_TV_FORMAT = + 1048576; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp24: _NV_DISPLAY_TV_FORMAT = 2097152; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp24_3840: _NV_DISPLAY_TV_FORMAT = + 2097152; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp24_SMPTE: _NV_DISPLAY_TV_FORMAT = + 4194304; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp50_3840: _NV_DISPLAY_TV_FORMAT = + 8388608; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp60_3840: _NV_DISPLAY_TV_FORMAT = + 9437184; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp30_4096: _NV_DISPLAY_TV_FORMAT = + 10485760; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp25_4096: _NV_DISPLAY_TV_FORMAT = + 11534336; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp24_4096: _NV_DISPLAY_TV_FORMAT = + 12582912; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp50_4096: _NV_DISPLAY_TV_FORMAT = + 13631488; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp60_4096: _NV_DISPLAY_TV_FORMAT = + 14680064; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp24_7680: _NV_DISPLAY_TV_FORMAT = + 16777216; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp25_7680: _NV_DISPLAY_TV_FORMAT = + 33554432; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp30_7680: _NV_DISPLAY_TV_FORMAT = + 67108864; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp48_7680: _NV_DISPLAY_TV_FORMAT = + 134217728; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp50_7680: _NV_DISPLAY_TV_FORMAT = + 150994944; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp60_7680: _NV_DISPLAY_TV_FORMAT = + 167772160; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp100_7680: _NV_DISPLAY_TV_FORMAT = + 184549376; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp120_7680: _NV_DISPLAY_TV_FORMAT = + 201326592; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp48_3840: _NV_DISPLAY_TV_FORMAT = + 218103808; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp48_4096: _NV_DISPLAY_TV_FORMAT = + 234881024; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp100_4096: _NV_DISPLAY_TV_FORMAT = + 251658240; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp100_3840: _NV_DISPLAY_TV_FORMAT = + 268435456; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp120_4096: _NV_DISPLAY_TV_FORMAT = + 285212672; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp120_3840: _NV_DISPLAY_TV_FORMAT = + 301989888; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp100_5120: _NV_DISPLAY_TV_FORMAT = + 318767104; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp120_5120: _NV_DISPLAY_TV_FORMAT = + 335544320; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp24_5120: _NV_DISPLAY_TV_FORMAT = + 352321536; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp25_5120: _NV_DISPLAY_TV_FORMAT = + 369098752; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp30_5120: _NV_DISPLAY_TV_FORMAT = + 385875968; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp48_5120: _NV_DISPLAY_TV_FORMAT = + 402653184; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp50_5120: _NV_DISPLAY_TV_FORMAT = + 419430400; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp60_5120: _NV_DISPLAY_TV_FORMAT = + 536870912; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp24_10240: _NV_DISPLAY_TV_FORMAT = + 553648128; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp25_10240: _NV_DISPLAY_TV_FORMAT = + 570425344; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp30_10240: _NV_DISPLAY_TV_FORMAT = + 587202560; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp48_10240: _NV_DISPLAY_TV_FORMAT = + 603979776; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp50_10240: _NV_DISPLAY_TV_FORMAT = + 620756992; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp60_10240: _NV_DISPLAY_TV_FORMAT = + 637534208; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp100_10240: _NV_DISPLAY_TV_FORMAT = + 654311424; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp120_10240: _NV_DISPLAY_TV_FORMAT = + 671088640; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_OTHER: _NV_DISPLAY_TV_FORMAT = 805306368; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_ED_OTHER: _NV_DISPLAY_TV_FORMAT = 1073741824; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_OTHER: _NV_DISPLAY_TV_FORMAT = 1342177280; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_ANY: _NV_DISPLAY_TV_FORMAT = -2147483648; +#[doc = "! \\ingroup tvapi\n! Used in NV_DISPLAY_TV_OUTPUT_INFO"] +pub type _NV_DISPLAY_TV_FORMAT = ::std::os::raw::c_int; +#[doc = "! \\ingroup tvapi\n! Used in NV_DISPLAY_TV_OUTPUT_INFO"] +pub use self::_NV_DISPLAY_TV_FORMAT as NV_DISPLAY_TV_FORMAT; +pub const _NV_TARGET_VIEW_MODE_NV_VIEW_MODE_STANDARD: _NV_TARGET_VIEW_MODE = 0; +pub const _NV_TARGET_VIEW_MODE_NV_VIEW_MODE_CLONE: _NV_TARGET_VIEW_MODE = 1; +pub const _NV_TARGET_VIEW_MODE_NV_VIEW_MODE_HSPAN: _NV_TARGET_VIEW_MODE = 2; +pub const _NV_TARGET_VIEW_MODE_NV_VIEW_MODE_VSPAN: _NV_TARGET_VIEW_MODE = 3; +pub const _NV_TARGET_VIEW_MODE_NV_VIEW_MODE_DUALVIEW: _NV_TARGET_VIEW_MODE = 4; +pub const _NV_TARGET_VIEW_MODE_NV_VIEW_MODE_MULTIVIEW: _NV_TARGET_VIEW_MODE = 5; +#[doc = "! Used in NvAPI_SetView()."] +pub type _NV_TARGET_VIEW_MODE = ::std::os::raw::c_int; +#[doc = "! Used in NvAPI_SetView()."] +pub use self::_NV_TARGET_VIEW_MODE as NV_TARGET_VIEW_MODE; +#[doc = "!< No change"] +pub const _NV_SCALING_NV_SCALING_DEFAULT: _NV_SCALING = 0; +#[doc = "!< Balanced - Full Screen"] +pub const _NV_SCALING_NV_SCALING_GPU_SCALING_TO_CLOSEST: _NV_SCALING = 1; +#[doc = "!< Force GPU - Full Screen"] +pub const _NV_SCALING_NV_SCALING_GPU_SCALING_TO_NATIVE: _NV_SCALING = 2; +#[doc = "!< Force GPU - Centered\\No Scaling"] +pub const _NV_SCALING_NV_SCALING_GPU_SCANOUT_TO_NATIVE: _NV_SCALING = 3; +#[doc = "!< Force GPU - Aspect Ratio"] +pub const _NV_SCALING_NV_SCALING_GPU_SCALING_TO_ASPECT_SCANOUT_TO_NATIVE: _NV_SCALING = 5; +#[doc = "!< Balanced - Aspect Ratio"] +pub const _NV_SCALING_NV_SCALING_GPU_SCALING_TO_ASPECT_SCANOUT_TO_CLOSEST: _NV_SCALING = 6; +#[doc = "!< Balanced - Centered\\No Scaling"] +pub const _NV_SCALING_NV_SCALING_GPU_SCANOUT_TO_CLOSEST: _NV_SCALING = 7; +#[doc = "!< Force GPU - Integer Scaling"] +pub const _NV_SCALING_NV_SCALING_GPU_INTEGER_ASPECT_SCALING: _NV_SCALING = 8; +pub const _NV_SCALING_NV_SCALING_MONITOR_SCALING: _NV_SCALING = 1; +pub const _NV_SCALING_NV_SCALING_ADAPTER_SCALING: _NV_SCALING = 2; +pub const _NV_SCALING_NV_SCALING_CENTERED: _NV_SCALING = 3; +pub const _NV_SCALING_NV_SCALING_ASPECT_SCALING: _NV_SCALING = 5; +#[doc = "!< For future use"] +pub const _NV_SCALING_NV_SCALING_CUSTOMIZED: _NV_SCALING = 255; +#[doc = "! Scaling modes - used in NvAPI_SetViewEx().\n! \\ingroup dispcontrol"] +pub type _NV_SCALING = ::std::os::raw::c_int; +#[doc = "! Scaling modes - used in NvAPI_SetViewEx().\n! \\ingroup dispcontrol"] +pub use self::_NV_SCALING as NV_SCALING; +pub const _NV_ROTATE_NV_ROTATE_0: _NV_ROTATE = 0; +pub const _NV_ROTATE_NV_ROTATE_90: _NV_ROTATE = 1; +pub const _NV_ROTATE_NV_ROTATE_180: _NV_ROTATE = 2; +pub const _NV_ROTATE_NV_ROTATE_270: _NV_ROTATE = 3; +pub const _NV_ROTATE_NV_ROTATE_IGNORED: _NV_ROTATE = 4; +#[doc = "! \\ingroup dispcontrol"] +pub type _NV_ROTATE = ::std::os::raw::c_int; +#[doc = "! \\ingroup dispcontrol"] +pub use self::_NV_ROTATE as NV_ROTATE; +#[doc = "!< unknown. Driver will choose one as following value."] +pub const _NV_FORMAT_NV_FORMAT_UNKNOWN: _NV_FORMAT = 0; +#[doc = "!< for 8bpp mode"] +pub const _NV_FORMAT_NV_FORMAT_P8: _NV_FORMAT = 41; +#[doc = "!< for 16bpp mode"] +pub const _NV_FORMAT_NV_FORMAT_R5G6B5: _NV_FORMAT = 23; +#[doc = "!< for 32bpp mode"] +pub const _NV_FORMAT_NV_FORMAT_A8R8G8B8: _NV_FORMAT = 21; +#[doc = "!< for 64bpp(floating point) mode."] +pub const _NV_FORMAT_NV_FORMAT_A16B16G16R16F: _NV_FORMAT = 113; +#[doc = "! Color formats- used in NvAPI_SetViewEx().\n! \\ingroup dispcontrol"] +pub type _NV_FORMAT = ::std::os::raw::c_int; +#[doc = "! Color formats- used in NvAPI_SetViewEx().\n! \\ingroup dispcontrol"] +pub use self::_NV_FORMAT as NV_FORMAT; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_VIEWPORTF { + #[doc = "!< x-coordinate of the viewport top-left point"] + pub x: f32, + #[doc = "!< y-coordinate of the viewport top-left point"] + pub y: f32, + #[doc = "!< Width of the viewport"] + pub w: f32, + #[doc = "!< Height of the viewport"] + pub h: f32, +} +#[doc = "!< get the current timing"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_CURRENT: _NV_TIMING_OVERRIDE = 0; +#[doc = "!< the timing the driver will use based the current policy"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_AUTO: _NV_TIMING_OVERRIDE = 1; +#[doc = "!< EDID timing"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_EDID: _NV_TIMING_OVERRIDE = 2; +#[doc = "!< VESA DMT timing"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_DMT: _NV_TIMING_OVERRIDE = 3; +#[doc = "!< VESA DMT timing with reduced blanking"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_DMT_RB: _NV_TIMING_OVERRIDE = 4; +#[doc = "!< VESA CVT timing"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_CVT: _NV_TIMING_OVERRIDE = 5; +#[doc = "!< VESA CVT timing with reduced blanking"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_CVT_RB: _NV_TIMING_OVERRIDE = 6; +#[doc = "!< VESA GTF timing"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_GTF: _NV_TIMING_OVERRIDE = 7; +#[doc = "!< EIA 861x pre-defined timing"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_EIA861: _NV_TIMING_OVERRIDE = 8; +#[doc = "!< analog SD/HDTV timing"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_ANALOG_TV: _NV_TIMING_OVERRIDE = 9; +#[doc = "!< NV custom timings"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_CUST: _NV_TIMING_OVERRIDE = 10; +#[doc = "!< NV pre-defined timing (basically the PsF timings)"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_NV_PREDEFINED: _NV_TIMING_OVERRIDE = 11; +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_NV_PSF: _NV_TIMING_OVERRIDE = 11; +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_NV_ASPR: _NV_TIMING_OVERRIDE = 12; +#[doc = "!< Override for SDI timing"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_SDI: _NV_TIMING_OVERRIDE = 13; +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVRRIDE_MAX: _NV_TIMING_OVERRIDE = 14; +#[doc = "! \\ingroup dispcontrol\n! The timing override is not supported yet; must be set to _AUTO. \\n"] +pub type _NV_TIMING_OVERRIDE = ::std::os::raw::c_int; +#[doc = "! \\ingroup dispcontrol\n! The timing override is not supported yet; must be set to _AUTO. \\n"] +pub use self::_NV_TIMING_OVERRIDE as NV_TIMING_OVERRIDE; +#[doc = "! \\ingroup dispcontrol\n! NVIDIA-specific timing extras \\n\n! Used in NV_TIMING."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct tagNV_TIMINGEXT { + #[doc = "!< Reserved for NVIDIA hardware-based enhancement, such as double-scan."] + pub flag: NvU32, + #[doc = "!< Logical refresh rate to present"] + pub rr: NvU16, + #[doc = "!< Physical vertical refresh rate in 0.001Hz"] + pub rrx1k: NvU32, + #[doc = "!< Display aspect ratio Hi(aspect):horizontal-aspect, Low(aspect):vertical-aspect"] + pub aspect: NvU32, + #[doc = "!< Bit-wise pixel repetition factor: 0x1:no pixel repetition; 0x2:each pixel repeats twice horizontally,.."] + pub rep: NvU16, + #[doc = "!< Timing standard"] + pub status: NvU32, + #[doc = "!< Timing name"] + pub name: [NvU8; 40usize], +} +#[doc = "! \\ingroup dispcontrol\n! NVIDIA-specific timing extras \\n\n! Used in NV_TIMING."] +pub type NV_TIMINGEXT = tagNV_TIMINGEXT; +#[doc = "! \\ingroup dispcontrol\n!The very basic timing structure based on the VESA standard:\n! \\code\n! |<----------------------------htotal--------------------------->|\n! ---------\"active\" video-------->|<-------blanking------>|<-----\n! |<-------hvisible-------->|<-hb->|<-hfp->|<-hsw->|<-hbp->|<-hb->|\n! --------- -+-------------------------+ | | | | |\n! A A | | | | | | |\n! : : | | | | | | |\n! : : | | | | | | |\n! :vertical| addressable video | | | | | |\n! : visible| | | | | | |\n! : : | | | | | | |\n! : : | | | | | | |\n! vertical V | | | | | | |\n! total --+-------------------------+ | | | | |\n! : vb border | | | | |\n! : -----------------------------------+ | | | |\n! : vfp front porch | | | |\n! : -------------------------------------------+ | | |\n! : vsw sync width | | |\n! : ---------------------------------------------------+ | |\n! : vbp back porch | |\n! : -----------------------------------------------------------+ |\n! V vb border |\n! ---------------------------------------------------------------------------+\n! \\endcode"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_TIMING { + #[doc = "!< horizontal visible"] + pub HVisible: NvU16, + #[doc = "!< horizontal border"] + pub HBorder: NvU16, + #[doc = "!< horizontal front porch"] + pub HFrontPorch: NvU16, + #[doc = "!< horizontal sync width"] + pub HSyncWidth: NvU16, + #[doc = "!< horizontal total"] + pub HTotal: NvU16, + #[doc = "!< horizontal sync polarity: 1-negative, 0-positive"] + pub HSyncPol: NvU8, + #[doc = "!< vertical visible"] + pub VVisible: NvU16, + #[doc = "!< vertical border"] + pub VBorder: NvU16, + #[doc = "!< vertical front porch"] + pub VFrontPorch: NvU16, + #[doc = "!< vertical sync width"] + pub VSyncWidth: NvU16, + #[doc = "!< vertical total"] + pub VTotal: NvU16, + #[doc = "!< vertical sync polarity: 1-negative, 0-positive"] + pub VSyncPol: NvU8, + #[doc = "!< 1-interlaced, 0-progressive"] + pub interlaced: NvU16, + #[doc = "!< pixel clock in 10 kHz"] + pub pclk: NvU32, + pub etc: NV_TIMINGEXT, +} +#[doc = "! \\ingroup dispcontrol\n!The very basic timing structure based on the VESA standard:\n! \\code\n! |<----------------------------htotal--------------------------->|\n! ---------\"active\" video-------->|<-------blanking------>|<-----\n! |<-------hvisible-------->|<-hb->|<-hfp->|<-hsw->|<-hbp->|<-hb->|\n! --------- -+-------------------------+ | | | | |\n! A A | | | | | | |\n! : : | | | | | | |\n! : : | | | | | | |\n! :vertical| addressable video | | | | | |\n! : visible| | | | | | |\n! : : | | | | | | |\n! : : | | | | | | |\n! vertical V | | | | | | |\n! total --+-------------------------+ | | | | |\n! : vb border | | | | |\n! : -----------------------------------+ | | | |\n! : vfp front porch | | | |\n! : -------------------------------------------+ | | |\n! : vsw sync width | | |\n! : ---------------------------------------------------+ | |\n! : vbp back porch | |\n! : -----------------------------------------------------------+ |\n! V vb border |\n! ---------------------------------------------------------------------------+\n! \\endcode"] +pub type NV_TIMING = _NV_TIMING; +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_SetView() and NvAPI_GetView()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_VIEW_TARGET_INFO { + #[doc = "!< (IN) structure version"] + pub version: NvU32, + #[doc = "!< (IN) target count"] + pub count: NvU32, + pub target: [NV_VIEW_TARGET_INFO__bindgen_ty_1; 2usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_VIEW_TARGET_INFO__bindgen_ty_1 { + #[doc = "!< (IN/OUT) Device mask"] + pub deviceMask: NvU32, + #[doc = "!< (IN/OUT) Source ID - values will be based on the number of heads exposed per GPU."] + pub sourceId: NvU32, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +impl NV_VIEW_TARGET_INFO__bindgen_ty_1 { + #[inline] + pub fn bPrimary(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bPrimary(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bPrimary_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bPrimary_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bInterlaced(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bInterlaced(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bInterlaced_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bInterlaced_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bGDIPrimary(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_bGDIPrimary(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bGDIPrimary_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bGDIPrimary_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bForceModeSet(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_bForceModeSet(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bForceModeSet_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bForceModeSet_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bPrimary: NvU32, + bInterlaced: NvU32, + bGDIPrimary: NvU32, + bForceModeSet: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bPrimary: u32 = unsafe { ::std::mem::transmute(bPrimary) }; + bPrimary as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bInterlaced: u32 = unsafe { ::std::mem::transmute(bInterlaced) }; + bInterlaced as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let bGDIPrimary: u32 = unsafe { ::std::mem::transmute(bGDIPrimary) }; + bGDIPrimary as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let bForceModeSet: u32 = unsafe { ::std::mem::transmute(bForceModeSet) }; + bForceModeSet as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PATH_INFO."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_DISPLAY_PATH { + #[doc = "!< (IN) Device mask"] + pub deviceMask: NvU32, + #[doc = "!< (IN) Values will be based on the number of heads exposed per GPU(0, 1?)"] + pub sourceId: NvU32, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + #[doc = "!< (IN) Specify connector type. For TV only."] + pub connector: NV_GPU_CONNECTOR_TYPE, + #[doc = "!< (IN) Width of the mode"] + pub width: NvU32, + #[doc = "!< (IN) Height of the mode"] + pub height: NvU32, + #[doc = "!< (IN) Depth of the mode"] + pub depth: NvU32, + #[doc = "!< Color format if it needs to be specified. Not used now."] + pub colorFormat: NV_FORMAT, + #[doc = "!< (IN) Rotation setting."] + pub rotation: NV_ROTATE, + #[doc = "!< (IN) Scaling setting"] + pub scaling: NV_SCALING, + #[doc = "!< (IN) Refresh rate of the mode"] + pub refreshRate: NvU32, + pub _bitfield_align_2: [u8; 0], + pub _bitfield_2: __BindgenBitfieldUnit<[u8; 1usize]>, + #[doc = "!< (IN) To choose the last TV format set this value to NV_DISPLAY_TV_FORMAT_NONE"] + pub tvFormat: NV_DISPLAY_TV_FORMAT, + #[doc = "!< (IN/OUT) X-offset of this display on the Windows desktop"] + pub posx: NvU32, + #[doc = "!< (IN/OUT) Y-offset of this display on the Windows desktop"] + pub posy: NvU32, + pub _bitfield_align_3: [u32; 0], + pub _bitfield_3: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl NV_DISPLAY_PATH { + #[inline] + pub fn bPrimary(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bPrimary(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bPrimary_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bPrimary_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1(bPrimary: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bPrimary: u32 = unsafe { ::std::mem::transmute(bPrimary) }; + bPrimary as u64 + }); + __bindgen_bitfield_unit + } + #[inline] + pub fn interlaced(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_interlaced(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_2.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn interlaced_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_2), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_interlaced_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_2(interlaced: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let interlaced: u32 = unsafe { ::std::mem::transmute(interlaced) }; + interlaced as u64 + }); + __bindgen_bitfield_unit + } + #[inline] + pub fn bGDIPrimary(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_3.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bGDIPrimary(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_3.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bGDIPrimary_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_3), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bGDIPrimary_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_3), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bForceModeSet(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_3.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bForceModeSet(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_3.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bForceModeSet_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_3), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bForceModeSet_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_3), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bFocusDisplay(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_3.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_bFocusDisplay(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_3.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bFocusDisplay_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_3), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bFocusDisplay_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_3), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn gpuId(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_3.get(3usize, 24u8) as u32) } + } + #[inline] + pub fn set_gpuId(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_3.set(3usize, 24u8, val as u64) + } + } + #[inline] + pub unsafe fn gpuId_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_3), + 3usize, + 24u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_gpuId_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_3), + 3usize, + 24u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_3( + bGDIPrimary: NvU32, + bForceModeSet: NvU32, + bFocusDisplay: NvU32, + gpuId: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bGDIPrimary: u32 = unsafe { ::std::mem::transmute(bGDIPrimary) }; + bGDIPrimary as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bForceModeSet: u32 = unsafe { ::std::mem::transmute(bForceModeSet) }; + bForceModeSet as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let bFocusDisplay: u32 = unsafe { ::std::mem::transmute(bFocusDisplay) }; + bFocusDisplay as u64 + }); + __bindgen_bitfield_unit.set(3usize, 24u8, { + let gpuId: u32 = unsafe { ::std::mem::transmute(gpuId) }; + gpuId as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_SetViewEx() and NvAPI_GetViewEx()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_DISPLAY_PATH_INFO_V3 { + #[doc = "!< (IN) Structure version"] + pub version: NvU32, + #[doc = "!< (IN) Path count"] + pub count: NvU32, + pub path: [NV_DISPLAY_PATH; 2usize], +} +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_SetViewEx() and NvAPI_GetViewEx()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_DISPLAY_PATH_INFO { + #[doc = "!< (IN) Structure version"] + pub version: NvU32, + #[doc = "!< (IN) Path count"] + pub count: NvU32, + pub path: [NV_DISPLAY_PATH; 4usize], +} +#[doc = "\n! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_POSITION { + pub x: NvS32, + pub y: NvS32, +} +#[doc = "\n! \\ingroup dispcontrol"] +pub type NV_POSITION = _NV_POSITION; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_RESOLUTION { + pub width: NvU32, + pub height: NvU32, + pub colorDepth: NvU32, +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_RESOLUTION = _NV_RESOLUTION; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO_V1 { + pub version: NvU32, + #[doc = "!< (IN) rotation setting."] + pub rotation: NV_ROTATE, + #[doc = "!< (IN) scaling setting."] + pub scaling: NV_SCALING, + #[doc = "!< (IN) Non-interlaced Refresh Rate of the mode, multiplied by 1000, 0 = ignored\n!< This is the value which driver reports to the OS."] + pub refreshRate1K: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Specify connector type. For TV only, ignored if tvFormat == NV_DISPLAY_TV_FORMAT_NONE"] + pub connector: NV_GPU_CONNECTOR_TYPE, + #[doc = "!< (IN) to choose the last TV format set this value to NV_DISPLAY_TV_FORMAT_NONE\n!< In case of NvAPI_DISP_GetDisplayConfig(), this field will indicate the currently applied TV format;\n!< if no TV format is applied, this field will have NV_DISPLAY_TV_FORMAT_NONE value.\n!< In case of NvAPI_DISP_SetDisplayConfig(), this field should only be set in case of TVs;\n!< for other displays this field will be ignored and resolution & refresh rate specified in input will be used to apply the TV format."] + pub tvFormat: NV_DISPLAY_TV_FORMAT, + #[doc = "!< Ignored if timingOverride == NV_TIMING_OVERRIDE_CURRENT"] + pub timingOverride: NV_TIMING_OVERRIDE, + #[doc = "!< Scan out timing, valid only if timingOverride == NV_TIMING_OVERRIDE_CUST\n!< The value NV_TIMING::NV_TIMINGEXT::rrx1k is obtained from the EDID. The driver may\n!< tweak this value for HDTV, stereo, etc., before reporting it to the OS."] + pub timing: NV_TIMING, +} +impl _NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO_V1 { + #[inline] + pub fn interlaced(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_interlaced(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn interlaced_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_interlaced_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn primary(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_primary(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn primary_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_primary_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reservedBit1(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_reservedBit1(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn reservedBit1_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reservedBit1_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn disableVirtualModeSupport(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_disableVirtualModeSupport(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn disableVirtualModeSupport_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_disableVirtualModeSupport_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isPreferredUnscaledTarget(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_isPreferredUnscaledTarget(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isPreferredUnscaledTarget_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isPreferredUnscaledTarget_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 27u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 27u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 27u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + interlaced: NvU32, + primary: NvU32, + reservedBit1: NvU32, + disableVirtualModeSupport: NvU32, + isPreferredUnscaledTarget: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let interlaced: u32 = unsafe { ::std::mem::transmute(interlaced) }; + interlaced as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let primary: u32 = unsafe { ::std::mem::transmute(primary) }; + primary as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let reservedBit1: u32 = unsafe { ::std::mem::transmute(reservedBit1) }; + reservedBit1 as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let disableVirtualModeSupport: u32 = + unsafe { ::std::mem::transmute(disableVirtualModeSupport) }; + disableVirtualModeSupport as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let isPreferredUnscaledTarget: u32 = + unsafe { ::std::mem::transmute(isPreferredUnscaledTarget) }; + isPreferredUnscaledTarget as u64 + }); + __bindgen_bitfield_unit.set(5usize, 27u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO_V1 = + _NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO_V1; +#[doc = "! \\ingroup dispcontrol"] +pub type NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO = NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO_V1; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_DISPLAYCONFIG_PATH_TARGET_INFO_V1 { + #[doc = "!< Display ID"] + pub displayId: NvU32, + #[doc = "!< May be NULL if no advanced settings are required. NULL for Non-NVIDIA Display."] + pub details: *mut NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO, +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_DISPLAYCONFIG_PATH_TARGET_INFO_V1 = _NV_DISPLAYCONFIG_PATH_TARGET_INFO_V1; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_DISPLAYCONFIG_PATH_TARGET_INFO_V2 { + #[doc = "!< Display ID"] + pub displayId: NvU32, + #[doc = "!< May be NULL if no advanced settings are required"] + pub details: *mut NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO, + #[doc = "!< Windows CCD target ID. Must be present only for non-NVIDIA adapter, for NVIDIA adapter this parameter is ignored."] + pub targetId: NvU32, +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_DISPLAYCONFIG_PATH_TARGET_INFO_V2 = _NV_DISPLAYCONFIG_PATH_TARGET_INFO_V2; +#[doc = "! \\ingroup dispcontrol\n! As version is not defined for this structure, we will be using version of NV_DISPLAYCONFIG_PATH_INFO"] +pub type NV_DISPLAYCONFIG_PATH_TARGET_INFO = NV_DISPLAYCONFIG_PATH_TARGET_INFO_V2; +pub const _NV_DISPLAYCONFIG_SPANNING_ORIENTATION_NV_DISPLAYCONFIG_SPAN_NONE: + _NV_DISPLAYCONFIG_SPANNING_ORIENTATION = 0; +pub const _NV_DISPLAYCONFIG_SPANNING_ORIENTATION_NV_DISPLAYCONFIG_SPAN_HORIZONTAL: + _NV_DISPLAYCONFIG_SPANNING_ORIENTATION = 1; +pub const _NV_DISPLAYCONFIG_SPANNING_ORIENTATION_NV_DISPLAYCONFIG_SPAN_VERTICAL: + _NV_DISPLAYCONFIG_SPANNING_ORIENTATION = 2; +#[doc = "! \\ingroup dispcontrol"] +pub type _NV_DISPLAYCONFIG_SPANNING_ORIENTATION = ::std::os::raw::c_int; +#[doc = "! \\ingroup dispcontrol"] +pub use self::_NV_DISPLAYCONFIG_SPANNING_ORIENTATION as NV_DISPLAYCONFIG_SPANNING_ORIENTATION; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1 { + pub resolution: NV_RESOLUTION, + #[doc = "!< Ignored at present, must be NV_FORMAT_UNKNOWN (0)"] + pub colorFormat: NV_FORMAT, + #[doc = "!< Is all positions are 0 or invalid, displays will be automatically\n!< positioned from left to right with GDI Primary at 0,0, and all\n!< other displays in the order of the path array."] + pub position: NV_POSITION, + #[doc = "!< Spanning is only supported on XP"] + pub spanningOrientation: NV_DISPLAYCONFIG_SPANNING_ORIENTATION, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl _NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1 { + #[inline] + pub fn bGDIPrimary(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bGDIPrimary(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bGDIPrimary_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bGDIPrimary_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bSLIFocus(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bSLIFocus(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bSLIFocus_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bSLIFocus_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 30u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 30u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 30u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bGDIPrimary: NvU32, + bSLIFocus: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bGDIPrimary: u32 = unsafe { ::std::mem::transmute(bGDIPrimary) }; + bGDIPrimary as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bSLIFocus: u32 = unsafe { ::std::mem::transmute(bSLIFocus) }; + bSLIFocus as u64 + }); + __bindgen_bitfield_unit.set(2usize, 30u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1 = _NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_DISPLAYCONFIG_PATH_INFO_V1 { + pub version: NvU32, + #[doc = "!< This field is reserved. There is ongoing debate if we need this field.\n!< Identifies sourceIds used by Windows. If all sourceIds are 0,\n!< these will be computed automatically."] + pub reserved_sourceId: NvU32, + #[doc = "!< Number of elements in targetInfo array"] + pub targetInfoCount: NvU32, + pub targetInfo: *mut NV_DISPLAYCONFIG_PATH_TARGET_INFO_V1, + #[doc = "!< May be NULL if mode info is not important"] + pub sourceModeInfo: *mut NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1, +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_DISPLAYCONFIG_PATH_INFO_V1 = _NV_DISPLAYCONFIG_PATH_INFO_V1; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_DISPLAYCONFIG_PATH_INFO { + pub version: NvU32, + pub __bindgen_anon_1: _NV_DISPLAYCONFIG_PATH_INFO__bindgen_ty_1, + #[doc = "!< Number of elements in targetInfo array"] + pub targetInfoCount: NvU32, + pub targetInfo: *mut NV_DISPLAYCONFIG_PATH_TARGET_INFO_V2, + #[doc = "!< May be NULL if mode info is not important"] + pub sourceModeInfo: *mut NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Used by Non-NVIDIA adapter for pointer to OS Adapter of LUID\n!< type, type casted to void *."] + pub pOSAdapterID: *mut ::std::os::raw::c_void, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union _NV_DISPLAYCONFIG_PATH_INFO__bindgen_ty_1 { + #[doc = "!< Identifies sourceId used by Windows CCD. This can be optionally set."] + pub sourceId: NvU32, + #[doc = "!< Only for compatibility"] + pub reserved_sourceId: NvU32, +} +impl _NV_DISPLAYCONFIG_PATH_INFO { + #[inline] + pub fn IsNonNVIDIAAdapter(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_IsNonNVIDIAAdapter(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn IsNonNVIDIAAdapter_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_IsNonNVIDIAAdapter_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + IsNonNVIDIAAdapter: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let IsNonNVIDIAAdapter: u32 = unsafe { ::std::mem::transmute(IsNonNVIDIAAdapter) }; + IsNonNVIDIAAdapter as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_DISPLAYCONFIG_PATH_INFO_V2 = _NV_DISPLAYCONFIG_PATH_INFO; +#[doc = "! \\ingroup dispcontrol"] +pub type NV_DISPLAYCONFIG_PATH_INFO = NV_DISPLAYCONFIG_PATH_INFO_V2; +#[doc = "! \\ingroup dispcontrol"] +pub type NV_DISPLAYCONFIG_SOURCE_MODE_INFO = NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1; +pub const _NV_DISPLAYCONFIG_FLAGS_NV_DISPLAYCONFIG_VALIDATE_ONLY: _NV_DISPLAYCONFIG_FLAGS = 1; +pub const _NV_DISPLAYCONFIG_FLAGS_NV_DISPLAYCONFIG_SAVE_TO_PERSISTENCE: _NV_DISPLAYCONFIG_FLAGS = 2; +#[doc = "!< Driver reload is permitted if necessary"] +pub const _NV_DISPLAYCONFIG_FLAGS_NV_DISPLAYCONFIG_DRIVER_RELOAD_ALLOWED: _NV_DISPLAYCONFIG_FLAGS = + 4; +#[doc = "!< Refresh OS mode list."] +pub const _NV_DISPLAYCONFIG_FLAGS_NV_DISPLAYCONFIG_FORCE_MODE_ENUMERATION: _NV_DISPLAYCONFIG_FLAGS = + 8; +#[doc = "!< Tell OS to avoid optimizing CommitVidPn call during a modeset"] +pub const _NV_DISPLAYCONFIG_FLAGS_NV_FORCE_COMMIT_VIDPN: _NV_DISPLAYCONFIG_FLAGS = 16; +#[doc = "! \\ingroup dispcontrol"] +pub type _NV_DISPLAYCONFIG_FLAGS = ::std::os::raw::c_int; +#[doc = "! \\ingroup dispcontrol"] +pub use self::_NV_DISPLAYCONFIG_FLAGS as NV_DISPLAYCONFIG_FLAGS; +pub type NvAPI_UnicodeString = [NvU16; 2048usize]; +pub type NvAPI_LPCWSTR = *const NvU16; +pub const _NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID_NVAPI_GPU_PERF_VOLTAGE_INFO_DOMAIN_CORE: + _NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID = 0; +pub const _NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID_NVAPI_GPU_PERF_VOLTAGE_INFO_DOMAIN_UNDEFINED: + _NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID = 16; +#[doc = "! \\ingroup gpuclock"] +pub type _NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpuclock"] +pub use self::_NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID as NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID; +pub const _NV_GPU_PUBLIC_CLOCK_ID_NVAPI_GPU_PUBLIC_CLOCK_GRAPHICS: _NV_GPU_PUBLIC_CLOCK_ID = 0; +pub const _NV_GPU_PUBLIC_CLOCK_ID_NVAPI_GPU_PUBLIC_CLOCK_MEMORY: _NV_GPU_PUBLIC_CLOCK_ID = 4; +pub const _NV_GPU_PUBLIC_CLOCK_ID_NVAPI_GPU_PUBLIC_CLOCK_PROCESSOR: _NV_GPU_PUBLIC_CLOCK_ID = 7; +pub const _NV_GPU_PUBLIC_CLOCK_ID_NVAPI_GPU_PUBLIC_CLOCK_VIDEO: _NV_GPU_PUBLIC_CLOCK_ID = 8; +pub const _NV_GPU_PUBLIC_CLOCK_ID_NVAPI_GPU_PUBLIC_CLOCK_UNDEFINED: _NV_GPU_PUBLIC_CLOCK_ID = 32; +#[doc = "! \\ingroup gpuclock"] +pub type _NV_GPU_PUBLIC_CLOCK_ID = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpuclock"] +pub use self::_NV_GPU_PUBLIC_CLOCK_ID as NV_GPU_PUBLIC_CLOCK_ID; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P0: _NV_GPU_PERF_PSTATE_ID = 0; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P1: _NV_GPU_PERF_PSTATE_ID = 1; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P2: _NV_GPU_PERF_PSTATE_ID = 2; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P3: _NV_GPU_PERF_PSTATE_ID = 3; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P4: _NV_GPU_PERF_PSTATE_ID = 4; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P5: _NV_GPU_PERF_PSTATE_ID = 5; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P6: _NV_GPU_PERF_PSTATE_ID = 6; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P7: _NV_GPU_PERF_PSTATE_ID = 7; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P8: _NV_GPU_PERF_PSTATE_ID = 8; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P9: _NV_GPU_PERF_PSTATE_ID = 9; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P10: _NV_GPU_PERF_PSTATE_ID = 10; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P11: _NV_GPU_PERF_PSTATE_ID = 11; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P12: _NV_GPU_PERF_PSTATE_ID = 12; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P13: _NV_GPU_PERF_PSTATE_ID = 13; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P14: _NV_GPU_PERF_PSTATE_ID = 14; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P15: _NV_GPU_PERF_PSTATE_ID = 15; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_UNDEFINED: _NV_GPU_PERF_PSTATE_ID = 16; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_ALL: _NV_GPU_PERF_PSTATE_ID = 17; +#[doc = "! \\addtogroup gpupstate\n! @{"] +pub type _NV_GPU_PERF_PSTATE_ID = ::std::os::raw::c_int; +#[doc = "! \\addtogroup gpupstate\n! @{"] +pub use self::_NV_GPU_PERF_PSTATE_ID as NV_GPU_PERF_PSTATE_ID; +#[doc = "! Clock domains that use single frequency value within given pstate"] +pub const NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID_NVAPI_GPU_PERF_PSTATE20_CLOCK_TYPE_SINGLE: + NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID = 0; +#[doc = "! Clock domains that allow range of frequency values within given pstate"] +pub const NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID_NVAPI_GPU_PERF_PSTATE20_CLOCK_TYPE_RANGE: + NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID = 1; +#[doc = "! Used to identify clock type"] +pub type NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID = ::std::os::raw::c_int; +#[doc = "! Used to describe both voltage and frequency deltas"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PERF_PSTATES20_PARAM_DELTA { + #[doc = "! Value of parameter delta (in respective units [kHz, uV])"] + pub value: NvS32, + pub valueRange: NV_GPU_PERF_PSTATES20_PARAM_DELTA__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PERF_PSTATES20_PARAM_DELTA__bindgen_ty_1 { + #[doc = "! Min value allowed for parameter delta (in respective units [kHz, uV])"] + pub min: NvS32, + #[doc = "! Max value allowed for parameter delta (in respective units [kHz, uV])"] + pub max: NvS32, +} +#[doc = "! Used to describe single clock entry"] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct NV_GPU_PSTATE20_CLOCK_ENTRY_V1 { + #[doc = "! ID of the clock domain"] + pub domainId: NV_GPU_PUBLIC_CLOCK_ID, + #[doc = "! Clock type ID"] + pub typeId: NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "! Current frequency delta from nominal settings in (kHz)"] + pub freqDelta_kHz: NV_GPU_PERF_PSTATES20_PARAM_DELTA, + pub data: NV_GPU_PSTATE20_CLOCK_ENTRY_V1__bindgen_ty_1, +} +#[doc = "! Clock domain type dependant information"] +#[repr(C)] +#[derive(Copy, Clone)] +pub union NV_GPU_PSTATE20_CLOCK_ENTRY_V1__bindgen_ty_1 { + pub single: NV_GPU_PSTATE20_CLOCK_ENTRY_V1__bindgen_ty_1__bindgen_ty_1, + pub range: NV_GPU_PSTATE20_CLOCK_ENTRY_V1__bindgen_ty_1__bindgen_ty_2, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PSTATE20_CLOCK_ENTRY_V1__bindgen_ty_1__bindgen_ty_1 { + #[doc = "! Clock frequency within given pstate in (kHz)"] + pub freq_kHz: NvU32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PSTATE20_CLOCK_ENTRY_V1__bindgen_ty_1__bindgen_ty_2 { + #[doc = "! Min clock frequency within given pstate in (kHz)"] + pub minFreq_kHz: NvU32, + #[doc = "! Max clock frequency within given pstate in (kHz)"] + pub maxFreq_kHz: NvU32, + #[doc = "! Voltage domain ID and value range in (uV) required for this clock"] + pub domainId: NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID, + pub minVoltage_uV: NvU32, + pub maxVoltage_uV: NvU32, +} +impl NV_GPU_PSTATE20_CLOCK_ENTRY_V1 { + #[inline] + pub fn bIsEditable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsEditable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsEditable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsEditable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsEditable: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsEditable: u32 = unsafe { ::std::mem::transmute(bIsEditable) }; + bIsEditable as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! Used to describe single base voltage entry"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY_V1 { + #[doc = "! ID of the voltage domain"] + pub domainId: NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "! Current base voltage settings in [uV]"] + pub volt_uV: NvU32, + pub voltDelta_uV: NV_GPU_PERF_PSTATES20_PARAM_DELTA, +} +impl NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY_V1 { + #[inline] + pub fn bIsEditable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsEditable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsEditable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsEditable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsEditable: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsEditable: u32 = unsafe { ::std::mem::transmute(bIsEditable) }; + bIsEditable as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! Used in NvAPI_GPU_GetPstates20() interface call."] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct NV_GPU_PERF_PSTATES20_INFO_V1 { + #[doc = "! Version info of the structure (NV_GPU_PERF_PSTATES20_INFO_VER)"] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "! Number of populated pstates"] + pub numPstates: NvU32, + #[doc = "! Number of populated clocks (per pstate)"] + pub numClocks: NvU32, + #[doc = "! Number of populated base voltages (per pstate)"] + pub numBaseVoltages: NvU32, + pub pstates: [NV_GPU_PERF_PSTATES20_INFO_V1__bindgen_ty_1; 16usize], +} +#[doc = "! Performance state (P-State) settings\n! Valid index range is 0 to numPstates-1"] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct NV_GPU_PERF_PSTATES20_INFO_V1__bindgen_ty_1 { + #[doc = "! ID of the P-State"] + pub pstateId: NV_GPU_PERF_PSTATE_ID, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "! Array of clock entries\n! Valid index range is 0 to numClocks-1"] + pub clocks: [NV_GPU_PSTATE20_CLOCK_ENTRY_V1; 8usize], + #[doc = "! Array of baseVoltage entries\n! Valid index range is 0 to numBaseVoltages-1"] + pub baseVoltages: [NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY_V1; 4usize], +} +impl NV_GPU_PERF_PSTATES20_INFO_V1__bindgen_ty_1 { + #[inline] + pub fn bIsEditable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsEditable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsEditable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsEditable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsEditable: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsEditable: u32 = unsafe { ::std::mem::transmute(bIsEditable) }; + bIsEditable as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +impl NV_GPU_PERF_PSTATES20_INFO_V1 { + #[inline] + pub fn bIsEditable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsEditable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsEditable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsEditable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsEditable: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsEditable: u32 = unsafe { ::std::mem::transmute(bIsEditable) }; + bIsEditable as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! Used in NvAPI_GPU_GetPstates20() interface call."] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_PERF_PSTATES20_INFO_V2 { + #[doc = "! Version info of the structure (NV_GPU_PERF_PSTATES20_INFO_VER)"] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "! Number of populated pstates"] + pub numPstates: NvU32, + #[doc = "! Number of populated clocks (per pstate)"] + pub numClocks: NvU32, + #[doc = "! Number of populated base voltages (per pstate)"] + pub numBaseVoltages: NvU32, + pub pstates: [_NV_GPU_PERF_PSTATES20_INFO_V2__bindgen_ty_1; 16usize], + pub ov: _NV_GPU_PERF_PSTATES20_INFO_V2__bindgen_ty_2, +} +#[doc = "! Performance state (P-State) settings\n! Valid index range is 0 to numPstates-1"] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_PERF_PSTATES20_INFO_V2__bindgen_ty_1 { + #[doc = "! ID of the P-State"] + pub pstateId: NV_GPU_PERF_PSTATE_ID, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "! Array of clock entries\n! Valid index range is 0 to numClocks-1"] + pub clocks: [NV_GPU_PSTATE20_CLOCK_ENTRY_V1; 8usize], + #[doc = "! Array of baseVoltage entries\n! Valid index range is 0 to numBaseVoltages-1"] + pub baseVoltages: [NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY_V1; 4usize], +} +impl _NV_GPU_PERF_PSTATES20_INFO_V2__bindgen_ty_1 { + #[inline] + pub fn bIsEditable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsEditable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsEditable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsEditable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsEditable: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsEditable: u32 = unsafe { ::std::mem::transmute(bIsEditable) }; + bIsEditable as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! OV settings - Please refer to NVIDIA over-volting recommendation to understand impact of this functionality\n! Valid index range is 0 to numVoltages-1"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_PERF_PSTATES20_INFO_V2__bindgen_ty_2 { + #[doc = "! Number of populated voltages"] + pub numVoltages: NvU32, + #[doc = "! Array of voltage entries\n! Valid index range is 0 to numVoltages-1"] + pub voltages: [NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY_V1; 4usize], +} +impl _NV_GPU_PERF_PSTATES20_INFO_V2 { + #[inline] + pub fn bIsEditable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsEditable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsEditable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsEditable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsEditable: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsEditable: u32 = unsafe { ::std::mem::transmute(bIsEditable) }; + bIsEditable as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! Used in NvAPI_GPU_GetPstates20() interface call."] +pub type NV_GPU_PERF_PSTATES20_INFO_V2 = _NV_GPU_PERF_PSTATES20_INFO_V2; +#[doc = "! Used in NvAPI_GPU_GetPstates20() interface call."] +pub type NV_GPU_PERF_PSTATES20_INFO = NV_GPU_PERF_PSTATES20_INFO_V2; +#[doc = "! \\ingroup driverapi\n! Used in NvAPI_GetDisplayDriverVersion()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_DISPLAY_DRIVER_VERSION { + pub version: NvU32, + pub drvVersion: NvU32, + pub bldChangeListNum: NvU32, + pub szBuildBranchString: NvAPI_ShortString, + pub szAdapterString: NvAPI_ShortString, +} +pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_UNINITIALIZED: NV_MONITOR_CONN_TYPE = 0; +pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_VGA: NV_MONITOR_CONN_TYPE = 1; +pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_COMPONENT: NV_MONITOR_CONN_TYPE = 2; +pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_SVIDEO: NV_MONITOR_CONN_TYPE = 3; +pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_HDMI: NV_MONITOR_CONN_TYPE = 4; +pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_DVI: NV_MONITOR_CONN_TYPE = 5; +pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_LVDS: NV_MONITOR_CONN_TYPE = 6; +pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_DP: NV_MONITOR_CONN_TYPE = 7; +pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_COMPOSITE: NV_MONITOR_CONN_TYPE = 8; +pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_UNKNOWN: NV_MONITOR_CONN_TYPE = -1; +#[doc = "! \\ingroup gpu"] +pub type NV_MONITOR_CONN_TYPE = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_DISPLAYIDS { + pub version: NvU32, + #[doc = "!< out: vga, tv, dvi, hdmi and dp. This is reserved for future use and clients should not rely on this information. Instead get the\n!< GPU connector type from NvAPI_GPU_GetConnectorInfo/NvAPI_GPU_GetConnectorInfoEx"] + pub connectorType: NV_MONITOR_CONN_TYPE, + #[doc = "!< this is a unique identifier for each device"] + pub displayId: NvU32, + pub _bitfield_align_1: [u16; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl _NV_GPU_DISPLAYIDS { + #[inline] + pub fn isDynamic(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isDynamic(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isDynamic_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isDynamic_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMultiStreamRootNode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMultiStreamRootNode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMultiStreamRootNode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMultiStreamRootNode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isActive(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_isActive(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isActive_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isActive_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isCluster(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_isCluster(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isCluster_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isCluster_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isOSVisible(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_isOSVisible(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isOSVisible_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isOSVisible_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isWFD(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_isWFD(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isWFD_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isWFD_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isConnected(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } + } + #[inline] + pub fn set_isConnected(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isConnected_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 6usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isConnected_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reservedInternal(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 10u8) as u32) } + } + #[inline] + pub fn set_reservedInternal(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 10u8, val as u64) + } + } + #[inline] + pub unsafe fn reservedInternal_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 7usize, + 10u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reservedInternal_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 7usize, + 10u8, + val as u64, + ) + } + } + #[inline] + pub fn isPhysicallyConnected(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) } + } + #[inline] + pub fn set_isPhysicallyConnected(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(17usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isPhysicallyConnected_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 17usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isPhysicallyConnected_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 17usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 14u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(18usize, 14u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 18usize, + 14u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 18usize, + 14u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isDynamic: NvU32, + isMultiStreamRootNode: NvU32, + isActive: NvU32, + isCluster: NvU32, + isOSVisible: NvU32, + isWFD: NvU32, + isConnected: NvU32, + reservedInternal: NvU32, + isPhysicallyConnected: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isDynamic: u32 = unsafe { ::std::mem::transmute(isDynamic) }; + isDynamic as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isMultiStreamRootNode: u32 = + unsafe { ::std::mem::transmute(isMultiStreamRootNode) }; + isMultiStreamRootNode as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let isActive: u32 = unsafe { ::std::mem::transmute(isActive) }; + isActive as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let isCluster: u32 = unsafe { ::std::mem::transmute(isCluster) }; + isCluster as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let isOSVisible: u32 = unsafe { ::std::mem::transmute(isOSVisible) }; + isOSVisible as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let isWFD: u32 = unsafe { ::std::mem::transmute(isWFD) }; + isWFD as u64 + }); + __bindgen_bitfield_unit.set(6usize, 1u8, { + let isConnected: u32 = unsafe { ::std::mem::transmute(isConnected) }; + isConnected as u64 + }); + __bindgen_bitfield_unit.set(7usize, 10u8, { + let reservedInternal: u32 = unsafe { ::std::mem::transmute(reservedInternal) }; + reservedInternal as u64 + }); + __bindgen_bitfield_unit.set(17usize, 1u8, { + let isPhysicallyConnected: u32 = + unsafe { ::std::mem::transmute(isPhysicallyConnected) }; + isPhysicallyConnected as u64 + }); + __bindgen_bitfield_unit.set(18usize, 14u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup gpu"] +pub type NV_GPU_DISPLAYIDS = _NV_GPU_DISPLAYIDS; +pub const NV_SYSTEM_TYPE_NV_SYSTEM_TYPE_UNKNOWN: NV_SYSTEM_TYPE = 0; +pub const NV_SYSTEM_TYPE_NV_SYSTEM_TYPE_LAPTOP: NV_SYSTEM_TYPE = 1; +pub const NV_SYSTEM_TYPE_NV_SYSTEM_TYPE_DESKTOP: NV_SYSTEM_TYPE = 2; +#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetSystemType()"] +pub type NV_SYSTEM_TYPE = ::std::os::raw::c_int; +pub const _NV_GPU_OUTPUT_TYPE_NVAPI_GPU_OUTPUT_UNKNOWN: _NV_GPU_OUTPUT_TYPE = 0; +#[doc = "!< CRT display device"] +pub const _NV_GPU_OUTPUT_TYPE_NVAPI_GPU_OUTPUT_CRT: _NV_GPU_OUTPUT_TYPE = 1; +#[doc = "!< Digital Flat Panel display device"] +pub const _NV_GPU_OUTPUT_TYPE_NVAPI_GPU_OUTPUT_DFP: _NV_GPU_OUTPUT_TYPE = 2; +#[doc = "!< TV display device"] +pub const _NV_GPU_OUTPUT_TYPE_NVAPI_GPU_OUTPUT_TV: _NV_GPU_OUTPUT_TYPE = 3; +#[doc = "! \\ingroup gpu\n! used in NvAPI_GPU_GetOutputType()"] +pub type _NV_GPU_OUTPUT_TYPE = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpu\n! used in NvAPI_GPU_GetOutputType()"] +pub use self::_NV_GPU_OUTPUT_TYPE as NV_GPU_OUTPUT_TYPE; +pub const _NV_GPU_TYPE_NV_SYSTEM_TYPE_GPU_UNKNOWN: _NV_GPU_TYPE = 0; +#[doc = "!< Integrated GPU"] +pub const _NV_GPU_TYPE_NV_SYSTEM_TYPE_IGPU: _NV_GPU_TYPE = 1; +#[doc = "!< Discrete GPU"] +pub const _NV_GPU_TYPE_NV_SYSTEM_TYPE_DGPU: _NV_GPU_TYPE = 2; +#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetGPUType()."] +pub type _NV_GPU_TYPE = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetGPUType()."] +pub use self::_NV_GPU_TYPE as NV_GPU_TYPE; +pub const _NV_GPU_BUS_TYPE_NVAPI_GPU_BUS_TYPE_UNDEFINED: _NV_GPU_BUS_TYPE = 0; +pub const _NV_GPU_BUS_TYPE_NVAPI_GPU_BUS_TYPE_PCI: _NV_GPU_BUS_TYPE = 1; +pub const _NV_GPU_BUS_TYPE_NVAPI_GPU_BUS_TYPE_AGP: _NV_GPU_BUS_TYPE = 2; +pub const _NV_GPU_BUS_TYPE_NVAPI_GPU_BUS_TYPE_PCI_EXPRESS: _NV_GPU_BUS_TYPE = 3; +pub const _NV_GPU_BUS_TYPE_NVAPI_GPU_BUS_TYPE_FPCI: _NV_GPU_BUS_TYPE = 4; +pub const _NV_GPU_BUS_TYPE_NVAPI_GPU_BUS_TYPE_AXI: _NV_GPU_BUS_TYPE = 5; +#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetBusType()"] +pub type _NV_GPU_BUS_TYPE = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetBusType()"] +pub use self::_NV_GPU_BUS_TYPE as NV_GPU_BUS_TYPE; +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_BOARD_INFO { + #[doc = "!< structure version"] + pub version: NvU32, + #[doc = "!< Board Serial Number"] + pub BoardNum: [NvU8; 16usize], +} +#[doc = "! \\ingroup gpu"] +pub type NV_BOARD_INFO_V1 = _NV_BOARD_INFO; +#[doc = "! \\ingroup gpu"] +pub type NV_BOARD_INFO = NV_BOARD_INFO_V1; +#[doc = "! Used in NvAPI_GPU_GetArchInfo()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_ARCH_INFO_V1 { + pub version: NvU32, + pub architecture: NvU32, + pub implementation: NvU32, + pub revision: NvU32, +} +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_T2X: _NV_GPU_ARCHITECTURE_ID = -536870880; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_T3X: _NV_GPU_ARCHITECTURE_ID = -536870864; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_T4X: _NV_GPU_ARCHITECTURE_ID = -536870848; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_T12X: _NV_GPU_ARCHITECTURE_ID = -536870848; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_NV40: _NV_GPU_ARCHITECTURE_ID = 64; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_NV50: _NV_GPU_ARCHITECTURE_ID = 80; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_G78: _NV_GPU_ARCHITECTURE_ID = 96; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_G80: _NV_GPU_ARCHITECTURE_ID = 128; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_G90: _NV_GPU_ARCHITECTURE_ID = 144; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GT200: _NV_GPU_ARCHITECTURE_ID = 160; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GF100: _NV_GPU_ARCHITECTURE_ID = 192; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GF110: _NV_GPU_ARCHITECTURE_ID = 208; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GK100: _NV_GPU_ARCHITECTURE_ID = 224; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GK110: _NV_GPU_ARCHITECTURE_ID = 240; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GK200: _NV_GPU_ARCHITECTURE_ID = 256; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GM000: _NV_GPU_ARCHITECTURE_ID = 272; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GM200: _NV_GPU_ARCHITECTURE_ID = 288; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GP100: _NV_GPU_ARCHITECTURE_ID = 304; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GV100: _NV_GPU_ARCHITECTURE_ID = 320; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GV110: _NV_GPU_ARCHITECTURE_ID = 336; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_TU100: _NV_GPU_ARCHITECTURE_ID = 352; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GA100: _NV_GPU_ARCHITECTURE_ID = 368; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_AD100: _NV_GPU_ARCHITECTURE_ID = 400; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GB200: _NV_GPU_ARCHITECTURE_ID = 432; +#[doc = "! NV_GPU_ARCH_INFO() values to identify Architecture level for the GPU."] +pub type _NV_GPU_ARCHITECTURE_ID = ::std::os::raw::c_int; +#[doc = "! NV_GPU_ARCH_INFO() values to identify Architecture level for the GPU."] +pub use self::_NV_GPU_ARCHITECTURE_ID as NV_GPU_ARCHITECTURE_ID; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_T20: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_T30: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_T35: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 5; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_T40: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_T124: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV40: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV41: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 1; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV42: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV43: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 3; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV44: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV44A: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 10; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV46: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV47: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 7; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV49: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 9; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV4B: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 11; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV4C: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 12; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV4E: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 14; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV50: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV63: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 3; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV67: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 7; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_G84: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_G86: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_G92: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_G94: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_G96: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_G98: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 8; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT200: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT212: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT214: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT215: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 3; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT216: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 5; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT218: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 8; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_MCP77: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 10; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT21C: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 11; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_MCP79: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 12; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT21A: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 13; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_MCP89: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 15; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF100: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF104: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF106: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 3; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF108: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 1; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF110: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF116: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF117: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 7; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF118: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 8; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF119: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 9; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GK104: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GK106: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GK107: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 7; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GK20A: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 10; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GK110: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GK208: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 8; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GM204: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GM206: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP100: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP000: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 1; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP102: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP104: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP106: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP107: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 7; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP108: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 8; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GV100: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GV10B: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 11; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU100: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU102: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU104: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU106: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU116: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 8; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU117: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 7; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU000: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 1; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GA100: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GA102: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GA104: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_AD102: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_AD103: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 3; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_AD104: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GB202: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; +#[doc = "! NV_GPU_ARCH_INFO() values to identify GPU Architecture Implementation."] +pub type _NV_GPU_ARCH_IMPLEMENTATION_ID = ::std::os::raw::c_int; +#[doc = "! NV_GPU_ARCH_INFO() values to identify GPU Architecture Implementation."] +pub use self::_NV_GPU_ARCH_IMPLEMENTATION_ID as NV_GPU_ARCH_IMPLEMENTATION_ID; +#[doc = "!< QT chip"] +pub const _NV_GPU_CHIP_REVISION_NV_GPU_CHIP_REV_EMULATION_QT: _NV_GPU_CHIP_REVISION = 0; +#[doc = "!< FPGA implementation of the chipset"] +pub const _NV_GPU_CHIP_REVISION_NV_GPU_CHIP_REV_EMULATION_FPGA: _NV_GPU_CHIP_REVISION = 1; +#[doc = "!< First silicon chipset revision"] +pub const _NV_GPU_CHIP_REVISION_NV_GPU_CHIP_REV_A01: _NV_GPU_CHIP_REVISION = 17; +#[doc = "!< Second Silicon chipset revision"] +pub const _NV_GPU_CHIP_REVISION_NV_GPU_CHIP_REV_A02: _NV_GPU_CHIP_REVISION = 18; +#[doc = "!< Third Silicon chipset revision"] +pub const _NV_GPU_CHIP_REVISION_NV_GPU_CHIP_REV_A03: _NV_GPU_CHIP_REVISION = 19; +#[doc = "!< Unknown chip revision"] +pub const _NV_GPU_CHIP_REVISION_NV_GPU_CHIP_REV_UNKNOWN: _NV_GPU_CHIP_REVISION = -1; +pub type _NV_GPU_CHIP_REVISION = ::std::os::raw::c_int; +pub use self::_NV_GPU_CHIP_REVISION as NV_GPU_CHIP_REVISION; +#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetArchInfo()"] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct NV_GPU_ARCH_INFO_V2 { + pub version: NvU32, + pub __bindgen_anon_1: NV_GPU_ARCH_INFO_V2__bindgen_ty_1, + pub __bindgen_anon_2: NV_GPU_ARCH_INFO_V2__bindgen_ty_2, + pub __bindgen_anon_3: NV_GPU_ARCH_INFO_V2__bindgen_ty_3, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union NV_GPU_ARCH_INFO_V2__bindgen_ty_1 { + #[doc = "!< architecture and architecture_id are the same. The former is NvU32 while the latter is an enum made for readability."] + pub architecture: NvU32, + #[doc = "!< specifies the architecture level for the GPU."] + pub architecture_id: NV_GPU_ARCHITECTURE_ID, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union NV_GPU_ARCH_INFO_V2__bindgen_ty_2 { + #[doc = "!< implementation and implementation_id are the same. The former is NvU32 while the latter is an enum made for readability."] + pub implementation: NvU32, + #[doc = "!< specifies the implementation of the architecture for the GPU."] + pub implementation_id: NV_GPU_ARCH_IMPLEMENTATION_ID, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union NV_GPU_ARCH_INFO_V2__bindgen_ty_3 { + #[doc = "!< revision and revision_id are the same. The former is NvU32 while the latter is an enum made for readability."] + pub revision: NvU32, + #[doc = "!< specifies the architecture revision of the GPU."] + pub revision_id: NV_GPU_CHIP_REVISION, +} +#[doc = "! \\ingroup gpu"] +pub type NV_GPU_ARCH_INFO = NV_GPU_ARCH_INFO_V2; +#[doc = "!< Set i2cSpeedKhz to I2C_SPEED_DEFAULT if default I2C speed is to be chosen, ie.use the current frequency setting."] +pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_DEFAULT: NV_I2C_SPEED = 0; +pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_3KHZ: NV_I2C_SPEED = 1; +pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_10KHZ: NV_I2C_SPEED = 2; +pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_33KHZ: NV_I2C_SPEED = 3; +pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_100KHZ: NV_I2C_SPEED = 4; +pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_200KHZ: NV_I2C_SPEED = 5; +pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_400KHZ: NV_I2C_SPEED = 6; +pub type NV_I2C_SPEED = ::std::os::raw::c_int; +#[doc = "! Used in NvAPI_I2CRead() and NvAPI_I2CWrite()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_I2C_INFO_V1 { + #[doc = "!< The structure version."] + pub version: NvU32, + #[doc = "!< The Display Mask of the concerned display."] + pub displayMask: NvU32, + #[doc = "!< This flag indicates either the DDC port (TRUE) or the communication port\n!< (FALSE) of the concerned display."] + pub bIsDDCPort: NvU8, + #[doc = "!< The address of the I2C slave. The address should be shifted left by one. For\n!< example, the I2C address 0x50, often used for reading EDIDs, would be stored\n!< here as 0xA0. This matches the position within the byte sent by the master, as\n!< the last bit is reserved to specify the read or write direction."] + pub i2cDevAddress: NvU8, + #[doc = "!< The I2C target register address. May be NULL, which indicates no register\n!< address should be sent."] + pub pbI2cRegAddress: *mut NvU8, + #[doc = "!< The size in bytes of target register address. If pbI2cRegAddress is NULL, this\n!< field must be 0."] + pub regAddrSize: NvU32, + #[doc = "!< The buffer of data which is to be read or written (depending on the command)."] + pub pbData: *mut NvU8, + #[doc = "!< The size of the data buffer, pbData, to be read or written."] + pub cbSize: NvU32, + #[doc = "!< The target speed of the transaction (between 28Kbps to 40Kbps; not guaranteed)."] + pub i2cSpeed: NvU32, +} +#[doc = "! Used in NvAPI_I2CRead() and NvAPI_I2CWrite()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_I2C_INFO_V2 { + #[doc = "!< The structure version."] + pub version: NvU32, + #[doc = "!< The Display Mask of the concerned display."] + pub displayMask: NvU32, + #[doc = "!< This flag indicates either the DDC port (TRUE) or the communication port\n!< (FALSE) of the concerned display."] + pub bIsDDCPort: NvU8, + #[doc = "!< The address of the I2C slave. The address should be shifted left by one. For\n!< example, the I2C address 0x50, often used for reading EDIDs, would be stored\n!< here as 0xA0. This matches the position within the byte sent by the master, as\n!< the last bit is reserved to specify the read or write direction."] + pub i2cDevAddress: NvU8, + #[doc = "!< The I2C target register address. May be NULL, which indicates no register\n!< address should be sent."] + pub pbI2cRegAddress: *mut NvU8, + #[doc = "!< The size in bytes of target register address. If pbI2cRegAddress is NULL, this\n!< field must be 0."] + pub regAddrSize: NvU32, + #[doc = "!< The buffer of data which is to be read or written (depending on the command)."] + pub pbData: *mut NvU8, + #[doc = "!< The size of the data buffer, pbData, to be read or written."] + pub cbSize: NvU32, + #[doc = "!< Deprecated, Must be set to NVAPI_I2C_SPEED_DEPRECATED."] + pub i2cSpeed: NvU32, + #[doc = "!< The target speed of the transaction in (kHz) (Chosen from the enum NV_I2C_SPEED)."] + pub i2cSpeedKhz: NV_I2C_SPEED, +} +#[doc = "! Used in NvAPI_I2CRead() and NvAPI_I2CWrite()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_I2C_INFO_V3 { + #[doc = "!< The structure version."] + pub version: NvU32, + #[doc = "!< The Display Mask of the concerned display."] + pub displayMask: NvU32, + #[doc = "!< This flag indicates either the DDC port (TRUE) or the communication port\n!< (FALSE) of the concerned display."] + pub bIsDDCPort: NvU8, + #[doc = "!< The address of the I2C slave. The address should be shifted left by one. For\n!< example, the I2C address 0x50, often used for reading EDIDs, would be stored\n!< here as 0xA0. This matches the position within the byte sent by the master, as\n!< the last bit is reserved to specify the read or write direction."] + pub i2cDevAddress: NvU8, + #[doc = "!< The I2C target register address. May be NULL, which indicates no register\n!< address should be sent."] + pub pbI2cRegAddress: *mut NvU8, + #[doc = "!< The size in bytes of target register address. If pbI2cRegAddress is NULL, this\n!< field must be 0."] + pub regAddrSize: NvU32, + #[doc = "!< The buffer of data which is to be read or written (depending on the command)."] + pub pbData: *mut NvU8, + #[doc = "!< The size of the data buffer, pbData, to be read or written."] + pub cbSize: NvU32, + #[doc = "!< Deprecated, Must be set to NVAPI_I2C_SPEED_DEPRECATED."] + pub i2cSpeed: NvU32, + #[doc = "!< The target speed of the transaction in (kHz) (Chosen from the enum NV_I2C_SPEED)."] + pub i2cSpeedKhz: NV_I2C_SPEED, + #[doc = "!< The portid on which device is connected (remember to set bIsPortIdSet if this value is set)\n!< Optional for pre-Kepler"] + pub portId: NvU8, + #[doc = "!< set this flag on if and only if portid value is set"] + pub bIsPortIdSet: NvU32, +} +#[doc = "! Used in NvAPI_I2CRead() and NvAPI_I2CWrite()"] +pub type NV_I2C_INFO = NV_I2C_INFO_V3; +pub const _NV_GPU_HDCP_FUSE_STATE_NV_GPU_HDCP_FUSE_STATE_UNKNOWN: _NV_GPU_HDCP_FUSE_STATE = 0; +pub const _NV_GPU_HDCP_FUSE_STATE_NV_GPU_HDCP_FUSE_STATE_DISABLED: _NV_GPU_HDCP_FUSE_STATE = 1; +pub const _NV_GPU_HDCP_FUSE_STATE_NV_GPU_HDCP_FUSE_STATE_ENABLED: _NV_GPU_HDCP_FUSE_STATE = 2; +#[doc = "! HDCP fuse states - used in NV_GPU_GET_HDCP_SUPPORT_STATUS"] +pub type _NV_GPU_HDCP_FUSE_STATE = ::std::os::raw::c_int; +#[doc = "! HDCP fuse states - used in NV_GPU_GET_HDCP_SUPPORT_STATUS"] +pub use self::_NV_GPU_HDCP_FUSE_STATE as NV_GPU_HDCP_FUSE_STATE; +pub const _NV_GPU_HDCP_KEY_SOURCE_NV_GPU_HDCP_KEY_SOURCE_UNKNOWN: _NV_GPU_HDCP_KEY_SOURCE = 0; +pub const _NV_GPU_HDCP_KEY_SOURCE_NV_GPU_HDCP_KEY_SOURCE_NONE: _NV_GPU_HDCP_KEY_SOURCE = 1; +pub const _NV_GPU_HDCP_KEY_SOURCE_NV_GPU_HDCP_KEY_SOURCE_CRYPTO_ROM: _NV_GPU_HDCP_KEY_SOURCE = 2; +pub const _NV_GPU_HDCP_KEY_SOURCE_NV_GPU_HDCP_KEY_SOURCE_SBIOS: _NV_GPU_HDCP_KEY_SOURCE = 3; +pub const _NV_GPU_HDCP_KEY_SOURCE_NV_GPU_HDCP_KEY_SOURCE_I2C_ROM: _NV_GPU_HDCP_KEY_SOURCE = 4; +pub const _NV_GPU_HDCP_KEY_SOURCE_NV_GPU_HDCP_KEY_SOURCE_FUSES: _NV_GPU_HDCP_KEY_SOURCE = 5; +#[doc = "! HDCP key sources - used in NV_GPU_GET_HDCP_SUPPORT_STATUS"] +pub type _NV_GPU_HDCP_KEY_SOURCE = ::std::os::raw::c_int; +#[doc = "! HDCP key sources - used in NV_GPU_GET_HDCP_SUPPORT_STATUS"] +pub use self::_NV_GPU_HDCP_KEY_SOURCE as NV_GPU_HDCP_KEY_SOURCE; +pub const _NV_GPU_HDCP_KEY_SOURCE_STATE_NV_GPU_HDCP_KEY_SOURCE_STATE_UNKNOWN: + _NV_GPU_HDCP_KEY_SOURCE_STATE = 0; +pub const _NV_GPU_HDCP_KEY_SOURCE_STATE_NV_GPU_HDCP_KEY_SOURCE_STATE_ABSENT: + _NV_GPU_HDCP_KEY_SOURCE_STATE = 1; +pub const _NV_GPU_HDCP_KEY_SOURCE_STATE_NV_GPU_HDCP_KEY_SOURCE_STATE_PRESENT: + _NV_GPU_HDCP_KEY_SOURCE_STATE = 2; +#[doc = "! HDCP key source states - used in NV_GPU_GET_HDCP_SUPPORT_STATUS"] +pub type _NV_GPU_HDCP_KEY_SOURCE_STATE = ::std::os::raw::c_int; +#[doc = "! HDCP key source states - used in NV_GPU_GET_HDCP_SUPPORT_STATUS"] +pub use self::_NV_GPU_HDCP_KEY_SOURCE_STATE as NV_GPU_HDCP_KEY_SOURCE_STATE; +#[doc = "! HDPC support status - used in NvAPI_GPU_GetHDCPSupportStatus()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_GET_HDCP_SUPPORT_STATUS { + pub version: NvU32, + #[doc = "! Structure version constucted by macro #NV_GPU_GET_HDCP_SUPPORT_STATUS"] + pub hdcpFuseState: NV_GPU_HDCP_FUSE_STATE, + #[doc = "! GPU's HDCP fuse state"] + pub hdcpKeySource: NV_GPU_HDCP_KEY_SOURCE, + #[doc = "! GPU's HDCP key source"] + pub hdcpKeySourceState: NV_GPU_HDCP_KEY_SOURCE_STATE, +} +#[doc = "! @}"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_COMPUTE_GPU_TOPOLOGY_V1 { + #[doc = "!< Structure version"] + pub version: NvU32, + #[doc = "!< Total number of compute-capable GPUs"] + pub gpuCount: NvU32, + #[doc = "!< Array of compute-capable physical GPUs."] + pub computeGpus: [NV_COMPUTE_GPU_TOPOLOGY_V1__bindgen_ty_1; 8usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_COMPUTE_GPU_TOPOLOGY_V1__bindgen_ty_1 { + #[doc = "!< Compute-capable physical GPU handle"] + pub hPhysicalGpu: NvPhysicalGpuHandle, + #[doc = "!< One or more flags from \\ref nvcomp_gpu_top"] + pub flags: NvU32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COMPUTE_GPU { + #[doc = "!< Compute-capable physical GPU handle"] + pub hPhysicalGpu: NvPhysicalGpuHandle, + #[doc = "!< One or more flags from \\ref nvcomp_gpu_top"] + pub flags: NvU32, +} +pub type NV_COMPUTE_GPU = _NV_COMPUTE_GPU; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COMPUTE_GPU_TOPOLOGY_V2 { + #[doc = "!< Structure version"] + pub version: NvU32, + #[doc = "!< Size of array"] + pub gpuCount: NvU32, + #[doc = "!< Array of compute-capable physical GPUs (allocate memory of size of Physical gpuCount of system)."] + pub computeGpus: *mut NV_COMPUTE_GPU, +} +pub type NV_COMPUTE_GPU_TOPOLOGY_V2 = _NV_COMPUTE_GPU_TOPOLOGY_V2; +pub type NV_COMPUTE_GPU_TOPOLOGY = NV_COMPUTE_GPU_TOPOLOGY_V2; +pub const _NV_ECC_CONFIGURATION_NV_ECC_CONFIGURATION_NOT_SUPPORTED: _NV_ECC_CONFIGURATION = 0; +#[doc = "!< Changes require a POST to take effect"] +pub const _NV_ECC_CONFIGURATION_NV_ECC_CONFIGURATION_DEFERRED: _NV_ECC_CONFIGURATION = 1; +#[doc = "!< Changes can optionally be made to take effect immediately"] +pub const _NV_ECC_CONFIGURATION_NV_ECC_CONFIGURATION_IMMEDIATE: _NV_ECC_CONFIGURATION = 2; +#[doc = "! \\addtogroup gpuecc\n! Used in NV_GPU_ECC_STATUS_INFO."] +pub type _NV_ECC_CONFIGURATION = ::std::os::raw::c_int; +#[doc = "! \\addtogroup gpuecc\n! Used in NV_GPU_ECC_STATUS_INFO."] +pub use self::_NV_ECC_CONFIGURATION as NV_ECC_CONFIGURATION; +#[doc = "! \\ingroup gpuecc\n! Used in NvAPI_GPU_GetECCStatusInfo()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_ECC_STATUS_INFO { + #[doc = "!< Structure version"] + pub version: NvU32, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + #[doc = "!< Supported ECC memory feature configuration options"] + pub configurationOptions: NV_ECC_CONFIGURATION, + pub _bitfield_align_2: [u8; 0], + pub _bitfield_2: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +impl NV_GPU_ECC_STATUS_INFO { + #[inline] + pub fn isSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1(isSupported: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isSupported: u32 = unsafe { ::std::mem::transmute(isSupported) }; + isSupported as u64 + }); + __bindgen_bitfield_unit + } + #[inline] + pub fn isEnabled(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isEnabled(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_2.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isEnabled_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_2), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isEnabled_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_2(isEnabled: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isEnabled: u32 = unsafe { ::std::mem::transmute(isEnabled) }; + isEnabled as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup gpuecc\n! Used in NvAPI_GPU_GetECCErrorInfo()/"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_ECC_ERROR_INFO { + #[doc = "!< Structure version"] + pub version: NvU32, + pub current: NV_GPU_ECC_ERROR_INFO__bindgen_ty_1, + pub aggregate: NV_GPU_ECC_ERROR_INFO__bindgen_ty_2, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_ECC_ERROR_INFO__bindgen_ty_1 { + #[doc = "!< Number of single-bit ECC errors detected since last boot"] + pub singleBitErrors: NvU64, + #[doc = "!< Number of double-bit ECC errors detected since last boot"] + pub doubleBitErrors: NvU64, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_ECC_ERROR_INFO__bindgen_ty_2 { + #[doc = "!< Number of single-bit ECC errors detected since last counter reset"] + pub singleBitErrors: NvU64, + #[doc = "!< Number of double-bit ECC errors detected since last counter reset"] + pub doubleBitErrors: NvU64, +} +#[doc = "! \\ingroup gpuecc\n! Used in NvAPI_GPU_GetECCConfigurationInfo()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_ECC_CONFIGURATION_INFO { + pub version: NvU32, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +impl NV_GPU_ECC_CONFIGURATION_INFO { + #[inline] + pub fn isEnabled(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isEnabled(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isEnabled_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isEnabled_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isEnabledByDefault(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isEnabledByDefault(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isEnabledByDefault_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isEnabledByDefault_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isEnabled: NvU32, + isEnabledByDefault: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isEnabled: u32 = unsafe { ::std::mem::transmute(isEnabled) }; + isEnabled as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isEnabledByDefault: u32 = unsafe { ::std::mem::transmute(isEnabledByDefault) }; + isEnabledByDefault as u64 + }); + __bindgen_bitfield_unit + } +} +pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_NONE: NV_QSYNC_EVENT = 0; +pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_SYNC_LOSS: NV_QSYNC_EVENT = 1; +pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_SYNC_GAIN: NV_QSYNC_EVENT = 2; +pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_HOUSESYNC_GAIN: NV_QSYNC_EVENT = 3; +pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_HOUSESYNC_LOSS: NV_QSYNC_EVENT = 4; +pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_RJ45_GAIN: NV_QSYNC_EVENT = 5; +pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_RJ45_LOSS: NV_QSYNC_EVENT = 6; +pub type NV_QSYNC_EVENT = ::std::os::raw::c_int; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_QSYNC_EVENT_DATA { + pub qsyncEvent: NV_QSYNC_EVENT, + pub reserved: [NvU32; 7usize], +} +#[doc = "! Callback for QSYNC event"] +pub type NVAPI_CALLBACK_QSYNCEVENT = ::std::option::Option< + unsafe extern "C" fn( + qyncEventData: NV_QSYNC_EVENT_DATA, + callbackParam: *mut ::std::os::raw::c_void, + ), +>; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_DISPLAY_OUTPUT_MODE_CHANGE_EVENT_DATA { + #[doc = "!< displayId of the display"] + pub displayId: NvU32, + #[doc = "!< display output mode"] + pub outputMode: NvU32, +} +pub type NV_DISPLAY_OUTPUT_MODE_CHANGE_EVENT_DATA = _NV_DISPLAY_OUTPUT_MODE_CHANGE_EVENT_DATA; +#[doc = "! Callback for Display Output Mode change events"] +pub type NVAPI_CALLBACK_DISPLAY_OUTPUT_MODE_CHANGE_EVENT = ::std::option::Option< + unsafe extern "C" fn( + pEventData: *mut NV_DISPLAY_OUTPUT_MODE_CHANGE_EVENT_DATA, + callbackParam: *mut ::std::os::raw::c_void, + ), +>; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_DISPLAY_COLORIMETRY_CHANGE_EVENT_DATA { + #[doc = "!< displayId of the monitor"] + pub displayId: NvU32, + #[doc = "!< min luminance, cd/m^2"] + pub min_luminance: f32, + #[doc = "!< max 100% frame luminance, cd/m^2"] + pub max_full_frame_luminance: f32, + #[doc = "!< max 10% frame luminance, cd/m^2"] + pub max_luminance: f32, + #[doc = "!< HDR brightness luminance scaling factor applied by GPU on output pixels"] + pub hdrBrightnessLuminanceScalingFactor: f32, + #[doc = "!< red primary chromaticity coordinate x"] + pub red_primary_x: f32, + #[doc = "!< red primary chromaticity coordinate y"] + pub red_primary_y: f32, + #[doc = "!< green primary chromaticity coordinate x"] + pub green_primary_x: f32, + #[doc = "!< green primary chromaticity coordinate y"] + pub green_primary_y: f32, + #[doc = "!< blue primary chromaticity coordinate x"] + pub blue_primary_x: f32, + #[doc = "!< blue primary chromaticity coordinate y"] + pub blue_primary_y: f32, + #[doc = "!< white point chromaticity coordinate x"] + pub white_point_x: f32, + #[doc = "!< white point chromaticity coordinate y"] + pub white_point_y: f32, +} +pub type NV_DISPLAY_COLORIMETRY_CHANGE_EVENT_DATA = _NV_DISPLAY_COLORIMETRY_CHANGE_EVENT_DATA; +#[doc = "! Callback for Display Colorimetry change events"] +pub type NVAPI_CALLBACK_DISPLAY_COLORIMETRY_CHANGE_EVENT = ::std::option::Option< + unsafe extern "C" fn( + pEventData: *mut NV_DISPLAY_COLORIMETRY_CHANGE_EVENT_DATA, + callbackParam: *mut ::std::os::raw::c_void, + ), +>; +pub const NV_EVENT_TYPE_NV_EVENT_TYPE_NONE: NV_EVENT_TYPE = 0; +pub const NV_EVENT_TYPE_NV_EVENT_TYPE_QSYNC: NV_EVENT_TYPE = 6; +pub const NV_EVENT_TYPE_NV_EVENT_TYPE_DISPLAY_OUTPUT_MODE_CHANGE: NV_EVENT_TYPE = 103; +pub const NV_EVENT_TYPE_NV_EVENT_TYPE_DISPLAY_COLORIMETRY_CHANGE: NV_EVENT_TYPE = 104; +#[doc = "! Enum for Event IDs"] +pub type NV_EVENT_TYPE = ::std::os::raw::c_int; +#[doc = "! Core NV_EVENT_REGISTER_CALLBACK structure declaration"] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct NV_EVENT_REGISTER_CALLBACK { + #[doc = "!< version field to ensure minimum version compatibility"] + pub version: NvU32, + #[doc = "!< ID of the event being sent"] + pub eventId: NV_EVENT_TYPE, + #[doc = "!< This value will be passed back to the callback function when an event occurs"] + pub callbackParam: *mut ::std::os::raw::c_void, + pub nvCallBackFunc: NV_EVENT_REGISTER_CALLBACK__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union NV_EVENT_REGISTER_CALLBACK__bindgen_ty_1 { + #[doc = "!< Callback function pointer for QSYNC events"] + pub nvQSYNCEventCallback: NVAPI_CALLBACK_QSYNCEVENT, + #[doc = "!< Callback function pointer for Display Output Mode change events"] + pub nvDisplayOutputModeChangeEventCallback: NVAPI_CALLBACK_DISPLAY_OUTPUT_MODE_CHANGE_EVENT, + #[doc = "!< Callback function pointer for Display Colorimetry change events"] + pub nvDisplayColorimetryChangeEventCallback: NVAPI_CALLBACK_DISPLAY_COLORIMETRY_CHANGE_EVENT, +} +#[doc = "!< NVIDIA RTX VR Ready"] +pub const _NV_GPU_WORKSTATION_FEATURE_TYPE_NV_GPU_WORKSTATION_FEATURE_TYPE_NVIDIA_RTX_VR_READY: + _NV_GPU_WORKSTATION_FEATURE_TYPE = 1; +#[doc = "!< DEPRECATED name - do not use"] +pub const _NV_GPU_WORKSTATION_FEATURE_TYPE_NV_GPU_WORKSTATION_FEATURE_TYPE_QUADRO_VR_READY: + _NV_GPU_WORKSTATION_FEATURE_TYPE = 1; +pub const _NV_GPU_WORKSTATION_FEATURE_TYPE_NV_GPU_WORKSTATION_FEATURE_TYPE_PROVIZ: + _NV_GPU_WORKSTATION_FEATURE_TYPE = 2; +#[doc = "! \\ingroup gpu"] +pub type _NV_GPU_WORKSTATION_FEATURE_TYPE = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpu"] +pub use self::_NV_GPU_WORKSTATION_FEATURE_TYPE as NV_GPU_WORKSTATION_FEATURE_TYPE; +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_SCANOUT_INTENSITY_DATA_V1 { + #[doc = "!< version of this structure"] + pub version: NvU32, + #[doc = "!< width of the input texture"] + pub width: NvU32, + #[doc = "!< height of the input texture"] + pub height: NvU32, + #[doc = "!< array of floating values building an intensity RGB texture"] + pub blendingTexture: *mut f32, +} +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_SCANOUT_INTENSITY_DATA_V2 { + #[doc = "!< version of this structure"] + pub version: NvU32, + #[doc = "!< width of the input texture"] + pub width: NvU32, + #[doc = "!< height of the input texture"] + pub height: NvU32, + #[doc = "!< array of floating values building an intensity RGB texture"] + pub blendingTexture: *mut f32, + #[doc = "!< array of floating values building an offset texture"] + pub offsetTexture: *mut f32, + #[doc = "!< number of channels per pixel in the offset texture"] + pub offsetTexChannels: NvU32, +} +#[doc = "! \\ingroup gpu"] +pub type NV_SCANOUT_INTENSITY_DATA = NV_SCANOUT_INTENSITY_DATA_V2; +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_SCANOUT_INTENSITY_STATE_DATA { + #[doc = "!< version of this structure"] + pub version: NvU32, + #[doc = "!< intensity is enabled or not"] + pub bEnabled: NvU32, +} +#[doc = "! \\ingroup gpu"] +pub type NV_SCANOUT_INTENSITY_STATE_DATA = _NV_SCANOUT_INTENSITY_STATE_DATA; +pub const NV_GPU_WARPING_VERTICE_FORMAT_NV_GPU_WARPING_VERTICE_FORMAT_TRIANGLESTRIP_XYUVRQ: + NV_GPU_WARPING_VERTICE_FORMAT = 0; +pub const NV_GPU_WARPING_VERTICE_FORMAT_NV_GPU_WARPING_VERTICE_FORMAT_TRIANGLES_XYUVRQ: + NV_GPU_WARPING_VERTICE_FORMAT = 1; +#[doc = "! \\ingroup gpu"] +pub type NV_GPU_WARPING_VERTICE_FORMAT = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_SCANOUT_WARPING_DATA { + #[doc = "!< version of this structure"] + pub version: NvU32, + #[doc = "!< width of the input texture"] + pub vertices: *mut f32, + #[doc = "!< format of the input vertices"] + pub vertexFormat: NV_GPU_WARPING_VERTICE_FORMAT, + #[doc = "!< number of the input vertices"] + pub numVertices: ::std::os::raw::c_int, + #[doc = "!< rectangle in desktop coordinates describing the source area for the warping"] + pub textureRect: *mut NvSBox, +} +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_SCANOUT_WARPING_STATE_DATA { + #[doc = "!< version of this structure"] + pub version: NvU32, + #[doc = "!< warping is enabled or not"] + pub bEnabled: NvU32, +} +#[doc = "! \\ingroup gpu"] +pub type NV_SCANOUT_WARPING_STATE_DATA = _NV_SCANOUT_WARPING_STATE_DATA; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_WARPING_RESAMPLING_METHOD : NV_GPU_SCANOUT_COMPOSITION_PARAMETER = 0 ; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_SCANOUT_INTENSITY_METHOD : NV_GPU_SCANOUT_COMPOSITION_PARAMETER = 1 ; +pub type NV_GPU_SCANOUT_COMPOSITION_PARAMETER = ::std::os::raw::c_int; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_SET_TO_DEFAULT : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 0 ; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BILINEAR : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 256 ; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_TRIANGULAR : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 257 ; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_BELL_SHAPED : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 258 ; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_BSPLINE : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 259 ; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_ADAPTIVE_TRIANGULAR : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 260 ; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_ADAPTIVE_BELL_SHAPED : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 261 ; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_ADAPTIVE_BSPLINE : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 262 ; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_SCANOUT_INTENSITY_NO_GAMMA : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 512 ; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_SCANOUT_INTENSITY_COLOR_GAMMA : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 513 ; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_SCANOUT_INTENSITY_COLOR_AND_OFFSET_GAMMA : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 514 ; +#[doc = "! This enum defines a collection of scanout composition values that can be used to configure\n! the supported scanout composition settings"] +pub type NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetScanoutConfigurationEx()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_SCANOUT_INFORMATION { + #[doc = "!< Structure version, needs to be initialized with NV_SCANOUT_INFORMATION_VER."] + pub version: NvU32, + #[doc = "!< Operating system display device rect in desktop coordinates displayId is scanning out from."] + pub sourceDesktopRect: NvSBox, + #[doc = "!< Area inside the sourceDesktopRect which is scanned out to the display."] + pub sourceViewportRect: NvSBox, + #[doc = "!< Area inside the rect described by targetDisplayWidth/Height sourceViewportRect is scanned out to."] + pub targetViewportRect: NvSBox, + #[doc = "!< Horizontal size of the active resolution scanned out to the display."] + pub targetDisplayWidth: NvU32, + #[doc = "!< Vertical size of the active resolution scanned out to the display."] + pub targetDisplayHeight: NvU32, + #[doc = "!< If targets are cloned views of the sourceDesktopRect the cloned targets have an importance assigned (0:primary,1 secondary,...)."] + pub cloneImportance: NvU32, + #[doc = "!< Rotation performed between the sourceViewportRect and the targetViewportRect."] + pub sourceToTargetRotation: NV_ROTATE, +} +#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetScanoutConfigurationEx()."] +pub type NV_SCANOUT_INFORMATION = _NV_SCANOUT_INFORMATION; +#[doc = "!< Represents Bare Metal GPU"] +pub const _NV_VIRTUALIZATION_MODE_NV_VIRTUALIZATION_MODE_NONE: _NV_VIRTUALIZATION_MODE = 0; +#[doc = "!< Represents GPU-Passthrough"] +pub const _NV_VIRTUALIZATION_MODE_NV_VIRTUALIZATION_MODE_NMOS: _NV_VIRTUALIZATION_MODE = 1; +#[doc = "!< Represents vGPU inside virtual machine"] +pub const _NV_VIRTUALIZATION_MODE_NV_VIRTUALIZATION_MODE_VGX: _NV_VIRTUALIZATION_MODE = 2; +#[doc = "!< Represents VGX hypervisor in vGPU mode"] +pub const _NV_VIRTUALIZATION_MODE_NV_VIRTUALIZATION_MODE_HOST_VGPU: _NV_VIRTUALIZATION_MODE = 3; +#[doc = "! \\ingroup gpu"] +pub type _NV_VIRTUALIZATION_MODE = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpu"] +pub use self::_NV_VIRTUALIZATION_MODE as NV_VIRTUALIZATION_MODE; +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_VIRTUALIZATION_INFO { + #[doc = "!< Structure version"] + pub version: NvU32, + #[doc = "!< one of NV_VIRTUALIZATION_MODE."] + pub virtualizationMode: NV_VIRTUALIZATION_MODE, + #[doc = "!< reserved for future use. Should be set to ZERO."] + pub reserved: NvU32, +} +#[doc = "! \\ingroup gpu"] +pub type NV_GPU_VIRTUALIZATION_INFO_V1 = _NV_GPU_VIRTUALIZATION_INFO; +#[doc = "! \\ingroup gpu"] +pub type NV_GPU_VIRTUALIZATION_INFO = NV_GPU_VIRTUALIZATION_INFO_V1; +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LOGICAL_GPU_DATA_V1 { + #[doc = "!< [in] Structure version."] + pub version: NvU32, + #[doc = "!< [out] Returns OS-AdapterId. User must send memory buffer of size atleast equal to the size of LUID structure before calling the NVAPI."] + pub pOSAdapterId: *mut ::std::os::raw::c_void, + #[doc = "!< [out] Number of physical GPU handles associated with the specified logical GPU handle."] + pub physicalGpuCount: NvU32, + #[doc = "!< [out] This array will be filled with physical GPU handles associated with the given logical GPU handle.\n!< The array index refers to the Physical Gpu Index (Idx).\n!< Idx value is the same as D3D11 MultiGPUDevice GPU index, D3D12 node index, OpenGL GL_NV_gpu_multicast GPU index.\n!< When converted to a bit mask (1 << Idx), it matches:\n!< 1. Vulkan deviceNodeMask in VkPhysicalDeviceIDProperties\n!< 2. CUDA deviceNodeMask returned by cuDeviceGetLuid"] + pub physicalGpuHandles: [NvPhysicalGpuHandle; 64usize], + #[doc = "!< Reserved for future use. Should be set to ZERO."] + pub reserved: [NvU32; 8usize], +} +#[doc = "! \\ingroup gpu"] +pub type NV_LOGICAL_GPU_DATA_V1 = _NV_LOGICAL_GPU_DATA_V1; +#[doc = "! \\ingroup gpu"] +pub type NV_LOGICAL_GPU_DATA = NV_LOGICAL_GPU_DATA_V1; +#[doc = "! License string"] +pub type NvAPI_LicenseString = [::std::os::raw::c_char; 128usize]; +pub const _NV_LICENSE_FEATURE_TYPE_NV_LICENSE_FEATURE_UNKNOWN: _NV_LICENSE_FEATURE_TYPE = 0; +pub const _NV_LICENSE_FEATURE_TYPE_NV_LICENSE_FEATURE_VGPU: _NV_LICENSE_FEATURE_TYPE = 1; +pub const _NV_LICENSE_FEATURE_TYPE_NV_LICENSE_FEATURE_NVIDIA_RTX: _NV_LICENSE_FEATURE_TYPE = 2; +#[doc = "!< DEPRECATED name - do not use"] +pub const _NV_LICENSE_FEATURE_TYPE_NV_LICENSE_FEATURE_QUADRO: _NV_LICENSE_FEATURE_TYPE = 2; +pub const _NV_LICENSE_FEATURE_TYPE_NV_LICENSE_FEATURE_GAMING: _NV_LICENSE_FEATURE_TYPE = 3; +pub const _NV_LICENSE_FEATURE_TYPE_NV_LICENSE_FEATURE_COMPUTE: _NV_LICENSE_FEATURE_TYPE = 4; +#[doc = "! Used in NV_LICENSE_FEATURE_DETAILS"] +pub type _NV_LICENSE_FEATURE_TYPE = ::std::os::raw::c_int; +#[doc = "! Used in NV_LICENSE_FEATURE_DETAILS"] +pub use self::_NV_LICENSE_FEATURE_TYPE as NV_LICENSE_FEATURE_TYPE; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LICENSE_EXPIRY_DETAILS { + #[doc = "!< Year value of license expiry"] + pub year: NvU32, + #[doc = "!< Month value of license expiry"] + pub month: NvU16, + #[doc = "!< Day value of license expiry"] + pub day: NvU16, + #[doc = "!< Hour value of license expiry"] + pub hour: NvU16, + #[doc = "!< Minutes value of license expiry"] + pub min: NvU16, + #[doc = "!< Seconds value of license expiry"] + pub sec: NvU16, + #[doc = "!< License expiry status"] + pub status: NvU8, +} +pub type NV_LICENSE_EXPIRY_DETAILS = _NV_LICENSE_EXPIRY_DETAILS; +#[doc = "! Used in NV_LICENSABLE_FEATURES"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LICENSE_FEATURE_DETAILS_V1 { + #[doc = "!< IN - Structure version."] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Feature code that corresponds to the licensable feature."] + pub featureCode: NV_LICENSE_FEATURE_TYPE, + #[doc = "!< Deprecated"] + pub licenseInfo: NvAPI_LicenseString, +} +impl _NV_LICENSE_FEATURE_DETAILS_V1 { + #[inline] + pub fn isEnabled(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isEnabled(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isEnabled_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isEnabled_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isEnabled: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isEnabled: u32 = unsafe { ::std::mem::transmute(isEnabled) }; + isEnabled as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! Used in NV_LICENSABLE_FEATURES"] +pub type NV_LICENSE_FEATURE_DETAILS_V1 = _NV_LICENSE_FEATURE_DETAILS_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LICENSE_FEATURE_DETAILS_V2 { + #[doc = "!< Unused."] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Feature code that corresponds to the licensable feature."] + pub featureCode: NV_LICENSE_FEATURE_TYPE, + #[doc = "!< Deprecated"] + pub licenseInfo: NvAPI_LicenseString, + #[doc = "!< Nvidia Grid licensable product name."] + pub productName: NvAPI_LicenseString, +} +impl _NV_LICENSE_FEATURE_DETAILS_V2 { + #[inline] + pub fn isEnabled(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isEnabled(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isEnabled_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isEnabled_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isEnabled: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isEnabled: u32 = unsafe { ::std::mem::transmute(isEnabled) }; + isEnabled as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_LICENSE_FEATURE_DETAILS_V2 = _NV_LICENSE_FEATURE_DETAILS_V2; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LICENSE_FEATURE_DETAILS_V3 { + #[doc = "!< Unused."] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Feature code that corresponds to the licensable feature."] + pub featureCode: NV_LICENSE_FEATURE_TYPE, + #[doc = "!< Deprecated"] + pub licenseInfo: NvAPI_LicenseString, + #[doc = "!< Nvidia Grid licensable product name."] + pub productName: NvAPI_LicenseString, +} +impl _NV_LICENSE_FEATURE_DETAILS_V3 { + #[inline] + pub fn isEnabled(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isEnabled(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isEnabled_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isEnabled_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isFeatureEnabled(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isFeatureEnabled(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isFeatureEnabled_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isFeatureEnabled_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 30u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 30u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 30u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isEnabled: NvU32, + isFeatureEnabled: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isEnabled: u32 = unsafe { ::std::mem::transmute(isEnabled) }; + isEnabled as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isFeatureEnabled: u32 = unsafe { ::std::mem::transmute(isFeatureEnabled) }; + isFeatureEnabled as u64 + }); + __bindgen_bitfield_unit.set(2usize, 30u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_LICENSE_FEATURE_DETAILS_V3 = _NV_LICENSE_FEATURE_DETAILS_V3; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LICENSE_FEATURE_DETAILS_V4 { + #[doc = "!< Unused."] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Feature code that corresponds to the licensable feature."] + pub featureCode: NV_LICENSE_FEATURE_TYPE, + #[doc = "!< Deprecated"] + pub licenseInfo: NvAPI_LicenseString, + #[doc = "!< Nvidia Grid licensable product name."] + pub productName: NvAPI_LicenseString, + #[doc = "!< License expiry information."] + pub licenseExpiry: NV_LICENSE_EXPIRY_DETAILS, +} +impl _NV_LICENSE_FEATURE_DETAILS_V4 { + #[inline] + pub fn isEnabled(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isEnabled(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isEnabled_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isEnabled_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isFeatureEnabled(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isFeatureEnabled(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isFeatureEnabled_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isFeatureEnabled_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 30u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 30u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 30u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isEnabled: NvU32, + isFeatureEnabled: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isEnabled: u32 = unsafe { ::std::mem::transmute(isEnabled) }; + isEnabled as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isFeatureEnabled: u32 = unsafe { ::std::mem::transmute(isFeatureEnabled) }; + isFeatureEnabled as u64 + }); + __bindgen_bitfield_unit.set(2usize, 30u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_LICENSE_FEATURE_DETAILS_V4 = _NV_LICENSE_FEATURE_DETAILS_V4; +#[doc = "! Used in NV_LICENSABLE_FEATURES"] +pub type NV_LICENSE_FEATURE_DETAILS = NV_LICENSE_FEATURE_DETAILS_V1; +#[doc = "! Licensable features"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LICENSABLE_FEATURES_V1 { + #[doc = "!< IN - Structure version."] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< The number of licensable features."] + pub licensableFeatureCount: NvU32, + #[doc = "!< Dynamic signature required for Authentication of the components,\n!< signature length limited to NV_LICENSE_SIGNATURE_SIZE"] + pub signature: [NvU8; 128usize], + #[doc = "!< Array of licensable features"] + pub licenseDetails: [NV_LICENSE_FEATURE_DETAILS_V1; 3usize], +} +impl _NV_LICENSABLE_FEATURES_V1 { + #[inline] + pub fn isLicenseSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isLicenseSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isLicenseSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isLicenseSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isLicenseSupported: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isLicenseSupported: u32 = unsafe { ::std::mem::transmute(isLicenseSupported) }; + isLicenseSupported as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! Licensable features"] +pub type NV_LICENSABLE_FEATURES_V1 = _NV_LICENSABLE_FEATURES_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LICENSABLE_FEATURES_V2 { + #[doc = "!< IN - Structure version."] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< The number of licensable features."] + pub licensableFeatureCount: NvU32, + #[doc = "!< Dynamic signature required for Authentication of the components,\n!< signature length limited to NV_LICENSE_SIGNATURE_SIZE"] + pub signature: [NvU8; 128usize], + #[doc = "!< Array of licensable features"] + pub licenseDetails: [NV_LICENSE_FEATURE_DETAILS_V2; 3usize], +} +impl _NV_LICENSABLE_FEATURES_V2 { + #[inline] + pub fn isLicenseSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isLicenseSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isLicenseSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isLicenseSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isLicenseSupported: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isLicenseSupported: u32 = unsafe { ::std::mem::transmute(isLicenseSupported) }; + isLicenseSupported as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_LICENSABLE_FEATURES_V2 = _NV_LICENSABLE_FEATURES_V2; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LICENSABLE_FEATURES_V3 { + #[doc = "!< IN - Structure version."] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< The number of licensable features."] + pub licensableFeatureCount: NvU32, + #[doc = "!< Dynamic signature required for Authentication of the components,\n!< signature length limited to NV_LICENSE_SIGNATURE_SIZE"] + pub signature: [NvU8; 128usize], + #[doc = "!< Array of licensable features"] + pub licenseDetails: [NV_LICENSE_FEATURE_DETAILS_V3; 3usize], +} +impl _NV_LICENSABLE_FEATURES_V3 { + #[inline] + pub fn isLicenseSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isLicenseSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isLicenseSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isLicenseSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isLicenseSupported: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isLicenseSupported: u32 = unsafe { ::std::mem::transmute(isLicenseSupported) }; + isLicenseSupported as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_LICENSABLE_FEATURES_V3 = _NV_LICENSABLE_FEATURES_V3; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LICENSABLE_FEATURES_V4 { + #[doc = "!< IN - Structure version."] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< The number of licensable features."] + pub licensableFeatureCount: NvU32, + #[doc = "!< Dynamic signature required for Authentication of the components,\n!< signature length limited to NV_LICENSE_SIGNATURE_SIZE"] + pub signature: [NvU8; 128usize], + #[doc = "!< Array of licensable features"] + pub licenseDetails: [NV_LICENSE_FEATURE_DETAILS_V4; 3usize], +} +impl _NV_LICENSABLE_FEATURES_V4 { + #[inline] + pub fn isLicenseSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isLicenseSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isLicenseSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isLicenseSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isLicenseSupported: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isLicenseSupported: u32 = unsafe { ::std::mem::transmute(isLicenseSupported) }; + isLicenseSupported as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_LICENSABLE_FEATURES_V4 = _NV_LICENSABLE_FEATURES_V4; +pub type NV_LICENSABLE_FEATURES = NV_LICENSABLE_FEATURES_V4; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_ENCODER_STATISTICS_V1 { + #[doc = "!< [in] Structure version value."] + pub version: NvU32, + #[doc = "!< [out] Count of active encoder sessions."] + pub sessionsCount: NvU32, + #[doc = "!< [out] Trailing average FPS of all active sessions."] + pub averageFps: NvU32, + #[doc = "!< [out] Encode latency in microseconds."] + pub averageLatency: NvU32, +} +pub type NV_ENCODER_STATISTICS_V1 = _NV_ENCODER_STATISTICS_V1; +pub type NV_ENCODER_STATISTICS = NV_ENCODER_STATISTICS_V1; +pub const _NV_ENCODER_TYPE_NV_ENCODER_H264: _NV_ENCODER_TYPE = 0; +pub const _NV_ENCODER_TYPE_NV_ENCODER_HEVC: _NV_ENCODER_TYPE = 1; +pub const _NV_ENCODER_TYPE_NV_ENCODER_UNKNOWN: _NV_ENCODER_TYPE = -1; +pub type _NV_ENCODER_TYPE = ::std::os::raw::c_int; +pub use self::_NV_ENCODER_TYPE as NV_ENCODER_TYPE; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_ENCODER_PER_SESSION_INFO_V1 { + #[doc = "!< Unique session ID."] + pub sessionId: NvU32, + #[doc = "!< Owning process ID."] + pub processId: NvU32, + #[doc = "!< Owning vGPU instance ID (only valid on vGPU hosts, otherwise zero)."] + pub vgpuInstance: NvU32, + #[doc = "!< Video encoder type."] + pub codecType: NV_ENCODER_TYPE, + #[doc = "!< Current encode horizontal resolution."] + pub hResolution: NvU32, + #[doc = "!< Current encode vertical resolution."] + pub vResolution: NvU32, + #[doc = "!< Moving average encode frames per second."] + pub averageEncodeFps: NvU32, + #[doc = "!< Moving average encode latency in microseconds."] + pub averageEncodeLatency: NvU32, +} +pub type NV_ENCODER_PER_SESSION_INFO_V1 = _NV_ENCODER_PER_SESSION_INFO_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_ENCODER_SESSIONS_INFO_V1 { + #[doc = "!< [in] Structure version value."] + pub version: NvU32, + #[doc = "!< [out] Count of active encoder sessions."] + pub sessionsCount: NvU32, + #[doc = "!< [out] Array of session info. Caller should allocate memory for this field before making\n!< the NvAPI_GPU_GetEncoderSessionsInfo() call, memory allocated should be of\n!< size = sizeof(NV_ENCODER_PER_SESSION_INFO_V1) * NV_ENCODER_SESSION_INFO_MAX_ENTRIES_V1."] + pub pSessionInfo: *mut NV_ENCODER_PER_SESSION_INFO_V1, +} +pub type NV_ENCODER_SESSIONS_INFO_V1 = _NV_ENCODER_SESSIONS_INFO_V1; +pub type NV_ENCODER_SESSIONS_INFO = NV_ENCODER_SESSIONS_INFO_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_INFO_V1 { + #[doc = "!< Structure Version."] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl _NV_GPU_INFO_V1 { + #[inline] + pub fn bIsExternalGpu(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsExternalGpu(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsExternalGpu_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsExternalGpu_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsExternalGpu: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsExternalGpu: u32 = unsafe { ::std::mem::transmute(bIsExternalGpu) }; + bIsExternalGpu as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_GPU_INFO_V1 = _NV_GPU_INFO_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_INFO_V2 { + #[doc = "!< Structure Version."] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Reserved for future use"] + pub reserved1: NvU64, + #[doc = "!< Number of \"Ray Tracing Cores\" supported by the GPU."] + pub rayTracingCores: NvU32, + #[doc = "!< Number of \"Tensor Cores\" supported by the GPU."] + pub tensorCores: NvU32, + #[doc = "!< Reserved for future use."] + pub reserved2: [NvU32; 14usize], +} +impl _NV_GPU_INFO_V2 { + #[inline] + pub fn bIsExternalGpu(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsExternalGpu(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsExternalGpu_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsExternalGpu_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved0(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved0(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved0_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved0_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsExternalGpu: NvU32, + reserved0: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsExternalGpu: u32 = unsafe { ::std::mem::transmute(bIsExternalGpu) }; + bIsExternalGpu as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved0: u32 = unsafe { ::std::mem::transmute(reserved0) }; + reserved0 as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_GPU_INFO_V2 = _NV_GPU_INFO_V2; +pub type NV_GPU_INFO = NV_GPU_INFO_V2; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_VR_READY_V1 { + #[doc = "!< Structure Version."] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl _NV_GPU_VR_READY_V1 { + #[inline] + pub fn isVRReady(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isVRReady(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isVRReady_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isVRReady_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isVRReady: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isVRReady: u32 = unsafe { ::std::mem::transmute(isVRReady) }; + isVRReady as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_GPU_VR_READY_V1 = _NV_GPU_VR_READY_V1; +pub type NV_GPU_VR_READY = NV_GPU_VR_READY_V1; +pub const _NV_ADAPTER_TYPE_NV_ADAPTER_TYPE_UNKNOWN: _NV_ADAPTER_TYPE = 0; +pub const _NV_ADAPTER_TYPE_NV_ADAPTER_TYPE_WDDM: _NV_ADAPTER_TYPE = 1; +pub const _NV_ADAPTER_TYPE_NV_ADAPTER_TYPE_MCDM: _NV_ADAPTER_TYPE = 2; +pub const _NV_ADAPTER_TYPE_NV_ADAPTER_TYPE_TCC: _NV_ADAPTER_TYPE = 4; +pub const _NV_ADAPTER_TYPE_NV_ADAPTER_TYPE_LAST: _NV_ADAPTER_TYPE = -1; +pub type _NV_ADAPTER_TYPE = ::std::os::raw::c_int; +pub use self::_NV_ADAPTER_TYPE as NV_ADAPTER_TYPE; +#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetGspFeatures()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_GSP_INFO_V1 { + #[doc = "!< [in] Structure version"] + pub version: NvU32, + #[doc = "!< [out] Contains GSP firmware version"] + pub firmwareVersion: [NvU8; 64usize], + #[doc = "!< Reserved for future use"] + pub reserved: NvU32, +} +#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetGspFeatures()."] +pub type NV_GPU_GSP_INFO_V1 = _NV_GPU_GSP_INFO_V1; +#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetGspFeatures()."] +pub type NV_GPU_GSP_INFO = NV_GPU_GSP_INFO_V1; +#[doc = "! \\fn NvAPI_GPU_GetUUID(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_UUID *pGpuUuid)\n! DESCRIPTION: This function returns the GPU UUID for the specified physical GPU handle.\n! The UUID is returned in GUID format (16 bytes).\n!\n! SUPPORTED OS: Windows 10 and higher\n!\n!\n! TCC_SUPPORTED\n!\n! MCDM_SUPPORTED\n!\n! \\since Release: 595\n!\n! \\param [in] hPhysicalGpu Physical GPU handle to get UUID for\n! \\param [in,out] pGpuUuid Pointer to structure that will receive the GPU UUID\n!\n! \\retval NVAPI_OK Request completed successfully\n! \\return This API can return any of the error codes enumerated in #NvAPI_Status.\n!\n! \\ingroup gpu\n\n! Used in NvAPI_GPU_GetUUID()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_UUID_V1 { + pub version: NvU32, + pub uuid: [NvU8; 16usize], +} +#[doc = "! \\fn NvAPI_GPU_GetUUID(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_UUID *pGpuUuid)\n! DESCRIPTION: This function returns the GPU UUID for the specified physical GPU handle.\n! The UUID is returned in GUID format (16 bytes).\n!\n! SUPPORTED OS: Windows 10 and higher\n!\n!\n! TCC_SUPPORTED\n!\n! MCDM_SUPPORTED\n!\n! \\since Release: 595\n!\n! \\param [in] hPhysicalGpu Physical GPU handle to get UUID for\n! \\param [in,out] pGpuUuid Pointer to structure that will receive the GPU UUID\n!\n! \\retval NVAPI_OK Request completed successfully\n! \\return This API can return any of the error codes enumerated in #NvAPI_Status.\n!\n! \\ingroup gpu\n\n! Used in NvAPI_GPU_GetUUID()"] +pub type NV_GPU_UUID_V1 = _NV_GPU_UUID_V1; +#[doc = "! \\fn NvAPI_GPU_GetUUID(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_UUID *pGpuUuid)\n! DESCRIPTION: This function returns the GPU UUID for the specified physical GPU handle.\n! The UUID is returned in GUID format (16 bytes).\n!\n! SUPPORTED OS: Windows 10 and higher\n!\n!\n! TCC_SUPPORTED\n!\n! MCDM_SUPPORTED\n!\n! \\since Release: 595\n!\n! \\param [in] hPhysicalGpu Physical GPU handle to get UUID for\n! \\param [in,out] pGpuUuid Pointer to structure that will receive the GPU UUID\n!\n! \\retval NVAPI_OK Request completed successfully\n! \\return This API can return any of the error codes enumerated in #NvAPI_Status.\n!\n! \\ingroup gpu\n\n! Used in NvAPI_GPU_GetUUID()"] +pub type NV_GPU_UUID = NV_GPU_UUID_V1; +#[doc = "! \\ingroup gpupstate\n! Used in NvAPI_GPU_GetPstatesInfoEx()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PERF_PSTATES_INFO_V1 { + pub version: NvU32, + #[doc = "!< - bit 0 indicates if perfmon is enabled or not\n!< - bit 1 indicates if dynamic Pstate is capable or not\n!< - bit 2 indicates if dynamic Pstate is enable or not\n!< - all other bits must be set to 0"] + pub flags: NvU32, + #[doc = "!< The number of available p-states"] + pub numPstates: NvU32, + #[doc = "!< The number of clock domains supported by each P-State"] + pub numClocks: NvU32, + pub pstates: [NV_GPU_PERF_PSTATES_INFO_V1__bindgen_ty_1; 16usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PERF_PSTATES_INFO_V1__bindgen_ty_1 { + #[doc = "!< ID of the p-state."] + pub pstateId: NV_GPU_PERF_PSTATE_ID, + #[doc = "!< - bit 0 indicates if the PCIE limit is GEN1 or GEN2\n!< - bit 1 indicates if the Pstate is overclocked or not\n!< - bit 2 indicates if the Pstate is overclockable or not\n!< - all other bits must be set to 0"] + pub flags: NvU32, + pub clocks: [NV_GPU_PERF_PSTATES_INFO_V1__bindgen_ty_1__bindgen_ty_1; 32usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PERF_PSTATES_INFO_V1__bindgen_ty_1__bindgen_ty_1 { + #[doc = "!< ID of the clock domain"] + pub domainId: NV_GPU_PUBLIC_CLOCK_ID, + #[doc = "!< Reserved. Must be set to 0"] + pub flags: NvU32, + #[doc = "!< Clock frequency in kHz"] + pub freq: NvU32, +} +#[doc = "! \\ingroup gpupstate"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PERF_PSTATES_INFO_V2 { + pub version: NvU32, + #[doc = "!< - bit 0 indicates if perfmon is enabled or not\n!< - bit 1 indicates if dynamic Pstate is capable or not\n!< - bit 2 indicates if dynamic Pstate is enable or not\n!< - all other bits must be set to 0"] + pub flags: NvU32, + #[doc = "!< The number of available p-states"] + pub numPstates: NvU32, + #[doc = "!< The number of clock domains supported by each P-State"] + pub numClocks: NvU32, + pub numVoltages: NvU32, + #[doc = "!< Valid index range is 0 to numVoltages-1"] + pub pstates: [NV_GPU_PERF_PSTATES_INFO_V2__bindgen_ty_1; 16usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PERF_PSTATES_INFO_V2__bindgen_ty_1 { + #[doc = "!< ID of the p-state."] + pub pstateId: NV_GPU_PERF_PSTATE_ID, + #[doc = "!< - bit 0 indicates if the PCIE limit is GEN1 or GEN2\n!< - bit 1 indicates if the Pstate is overclocked or not\n!< - bit 2 indicates if the Pstate is overclockable or not\n!< - all other bits must be set to 0"] + pub flags: NvU32, + pub clocks: [NV_GPU_PERF_PSTATES_INFO_V2__bindgen_ty_1__bindgen_ty_1; 32usize], + pub voltages: [NV_GPU_PERF_PSTATES_INFO_V2__bindgen_ty_1__bindgen_ty_2; 16usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PERF_PSTATES_INFO_V2__bindgen_ty_1__bindgen_ty_1 { + pub domainId: NV_GPU_PUBLIC_CLOCK_ID, + #[doc = "!< bit 0 indicates if this clock is overclockable\n!< all other bits must be set to 0"] + pub flags: NvU32, + pub freq: NvU32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PERF_PSTATES_INFO_V2__bindgen_ty_1__bindgen_ty_2 { + #[doc = "!< ID of the voltage domain, containing flags and mvolt info"] + pub domainId: NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID, + #[doc = "!< Reserved for future use. Must be set to 0"] + pub flags: NvU32, + #[doc = "!< Voltage in mV"] + pub mvolt: NvU32, +} +#[doc = "! \\ingroup gpupstate"] +pub type NV_GPU_PERF_PSTATES_INFO = NV_GPU_PERF_PSTATES_INFO_V2; +#[doc = "! \\ingroup gpupstate\n! Used in NvAPI_GPU_GetDynamicPstatesInfoEx()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_DYNAMIC_PSTATES_INFO_EX { + #[doc = "!< Structure version"] + pub version: NvU32, + #[doc = "!< bit 0 indicates if the dynamic Pstate is enabled or not"] + pub flags: NvU32, + pub utilization: [NV_GPU_DYNAMIC_PSTATES_INFO_EX__bindgen_ty_1; 8usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_DYNAMIC_PSTATES_INFO_EX__bindgen_ty_1 { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + #[doc = "!< Percentage of time where the domain is considered busy in the last 1 second interval"] + pub percentage: NvU32, +} +impl NV_GPU_DYNAMIC_PSTATES_INFO_EX__bindgen_ty_1 { + #[inline] + pub fn bIsPresent(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsPresent(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsPresent_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsPresent_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1(bIsPresent: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsPresent: u32 = unsafe { ::std::mem::transmute(bIsPresent) }; + bIsPresent as u64 + }); + __bindgen_bitfield_unit + } +} +pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_NONE: NV_THERMAL_TARGET = 0; +#[doc = "!< GPU core temperature requires NvPhysicalGpuHandle"] +pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_GPU: NV_THERMAL_TARGET = 1; +#[doc = "!< GPU memory temperature requires NvPhysicalGpuHandle"] +pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_MEMORY: NV_THERMAL_TARGET = 2; +#[doc = "!< GPU power supply temperature requires NvPhysicalGpuHandle"] +pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_POWER_SUPPLY: NV_THERMAL_TARGET = 4; +#[doc = "!< GPU board ambient temperature requires NvPhysicalGpuHandle"] +pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_BOARD: NV_THERMAL_TARGET = 8; +#[doc = "!< Visual Computing Device Board temperature requires NvVisualComputingDeviceHandle"] +pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_VCD_BOARD: NV_THERMAL_TARGET = 9; +#[doc = "!< Visual Computing Device Inlet temperature requires NvVisualComputingDeviceHandle"] +pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_VCD_INLET: NV_THERMAL_TARGET = 10; +#[doc = "!< Visual Computing Device Outlet temperature requires NvVisualComputingDeviceHandle"] +pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_VCD_OUTLET: NV_THERMAL_TARGET = 11; +pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_ALL: NV_THERMAL_TARGET = 15; +pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_UNKNOWN: NV_THERMAL_TARGET = -1; +#[doc = "! \\ingroup gputhermal\n! Used in NV_GPU_THERMAL_SETTINGS"] +pub type NV_THERMAL_TARGET = ::std::os::raw::c_int; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_NONE: NV_THERMAL_CONTROLLER = 0; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_GPU_INTERNAL: NV_THERMAL_CONTROLLER = 1; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_ADM1032: NV_THERMAL_CONTROLLER = 2; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_MAX6649: NV_THERMAL_CONTROLLER = 3; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_MAX1617: NV_THERMAL_CONTROLLER = 4; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_LM99: NV_THERMAL_CONTROLLER = 5; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_LM89: NV_THERMAL_CONTROLLER = 6; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_LM64: NV_THERMAL_CONTROLLER = 7; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_ADT7473: NV_THERMAL_CONTROLLER = 8; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_SBMAX6649: NV_THERMAL_CONTROLLER = 9; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_VBIOSEVT: NV_THERMAL_CONTROLLER = 10; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_OS: NV_THERMAL_CONTROLLER = 11; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_UNKNOWN: NV_THERMAL_CONTROLLER = -1; +#[doc = "! \\ingroup gputhermal\n! Used in NV_GPU_THERMAL_SETTINGS"] +pub type NV_THERMAL_CONTROLLER = ::std::os::raw::c_int; +#[doc = "! \\ingroup gputhermal\n! Used in NvAPI_GPU_GetThermalSettings()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_THERMAL_SETTINGS_V1 { + #[doc = "!< structure version"] + pub version: NvU32, + #[doc = "!< number of associated thermal sensors"] + pub count: NvU32, + pub sensor: [NV_GPU_THERMAL_SETTINGS_V1__bindgen_ty_1; 3usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_THERMAL_SETTINGS_V1__bindgen_ty_1 { + #[doc = "!< internal, ADM1032, MAX6649..."] + pub controller: NV_THERMAL_CONTROLLER, + #[doc = "!< The min default temperature value of the thermal sensor in degree Celsius"] + pub defaultMinTemp: NvU32, + #[doc = "!< The max default temperature value of the thermal sensor in degree Celsius"] + pub defaultMaxTemp: NvU32, + #[doc = "!< The current temperature value of the thermal sensor in degree Celsius"] + pub currentTemp: NvU32, + #[doc = "!< Thermal sensor targeted @ GPU, memory, chipset, powersupply, Visual Computing Device, etc."] + pub target: NV_THERMAL_TARGET, +} +#[doc = "! \\ingroup gputhermal"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_THERMAL_SETTINGS_V2 { + #[doc = "!< structure version"] + pub version: NvU32, + #[doc = "!< number of associated thermal sensors"] + pub count: NvU32, + pub sensor: [NV_GPU_THERMAL_SETTINGS_V2__bindgen_ty_1; 3usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_THERMAL_SETTINGS_V2__bindgen_ty_1 { + #[doc = "!< internal, ADM1032, MAX6649..."] + pub controller: NV_THERMAL_CONTROLLER, + #[doc = "!< Minimum default temperature value of the thermal sensor in degree Celsius"] + pub defaultMinTemp: NvS32, + #[doc = "!< Maximum default temperature value of the thermal sensor in degree Celsius"] + pub defaultMaxTemp: NvS32, + #[doc = "!< Current temperature value of the thermal sensor in degree Celsius"] + pub currentTemp: NvS32, + #[doc = "!< Thermal sensor targeted - GPU, memory, chipset, powersupply, Visual Computing Device, etc"] + pub target: NV_THERMAL_TARGET, +} +#[doc = "! \\ingroup gputhermal"] +pub type NV_GPU_THERMAL_SETTINGS = NV_GPU_THERMAL_SETTINGS_V2; +#[doc = "! \\ingroup gpuclock\n! Used in NvAPI_GPU_GetAllClockFrequencies()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_CLOCK_FREQUENCIES_V1 { + #[doc = "!< Structure version"] + pub version: NvU32, + #[doc = "!< These bits are reserved for future use."] + pub reserved: NvU32, + pub domain: [NV_GPU_CLOCK_FREQUENCIES_V1__bindgen_ty_1; 32usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_CLOCK_FREQUENCIES_V1__bindgen_ty_1 { + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Clock frequency (kHz)"] + pub frequency: NvU32, +} +impl NV_GPU_CLOCK_FREQUENCIES_V1__bindgen_ty_1 { + #[inline] + pub fn bIsPresent(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsPresent(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsPresent_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsPresent_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsPresent: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsPresent: u32 = unsafe { ::std::mem::transmute(bIsPresent) }; + bIsPresent as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub const NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE_NV_GPU_CLOCK_FREQUENCIES_CURRENT_FREQ: + NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE = 0; +pub const NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE_NV_GPU_CLOCK_FREQUENCIES_BASE_CLOCK: + NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE = 1; +pub const NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE_NV_GPU_CLOCK_FREQUENCIES_BOOST_CLOCK: + NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE = 2; +pub const NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE_NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE_NUM: + NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE = 3; +#[doc = "! \\ingroup gpuclock\n! Used in NvAPI_GPU_GetAllClockFrequencies()"] +pub type NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpuclock\n! Used in NvAPI_GPU_GetAllClockFrequencies()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_CLOCK_FREQUENCIES_V2 { + #[doc = "!< Structure version"] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + pub domain: [NV_GPU_CLOCK_FREQUENCIES_V2__bindgen_ty_1; 32usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_CLOCK_FREQUENCIES_V2__bindgen_ty_1 { + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Clock frequency (kHz)"] + pub frequency: NvU32, +} +impl NV_GPU_CLOCK_FREQUENCIES_V2__bindgen_ty_1 { + #[inline] + pub fn bIsPresent(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsPresent(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsPresent_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsPresent_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsPresent: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsPresent: u32 = unsafe { ::std::mem::transmute(bIsPresent) }; + bIsPresent as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +impl NV_GPU_CLOCK_FREQUENCIES_V2 { + #[inline] + pub fn ClockType(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32) } + } + #[inline] + pub fn set_ClockType(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn ClockType_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 4u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_ClockType_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 20u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 20u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 20u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 20u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved1(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u32) } + } + #[inline] + pub fn set_reserved1(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(24usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved1_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 24usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved1_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 24usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + ClockType: NvU32, + reserved: NvU32, + reserved1: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 4u8, { + let ClockType: u32 = unsafe { ::std::mem::transmute(ClockType) }; + ClockType as u64 + }); + __bindgen_bitfield_unit.set(4usize, 20u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit.set(24usize, 8u8, { + let reserved1: u32 = unsafe { ::std::mem::transmute(reserved1) }; + reserved1 as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup gpuclock\n! Used in NvAPI_GPU_GetAllClockFrequencies()"] +pub type NV_GPU_CLOCK_FREQUENCIES = NV_GPU_CLOCK_FREQUENCIES_V2; +pub const _NV_GPU_ILLUMINATION_ATTRIB_NV_GPU_IA_LOGO_BRIGHTNESS: _NV_GPU_ILLUMINATION_ATTRIB = 0; +pub const _NV_GPU_ILLUMINATION_ATTRIB_NV_GPU_IA_SLI_BRIGHTNESS: _NV_GPU_ILLUMINATION_ATTRIB = 1; +#[doc = "! \\ingroup gpu"] +pub type _NV_GPU_ILLUMINATION_ATTRIB = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpu"] +pub use self::_NV_GPU_ILLUMINATION_ATTRIB as NV_GPU_ILLUMINATION_ATTRIB; +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_QUERY_ILLUMINATION_SUPPORT_PARM_V1 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< The handle of the GPU that you are checking for the specified attribute.\n!< note that this is the GPU that is managing the attribute.\n!< Only a single GPU can manage an given attribute on a given HW element,\n!< regardless of how many are attatched.\n!< I.E. only one GPU will be used to control the brightness of the LED on an SLI bridge,\n!< regardless of how many are physicaly attached.\n!< You enumerate thru the GPUs with this call to determine which GPU is managing the attribute."] + pub hPhysicalGpu: NvPhysicalGpuHandle, + #[doc = "!< An enumeration value specifying the Illumination attribute to be querried.\n!< refer to enum \\ref NV_GPU_ILLUMINATION_ATTRIB."] + pub Attribute: NV_GPU_ILLUMINATION_ATTRIB, + #[doc = "!< A boolean indicating if the attribute is supported."] + pub bSupported: NvU32, +} +#[doc = "! \\ingroup gpu"] +pub type NV_GPU_QUERY_ILLUMINATION_SUPPORT_PARM_V1 = _NV_GPU_QUERY_ILLUMINATION_SUPPORT_PARM_V1; +#[doc = "! \\ingroup gpu"] +pub type NV_GPU_QUERY_ILLUMINATION_SUPPORT_PARM = NV_GPU_QUERY_ILLUMINATION_SUPPORT_PARM_V1; +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_GET_ILLUMINATION_PARM_V1 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< The handle of the GPU that you are checking for the specified attribute.\n!< Note that this is the GPU that is managing the attribute.\n!< Only a single GPU can manage an given attribute on a given HW element,\n!< regardless of how many are attatched.\n!< I.E. only one GPU will be used to control the brightness of the LED on an SLI bridge,\n!< regardless of how many are physicaly attached.\n!< You enumerate thru the GPUs with this call to determine which GPU is managing the attribute."] + pub hPhysicalGpu: NvPhysicalGpuHandle, + #[doc = "!< An enumeration value specifying the Illumination attribute to be querried.\n!< refer to enum \\ref NV_GPU_ILLUMINATION_ATTRIB."] + pub Attribute: NV_GPU_ILLUMINATION_ATTRIB, + #[doc = "!< A DWORD that will contain the current value of the specified attribute."] + pub Value: NvU32, +} +#[doc = "! \\ingroup gpu"] +pub type NV_GPU_GET_ILLUMINATION_PARM_V1 = _NV_GPU_GET_ILLUMINATION_PARM_V1; +#[doc = "! \\ingroup gpu"] +pub type NV_GPU_GET_ILLUMINATION_PARM = NV_GPU_GET_ILLUMINATION_PARM_V1; +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_SET_ILLUMINATION_PARM_V1 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< The handle of the GPU that you are checking for the specified attribute.\n!< Note that this is the GPU that is managing the attribute.\n!< Only a single GPU can manage an given attribute on a given HW element,\n!< regardless of how many are attatched.\n!< I.E. only one GPU will be used to control the brightness of the LED on an SLI bridge,\n!< regardless of how many are physicaly attached.\n!< You enumerate thru the GPUs with this call to determine which GPU is managing the attribute."] + pub hPhysicalGpu: NvPhysicalGpuHandle, + #[doc = "!< An enumeration value specifying the Illumination attribute to be querried.\n!< refer to enum \\ref NV_GPU_ILLUMINATION_ATTRIB."] + pub Attribute: NV_GPU_ILLUMINATION_ATTRIB, + #[doc = "!< A DWORD containing the new value for the specified attribute.\n!< This should be specified as a percentage of the full range of the attribute\n!< (0-100; 0 = off, 100 = full brightness)\n!< If a value is specified outside this range, NVAPI_INVALID_ARGUMENT will be returned."] + pub Value: NvU32, +} +#[doc = "! \\ingroup gpu"] +pub type NV_GPU_SET_ILLUMINATION_PARM_V1 = _NV_GPU_SET_ILLUMINATION_PARM_V1; +#[doc = "! \\ingroup gpu"] +pub type NV_GPU_SET_ILLUMINATION_PARM = NV_GPU_SET_ILLUMINATION_PARM_V1; +pub const NV_GPU_CLIENT_ILLUM_CTRL_MODE_NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB: + NV_GPU_CLIENT_ILLUM_CTRL_MODE = 0; +pub const NV_GPU_CLIENT_ILLUM_CTRL_MODE_NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB: + NV_GPU_CLIENT_ILLUM_CTRL_MODE = 1; +pub const NV_GPU_CLIENT_ILLUM_CTRL_MODE_NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL: + NV_GPU_CLIENT_ILLUM_CTRL_MODE = 0; +pub const NV_GPU_CLIENT_ILLUM_CTRL_MODE_NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR: + NV_GPU_CLIENT_ILLUM_CTRL_MODE = 1; +pub const NV_GPU_CLIENT_ILLUM_CTRL_MODE_NV_GPU_CLIENT_ILLUM_CTRL_MODE_INVALID: + NV_GPU_CLIENT_ILLUM_CTRL_MODE = 255; +#[doc = " Enumeration of control modes that can be applied to Illumination Zones."] +pub type NV_GPU_CLIENT_ILLUM_CTRL_MODE = ::std::os::raw::c_int; +pub const NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_GPU_TOP_0: + NV_GPU_CLIENT_ILLUM_ZONE_LOCATION = 0; +pub const NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_GPU_FRONT_0: + NV_GPU_CLIENT_ILLUM_ZONE_LOCATION = 8; +pub const NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_GPU_BACK_0: + NV_GPU_CLIENT_ILLUM_ZONE_LOCATION = 12; +pub const NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_SLI_TOP_0: + NV_GPU_CLIENT_ILLUM_ZONE_LOCATION = 32; +pub const NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_INVALID: + NV_GPU_CLIENT_ILLUM_ZONE_LOCATION = -1; +#[doc = " Enumeration of locations where an Illumination Zone might be present.\n Encoding used -\n 1:0 - Number specifier (0)\n 4:2 - Location (TOP)\n 7:5 - Type (GPU/SLI)"] +pub type NV_GPU_CLIENT_ILLUM_ZONE_LOCATION = ::std::os::raw::c_int; +pub const NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_INVALID: + NV_GPU_CLIENT_ILLUM_DEVICE_TYPE = 0; +pub const NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_MCUV10: + NV_GPU_CLIENT_ILLUM_DEVICE_TYPE = 1; +pub const NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_GPIO_PWM_RGBW_V10: + NV_GPU_CLIENT_ILLUM_DEVICE_TYPE = 2; +pub const NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_GPIO_PWM_SINGLE_COLOR_V10 : NV_GPU_CLIENT_ILLUM_DEVICE_TYPE = 3 ; +#[doc = " Enumeration of ILLUM_DEVICEs."] +pub type NV_GPU_CLIENT_ILLUM_DEVICE_TYPE = ::std::os::raw::c_int; +pub const NV_GPU_CLIENT_ILLUM_ZONE_TYPE_NV_GPU_CLIENT_ILLUM_ZONE_TYPE_INVALID: + NV_GPU_CLIENT_ILLUM_ZONE_TYPE = 0; +pub const NV_GPU_CLIENT_ILLUM_ZONE_TYPE_NV_GPU_CLIENT_ILLUM_ZONE_TYPE_RGB: + NV_GPU_CLIENT_ILLUM_ZONE_TYPE = 1; +pub const NV_GPU_CLIENT_ILLUM_ZONE_TYPE_NV_GPU_CLIENT_ILLUM_ZONE_TYPE_COLOR_FIXED: + NV_GPU_CLIENT_ILLUM_ZONE_TYPE = 2; +pub const NV_GPU_CLIENT_ILLUM_ZONE_TYPE_NV_GPU_CLIENT_ILLUM_ZONE_TYPE_RGBW: + NV_GPU_CLIENT_ILLUM_ZONE_TYPE = 3; +pub const NV_GPU_CLIENT_ILLUM_ZONE_TYPE_NV_GPU_CLIENT_ILLUM_ZONE_TYPE_SINGLE_COLOR: + NV_GPU_CLIENT_ILLUM_ZONE_TYPE = 4; +#[doc = " Enumeration of ILLUM_ZONEs."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_TYPE = ::std::os::raw::c_int; +pub const NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE_NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_HALF_HALT : NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE = 0 ; +pub const NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE_NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_FULL_HALT : NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE = 1 ; +pub const NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE_NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_FULL_REPEAT : NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE = 2 ; +pub const NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE_NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_INVALID : NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE = 255 ; +#[doc = " Enumeration of Cycle types for piecewise linear control mode."] +pub type NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE = ::std::os::raw::c_int; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1\n Describes the static information of illumination device type MCUV10."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_MCUV10 { + #[doc = " I2C Device Index: Pointing to the illumination device in I2C Devices Table."] + pub i2cDevIdx: NvU8, +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1\n Describes the static information of illumination device type MCUV10."] +pub type NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_MCUV10 = _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_MCUV10; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1\n Describes the static information of illum device type GPIO_PWM_RGBW."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_RGBW { + #[doc = " Red drive GPIO pin."] + pub gpioPinRed: NvU8, + #[doc = " Green drive GPIO pin."] + pub gpioPinGreen: NvU8, + #[doc = " Blue drive GPIO pin."] + pub gpioPinBlue: NvU8, + #[doc = " White drive GPIO pin."] + pub gpioPinWhite: NvU8, +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1\n Describes the static information of illum device type GPIO_PWM_RGBW."] +pub type NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_RGBW = + _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_RGBW; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1\n Describes the static information of illum device type GPIO_PWM_SINGLE_COLOR."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_SINGLE_COLOR { + #[doc = " Single Color GPIO pin."] + pub gpioPinSingleColor: NvU8, +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1\n Describes the static information of illum device type GPIO_PWM_SINGLE_COLOR."] +pub type NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_SINGLE_COLOR = + _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_SINGLE_COLOR; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1 { + #[doc = " Type of the illumination device."] + pub type_: NV_GPU_CLIENT_ILLUM_DEVICE_TYPE, + #[doc = " Supported control modes for this illumination device."] + pub ctrlModeMask: NvU32, + pub data: _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1__bindgen_ty_1, + #[doc = " Reserved for future."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Union of illumination device info data. Interpreted as per\n @ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1::type"] +#[repr(C)] +#[derive(Copy, Clone)] +pub union _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1__bindgen_ty_1 { + pub mcuv10: NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_MCUV10, + pub gpioPwmRgbwv10: NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_RGBW, + pub gpioPwmSingleColorv10: NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_SINGLE_COLOR, + #[doc = " Reserved bytes for possible future extension of this struct."] + pub rsvd: [NvU8; 64usize], +} +pub type NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1 = _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_PARAMS_V1 { + #[doc = " Version of structure. Must always be first member."] + pub version: NvU32, + #[doc = " Number of illumination devices present."] + pub numIllumDevices: NvU32, + #[doc = " Reserved bytes for possible future extension of this struct."] + pub rsvd: [NvU8; 64usize], + pub devices: [NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1; 32usize], +} +pub type NV_GPU_CLIENT_ILLUM_DEVICE_INFO_PARAMS_V1 = _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_PARAMS_V1; +pub type NV_GPU_CLIENT_ILLUM_DEVICE_INFO_PARAMS = NV_GPU_CLIENT_ILLUM_DEVICE_INFO_PARAMS_V1; +#[doc = " Structure representing the data required for synchronization."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_CLIENT_ILLUM_DEVICE_SYNC_V1 { + #[doc = " Boolean representing the need for synchronization."] + pub bSync: NvBool, + #[doc = " Time stamp value required for synchronization."] + pub timeStampms: NvU64, + #[doc = " Reserved for future."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Structure representing the device control parameters of each ILLUM_DEVICE."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_V1 { + #[doc = " Type of the illum device."] + pub type_: NV_GPU_CLIENT_ILLUM_DEVICE_TYPE, + #[doc = " Structure containing the synchronization data for the illumination device."] + pub syncData: NV_GPU_CLIENT_ILLUM_DEVICE_SYNC_V1, + #[doc = " Reserved for future."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Structure representing the device control parameters of each ILLUM_DEVICE."] +pub type NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL = NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_V1; +#[doc = " Structure representing the control parameters of ILLUM_DEVICE-s."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_PARAMS_V1 { + #[doc = " Version of structure. Must always be first member."] + pub version: NvU32, + #[doc = " Number of illumination devices present."] + pub numIllumDevices: NvU32, + #[doc = " Reserved bytes for possible future extension of this struct."] + pub rsvd: [NvU8; 64usize], + pub devices: [NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_V1; 32usize], +} +#[doc = " Structure representing the control parameters of ILLUM_DEVICE-s."] +pub type NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_PARAMS = NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_PARAMS_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGB { + pub rsvd: NvU8, +} +pub type NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGB = _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGB; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1\n Describes the static information of illum zone type RGBW."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGBW { + pub rsvd: NvU8, +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1\n Describes the static information of illum zone type RGBW."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGBW = _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGBW; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1\n Describes the static information of illum zone type SINGLE_COLOR."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_SINGLE_COLOR { + pub rsvd: NvU8, +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1\n Describes the static information of illum zone type SINGLE_COLOR."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_SINGLE_COLOR = + _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_SINGLE_COLOR; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1 { + pub type_: NV_GPU_CLIENT_ILLUM_ZONE_TYPE, + #[doc = " Index pointing to an Illumination Device that controls this zone."] + pub illumDeviceIdx: NvU8, + #[doc = " Provider index for representing logical to physical zone mapping."] + pub provIdx: NvU8, + #[doc = " Location of the zone on the board."] + pub zoneLocation: NV_GPU_CLIENT_ILLUM_ZONE_LOCATION, + pub data: _NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1__bindgen_ty_1, + pub rsvd: [NvU8; 64usize], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union _NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1__bindgen_ty_1 { + pub rgb: NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGB, + pub rgbw: NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGBW, + pub singleColor: NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_SINGLE_COLOR, + #[doc = " Reserved bytes for possible future extension of this struct."] + pub rsvd: [NvU8; 64usize], +} +pub type NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1 = _NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_INFO_PARAMS_V1 { + #[doc = " Version of structure. Must always be first member."] + pub version: NvU32, + #[doc = " Number of illumination zones present."] + pub numIllumZones: NvU32, + #[doc = " Reserved bytes for possible future extension of this struct."] + pub rsvd: [NvU8; 64usize], + pub zones: [NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1; 32usize], +} +pub type NV_GPU_CLIENT_ILLUM_ZONE_INFO_PARAMS_V1 = _NV_GPU_CLIENT_ILLUM_ZONE_INFO_PARAMS_V1; +pub type NV_GPU_CLIENT_ILLUM_ZONE_INFO_PARAMS = NV_GPU_CLIENT_ILLUM_ZONE_INFO_PARAMS_V1; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB\n Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB_PARAMS { + #[doc = " Red compenent of color applied to the zone."] + pub colorR: NvU8, + #[doc = " Green compenent of color applied to the zone."] + pub colorG: NvU8, + #[doc = " Blue compenent of color applied to the zone."] + pub colorB: NvU8, + #[doc = " Brightness perecentage value of the zone."] + pub brightnessPct: NvU8, +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB\n Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB_PARAMS = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB_PARAMS; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB { + #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] + pub rgbParams: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB_PARAMS, +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB; +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR { + #[doc = " Type of cycle effect to apply."] + pub cycleType: NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE, + #[doc = " Number of times to repeat function within group period."] + pub grpCount: NvU8, + #[doc = " Time in ms to transition from color A to color B."] + pub riseTimems: NvU16, + #[doc = " Time in ms to transition from color B to color A."] + pub fallTimems: NvU16, + #[doc = " Time in ms to remain at color A before color A to color B transition."] + pub ATimems: NvU16, + #[doc = " Time in ms to remain at color B before color B to color A transition."] + pub BTimems: NvU16, + #[doc = " Time in ms to remain idle before next group of repeated function cycles."] + pub grpIdleTimems: NvU16, + #[doc = " Time in ms to offset the cycle relative to other zones."] + pub phaseOffsetms: NvU16, +} +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB { + #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] + pub rgbParams: [NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB_PARAMS; 2usize], + pub piecewiseLinearData: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR, +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illumination zone of type\n \\ref NV_GPU_CLIENT_ILLUM_ZONE_TYPE_RGB."] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB { + pub data: _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB__bindgen_ty_1, + #[doc = " Reserved for future."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Union of illumination zone control data for zone of type NV_GPU_CLIENT_ILLUM_ZONE_TYPE_RGB.\n Interpreted as per ctrlMode."] +#[repr(C)] +#[derive(Copy, Clone)] +pub union _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB__bindgen_ty_1 { + pub manualRGB: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB, + pub piecewiseLinearRGB: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB, + #[doc = " Reserved bytes for possible future extension of this struct."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illumination zone of type\n \\ref NV_GPU_CLIENT_ILLUM_ZONE_TYPE_RGB."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB = _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB; +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED\n Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_RGB."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED_PARAMS { + #[doc = " Brightness percentage value of the zone."] + pub brightnessPct: NvU8, +} +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED\n Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_RGB."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED_PARAMS = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED_PARAMS; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED { + #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] + pub colorFixedParams: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED_PARAMS, +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_COLOR_FIXED { + #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] + pub colorFixedParams: [NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED_PARAMS; 2usize], + pub piecewiseLinearData: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR, +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_COLOR_FIXED = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_COLOR_FIXED; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illum zone of type\n \\ref NV_GPU_CLIENT_ILLUM_ZONE_TYPE_COLOR_FIXED."] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED { + pub data: _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED__bindgen_ty_1, + #[doc = " Reserved for future."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Union of illum zone control data for zone of type NV_GPU_CLIENT_ILLUM_ZONE_TYPE_COLOR_FIXED.\n Interpreted as per ctrlMode."] +#[repr(C)] +#[derive(Copy, Clone)] +pub union _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED__bindgen_ty_1 { + pub manualColorFixed: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED, + pub piecewiseLinearColorFixed: + NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_COLOR_FIXED, + #[doc = " Reserved bytes for possible future extension of this struct."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illum zone of type\n \\ref NV_GPU_CLIENT_ILLUM_ZONE_TYPE_COLOR_FIXED."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW\n Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGBW."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW_PARAMS { + #[doc = " Red component of color applied to the zone."] + pub colorR: NvU8, + #[doc = " Green component of color applied to the zone."] + pub colorG: NvU8, + #[doc = " Blue component of color applied to the zone."] + pub colorB: NvU8, + #[doc = " White component of color applied to the zone."] + pub colorW: NvU8, + #[doc = " Brightness percentage value of the zone."] + pub brightnessPct: NvU8, +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW\n Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGBW."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW_PARAMS = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW_PARAMS; +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_RGBW\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_RGBW."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW { + #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_RGBW."] + pub rgbwParams: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW_PARAMS, +} +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_RGBW\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_RGBW."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW; +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_RGBW\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGBW."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGBW { + #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGBW."] + pub rgbwParams: [NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW_PARAMS; 2usize], + pub piecewiseLinearData: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR, +} +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_RGBW\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGBW."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGBW = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGBW; +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illum zone of type\n \\ref NV_GPU_ILLUM_ZONE_TYPE_RGBW."] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW { + pub data: _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW__bindgen_ty_1, + #[doc = " Reserved for future."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Union of illum zone control data for zone of type NV_GPU_ILLUM_ZONE_TYPE_RGBW.\n Interpreted as per ctrlMode."] +#[repr(C)] +#[derive(Copy, Clone)] +pub union _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW__bindgen_ty_1 { + pub manualRGBW: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW, + pub piecewiseLinearRGBW: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGBW, + #[doc = " Reserved bytes for possible future extension of this struct."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illum zone of type\n \\ref NV_GPU_ILLUM_ZONE_TYPE_RGBW."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW = _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW; +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR\n Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_SINGLE_COLOR."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR_PARAMS { + #[doc = " Brightness percentage value of the zone."] + pub brightnessPct: NvU8, +} +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR\n Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_SINGLE_COLOR."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR_PARAMS = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR_PARAMS; +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_SINGLE_COLOR."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR { + #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_SINGLE_COLOR."] + pub singleColorParams: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR_PARAMS, +} +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_SINGLE_COLOR."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR; +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_SINGLE_COLOR."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_SINGLE_COLOR { + #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_SINGLE_COLOR."] + pub singleColorParams: + [NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR_PARAMS; 2usize], + pub piecewiseLinearData: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR, +} +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_SINGLE_COLOR."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_SINGLE_COLOR = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_SINGLE_COLOR; +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illum zone of type\n \\ref NV_GPU_ILLUM_ZONE_TYPE_SINGLE_COLOR."] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR { + pub data: _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR__bindgen_ty_1, + #[doc = " Reserved for future."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Union of illum zone control data for zone of type NV_GPU_ILLUM_ZONE_TYPE_SINGLE_COLOR.\n Interpreted as per ctrlMode."] +#[repr(C)] +#[derive(Copy, Clone)] +pub union _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR__bindgen_ty_1 { + pub manualSingleColor: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR, + pub piecewiseLinearSingleColor: + NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_SINGLE_COLOR, + #[doc = " Reserved bytes for possible future extension of this struct."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illum zone of type\n \\ref NV_GPU_ILLUM_ZONE_TYPE_SINGLE_COLOR."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1 { + pub type_: NV_GPU_CLIENT_ILLUM_ZONE_TYPE, + pub ctrlMode: NV_GPU_CLIENT_ILLUM_CTRL_MODE, + pub data: _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1__bindgen_ty_1, + pub rsvd: [NvU8; 64usize], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1__bindgen_ty_1 { + pub rgb: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB, + pub colorFixed: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED, + pub rgbw: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW, + pub singleColor: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR, + pub rsvd: [NvU8; 64usize], +} +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1 = _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS_V1 { + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = " Number of illumination zones present."] + pub numIllumZonesControl: NvU32, + #[doc = " Reserved bytes for possible future extension of this struct."] + pub rsvd: [NvU8; 64usize], + pub zones: [NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1; 32usize], +} +impl _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS_V1 { + #[inline] + pub fn bDefault(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bDefault(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bDefault_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bDefault_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn rsvdField(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_rsvdField(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn rsvdField_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_rsvdField_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bDefault: NvU32, + rsvdField: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bDefault: u32 = unsafe { ::std::mem::transmute(bDefault) }; + bDefault as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let rsvdField: u32 = unsafe { ::std::mem::transmute(rsvdField) }; + rsvdField as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS_V1 = _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS_V1; +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS = NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS_V1; +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_GetDisplayPortInfo()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_DISPLAY_PORT_INFO_V1 { + #[doc = "!< Structure version"] + pub version: NvU32, + #[doc = "!< DPCD version of the monitor"] + pub dpcd_ver: NvU32, + #[doc = "!< Maximum supported link rate"] + pub maxLinkRate: NV_DP_LINK_RATE, + #[doc = "!< Maximum supported lane count"] + pub maxLaneCount: NV_DP_LANE_COUNT, + #[doc = "!< Current link rate"] + pub curLinkRate: NV_DP_LINK_RATE, + #[doc = "!< Current lane count"] + pub curLaneCount: NV_DP_LANE_COUNT, + #[doc = "!< Current color format"] + pub colorFormat: NV_DP_COLOR_FORMAT, + #[doc = "!< Dynamic range"] + pub dynamicRange: NV_DP_DYNAMIC_RANGE, + #[doc = "!< Ignored in RGB space"] + pub colorimetry: NV_DP_COLORIMETRY, + #[doc = "!< Current bit-per-component"] + pub bpc: NV_DP_BPC, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl _NV_DISPLAY_PORT_INFO_V1 { + #[inline] + pub fn isDp(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isDp(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isDp_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isDp_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isInternalDp(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isInternalDp(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isInternalDp_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isInternalDp_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isColorCtrlSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_isColorCtrlSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isColorCtrlSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isColorCtrlSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is6BPCSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_is6BPCSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is6BPCSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is6BPCSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is8BPCSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_is8BPCSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is8BPCSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is8BPCSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is10BPCSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_is10BPCSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is10BPCSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is10BPCSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is12BPCSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } + } + #[inline] + pub fn set_is12BPCSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is12BPCSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 6usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is12BPCSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is16BPCSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } + } + #[inline] + pub fn set_is16BPCSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is16BPCSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 7usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is16BPCSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 7usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isYCrCb420Supported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) } + } + #[inline] + pub fn set_isYCrCb420Supported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isYCrCb420Supported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 8usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isYCrCb420Supported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 8usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isYCrCb422Supported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) } + } + #[inline] + pub fn set_isYCrCb422Supported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(9usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isYCrCb422Supported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 9usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isYCrCb422Supported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 9usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isYCrCb444Supported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) } + } + #[inline] + pub fn set_isYCrCb444Supported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(10usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isYCrCb444Supported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 10usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isYCrCb444Supported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 10usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isRgb444SupportedOnCurrentMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) } + } + #[inline] + pub fn set_isRgb444SupportedOnCurrentMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(11usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isRgb444SupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 11usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isRgb444SupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 11usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isYCbCr444SupportedOnCurrentMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) } + } + #[inline] + pub fn set_isYCbCr444SupportedOnCurrentMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(12usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isYCbCr444SupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 12usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isYCbCr444SupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 12usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isYCbCr422SupportedOnCurrentMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) } + } + #[inline] + pub fn set_isYCbCr422SupportedOnCurrentMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(13usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isYCbCr422SupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 13usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isYCbCr422SupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 13usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isYCbCr420SupportedOnCurrentMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) } + } + #[inline] + pub fn set_isYCbCr420SupportedOnCurrentMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(14usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isYCbCr420SupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 14usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isYCbCr420SupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 14usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is6BPCSupportedOnCurrentMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) } + } + #[inline] + pub fn set_is6BPCSupportedOnCurrentMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(15usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is6BPCSupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 15usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is6BPCSupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 15usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is8BPCSupportedOnCurrentMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) } + } + #[inline] + pub fn set_is8BPCSupportedOnCurrentMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(16usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is8BPCSupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 16usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is8BPCSupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 16usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is10BPCSupportedOnCurrentMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) } + } + #[inline] + pub fn set_is10BPCSupportedOnCurrentMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(17usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is10BPCSupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 17usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is10BPCSupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 17usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is12BPCSupportedOnCurrentMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) } + } + #[inline] + pub fn set_is12BPCSupportedOnCurrentMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(18usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is12BPCSupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 18usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is12BPCSupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 18usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is16BPCSupportedOnCurrentMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u32) } + } + #[inline] + pub fn set_is16BPCSupportedOnCurrentMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(19usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is16BPCSupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 19usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is16BPCSupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 19usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonxvYCC601Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonxvYCC601Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(20usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonxvYCC601Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 20usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonxvYCC601Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 20usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonxvYCC709Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonxvYCC709Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(21usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonxvYCC709Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 21usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonxvYCC709Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 21usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonsYCC601Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonsYCC601Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(22usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonsYCC601Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 22usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonsYCC601Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 22usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonAdobeYCC601Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonAdobeYCC601Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(23usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonAdobeYCC601Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 23usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonAdobeYCC601Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 23usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonAdobeRGBCapable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonAdobeRGBCapable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(24usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonAdobeRGBCapable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 24usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonAdobeRGBCapable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 24usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonBT2020RGBCapable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonBT2020RGBCapable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(25usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonBT2020RGBCapable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 25usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonBT2020RGBCapable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 25usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonBT2020YCCCapable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonBT2020YCCCapable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(26usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonBT2020YCCCapable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 26usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonBT2020YCCCapable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 26usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonBT2020cYCCCapable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonBT2020cYCCCapable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(27usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonBT2020cYCCCapable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 27usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonBT2020cYCCCapable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 27usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 4u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(28usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 28usize, + 4u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 28usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isDp: NvU32, + isInternalDp: NvU32, + isColorCtrlSupported: NvU32, + is6BPCSupported: NvU32, + is8BPCSupported: NvU32, + is10BPCSupported: NvU32, + is12BPCSupported: NvU32, + is16BPCSupported: NvU32, + isYCrCb420Supported: NvU32, + isYCrCb422Supported: NvU32, + isYCrCb444Supported: NvU32, + isRgb444SupportedOnCurrentMode: NvU32, + isYCbCr444SupportedOnCurrentMode: NvU32, + isYCbCr422SupportedOnCurrentMode: NvU32, + isYCbCr420SupportedOnCurrentMode: NvU32, + is6BPCSupportedOnCurrentMode: NvU32, + is8BPCSupportedOnCurrentMode: NvU32, + is10BPCSupportedOnCurrentMode: NvU32, + is12BPCSupportedOnCurrentMode: NvU32, + is16BPCSupportedOnCurrentMode: NvU32, + isMonxvYCC601Capable: NvU32, + isMonxvYCC709Capable: NvU32, + isMonsYCC601Capable: NvU32, + isMonAdobeYCC601Capable: NvU32, + isMonAdobeRGBCapable: NvU32, + isMonBT2020RGBCapable: NvU32, + isMonBT2020YCCCapable: NvU32, + isMonBT2020cYCCCapable: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isDp: u32 = unsafe { ::std::mem::transmute(isDp) }; + isDp as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isInternalDp: u32 = unsafe { ::std::mem::transmute(isInternalDp) }; + isInternalDp as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let isColorCtrlSupported: u32 = unsafe { ::std::mem::transmute(isColorCtrlSupported) }; + isColorCtrlSupported as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let is6BPCSupported: u32 = unsafe { ::std::mem::transmute(is6BPCSupported) }; + is6BPCSupported as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let is8BPCSupported: u32 = unsafe { ::std::mem::transmute(is8BPCSupported) }; + is8BPCSupported as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let is10BPCSupported: u32 = unsafe { ::std::mem::transmute(is10BPCSupported) }; + is10BPCSupported as u64 + }); + __bindgen_bitfield_unit.set(6usize, 1u8, { + let is12BPCSupported: u32 = unsafe { ::std::mem::transmute(is12BPCSupported) }; + is12BPCSupported as u64 + }); + __bindgen_bitfield_unit.set(7usize, 1u8, { + let is16BPCSupported: u32 = unsafe { ::std::mem::transmute(is16BPCSupported) }; + is16BPCSupported as u64 + }); + __bindgen_bitfield_unit.set(8usize, 1u8, { + let isYCrCb420Supported: u32 = unsafe { ::std::mem::transmute(isYCrCb420Supported) }; + isYCrCb420Supported as u64 + }); + __bindgen_bitfield_unit.set(9usize, 1u8, { + let isYCrCb422Supported: u32 = unsafe { ::std::mem::transmute(isYCrCb422Supported) }; + isYCrCb422Supported as u64 + }); + __bindgen_bitfield_unit.set(10usize, 1u8, { + let isYCrCb444Supported: u32 = unsafe { ::std::mem::transmute(isYCrCb444Supported) }; + isYCrCb444Supported as u64 + }); + __bindgen_bitfield_unit.set(11usize, 1u8, { + let isRgb444SupportedOnCurrentMode: u32 = + unsafe { ::std::mem::transmute(isRgb444SupportedOnCurrentMode) }; + isRgb444SupportedOnCurrentMode as u64 + }); + __bindgen_bitfield_unit.set(12usize, 1u8, { + let isYCbCr444SupportedOnCurrentMode: u32 = + unsafe { ::std::mem::transmute(isYCbCr444SupportedOnCurrentMode) }; + isYCbCr444SupportedOnCurrentMode as u64 + }); + __bindgen_bitfield_unit.set(13usize, 1u8, { + let isYCbCr422SupportedOnCurrentMode: u32 = + unsafe { ::std::mem::transmute(isYCbCr422SupportedOnCurrentMode) }; + isYCbCr422SupportedOnCurrentMode as u64 + }); + __bindgen_bitfield_unit.set(14usize, 1u8, { + let isYCbCr420SupportedOnCurrentMode: u32 = + unsafe { ::std::mem::transmute(isYCbCr420SupportedOnCurrentMode) }; + isYCbCr420SupportedOnCurrentMode as u64 + }); + __bindgen_bitfield_unit.set(15usize, 1u8, { + let is6BPCSupportedOnCurrentMode: u32 = + unsafe { ::std::mem::transmute(is6BPCSupportedOnCurrentMode) }; + is6BPCSupportedOnCurrentMode as u64 + }); + __bindgen_bitfield_unit.set(16usize, 1u8, { + let is8BPCSupportedOnCurrentMode: u32 = + unsafe { ::std::mem::transmute(is8BPCSupportedOnCurrentMode) }; + is8BPCSupportedOnCurrentMode as u64 + }); + __bindgen_bitfield_unit.set(17usize, 1u8, { + let is10BPCSupportedOnCurrentMode: u32 = + unsafe { ::std::mem::transmute(is10BPCSupportedOnCurrentMode) }; + is10BPCSupportedOnCurrentMode as u64 + }); + __bindgen_bitfield_unit.set(18usize, 1u8, { + let is12BPCSupportedOnCurrentMode: u32 = + unsafe { ::std::mem::transmute(is12BPCSupportedOnCurrentMode) }; + is12BPCSupportedOnCurrentMode as u64 + }); + __bindgen_bitfield_unit.set(19usize, 1u8, { + let is16BPCSupportedOnCurrentMode: u32 = + unsafe { ::std::mem::transmute(is16BPCSupportedOnCurrentMode) }; + is16BPCSupportedOnCurrentMode as u64 + }); + __bindgen_bitfield_unit.set(20usize, 1u8, { + let isMonxvYCC601Capable: u32 = unsafe { ::std::mem::transmute(isMonxvYCC601Capable) }; + isMonxvYCC601Capable as u64 + }); + __bindgen_bitfield_unit.set(21usize, 1u8, { + let isMonxvYCC709Capable: u32 = unsafe { ::std::mem::transmute(isMonxvYCC709Capable) }; + isMonxvYCC709Capable as u64 + }); + __bindgen_bitfield_unit.set(22usize, 1u8, { + let isMonsYCC601Capable: u32 = unsafe { ::std::mem::transmute(isMonsYCC601Capable) }; + isMonsYCC601Capable as u64 + }); + __bindgen_bitfield_unit.set(23usize, 1u8, { + let isMonAdobeYCC601Capable: u32 = + unsafe { ::std::mem::transmute(isMonAdobeYCC601Capable) }; + isMonAdobeYCC601Capable as u64 + }); + __bindgen_bitfield_unit.set(24usize, 1u8, { + let isMonAdobeRGBCapable: u32 = unsafe { ::std::mem::transmute(isMonAdobeRGBCapable) }; + isMonAdobeRGBCapable as u64 + }); + __bindgen_bitfield_unit.set(25usize, 1u8, { + let isMonBT2020RGBCapable: u32 = + unsafe { ::std::mem::transmute(isMonBT2020RGBCapable) }; + isMonBT2020RGBCapable as u64 + }); + __bindgen_bitfield_unit.set(26usize, 1u8, { + let isMonBT2020YCCCapable: u32 = + unsafe { ::std::mem::transmute(isMonBT2020YCCCapable) }; + isMonBT2020YCCCapable as u64 + }); + __bindgen_bitfield_unit.set(27usize, 1u8, { + let isMonBT2020cYCCCapable: u32 = + unsafe { ::std::mem::transmute(isMonBT2020cYCCCapable) }; + isMonBT2020cYCCCapable as u64 + }); + __bindgen_bitfield_unit.set(28usize, 4u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_GetDisplayPortInfo()."] +pub type NV_DISPLAY_PORT_INFO_V1 = _NV_DISPLAY_PORT_INFO_V1; +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_GetDisplayPortInfo()."] +pub type NV_DISPLAY_PORT_INFO = NV_DISPLAY_PORT_INFO_V1; +#[doc = "! \\ingroup dispcontrol\n! DisplayPort configuration settings - used in NvAPI_SetDisplayPort()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_DISPLAY_PORT_CONFIG { + #[doc = "!< Structure version - 2 is the latest"] + pub version: NvU32, + #[doc = "!< Link rate"] + pub linkRate: NV_DP_LINK_RATE, + #[doc = "!< Lane count"] + pub laneCount: NV_DP_LANE_COUNT, + #[doc = "!< Color format to set"] + pub colorFormat: NV_DP_COLOR_FORMAT, + #[doc = "!< Dynamic range"] + pub dynamicRange: NV_DP_DYNAMIC_RANGE, + #[doc = "!< Ignored in RGB space"] + pub colorimetry: NV_DP_COLORIMETRY, + #[doc = "!< Bit-per-component"] + pub bpc: NV_DP_BPC, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +impl NV_DISPLAY_PORT_CONFIG { + #[inline] + pub fn isHPD(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isHPD(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isHPD_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isHPD_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isSetDeferred(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isSetDeferred(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isSetDeferred_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isSetDeferred_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isChromaLpfOff(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_isChromaLpfOff(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isChromaLpfOff_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isChromaLpfOff_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isDitherOff(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_isDitherOff(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isDitherOff_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isDitherOff_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn testLinkTrain(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_testLinkTrain(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn testLinkTrain_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_testLinkTrain_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn testColorChange(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_testColorChange(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn testColorChange_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_testColorChange_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isHPD: NvU32, + isSetDeferred: NvU32, + isChromaLpfOff: NvU32, + isDitherOff: NvU32, + testLinkTrain: NvU32, + testColorChange: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isHPD: u32 = unsafe { ::std::mem::transmute(isHPD) }; + isHPD as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isSetDeferred: u32 = unsafe { ::std::mem::transmute(isSetDeferred) }; + isSetDeferred as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let isChromaLpfOff: u32 = unsafe { ::std::mem::transmute(isChromaLpfOff) }; + isChromaLpfOff as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let isDitherOff: u32 = unsafe { ::std::mem::transmute(isDitherOff) }; + isDitherOff as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let testLinkTrain: u32 = unsafe { ::std::mem::transmute(testLinkTrain) }; + testLinkTrain as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let testColorChange: u32 = unsafe { ::std::mem::transmute(testColorChange) }; + testColorChange as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_GetHDMISupportInfo()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDMI_SUPPORT_INFO_V1 { + #[doc = "!< Structure version"] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Revision number of the EDID 861 extension"] + pub EDID861ExtRev: NvU32, +} +impl _NV_HDMI_SUPPORT_INFO_V1 { + #[inline] + pub fn isGpuHDMICapable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isGpuHDMICapable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isGpuHDMICapable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isGpuHDMICapable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonUnderscanCapable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonUnderscanCapable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonUnderscanCapable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonUnderscanCapable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonBasicAudioCapable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonBasicAudioCapable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonBasicAudioCapable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonBasicAudioCapable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonYCbCr444Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonYCbCr444Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonYCbCr444Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonYCbCr444Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonYCbCr422Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonYCbCr422Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonYCbCr422Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonYCbCr422Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonxvYCC601Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonxvYCC601Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonxvYCC601Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonxvYCC601Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonxvYCC709Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonxvYCC709Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonxvYCC709Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 6usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonxvYCC709Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonHDMI(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonHDMI(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonHDMI_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 7usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonHDMI_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 7usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 24u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 24u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 8usize, + 24u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 8usize, + 24u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isGpuHDMICapable: NvU32, + isMonUnderscanCapable: NvU32, + isMonBasicAudioCapable: NvU32, + isMonYCbCr444Capable: NvU32, + isMonYCbCr422Capable: NvU32, + isMonxvYCC601Capable: NvU32, + isMonxvYCC709Capable: NvU32, + isMonHDMI: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isGpuHDMICapable: u32 = unsafe { ::std::mem::transmute(isGpuHDMICapable) }; + isGpuHDMICapable as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isMonUnderscanCapable: u32 = + unsafe { ::std::mem::transmute(isMonUnderscanCapable) }; + isMonUnderscanCapable as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let isMonBasicAudioCapable: u32 = + unsafe { ::std::mem::transmute(isMonBasicAudioCapable) }; + isMonBasicAudioCapable as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let isMonYCbCr444Capable: u32 = unsafe { ::std::mem::transmute(isMonYCbCr444Capable) }; + isMonYCbCr444Capable as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let isMonYCbCr422Capable: u32 = unsafe { ::std::mem::transmute(isMonYCbCr422Capable) }; + isMonYCbCr422Capable as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let isMonxvYCC601Capable: u32 = unsafe { ::std::mem::transmute(isMonxvYCC601Capable) }; + isMonxvYCC601Capable as u64 + }); + __bindgen_bitfield_unit.set(6usize, 1u8, { + let isMonxvYCC709Capable: u32 = unsafe { ::std::mem::transmute(isMonxvYCC709Capable) }; + isMonxvYCC709Capable as u64 + }); + __bindgen_bitfield_unit.set(7usize, 1u8, { + let isMonHDMI: u32 = unsafe { ::std::mem::transmute(isMonHDMI) }; + isMonHDMI as u64 + }); + __bindgen_bitfield_unit.set(8usize, 24u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_GetHDMISupportInfo()."] +pub type NV_HDMI_SUPPORT_INFO_V1 = _NV_HDMI_SUPPORT_INFO_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDMI_SUPPORT_INFO_V2 { + #[doc = "!< Structure version"] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Revision number of the EDID 861 extension"] + pub EDID861ExtRev: NvU32, +} +impl _NV_HDMI_SUPPORT_INFO_V2 { + #[inline] + pub fn isGpuHDMICapable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isGpuHDMICapable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isGpuHDMICapable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isGpuHDMICapable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonUnderscanCapable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonUnderscanCapable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonUnderscanCapable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonUnderscanCapable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonBasicAudioCapable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonBasicAudioCapable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonBasicAudioCapable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonBasicAudioCapable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonYCbCr444Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonYCbCr444Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonYCbCr444Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonYCbCr444Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonYCbCr422Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonYCbCr422Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonYCbCr422Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonYCbCr422Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonxvYCC601Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonxvYCC601Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonxvYCC601Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonxvYCC601Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonxvYCC709Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonxvYCC709Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonxvYCC709Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 6usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonxvYCC709Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonHDMI(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonHDMI(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonHDMI_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 7usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonHDMI_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 7usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonsYCC601Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonsYCC601Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonsYCC601Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 8usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonsYCC601Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 8usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonAdobeYCC601Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonAdobeYCC601Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(9usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonAdobeYCC601Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 9usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonAdobeYCC601Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 9usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonAdobeRGBCapable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonAdobeRGBCapable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(10usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonAdobeRGBCapable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 10usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonAdobeRGBCapable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 10usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 21u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(11usize, 21u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 11usize, + 21u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 11usize, + 21u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isGpuHDMICapable: NvU32, + isMonUnderscanCapable: NvU32, + isMonBasicAudioCapable: NvU32, + isMonYCbCr444Capable: NvU32, + isMonYCbCr422Capable: NvU32, + isMonxvYCC601Capable: NvU32, + isMonxvYCC709Capable: NvU32, + isMonHDMI: NvU32, + isMonsYCC601Capable: NvU32, + isMonAdobeYCC601Capable: NvU32, + isMonAdobeRGBCapable: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isGpuHDMICapable: u32 = unsafe { ::std::mem::transmute(isGpuHDMICapable) }; + isGpuHDMICapable as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isMonUnderscanCapable: u32 = + unsafe { ::std::mem::transmute(isMonUnderscanCapable) }; + isMonUnderscanCapable as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let isMonBasicAudioCapable: u32 = + unsafe { ::std::mem::transmute(isMonBasicAudioCapable) }; + isMonBasicAudioCapable as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let isMonYCbCr444Capable: u32 = unsafe { ::std::mem::transmute(isMonYCbCr444Capable) }; + isMonYCbCr444Capable as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let isMonYCbCr422Capable: u32 = unsafe { ::std::mem::transmute(isMonYCbCr422Capable) }; + isMonYCbCr422Capable as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let isMonxvYCC601Capable: u32 = unsafe { ::std::mem::transmute(isMonxvYCC601Capable) }; + isMonxvYCC601Capable as u64 + }); + __bindgen_bitfield_unit.set(6usize, 1u8, { + let isMonxvYCC709Capable: u32 = unsafe { ::std::mem::transmute(isMonxvYCC709Capable) }; + isMonxvYCC709Capable as u64 + }); + __bindgen_bitfield_unit.set(7usize, 1u8, { + let isMonHDMI: u32 = unsafe { ::std::mem::transmute(isMonHDMI) }; + isMonHDMI as u64 + }); + __bindgen_bitfield_unit.set(8usize, 1u8, { + let isMonsYCC601Capable: u32 = unsafe { ::std::mem::transmute(isMonsYCC601Capable) }; + isMonsYCC601Capable as u64 + }); + __bindgen_bitfield_unit.set(9usize, 1u8, { + let isMonAdobeYCC601Capable: u32 = + unsafe { ::std::mem::transmute(isMonAdobeYCC601Capable) }; + isMonAdobeYCC601Capable as u64 + }); + __bindgen_bitfield_unit.set(10usize, 1u8, { + let isMonAdobeRGBCapable: u32 = unsafe { ::std::mem::transmute(isMonAdobeRGBCapable) }; + isMonAdobeRGBCapable as u64 + }); + __bindgen_bitfield_unit.set(11usize, 21u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_HDMI_SUPPORT_INFO_V2 = _NV_HDMI_SUPPORT_INFO_V2; +pub type NV_HDMI_SUPPORT_INFO = NV_HDMI_SUPPORT_INFO_V2; +#[doc = "!< Returns the fields in the infoframe with values set by the manufacturer - NVIDIA/OEM."] +pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_GET_DEFAULT: NV_INFOFRAME_CMD = 0; +#[doc = "!< Sets the fields in the infoframe to auto, and infoframe to the default infoframe for use in a set."] +pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_RESET: NV_INFOFRAME_CMD = 1; +#[doc = "!< Get the current infoframe state."] +pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_GET: NV_INFOFRAME_CMD = 2; +#[doc = "!< Set the current infoframe state (flushed to the monitor), the values are one time and do not persist."] +pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_SET: NV_INFOFRAME_CMD = 3; +#[doc = "!< Get the override infoframe state, non-override fields will be set to value = AUTO, overridden fields will have the current override values."] +pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_GET_OVERRIDE: NV_INFOFRAME_CMD = 4; +#[doc = "!< Set the override infoframe state, non-override fields will be set to value = AUTO, other values indicate override; persist across modeset/reboot"] +pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_SET_OVERRIDE: NV_INFOFRAME_CMD = 5; +#[doc = "!< get properties associated with infoframe (each of the infoframe type will have properties)"] +pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_GET_PROPERTY: NV_INFOFRAME_CMD = 6; +#[doc = "!< set properties associated with infoframe"] +pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_SET_PROPERTY: NV_INFOFRAME_CMD = 7; +#[doc = "! \\ingroup dispcontrol"] +pub type NV_INFOFRAME_CMD = ::std::os::raw::c_int; +#[doc = "!< Driver determines whether to send infoframes."] +pub const NV_INFOFRAME_PROPERTY_MODE_NV_INFOFRAME_PROPERTY_MODE_AUTO: NV_INFOFRAME_PROPERTY_MODE = + 0; +#[doc = "!< Driver always sends infoframe."] +pub const NV_INFOFRAME_PROPERTY_MODE_NV_INFOFRAME_PROPERTY_MODE_ENABLE: NV_INFOFRAME_PROPERTY_MODE = + 1; +#[doc = "!< Driver never sends infoframe."] +pub const NV_INFOFRAME_PROPERTY_MODE_NV_INFOFRAME_PROPERTY_MODE_DISABLE: + NV_INFOFRAME_PROPERTY_MODE = 2; +#[doc = "!< Driver only sends infoframe when client requests it via infoframe escape call."] +pub const NV_INFOFRAME_PROPERTY_MODE_NV_INFOFRAME_PROPERTY_MODE_ALLOW_OVERRIDE: + NV_INFOFRAME_PROPERTY_MODE = 3; +pub type NV_INFOFRAME_PROPERTY_MODE = ::std::os::raw::c_int; +pub const NV_INFOFRAME_PROPERTY_BLACKLIST_NV_INFOFRAME_PROPERTY_BLACKLIST_FALSE: + NV_INFOFRAME_PROPERTY_BLACKLIST = 0; +pub const NV_INFOFRAME_PROPERTY_BLACKLIST_NV_INFOFRAME_PROPERTY_BLACKLIST_TRUE: + NV_INFOFRAME_PROPERTY_BLACKLIST = 1; +#[doc = "! Returns whether the current monitor is in blacklist or force this monitor to be in blacklist."] +pub type NV_INFOFRAME_PROPERTY_BLACKLIST = ::std::os::raw::c_int; +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct NV_INFOFRAME_PROPERTY { + pub _bitfield_align_1: [u16; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl NV_INFOFRAME_PROPERTY { + #[inline] + pub fn mode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32) } + } + #[inline] + pub fn set_mode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn mode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 4u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_mode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn blackList(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 2u8) as u32) } + } + #[inline] + pub fn set_blackList(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn blackList_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_blackList_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 10u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 10u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 6usize, + 10u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 10u8, + val as u64, + ) + } + } + #[inline] + pub fn version(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 8u8) as u32) } + } + #[inline] + pub fn set_version(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(16usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn version_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 16usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_version_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 16usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn length(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u32) } + } + #[inline] + pub fn set_length(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(24usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn length_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 24usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_length_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 24usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + mode: NvU32, + blackList: NvU32, + reserved: NvU32, + version: NvU32, + length: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 4u8, { + let mode: u32 = unsafe { ::std::mem::transmute(mode) }; + mode as u64 + }); + __bindgen_bitfield_unit.set(4usize, 2u8, { + let blackList: u32 = unsafe { ::std::mem::transmute(blackList) }; + blackList as u64 + }); + __bindgen_bitfield_unit.set(6usize, 10u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit.set(16usize, 8u8, { + let version: u32 = unsafe { ::std::mem::transmute(version) }; + version as u64 + }); + __bindgen_bitfield_unit.set(24usize, 8u8, { + let length: u32 = unsafe { ::std::mem::transmute(length) }; + length as u64 + }); + __bindgen_bitfield_unit + } +} +pub const NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_NODATA: + NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO = 0; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_OVERSCAN: + NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO = 1; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_UNDERSCAN: + NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO = 2; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_FUTURE: + NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO = 3; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_AUTO: + NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO = 7; +#[doc = "! Byte1 related"] +pub type NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_NOT_PRESENT: + NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA = 0; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_VERTICAL_PRESENT : NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_HORIZONTAL_PRESENT : NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_BOTH_PRESENT: + NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA = 3; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_AUTO: + NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA = 7; +pub type NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO_NV_INFOFRAME_FIELD_VALUE_AVI_AFI_ABSENT: + NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO = 0; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO_NV_INFOFRAME_FIELD_VALUE_AVI_AFI_PRESENT: + NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO = 1; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO_NV_INFOFRAME_FIELD_VALUE_AVI_AFI_AUTO: + NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO = 3; +pub type NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_RGB: + NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT = 0; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_YCbCr422 : NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_YCbCr444 : NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_FUTURE : NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_AUTO: + NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT = 7; +pub type NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_F17_NV_INFOFRAME_FIELD_VALUE_AVI_F17_FALSE: + NV_INFOFRAME_FIELD_VALUE_AVI_F17 = 0; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_F17_NV_INFOFRAME_FIELD_VALUE_AVI_F17_TRUE: + NV_INFOFRAME_FIELD_VALUE_AVI_F17 = 1; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_F17_NV_INFOFRAME_FIELD_VALUE_AVI_F17_AUTO: + NV_INFOFRAME_FIELD_VALUE_AVI_F17 = 3; +pub type NV_INFOFRAME_FIELD_VALUE_AVI_F17 = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NO_AFD : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE01 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE02 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE03 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_LETTERBOX_GT16x9 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 4 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE05 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 5 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE06 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 6 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE07 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 7 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_EQUAL_CODEDFRAME : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 8 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_CENTER_4x3 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 9 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_CENTER_16x9 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 10 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_CENTER_14x9 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 11 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE12 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 12 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_4x3_ON_14x9 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 13 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_16x9_ON_14x9 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 14 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_16x9_ON_4x3 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 15 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 31 ; +#[doc = "! Byte2 related"] +pub type NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_NO_DATA : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_4x3 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_16x9 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_FUTURE : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME = 7 ; +pub type NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_NO_DATA : NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_SMPTE_170M : NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_ITUR_BT709 : NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_USE_EXTENDED_COLORIMETRY : NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_AUTO: + NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY = 7; +pub type NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_NO_DATA : NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_HORIZONTAL : NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_VERTICAL : NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_BOTH : NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING = 7 ; +#[doc = "! Byte 3 related"] +pub type NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_DEFAULT : NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_LIMITED_RANGE : NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_FULL_RANGE : NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_RESERVED : NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION = 7 ; +pub type NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_XVYCC601 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_XVYCC709 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_SYCC601 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_ADOBEYCC601 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_ADOBERGB : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 4 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_RESERVED05 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 5 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_RESERVED06 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 6 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_RESERVED07 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 7 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 15 ; +pub type NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ITC_NV_INFOFRAME_FIELD_VALUE_AVI_ITC_VIDEO_CONTENT: + NV_INFOFRAME_FIELD_VALUE_AVI_ITC = 0; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ITC_NV_INFOFRAME_FIELD_VALUE_AVI_ITC_ITCONTENT: + NV_INFOFRAME_FIELD_VALUE_AVI_ITC = 1; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ITC_NV_INFOFRAME_FIELD_VALUE_AVI_ITC_AUTO: + NV_INFOFRAME_FIELD_VALUE_AVI_ITC = 3; +pub type NV_INFOFRAME_FIELD_VALUE_AVI_ITC = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NONE : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X02 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X03 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X04 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X05 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 4 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X06 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 5 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X07 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 6 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X08 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 7 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X09 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 8 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X10 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 9 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED10 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 10 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED11 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 11 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED12 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 12 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED13 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 13 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED14 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 14 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED15 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 15 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 31 ; +#[doc = "! Byte 4 related"] +pub type NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_GRAPHICS : NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_PHOTO : NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_CINEMA : NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_GAME: + NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE = 3; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_AUTO: + NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE = 7; +pub type NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_LIMITED_RANGE : NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_FULL_RANGE : NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_RESERVED02 : NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_RESERVED03 : NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION = 7 ; +pub type NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION = ::std::os::raw::c_int; +#[doc = "! Adding an Auto bit to each field"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_INFOFRAME_VIDEO { + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 23usize]>, +} +impl NV_INFOFRAME_VIDEO { + #[inline] + pub fn vic(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) } + } + #[inline] + pub fn set_vic(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn vic_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_vic_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn pixelRepeat(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 5u8) as u32) } + } + #[inline] + pub fn set_pixelRepeat(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 5u8, val as u64) + } + } + #[inline] + pub unsafe fn pixelRepeat_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 8usize, + 5u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_pixelRepeat_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 8usize, + 5u8, + val as u64, + ) + } + } + #[inline] + pub fn colorSpace(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 3u8) as u32) } + } + #[inline] + pub fn set_colorSpace(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(13usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn colorSpace_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 13usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_colorSpace_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 13usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn colorimetry(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 3u8) as u32) } + } + #[inline] + pub fn set_colorimetry(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(16usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn colorimetry_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 16usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_colorimetry_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 16usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn extendedColorimetry(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 4u8) as u32) } + } + #[inline] + pub fn set_extendedColorimetry(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(19usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn extendedColorimetry_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 19usize, + 4u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_extendedColorimetry_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 19usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn rgbQuantizationRange(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 3u8) as u32) } + } + #[inline] + pub fn set_rgbQuantizationRange(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(23usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn rgbQuantizationRange_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 23usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_rgbQuantizationRange_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 23usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn yccQuantizationRange(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 3u8) as u32) } + } + #[inline] + pub fn set_yccQuantizationRange(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(26usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn yccQuantizationRange_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 26usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_yccQuantizationRange_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 26usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn itContent(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 2u8) as u32) } + } + #[inline] + pub fn set_itContent(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(29usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn itContent_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 29usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_itContent_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 29usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn contentTypes(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 3u8) as u32) } + } + #[inline] + pub fn set_contentTypes(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(32usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn contentTypes_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 32usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_contentTypes_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 32usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn scanInfo(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(35usize, 3u8) as u32) } + } + #[inline] + pub fn set_scanInfo(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(35usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn scanInfo_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 35usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_scanInfo_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 35usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn activeFormatInfoPresent(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(38usize, 2u8) as u32) } + } + #[inline] + pub fn set_activeFormatInfoPresent(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(38usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn activeFormatInfoPresent_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 38usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_activeFormatInfoPresent_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 38usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn activeFormatAspectRatio(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(40usize, 5u8) as u32) } + } + #[inline] + pub fn set_activeFormatAspectRatio(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(40usize, 5u8, val as u64) + } + } + #[inline] + pub unsafe fn activeFormatAspectRatio_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 40usize, + 5u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_activeFormatAspectRatio_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 40usize, + 5u8, + val as u64, + ) + } + } + #[inline] + pub fn picAspectRatio(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(45usize, 3u8) as u32) } + } + #[inline] + pub fn set_picAspectRatio(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(45usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn picAspectRatio_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 45usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_picAspectRatio_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 45usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn nonuniformScaling(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 3u8) as u32) } + } + #[inline] + pub fn set_nonuniformScaling(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(48usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn nonuniformScaling_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 48usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_nonuniformScaling_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 48usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn barInfo(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(51usize, 3u8) as u32) } + } + #[inline] + pub fn set_barInfo(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(51usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn barInfo_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 51usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_barInfo_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 51usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn top_bar(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(64usize, 17u8) as u32) } + } + #[inline] + pub fn set_top_bar(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(64usize, 17u8, val as u64) + } + } + #[inline] + pub unsafe fn top_bar_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 64usize, + 17u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_top_bar_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 64usize, + 17u8, + val as u64, + ) + } + } + #[inline] + pub fn bottom_bar(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(96usize, 17u8) as u32) } + } + #[inline] + pub fn set_bottom_bar(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(96usize, 17u8, val as u64) + } + } + #[inline] + pub unsafe fn bottom_bar_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 96usize, + 17u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bottom_bar_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 96usize, + 17u8, + val as u64, + ) + } + } + #[inline] + pub fn left_bar(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(128usize, 17u8) as u32) } + } + #[inline] + pub fn set_left_bar(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(128usize, 17u8, val as u64) + } + } + #[inline] + pub unsafe fn left_bar_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 128usize, + 17u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_left_bar_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 128usize, + 17u8, + val as u64, + ) + } + } + #[inline] + pub fn right_bar(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(160usize, 17u8) as u32) } + } + #[inline] + pub fn set_right_bar(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(160usize, 17u8, val as u64) + } + } + #[inline] + pub unsafe fn right_bar_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 160usize, + 17u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_right_bar_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 160usize, + 17u8, + val as u64, + ) + } + } + #[inline] + pub fn Future17(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(177usize, 2u8) as u32) } + } + #[inline] + pub fn set_Future17(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(177usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn Future17_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 177usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_Future17_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 177usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn Future47(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(179usize, 2u8) as u32) } + } + #[inline] + pub fn set_Future47(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(179usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn Future47_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 179usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_Future47_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 179usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + vic: NvU32, + pixelRepeat: NvU32, + colorSpace: NvU32, + colorimetry: NvU32, + extendedColorimetry: NvU32, + rgbQuantizationRange: NvU32, + yccQuantizationRange: NvU32, + itContent: NvU32, + contentTypes: NvU32, + scanInfo: NvU32, + activeFormatInfoPresent: NvU32, + activeFormatAspectRatio: NvU32, + picAspectRatio: NvU32, + nonuniformScaling: NvU32, + barInfo: NvU32, + top_bar: NvU32, + bottom_bar: NvU32, + left_bar: NvU32, + right_bar: NvU32, + Future17: NvU32, + Future47: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 23usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 23usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 8u8, { + let vic: u32 = unsafe { ::std::mem::transmute(vic) }; + vic as u64 + }); + __bindgen_bitfield_unit.set(8usize, 5u8, { + let pixelRepeat: u32 = unsafe { ::std::mem::transmute(pixelRepeat) }; + pixelRepeat as u64 + }); + __bindgen_bitfield_unit.set(13usize, 3u8, { + let colorSpace: u32 = unsafe { ::std::mem::transmute(colorSpace) }; + colorSpace as u64 + }); + __bindgen_bitfield_unit.set(16usize, 3u8, { + let colorimetry: u32 = unsafe { ::std::mem::transmute(colorimetry) }; + colorimetry as u64 + }); + __bindgen_bitfield_unit.set(19usize, 4u8, { + let extendedColorimetry: u32 = unsafe { ::std::mem::transmute(extendedColorimetry) }; + extendedColorimetry as u64 + }); + __bindgen_bitfield_unit.set(23usize, 3u8, { + let rgbQuantizationRange: u32 = unsafe { ::std::mem::transmute(rgbQuantizationRange) }; + rgbQuantizationRange as u64 + }); + __bindgen_bitfield_unit.set(26usize, 3u8, { + let yccQuantizationRange: u32 = unsafe { ::std::mem::transmute(yccQuantizationRange) }; + yccQuantizationRange as u64 + }); + __bindgen_bitfield_unit.set(29usize, 2u8, { + let itContent: u32 = unsafe { ::std::mem::transmute(itContent) }; + itContent as u64 + }); + __bindgen_bitfield_unit.set(32usize, 3u8, { + let contentTypes: u32 = unsafe { ::std::mem::transmute(contentTypes) }; + contentTypes as u64 + }); + __bindgen_bitfield_unit.set(35usize, 3u8, { + let scanInfo: u32 = unsafe { ::std::mem::transmute(scanInfo) }; + scanInfo as u64 + }); + __bindgen_bitfield_unit.set(38usize, 2u8, { + let activeFormatInfoPresent: u32 = + unsafe { ::std::mem::transmute(activeFormatInfoPresent) }; + activeFormatInfoPresent as u64 + }); + __bindgen_bitfield_unit.set(40usize, 5u8, { + let activeFormatAspectRatio: u32 = + unsafe { ::std::mem::transmute(activeFormatAspectRatio) }; + activeFormatAspectRatio as u64 + }); + __bindgen_bitfield_unit.set(45usize, 3u8, { + let picAspectRatio: u32 = unsafe { ::std::mem::transmute(picAspectRatio) }; + picAspectRatio as u64 + }); + __bindgen_bitfield_unit.set(48usize, 3u8, { + let nonuniformScaling: u32 = unsafe { ::std::mem::transmute(nonuniformScaling) }; + nonuniformScaling as u64 + }); + __bindgen_bitfield_unit.set(51usize, 3u8, { + let barInfo: u32 = unsafe { ::std::mem::transmute(barInfo) }; + barInfo as u64 + }); + __bindgen_bitfield_unit.set(64usize, 17u8, { + let top_bar: u32 = unsafe { ::std::mem::transmute(top_bar) }; + top_bar as u64 + }); + __bindgen_bitfield_unit.set(96usize, 17u8, { + let bottom_bar: u32 = unsafe { ::std::mem::transmute(bottom_bar) }; + bottom_bar as u64 + }); + __bindgen_bitfield_unit.set(128usize, 17u8, { + let left_bar: u32 = unsafe { ::std::mem::transmute(left_bar) }; + left_bar as u64 + }); + __bindgen_bitfield_unit.set(160usize, 17u8, { + let right_bar: u32 = unsafe { ::std::mem::transmute(right_bar) }; + right_bar as u64 + }); + __bindgen_bitfield_unit.set(177usize, 2u8, { + let Future17: u32 = unsafe { ::std::mem::transmute(Future17) }; + Future17 as u64 + }); + __bindgen_bitfield_unit.set(179usize, 2u8, { + let Future47: u32 = unsafe { ::std::mem::transmute(Future47) }; + Future47 as u64 + }); + __bindgen_bitfield_unit + } +} +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_IN_HEADER : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_2 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_3 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_4 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_5 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 4 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_6 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 5 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_7 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 6 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_8 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 7 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 15 ; +#[doc = "! Byte 1 related"] +pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_IN_HEADER : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_PCM : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_AC3 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_MPEG1 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_MP3 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 4 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_MPEG2 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 5 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_AACLC : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 6 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_DTS : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 7 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_ATRAC : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 8 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_DSD : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 9 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_EAC3 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 10 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_DTSHD : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 11 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_MLP : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 12 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_DST : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 13 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_WMAPRO : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 14 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_USE_CODING_EXTENSION_TYPE : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 15 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 31 ; +pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_IN_HEADER : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_16BITS : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_20BITS : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_24BITS : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE = 7 ; +#[doc = "! Byte 2 related"] +pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_IN_HEADER : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_32000HZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_44100HZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_48000HZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_88200KHZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 4 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_96000KHZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 5 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_176400KHZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 6 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_192000KHZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 7 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 15 ; +pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_USE_CODING_TYPE : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_HEAAC : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_HEAACV2 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_MPEGSURROUND : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE04 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 4 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE05 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 5 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE06 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 6 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE07 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 7 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE08 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 8 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE09 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 9 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE10 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 10 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE11 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 11 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE12 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 12 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE13 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 13 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE14 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 14 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE15 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 15 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE16 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 16 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE17 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 17 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE18 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 18 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE19 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 19 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE20 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 20 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE21 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 21 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE22 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 22 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE23 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 23 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE24 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 24 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE25 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 25 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE26 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 26 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE27 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 27 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE28 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 28 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE29 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 29 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE30 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 30 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE31 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 31 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 63 ; +#[doc = "! Byte 3 related"] +pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_X_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_X_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_X_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_X_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_RC_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 4 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_RC_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 5 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_RC_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 6 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_RC_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 7 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_RR_RL_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 8 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_RR_RL_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 9 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 10 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 11 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_RC_RR_RL_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 12 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_RC_RR_RL_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 13 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_RC_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 14 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_RC_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 15 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_RRC_RLC_RR_RL_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 16 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_RRC_RLC_RR_RL_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 17 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_RRC_RLC_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 18 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_RRC_RLC_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 19 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_X_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 20 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_X_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 21 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_X_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 22 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_X_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 23 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_RC_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 24 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_RC_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 25 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_RC_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 26 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_RC_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 27 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_RR_RL_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 28 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_RR_RL_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 29 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 30 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 31 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_FCH_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 32 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_FCH_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 33 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_X_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 34 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_X_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 35 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRH_FLH_RR_RL_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 36 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRH_FLH_RR_RL_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 37 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRW_FLW_RR_RL_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 38 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRW_FLW_RR_RL_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 39 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_RC_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 40 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_RC_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 41 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FCH_RC_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 42 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FCH_RC_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 43 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_FCH_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 44 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_FCH_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 45 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRH_FLH_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 46 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRH_FLH_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 47 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRW_FLW_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 48 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRW_FLW_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 49 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 511 ; +#[doc = "! Byte 4 related"] +pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_NO_DATA : NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_0DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_PLUS10DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_RESERVED03 : NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL = 7 ; +#[doc = "! Byte 5 related"] +pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_0DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_1DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_2DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_3DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_4DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 4 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_5DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 5 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_6DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 6 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_7DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 7 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_8DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 8 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_9DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 9 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_10DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 10 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_11DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 11 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_12DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 12 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_13DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 13 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_14DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 14 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_15DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 15 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 31 ; +pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_PERMITTED : NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_PROHIBITED : NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_AUTO: + NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX = 3; +pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX = ::std::os::raw::c_int; +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct NV_INFOFRAME_AUDIO { + pub _bitfield_align_1: [u16; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 14usize]>, + pub __bindgen_padding_0: u16, +} +impl NV_INFOFRAME_AUDIO { + #[inline] + pub fn codingType(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 5u8) as u32) } + } + #[inline] + pub fn set_codingType(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 5u8, val as u64) + } + } + #[inline] + pub unsafe fn codingType_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 5u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_codingType_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 5u8, + val as u64, + ) + } + } + #[inline] + pub fn codingExtensionType(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 6u8) as u32) } + } + #[inline] + pub fn set_codingExtensionType(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 6u8, val as u64) + } + } + #[inline] + pub unsafe fn codingExtensionType_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 6u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_codingExtensionType_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 6u8, + val as u64, + ) + } + } + #[inline] + pub fn sampleSize(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 3u8) as u32) } + } + #[inline] + pub fn set_sampleSize(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(11usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn sampleSize_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 11usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_sampleSize_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 11usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn sampleRate(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 4u8) as u32) } + } + #[inline] + pub fn set_sampleRate(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(14usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn sampleRate_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 14usize, + 4u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_sampleRate_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 14usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn channelCount(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 4u8) as u32) } + } + #[inline] + pub fn set_channelCount(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(18usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn channelCount_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 18usize, + 4u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_channelCount_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 18usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn speakerPlacement(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 9u8) as u32) } + } + #[inline] + pub fn set_speakerPlacement(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(22usize, 9u8, val as u64) + } + } + #[inline] + pub unsafe fn speakerPlacement_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 22usize, + 9u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_speakerPlacement_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 22usize, + 9u8, + val as u64, + ) + } + } + #[inline] + pub fn downmixInhibit(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 2u8) as u32) } + } + #[inline] + pub fn set_downmixInhibit(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(32usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn downmixInhibit_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 32usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_downmixInhibit_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 32usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn lfePlaybackLevel(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(34usize, 3u8) as u32) } + } + #[inline] + pub fn set_lfePlaybackLevel(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(34usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn lfePlaybackLevel_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 34usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_lfePlaybackLevel_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 34usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn levelShift(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(37usize, 5u8) as u32) } + } + #[inline] + pub fn set_levelShift(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(37usize, 5u8, val as u64) + } + } + #[inline] + pub unsafe fn levelShift_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 37usize, + 5u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_levelShift_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 37usize, + 5u8, + val as u64, + ) + } + } + #[inline] + pub fn Future12(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(42usize, 2u8) as u32) } + } + #[inline] + pub fn set_Future12(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(42usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn Future12_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 42usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_Future12_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 42usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn Future2x(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(44usize, 4u8) as u32) } + } + #[inline] + pub fn set_Future2x(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(44usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn Future2x_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 44usize, + 4u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_Future2x_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 44usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn Future3x(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 4u8) as u32) } + } + #[inline] + pub fn set_Future3x(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(48usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn Future3x_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 48usize, + 4u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_Future3x_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 48usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn Future52(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(52usize, 2u8) as u32) } + } + #[inline] + pub fn set_Future52(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(52usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn Future52_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 52usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_Future52_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 52usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn Future6(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(54usize, 9u8) as u32) } + } + #[inline] + pub fn set_Future6(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(54usize, 9u8, val as u64) + } + } + #[inline] + pub unsafe fn Future6_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 54usize, + 9u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_Future6_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 54usize, + 9u8, + val as u64, + ) + } + } + #[inline] + pub fn Future7(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(64usize, 9u8) as u32) } + } + #[inline] + pub fn set_Future7(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(64usize, 9u8, val as u64) + } + } + #[inline] + pub unsafe fn Future7_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 64usize, + 9u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_Future7_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 64usize, + 9u8, + val as u64, + ) + } + } + #[inline] + pub fn Future8(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(73usize, 9u8) as u32) } + } + #[inline] + pub fn set_Future8(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(73usize, 9u8, val as u64) + } + } + #[inline] + pub unsafe fn Future8_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 73usize, + 9u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_Future8_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 73usize, + 9u8, + val as u64, + ) + } + } + #[inline] + pub fn Future9(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(82usize, 9u8) as u32) } + } + #[inline] + pub fn set_Future9(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(82usize, 9u8, val as u64) + } + } + #[inline] + pub unsafe fn Future9_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 82usize, + 9u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_Future9_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 82usize, + 9u8, + val as u64, + ) + } + } + #[inline] + pub fn Future10(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(96usize, 9u8) as u32) } + } + #[inline] + pub fn set_Future10(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(96usize, 9u8, val as u64) + } + } + #[inline] + pub unsafe fn Future10_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 96usize, + 9u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_Future10_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 96usize, + 9u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + codingType: NvU32, + codingExtensionType: NvU32, + sampleSize: NvU32, + sampleRate: NvU32, + channelCount: NvU32, + speakerPlacement: NvU32, + downmixInhibit: NvU32, + lfePlaybackLevel: NvU32, + levelShift: NvU32, + Future12: NvU32, + Future2x: NvU32, + Future3x: NvU32, + Future52: NvU32, + Future6: NvU32, + Future7: NvU32, + Future8: NvU32, + Future9: NvU32, + Future10: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 14usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 14usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 5u8, { + let codingType: u32 = unsafe { ::std::mem::transmute(codingType) }; + codingType as u64 + }); + __bindgen_bitfield_unit.set(5usize, 6u8, { + let codingExtensionType: u32 = unsafe { ::std::mem::transmute(codingExtensionType) }; + codingExtensionType as u64 + }); + __bindgen_bitfield_unit.set(11usize, 3u8, { + let sampleSize: u32 = unsafe { ::std::mem::transmute(sampleSize) }; + sampleSize as u64 + }); + __bindgen_bitfield_unit.set(14usize, 4u8, { + let sampleRate: u32 = unsafe { ::std::mem::transmute(sampleRate) }; + sampleRate as u64 + }); + __bindgen_bitfield_unit.set(18usize, 4u8, { + let channelCount: u32 = unsafe { ::std::mem::transmute(channelCount) }; + channelCount as u64 + }); + __bindgen_bitfield_unit.set(22usize, 9u8, { + let speakerPlacement: u32 = unsafe { ::std::mem::transmute(speakerPlacement) }; + speakerPlacement as u64 + }); + __bindgen_bitfield_unit.set(32usize, 2u8, { + let downmixInhibit: u32 = unsafe { ::std::mem::transmute(downmixInhibit) }; + downmixInhibit as u64 + }); + __bindgen_bitfield_unit.set(34usize, 3u8, { + let lfePlaybackLevel: u32 = unsafe { ::std::mem::transmute(lfePlaybackLevel) }; + lfePlaybackLevel as u64 + }); + __bindgen_bitfield_unit.set(37usize, 5u8, { + let levelShift: u32 = unsafe { ::std::mem::transmute(levelShift) }; + levelShift as u64 + }); + __bindgen_bitfield_unit.set(42usize, 2u8, { + let Future12: u32 = unsafe { ::std::mem::transmute(Future12) }; + Future12 as u64 + }); + __bindgen_bitfield_unit.set(44usize, 4u8, { + let Future2x: u32 = unsafe { ::std::mem::transmute(Future2x) }; + Future2x as u64 + }); + __bindgen_bitfield_unit.set(48usize, 4u8, { + let Future3x: u32 = unsafe { ::std::mem::transmute(Future3x) }; + Future3x as u64 + }); + __bindgen_bitfield_unit.set(52usize, 2u8, { + let Future52: u32 = unsafe { ::std::mem::transmute(Future52) }; + Future52 as u64 + }); + __bindgen_bitfield_unit.set(54usize, 9u8, { + let Future6: u32 = unsafe { ::std::mem::transmute(Future6) }; + Future6 as u64 + }); + __bindgen_bitfield_unit.set(64usize, 9u8, { + let Future7: u32 = unsafe { ::std::mem::transmute(Future7) }; + Future7 as u64 + }); + __bindgen_bitfield_unit.set(73usize, 9u8, { + let Future8: u32 = unsafe { ::std::mem::transmute(Future8) }; + Future8 as u64 + }); + __bindgen_bitfield_unit.set(82usize, 9u8, { + let Future9: u32 = unsafe { ::std::mem::transmute(Future9) }; + Future9 as u64 + }); + __bindgen_bitfield_unit.set(96usize, 9u8, { + let Future10: u32 = unsafe { ::std::mem::transmute(Future10) }; + Future10 as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct NV_INFOFRAME_DATA { + #[doc = "!< version of this structure"] + pub version: NvU32, + #[doc = "!< size of this structure"] + pub size: NvU16, + #[doc = "!< The actions to perform from NV_INFOFRAME_CMD"] + pub cmd: NvU8, + #[doc = "!< type of infoframe"] + pub type_: NvU8, + pub infoframe: NV_INFOFRAME_DATA__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union NV_INFOFRAME_DATA__bindgen_ty_1 { + #[doc = "!< This is NVIDIA-specific and corresponds to the property cmds and associated infoframe."] + pub property: NV_INFOFRAME_PROPERTY, + pub audio: NV_INFOFRAME_AUDIO, + pub video: NV_INFOFRAME_VIDEO, +} +pub const NV_COLOR_CMD_NV_COLOR_CMD_GET: NV_COLOR_CMD = 1; +pub const NV_COLOR_CMD_NV_COLOR_CMD_SET: NV_COLOR_CMD = 2; +pub const NV_COLOR_CMD_NV_COLOR_CMD_IS_SUPPORTED_COLOR: NV_COLOR_CMD = 3; +pub const NV_COLOR_CMD_NV_COLOR_CMD_GET_DEFAULT: NV_COLOR_CMD = 4; +pub type NV_COLOR_CMD = ::std::os::raw::c_int; +pub const NV_COLOR_FORMAT_NV_COLOR_FORMAT_RGB: NV_COLOR_FORMAT = 0; +pub const NV_COLOR_FORMAT_NV_COLOR_FORMAT_YUV422: NV_COLOR_FORMAT = 1; +pub const NV_COLOR_FORMAT_NV_COLOR_FORMAT_YUV444: NV_COLOR_FORMAT = 2; +pub const NV_COLOR_FORMAT_NV_COLOR_FORMAT_YUV420: NV_COLOR_FORMAT = 3; +pub const NV_COLOR_FORMAT_NV_COLOR_FORMAT_DEFAULT: NV_COLOR_FORMAT = 254; +pub const NV_COLOR_FORMAT_NV_COLOR_FORMAT_AUTO: NV_COLOR_FORMAT = 255; +#[doc = "! See Table 14 of CEA-861E. Not all of this is supported by the GPU."] +pub type NV_COLOR_FORMAT = ::std::os::raw::c_int; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_RGB: NV_COLOR_COLORIMETRY = 0; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_YCC601: NV_COLOR_COLORIMETRY = 1; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_YCC709: NV_COLOR_COLORIMETRY = 2; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_XVYCC601: NV_COLOR_COLORIMETRY = 3; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_XVYCC709: NV_COLOR_COLORIMETRY = 4; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_SYCC601: NV_COLOR_COLORIMETRY = 5; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_ADOBEYCC601: NV_COLOR_COLORIMETRY = 6; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_ADOBERGB: NV_COLOR_COLORIMETRY = 7; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_BT2020RGB: NV_COLOR_COLORIMETRY = 8; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_BT2020YCC: NV_COLOR_COLORIMETRY = 9; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_BT2020cYCC: NV_COLOR_COLORIMETRY = 10; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_DEFAULT: NV_COLOR_COLORIMETRY = 254; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_AUTO: NV_COLOR_COLORIMETRY = 255; +pub type NV_COLOR_COLORIMETRY = ::std::os::raw::c_int; +pub const _NV_DYNAMIC_RANGE_NV_DYNAMIC_RANGE_VESA: _NV_DYNAMIC_RANGE = 0; +pub const _NV_DYNAMIC_RANGE_NV_DYNAMIC_RANGE_CEA: _NV_DYNAMIC_RANGE = 1; +pub const _NV_DYNAMIC_RANGE_NV_DYNAMIC_RANGE_AUTO: _NV_DYNAMIC_RANGE = 255; +pub type _NV_DYNAMIC_RANGE = ::std::os::raw::c_int; +pub use self::_NV_DYNAMIC_RANGE as NV_DYNAMIC_RANGE; +pub const _NV_BPC_NV_BPC_DEFAULT: _NV_BPC = 0; +pub const _NV_BPC_NV_BPC_6: _NV_BPC = 1; +pub const _NV_BPC_NV_BPC_8: _NV_BPC = 2; +pub const _NV_BPC_NV_BPC_10: _NV_BPC = 3; +pub const _NV_BPC_NV_BPC_12: _NV_BPC = 4; +pub const _NV_BPC_NV_BPC_16: _NV_BPC = 5; +pub type _NV_BPC = ::std::os::raw::c_int; +pub use self::_NV_BPC as NV_BPC; +#[doc = "!< app/nvcpl make decision to select the desire color format"] +pub const _NV_COLOR_SELECTION_POLICY_NV_COLOR_SELECTION_POLICY_USER: _NV_COLOR_SELECTION_POLICY = 0; +#[doc = "!< driver/ OS make decision to select the best color format"] +pub const _NV_COLOR_SELECTION_POLICY_NV_COLOR_SELECTION_POLICY_BEST_QUALITY: + _NV_COLOR_SELECTION_POLICY = 1; +pub const _NV_COLOR_SELECTION_POLICY_NV_COLOR_SELECTION_POLICY_DEFAULT: _NV_COLOR_SELECTION_POLICY = + 1; +pub const _NV_COLOR_SELECTION_POLICY_NV_COLOR_SELECTION_POLICY_UNKNOWN: _NV_COLOR_SELECTION_POLICY = + 255; +pub type _NV_COLOR_SELECTION_POLICY = ::std::os::raw::c_int; +pub use self::_NV_COLOR_SELECTION_POLICY as NV_COLOR_SELECTION_POLICY; +pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_DEFAULT: _NV_DESKTOP_COLOR_DEPTH = 0; +pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_8BPC: _NV_DESKTOP_COLOR_DEPTH = 1; +pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_10BPC: _NV_DESKTOP_COLOR_DEPTH = 2; +pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_16BPC_FLOAT: _NV_DESKTOP_COLOR_DEPTH = 3; +pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_16BPC_FLOAT_WCG: _NV_DESKTOP_COLOR_DEPTH = + 4; +pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_16BPC_FLOAT_HDR: _NV_DESKTOP_COLOR_DEPTH = + 5; +pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_MAX_VALUE: _NV_DESKTOP_COLOR_DEPTH = 5; +pub type _NV_DESKTOP_COLOR_DEPTH = ::std::os::raw::c_int; +pub use self::_NV_DESKTOP_COLOR_DEPTH as NV_DESKTOP_COLOR_DEPTH; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COLOR_DATA_V1 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Size of this structure"] + pub size: NvU16, + pub cmd: NvU8, + pub data: _NV_COLOR_DATA_V1__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COLOR_DATA_V1__bindgen_ty_1 { + #[doc = "!< One of NV_COLOR_FORMAT enum values."] + pub colorFormat: NvU8, + #[doc = "!< One of NV_COLOR_COLORIMETRY enum values."] + pub colorimetry: NvU8, +} +pub type NV_COLOR_DATA_V1 = _NV_COLOR_DATA_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COLOR_DATA_V2 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Size of this structure"] + pub size: NvU16, + pub cmd: NvU8, + pub data: _NV_COLOR_DATA_V2__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COLOR_DATA_V2__bindgen_ty_1 { + #[doc = "!< One of NV_COLOR_FORMAT enum values."] + pub colorFormat: NvU8, + #[doc = "!< One of NV_COLOR_COLORIMETRY enum values."] + pub colorimetry: NvU8, + #[doc = "!< One of NV_DYNAMIC_RANGE enum values."] + pub dynamicRange: NvU8, +} +pub type NV_COLOR_DATA_V2 = _NV_COLOR_DATA_V2; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COLOR_DATA_V3 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Size of this structure"] + pub size: NvU16, + pub cmd: NvU8, + pub data: _NV_COLOR_DATA_V3__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COLOR_DATA_V3__bindgen_ty_1 { + #[doc = "!< One of NV_COLOR_FORMAT enum values."] + pub colorFormat: NvU8, + #[doc = "!< One of NV_COLOR_COLORIMETRY enum values."] + pub colorimetry: NvU8, + #[doc = "!< One of NV_DYNAMIC_RANGE enum values."] + pub dynamicRange: NvU8, + #[doc = "!< One of NV_BPC enum values."] + pub bpc: NV_BPC, +} +pub type NV_COLOR_DATA_V3 = _NV_COLOR_DATA_V3; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COLOR_DATA_V4 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Size of this structure"] + pub size: NvU16, + pub cmd: NvU8, + pub data: _NV_COLOR_DATA_V4__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COLOR_DATA_V4__bindgen_ty_1 { + #[doc = "!< One of NV_COLOR_FORMAT enum values."] + pub colorFormat: NvU8, + #[doc = "!< One of NV_COLOR_COLORIMETRY enum values."] + pub colorimetry: NvU8, + #[doc = "!< One of NV_DYNAMIC_RANGE enum values."] + pub dynamicRange: NvU8, + #[doc = "!< One of NV_BPC enum values."] + pub bpc: NV_BPC, + #[doc = "!< One of the color selection policy"] + pub colorSelectionPolicy: NV_COLOR_SELECTION_POLICY, +} +pub type NV_COLOR_DATA_V4 = _NV_COLOR_DATA_V4; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COLOR_DATA_V5 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Size of this structure"] + pub size: NvU16, + pub cmd: NvU8, + pub data: _NV_COLOR_DATA_V5__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COLOR_DATA_V5__bindgen_ty_1 { + #[doc = "!< One of NV_COLOR_FORMAT enum values."] + pub colorFormat: NvU8, + #[doc = "!< One of NV_COLOR_COLORIMETRY enum values."] + pub colorimetry: NvU8, + #[doc = "!< One of NV_DYNAMIC_RANGE enum values."] + pub dynamicRange: NvU8, + #[doc = "!< One of NV_BPC enum values."] + pub bpc: NV_BPC, + #[doc = "!< One of the color selection policy"] + pub colorSelectionPolicy: NV_COLOR_SELECTION_POLICY, + #[doc = "!< One of NV_DESKTOP_COLOR_DEPTH enum values."] + pub depth: NV_DESKTOP_COLOR_DEPTH, +} +pub type NV_COLOR_DATA_V5 = _NV_COLOR_DATA_V5; +pub type NV_COLOR_DATA = NV_COLOR_DATA_V5; +#[doc = "!< Tells the type of structure used to define the Static Metadata Descriptor block."] +pub const NV_STATIC_METADATA_DESCRIPTOR_ID_NV_STATIC_METADATA_TYPE_1: + NV_STATIC_METADATA_DESCRIPTOR_ID = 0; +#[doc = "! @}"] +pub type NV_STATIC_METADATA_DESCRIPTOR_ID = ::std::os::raw::c_int; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_CAPABILITIES_V1 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Static Metadata Descriptor Id (0 for static metadata type 1)"] + pub static_metadata_descriptor_id: NV_STATIC_METADATA_DESCRIPTOR_ID, + pub display_data: _NV_HDR_CAPABILITIES_V1__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_CAPABILITIES_V1__bindgen_ty_1 { + #[doc = "!< x coordinate of color primary 0 (e.g. Red) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x0: NvU16, + #[doc = "!< y coordinate of color primary 0 (e.g. Red) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y0: NvU16, + #[doc = "!< x coordinate of color primary 1 (e.g. Green) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x1: NvU16, + #[doc = "!< y coordinate of color primary 1 (e.g. Green) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y1: NvU16, + #[doc = "!< x coordinate of color primary 2 (e.g. Blue) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x2: NvU16, + #[doc = "!< y coordinate of color primary 2 (e.g. Blue) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y2: NvU16, + #[doc = "!< x coordinate of white point of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_x: NvU16, + #[doc = "!< y coordinate of white point of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_y: NvU16, + #[doc = "!< Maximum display luminance = desired max luminance of HDR content ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] + pub desired_content_max_luminance: NvU16, + #[doc = "!< Minimum display luminance = desired min luminance of HDR content ([0x0001-0xFFFF] = [1.0 - 6.55350] cd/m^2)"] + pub desired_content_min_luminance: NvU16, + #[doc = "!< Desired maximum Frame-Average Light Level (MaxFALL) of HDR content ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] + pub desired_content_max_frame_average_luminance: NvU16, +} +impl _NV_HDR_CAPABILITIES_V1 { + #[inline] + pub fn isST2084EotfSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isST2084EotfSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isST2084EotfSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isST2084EotfSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isTraditionalHdrGammaSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isTraditionalHdrGammaSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isTraditionalHdrGammaSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isTraditionalHdrGammaSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isEdrSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_isEdrSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isEdrSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isEdrSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn driverExpandDefaultHdrParameters(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_driverExpandDefaultHdrParameters(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn driverExpandDefaultHdrParameters_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_driverExpandDefaultHdrParameters_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isTraditionalSdrGammaSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_isTraditionalSdrGammaSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isTraditionalSdrGammaSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isTraditionalSdrGammaSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 27u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 27u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 27u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isST2084EotfSupported: NvU32, + isTraditionalHdrGammaSupported: NvU32, + isEdrSupported: NvU32, + driverExpandDefaultHdrParameters: NvU32, + isTraditionalSdrGammaSupported: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isST2084EotfSupported: u32 = + unsafe { ::std::mem::transmute(isST2084EotfSupported) }; + isST2084EotfSupported as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isTraditionalHdrGammaSupported: u32 = + unsafe { ::std::mem::transmute(isTraditionalHdrGammaSupported) }; + isTraditionalHdrGammaSupported as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let isEdrSupported: u32 = unsafe { ::std::mem::transmute(isEdrSupported) }; + isEdrSupported as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let driverExpandDefaultHdrParameters: u32 = + unsafe { ::std::mem::transmute(driverExpandDefaultHdrParameters) }; + driverExpandDefaultHdrParameters as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let isTraditionalSdrGammaSupported: u32 = + unsafe { ::std::mem::transmute(isTraditionalSdrGammaSupported) }; + isTraditionalSdrGammaSupported as u64 + }); + __bindgen_bitfield_unit.set(5usize, 27u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_HDR_CAPABILITIES_V1 = _NV_HDR_CAPABILITIES_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_CAPABILITIES_V2 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Static Metadata Descriptor Id (0 for static metadata type 1)"] + pub static_metadata_descriptor_id: NV_STATIC_METADATA_DESCRIPTOR_ID, + pub display_data: _NV_HDR_CAPABILITIES_V2__bindgen_ty_1, + pub dv_static_metadata: _NV_HDR_CAPABILITIES_V2__bindgen_ty_2, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_CAPABILITIES_V2__bindgen_ty_1 { + #[doc = "!< x coordinate of color primary 0 (e.g. Red) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x0: NvU16, + #[doc = "!< y coordinate of color primary 0 (e.g. Red) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y0: NvU16, + #[doc = "!< x coordinate of color primary 1 (e.g. Green) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x1: NvU16, + #[doc = "!< y coordinate of color primary 1 (e.g. Green) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y1: NvU16, + #[doc = "!< x coordinate of color primary 2 (e.g. Blue) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x2: NvU16, + #[doc = "!< y coordinate of color primary 2 (e.g. Blue) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y2: NvU16, + #[doc = "!< x coordinate of white point of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_x: NvU16, + #[doc = "!< y coordinate of white point of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_y: NvU16, + #[doc = "!< Maximum display luminance = desired max luminance of HDR content ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] + pub desired_content_max_luminance: NvU16, + #[doc = "!< Minimum display luminance = desired min luminance of HDR content ([0x0001-0xFFFF] = [1.0 - 6.55350] cd/m^2)"] + pub desired_content_min_luminance: NvU16, + #[doc = "!< Desired maximum Frame-Average Light Level (MaxFALL) of HDR content ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] + pub desired_content_max_frame_average_luminance: NvU16, +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_CAPABILITIES_V2__bindgen_ty_2 { + pub _bitfield_align_1: [u16; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Represents min luminance level of Sink"] + pub target_min_luminance: NvU16, + #[doc = "!< Represents max luminance level of sink"] + pub target_max_luminance: NvU16, + #[doc = "!< Red primary chromaticity coordinate x"] + pub cc_red_x: NvU16, + #[doc = "!< Red primary chromaticity coordinate y"] + pub cc_red_y: NvU16, + #[doc = "!< Green primary chromaticity coordinate x"] + pub cc_green_x: NvU16, + #[doc = "!< Green primary chromaticity coordinate Y"] + pub cc_green_y: NvU16, + #[doc = "!< Blue primary chromaticity coordinate x"] + pub cc_blue_x: NvU16, + #[doc = "!< Blue primary chromaticity coordinate y"] + pub cc_blue_y: NvU16, + #[doc = "!< White primary chromaticity coordinate x"] + pub cc_white_x: NvU16, + #[doc = "!< White primary chromaticity coordinate y"] + pub cc_white_y: NvU16, +} +impl _NV_HDR_CAPABILITIES_V2__bindgen_ty_2 { + #[inline] + pub fn VSVDB_version(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 3u8) as u32) } + } + #[inline] + pub fn set_VSVDB_version(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn VSVDB_version_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_VSVDB_version_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn dm_version(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 8u8) as u32) } + } + #[inline] + pub fn set_dm_version(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn dm_version_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_dm_version_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn supports_2160p60hz(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) } + } + #[inline] + pub fn set_supports_2160p60hz(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(11usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supports_2160p60hz_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 11usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_supports_2160p60hz_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 11usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn supports_YUV422_12bit(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) } + } + #[inline] + pub fn set_supports_YUV422_12bit(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(12usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supports_YUV422_12bit_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 12usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_supports_YUV422_12bit_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 12usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn supports_global_dimming(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) } + } + #[inline] + pub fn set_supports_global_dimming(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(13usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supports_global_dimming_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 13usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_supports_global_dimming_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 13usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn colorimetry(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) } + } + #[inline] + pub fn set_colorimetry(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(14usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn colorimetry_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 14usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_colorimetry_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 14usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn supports_backlight_control(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 2u8) as u32) } + } + #[inline] + pub fn set_supports_backlight_control(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(15usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn supports_backlight_control_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 15usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_supports_backlight_control_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 15usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn backlt_min_luma(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 2u8) as u32) } + } + #[inline] + pub fn set_backlt_min_luma(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(17usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn backlt_min_luma_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 17usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_backlt_min_luma_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 17usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn interface_supported_by_sink(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 2u8) as u32) } + } + #[inline] + pub fn set_interface_supported_by_sink(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(19usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn interface_supported_by_sink_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 19usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_interface_supported_by_sink_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 19usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn supports_10b_12b_444(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 2u8) as u32) } + } + #[inline] + pub fn set_supports_10b_12b_444(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(21usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn supports_10b_12b_444_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 21usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_supports_10b_12b_444_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 21usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 9u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(23usize, 9u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 23usize, + 9u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 23usize, + 9u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + VSVDB_version: NvU32, + dm_version: NvU32, + supports_2160p60hz: NvU32, + supports_YUV422_12bit: NvU32, + supports_global_dimming: NvU32, + colorimetry: NvU32, + supports_backlight_control: NvU32, + backlt_min_luma: NvU32, + interface_supported_by_sink: NvU32, + supports_10b_12b_444: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 3u8, { + let VSVDB_version: u32 = unsafe { ::std::mem::transmute(VSVDB_version) }; + VSVDB_version as u64 + }); + __bindgen_bitfield_unit.set(3usize, 8u8, { + let dm_version: u32 = unsafe { ::std::mem::transmute(dm_version) }; + dm_version as u64 + }); + __bindgen_bitfield_unit.set(11usize, 1u8, { + let supports_2160p60hz: u32 = unsafe { ::std::mem::transmute(supports_2160p60hz) }; + supports_2160p60hz as u64 + }); + __bindgen_bitfield_unit.set(12usize, 1u8, { + let supports_YUV422_12bit: u32 = + unsafe { ::std::mem::transmute(supports_YUV422_12bit) }; + supports_YUV422_12bit as u64 + }); + __bindgen_bitfield_unit.set(13usize, 1u8, { + let supports_global_dimming: u32 = + unsafe { ::std::mem::transmute(supports_global_dimming) }; + supports_global_dimming as u64 + }); + __bindgen_bitfield_unit.set(14usize, 1u8, { + let colorimetry: u32 = unsafe { ::std::mem::transmute(colorimetry) }; + colorimetry as u64 + }); + __bindgen_bitfield_unit.set(15usize, 2u8, { + let supports_backlight_control: u32 = + unsafe { ::std::mem::transmute(supports_backlight_control) }; + supports_backlight_control as u64 + }); + __bindgen_bitfield_unit.set(17usize, 2u8, { + let backlt_min_luma: u32 = unsafe { ::std::mem::transmute(backlt_min_luma) }; + backlt_min_luma as u64 + }); + __bindgen_bitfield_unit.set(19usize, 2u8, { + let interface_supported_by_sink: u32 = + unsafe { ::std::mem::transmute(interface_supported_by_sink) }; + interface_supported_by_sink as u64 + }); + __bindgen_bitfield_unit.set(21usize, 2u8, { + let supports_10b_12b_444: u32 = unsafe { ::std::mem::transmute(supports_10b_12b_444) }; + supports_10b_12b_444 as u64 + }); + __bindgen_bitfield_unit.set(23usize, 9u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +impl _NV_HDR_CAPABILITIES_V2 { + #[inline] + pub fn isST2084EotfSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isST2084EotfSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isST2084EotfSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isST2084EotfSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isTraditionalHdrGammaSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isTraditionalHdrGammaSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isTraditionalHdrGammaSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isTraditionalHdrGammaSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isEdrSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_isEdrSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isEdrSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isEdrSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn driverExpandDefaultHdrParameters(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_driverExpandDefaultHdrParameters(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn driverExpandDefaultHdrParameters_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_driverExpandDefaultHdrParameters_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isTraditionalSdrGammaSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_isTraditionalSdrGammaSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isTraditionalSdrGammaSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isTraditionalSdrGammaSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isDolbyVisionSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_isDolbyVisionSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isDolbyVisionSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isDolbyVisionSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 26u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 26u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 6usize, + 26u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 26u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isST2084EotfSupported: NvU32, + isTraditionalHdrGammaSupported: NvU32, + isEdrSupported: NvU32, + driverExpandDefaultHdrParameters: NvU32, + isTraditionalSdrGammaSupported: NvU32, + isDolbyVisionSupported: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isST2084EotfSupported: u32 = + unsafe { ::std::mem::transmute(isST2084EotfSupported) }; + isST2084EotfSupported as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isTraditionalHdrGammaSupported: u32 = + unsafe { ::std::mem::transmute(isTraditionalHdrGammaSupported) }; + isTraditionalHdrGammaSupported as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let isEdrSupported: u32 = unsafe { ::std::mem::transmute(isEdrSupported) }; + isEdrSupported as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let driverExpandDefaultHdrParameters: u32 = + unsafe { ::std::mem::transmute(driverExpandDefaultHdrParameters) }; + driverExpandDefaultHdrParameters as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let isTraditionalSdrGammaSupported: u32 = + unsafe { ::std::mem::transmute(isTraditionalSdrGammaSupported) }; + isTraditionalSdrGammaSupported as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let isDolbyVisionSupported: u32 = + unsafe { ::std::mem::transmute(isDolbyVisionSupported) }; + isDolbyVisionSupported as u64 + }); + __bindgen_bitfield_unit.set(6usize, 26u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_HDR_CAPABILITIES_V2 = _NV_HDR_CAPABILITIES_V2; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_CAPABILITIES_V3 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Static Metadata Descriptor Id (0 for static metadata type 1)"] + pub static_metadata_descriptor_id: NV_STATIC_METADATA_DESCRIPTOR_ID, + pub display_data: _NV_HDR_CAPABILITIES_V3__bindgen_ty_1, + pub dv_static_metadata: _NV_HDR_CAPABILITIES_V3__bindgen_ty_2, + pub hdr10plus_vsvdb: _NV_HDR_CAPABILITIES_V3__bindgen_ty_3, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_CAPABILITIES_V3__bindgen_ty_1 { + #[doc = "!< x coordinate of color primary 0 (e.g. Red) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x0: NvU16, + #[doc = "!< y coordinate of color primary 0 (e.g. Red) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y0: NvU16, + #[doc = "!< x coordinate of color primary 1 (e.g. Green) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x1: NvU16, + #[doc = "!< y coordinate of color primary 1 (e.g. Green) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y1: NvU16, + #[doc = "!< x coordinate of color primary 2 (e.g. Blue) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x2: NvU16, + #[doc = "!< y coordinate of color primary 2 (e.g. Blue) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y2: NvU16, + #[doc = "!< x coordinate of white point of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_x: NvU16, + #[doc = "!< y coordinate of white point of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_y: NvU16, + #[doc = "!< Maximum display luminance = desired max luminance of HDR content ([0x0000-0xFFFF] = [0.0 - 65535.0] cd/m^2, in units of 1 cd/m^2)"] + pub desired_content_max_luminance: NvU16, + #[doc = "!< Minimum display luminance = desired min luminance of HDR content ([0x0000-0xFFFF] = [0.0 - 6.55350] cd/m^2, in units of 0.0001 cd/m^2)"] + pub desired_content_min_luminance: NvU16, + #[doc = "!< Desired maximum Frame-Average Light Level (MaxFALL) of HDR content ([0x0000-0xFFFF] = [0.0 - 65535.0] cd/m^2, in units of 1 cd/m^2)"] + pub desired_content_max_frame_average_luminance: NvU16, +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_CAPABILITIES_V3__bindgen_ty_2 { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Represents min luminance level of Sink"] + pub target_min_luminance: NvU16, + #[doc = "!< Represents max luminance level of sink"] + pub target_max_luminance: NvU16, + #[doc = "!< Red primary chromaticity coordinate x"] + pub cc_red_x: NvU16, + #[doc = "!< Red primary chromaticity coordinate y"] + pub cc_red_y: NvU16, + #[doc = "!< Green primary chromaticity coordinate x"] + pub cc_green_x: NvU16, + #[doc = "!< Green primary chromaticity coordinate Y"] + pub cc_green_y: NvU16, + #[doc = "!< Blue primary chromaticity coordinate x"] + pub cc_blue_x: NvU16, + #[doc = "!< Blue primary chromaticity coordinate y"] + pub cc_blue_y: NvU16, + #[doc = "!< White primary chromaticity coordinate x"] + pub cc_white_x: NvU16, + #[doc = "!< White primary chromaticity coordinate y"] + pub cc_white_y: NvU16, +} +impl _NV_HDR_CAPABILITIES_V3__bindgen_ty_2 { + #[inline] + pub fn VSVDB_version(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 3u8) as u32) } + } + #[inline] + pub fn set_VSVDB_version(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn VSVDB_version_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_VSVDB_version_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn dm_version(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 8u8) as u32) } + } + #[inline] + pub fn set_dm_version(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn dm_version_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_dm_version_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn supports_2160p60hz(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) } + } + #[inline] + pub fn set_supports_2160p60hz(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(11usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supports_2160p60hz_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 11usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_supports_2160p60hz_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 11usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn supports_YUV422_12bit(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) } + } + #[inline] + pub fn set_supports_YUV422_12bit(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(12usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supports_YUV422_12bit_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 12usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_supports_YUV422_12bit_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 12usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn supports_global_dimming(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) } + } + #[inline] + pub fn set_supports_global_dimming(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(13usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supports_global_dimming_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 13usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_supports_global_dimming_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 13usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn colorimetry(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) } + } + #[inline] + pub fn set_colorimetry(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(14usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn colorimetry_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 14usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_colorimetry_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 14usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn supports_backlight_control(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 2u8) as u32) } + } + #[inline] + pub fn set_supports_backlight_control(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(15usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn supports_backlight_control_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 15usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_supports_backlight_control_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 15usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn backlt_min_luma(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 2u8) as u32) } + } + #[inline] + pub fn set_backlt_min_luma(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(17usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn backlt_min_luma_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 17usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_backlt_min_luma_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 17usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn interface_supported_by_sink(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 2u8) as u32) } + } + #[inline] + pub fn set_interface_supported_by_sink(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(19usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn interface_supported_by_sink_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 19usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_interface_supported_by_sink_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 19usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn supports_10b_12b_444(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 2u8) as u32) } + } + #[inline] + pub fn set_supports_10b_12b_444(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(21usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn supports_10b_12b_444_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 21usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_supports_10b_12b_444_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 21usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn parity(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u32) } + } + #[inline] + pub fn set_parity(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(23usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn parity_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 23usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_parity_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 23usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(24usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 24usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 24usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + VSVDB_version: NvU32, + dm_version: NvU32, + supports_2160p60hz: NvU32, + supports_YUV422_12bit: NvU32, + supports_global_dimming: NvU32, + colorimetry: NvU32, + supports_backlight_control: NvU32, + backlt_min_luma: NvU32, + interface_supported_by_sink: NvU32, + supports_10b_12b_444: NvU32, + parity: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 3u8, { + let VSVDB_version: u32 = unsafe { ::std::mem::transmute(VSVDB_version) }; + VSVDB_version as u64 + }); + __bindgen_bitfield_unit.set(3usize, 8u8, { + let dm_version: u32 = unsafe { ::std::mem::transmute(dm_version) }; + dm_version as u64 + }); + __bindgen_bitfield_unit.set(11usize, 1u8, { + let supports_2160p60hz: u32 = unsafe { ::std::mem::transmute(supports_2160p60hz) }; + supports_2160p60hz as u64 + }); + __bindgen_bitfield_unit.set(12usize, 1u8, { + let supports_YUV422_12bit: u32 = + unsafe { ::std::mem::transmute(supports_YUV422_12bit) }; + supports_YUV422_12bit as u64 + }); + __bindgen_bitfield_unit.set(13usize, 1u8, { + let supports_global_dimming: u32 = + unsafe { ::std::mem::transmute(supports_global_dimming) }; + supports_global_dimming as u64 + }); + __bindgen_bitfield_unit.set(14usize, 1u8, { + let colorimetry: u32 = unsafe { ::std::mem::transmute(colorimetry) }; + colorimetry as u64 + }); + __bindgen_bitfield_unit.set(15usize, 2u8, { + let supports_backlight_control: u32 = + unsafe { ::std::mem::transmute(supports_backlight_control) }; + supports_backlight_control as u64 + }); + __bindgen_bitfield_unit.set(17usize, 2u8, { + let backlt_min_luma: u32 = unsafe { ::std::mem::transmute(backlt_min_luma) }; + backlt_min_luma as u64 + }); + __bindgen_bitfield_unit.set(19usize, 2u8, { + let interface_supported_by_sink: u32 = + unsafe { ::std::mem::transmute(interface_supported_by_sink) }; + interface_supported_by_sink as u64 + }); + __bindgen_bitfield_unit.set(21usize, 2u8, { + let supports_10b_12b_444: u32 = unsafe { ::std::mem::transmute(supports_10b_12b_444) }; + supports_10b_12b_444 as u64 + }); + __bindgen_bitfield_unit.set(23usize, 1u8, { + let parity: u32 = unsafe { ::std::mem::transmute(parity) }; + parity as u64 + }); + __bindgen_bitfield_unit.set(24usize, 8u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[repr(align(2))] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_CAPABILITIES_V3__bindgen_ty_3 { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>, +} +impl _NV_HDR_CAPABILITIES_V3__bindgen_ty_3 { + #[inline] + pub fn application_version(&self) -> NvU16 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u16) } + } + #[inline] + pub fn set_application_version(&mut self, val: NvU16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn application_version_raw(this: *const Self) -> NvU16 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 2u8, + ) as u16) + } + } + #[inline] + pub unsafe fn set_application_version_raw(this: *mut Self, val: NvU16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn full_frame_peak_luminance_index(&self) -> NvU16 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 2u8) as u16) } + } + #[inline] + pub fn set_full_frame_peak_luminance_index(&mut self, val: NvU16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn full_frame_peak_luminance_index_raw(this: *const Self) -> NvU16 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 2u8, + ) as u16) + } + } + #[inline] + pub unsafe fn set_full_frame_peak_luminance_index_raw(this: *mut Self, val: NvU16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn peak_luminance_index(&self) -> NvU16 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u16) } + } + #[inline] + pub fn set_peak_luminance_index(&mut self, val: NvU16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn peak_luminance_index_raw(this: *const Self) -> NvU16 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 4u8, + ) as u16) + } + } + #[inline] + pub unsafe fn set_peak_luminance_index_raw(this: *mut Self, val: NvU16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU16 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 8u8) as u16) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU16 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 8usize, + 8u8, + ) as u16) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 8usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + application_version: NvU16, + full_frame_peak_luminance_index: NvU16, + peak_luminance_index: NvU16, + reserved: NvU16, + ) -> __BindgenBitfieldUnit<[u8; 2usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 2u8, { + let application_version: u16 = unsafe { ::std::mem::transmute(application_version) }; + application_version as u64 + }); + __bindgen_bitfield_unit.set(2usize, 2u8, { + let full_frame_peak_luminance_index: u16 = + unsafe { ::std::mem::transmute(full_frame_peak_luminance_index) }; + full_frame_peak_luminance_index as u64 + }); + __bindgen_bitfield_unit.set(4usize, 4u8, { + let peak_luminance_index: u16 = unsafe { ::std::mem::transmute(peak_luminance_index) }; + peak_luminance_index as u64 + }); + __bindgen_bitfield_unit.set(8usize, 8u8, { + let reserved: u16 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +impl _NV_HDR_CAPABILITIES_V3 { + #[inline] + pub fn isST2084EotfSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isST2084EotfSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isST2084EotfSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isST2084EotfSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isTraditionalHdrGammaSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isTraditionalHdrGammaSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isTraditionalHdrGammaSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isTraditionalHdrGammaSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isEdrSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_isEdrSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isEdrSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isEdrSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn driverExpandDefaultHdrParameters(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_driverExpandDefaultHdrParameters(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn driverExpandDefaultHdrParameters_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_driverExpandDefaultHdrParameters_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isTraditionalSdrGammaSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_isTraditionalSdrGammaSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isTraditionalSdrGammaSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isTraditionalSdrGammaSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isDolbyVisionSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_isDolbyVisionSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isDolbyVisionSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isDolbyVisionSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isHdr10PlusSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } + } + #[inline] + pub fn set_isHdr10PlusSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isHdr10PlusSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 6usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isHdr10PlusSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isHdr10PlusGamingSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } + } + #[inline] + pub fn set_isHdr10PlusGamingSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isHdr10PlusGamingSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 7usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isHdr10PlusGamingSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 7usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isNvidiaCertifiedDisplay(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) } + } + #[inline] + pub fn set_isNvidiaCertifiedDisplay(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isNvidiaCertifiedDisplay_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 8usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isNvidiaCertifiedDisplay_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 8usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 23u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(9usize, 23u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 9usize, + 23u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 9usize, + 23u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isST2084EotfSupported: NvU32, + isTraditionalHdrGammaSupported: NvU32, + isEdrSupported: NvU32, + driverExpandDefaultHdrParameters: NvU32, + isTraditionalSdrGammaSupported: NvU32, + isDolbyVisionSupported: NvU32, + isHdr10PlusSupported: NvU32, + isHdr10PlusGamingSupported: NvU32, + isNvidiaCertifiedDisplay: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isST2084EotfSupported: u32 = + unsafe { ::std::mem::transmute(isST2084EotfSupported) }; + isST2084EotfSupported as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isTraditionalHdrGammaSupported: u32 = + unsafe { ::std::mem::transmute(isTraditionalHdrGammaSupported) }; + isTraditionalHdrGammaSupported as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let isEdrSupported: u32 = unsafe { ::std::mem::transmute(isEdrSupported) }; + isEdrSupported as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let driverExpandDefaultHdrParameters: u32 = + unsafe { ::std::mem::transmute(driverExpandDefaultHdrParameters) }; + driverExpandDefaultHdrParameters as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let isTraditionalSdrGammaSupported: u32 = + unsafe { ::std::mem::transmute(isTraditionalSdrGammaSupported) }; + isTraditionalSdrGammaSupported as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let isDolbyVisionSupported: u32 = + unsafe { ::std::mem::transmute(isDolbyVisionSupported) }; + isDolbyVisionSupported as u64 + }); + __bindgen_bitfield_unit.set(6usize, 1u8, { + let isHdr10PlusSupported: u32 = unsafe { ::std::mem::transmute(isHdr10PlusSupported) }; + isHdr10PlusSupported as u64 + }); + __bindgen_bitfield_unit.set(7usize, 1u8, { + let isHdr10PlusGamingSupported: u32 = + unsafe { ::std::mem::transmute(isHdr10PlusGamingSupported) }; + isHdr10PlusGamingSupported as u64 + }); + __bindgen_bitfield_unit.set(8usize, 1u8, { + let isNvidiaCertifiedDisplay: u32 = + unsafe { ::std::mem::transmute(isNvidiaCertifiedDisplay) }; + isNvidiaCertifiedDisplay as u64 + }); + __bindgen_bitfield_unit.set(9usize, 23u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_HDR_CAPABILITIES_V3 = _NV_HDR_CAPABILITIES_V3; +pub type NV_HDR_CAPABILITIES = NV_HDR_CAPABILITIES_V3; +#[doc = "!< Get current HDR output configuration"] +pub const NV_HDR_CMD_NV_HDR_CMD_GET: NV_HDR_CMD = 0; +#[doc = "!< Set HDR output configuration"] +pub const NV_HDR_CMD_NV_HDR_CMD_SET: NV_HDR_CMD = 1; +#[doc = "! @}"] +pub type NV_HDR_CMD = ::std::os::raw::c_int; +#[doc = "!< Turn off HDR"] +pub const NV_HDR_MODE_NV_HDR_MODE_OFF: NV_HDR_MODE = 0; +#[doc = "!< Source: CCCS [a.k.a FP16 scRGB, linear, sRGB primaries, [-65504,0, 65504] range, RGB(1,1,1) = 80nits] Output : UHDA HDR [a.k.a HDR10, RGB/YCC 10/12bpc ST2084(PQ) EOTF RGB(1,1,1) = 10000 nits, Rec2020 color primaries, ST2086 static HDR metadata]. This is the only supported production HDR mode."] +pub const NV_HDR_MODE_NV_HDR_MODE_UHDA: NV_HDR_MODE = 2; +#[doc = "!< Experimental mode only, not for production! Source: HDR10 RGB 10bpc Output: HDR10 RGB 10 bpc - signal UHDA HDR mode (PQ + Rec2020) to the sink but send source pixel values unmodified (no PQ or Rec2020 conversions) - assumes source is already in HDR10 format."] +pub const NV_HDR_MODE_NV_HDR_MODE_UHDA_PASSTHROUGH: NV_HDR_MODE = 5; +#[doc = "!< Experimental mode only, not for production! Source: RGB8 Dolby Vision encoded (12 bpc YCbCr422 packed into RGB8) Output: Dolby Vision encoded : Application is to encoded frames in DV format and embed DV dynamic metadata as described in Dolby Vision specification."] +pub const NV_HDR_MODE_NV_HDR_MODE_DOLBY_VISION: NV_HDR_MODE = 7; +#[doc = "!< Do not use! Internal test mode only, to be removed. Source: CCCS (a.k.a FP16 scRGB) Output : EDR (Extended Dynamic Range) - HDR content is tonemapped and gamut mapped to output on regular SDR display set to max luminance ( ~300 nits )."] +pub const NV_HDR_MODE_NV_HDR_MODE_EDR: NV_HDR_MODE = 3; +#[doc = "!< Do not use! Internal test mode only, to be removed. Source: any Output: SDR (Standard Dynamic Range), we continuously send SDR EOTF InfoFrame signaling, HDMI compliance testing."] +pub const NV_HDR_MODE_NV_HDR_MODE_SDR: NV_HDR_MODE = 4; +#[doc = "!< Do not use! Internal test mode only, to be removed. Source: CCCS (a.k.a FP16 scRGB) Output : notebook HDR"] +pub const NV_HDR_MODE_NV_HDR_MODE_UHDA_NB: NV_HDR_MODE = 6; +#[doc = "!< Do not use! Obsolete, to be removed. NV_HDR_MODE_UHDBD == NV_HDR_MODE_UHDA, reflects obsolete pre-UHDA naming convention."] +pub const NV_HDR_MODE_NV_HDR_MODE_UHDBD: NV_HDR_MODE = 2; +pub type NV_HDR_MODE = ::std::os::raw::c_int; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_COLOR_DATA_V1 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Command get/set"] + pub cmd: NV_HDR_CMD, + #[doc = "!< HDR mode"] + pub hdrMode: NV_HDR_MODE, + #[doc = "!< Static Metadata Descriptor Id (0 for static metadata type 1)"] + pub static_metadata_descriptor_id: NV_STATIC_METADATA_DESCRIPTOR_ID, + pub mastering_display_data: _NV_HDR_COLOR_DATA_V1__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_COLOR_DATA_V1__bindgen_ty_1 { + #[doc = "!< x coordinate of color primary 0 (e.g. Red) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x0: NvU16, + #[doc = "!< y coordinate of color primary 0 (e.g. Red) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y0: NvU16, + #[doc = "!< x coordinate of color primary 1 (e.g. Green) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x1: NvU16, + #[doc = "!< y coordinate of color primary 1 (e.g. Green) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y1: NvU16, + #[doc = "!< x coordinate of color primary 2 (e.g. Blue) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x2: NvU16, + #[doc = "!< y coordinate of color primary 2 (e.g. Blue) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y2: NvU16, + #[doc = "!< x coordinate of white point of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_x: NvU16, + #[doc = "!< y coordinate of white point of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_y: NvU16, + #[doc = "!< Maximum display mastering luminance ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] + pub max_display_mastering_luminance: NvU16, + #[doc = "!< Minimum display mastering luminance ([0x0001-0xFFFF] = [1.0 - 6.55350] cd/m^2)"] + pub min_display_mastering_luminance: NvU16, + #[doc = "!< Maximum Content Light level (MaxCLL) ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] + pub max_content_light_level: NvU16, + #[doc = "!< Maximum Frame-Average Light Level (MaxFALL) ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] + pub max_frame_average_light_level: NvU16, +} +pub type NV_HDR_COLOR_DATA_V1 = _NV_HDR_COLOR_DATA_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_COLOR_DATA_V2 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Command get/set"] + pub cmd: NV_HDR_CMD, + #[doc = "!< HDR mode"] + pub hdrMode: NV_HDR_MODE, + #[doc = "!< Static Metadata Descriptor Id (0 for static metadata type 1)"] + pub static_metadata_descriptor_id: NV_STATIC_METADATA_DESCRIPTOR_ID, + pub mastering_display_data: _NV_HDR_COLOR_DATA_V2__bindgen_ty_1, + #[doc = "!< Optional, One of NV_COLOR_FORMAT enum values, if set it will apply requested color format for HDR session"] + pub hdrColorFormat: NV_COLOR_FORMAT, + #[doc = "!< Optional, One of NV_DYNAMIC_RANGE enum values, if set it will apply requested dynamic range for HDR session"] + pub hdrDynamicRange: NV_DYNAMIC_RANGE, + #[doc = "!< Optional, One of NV_BPC enum values, if set it will apply requested color depth\n!< Dolby Vision mode: DV supports specific combinations of colorformat, dynamic range and bpc. Please refer Dolby Vision specification.\n!< If invalid or no combination is passed driver will force default combination of RGB format + full range + 8bpc.\n!< HDR mode: These fields are ignored in hdr mode"] + pub hdrBpc: NV_BPC, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_COLOR_DATA_V2__bindgen_ty_1 { + #[doc = "!< x coordinate of color primary 0 (e.g. Red) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x0: NvU16, + #[doc = "!< y coordinate of color primary 0 (e.g. Red) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y0: NvU16, + #[doc = "!< x coordinate of color primary 1 (e.g. Green) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x1: NvU16, + #[doc = "!< y coordinate of color primary 1 (e.g. Green) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y1: NvU16, + #[doc = "!< x coordinate of color primary 2 (e.g. Blue) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x2: NvU16, + #[doc = "!< y coordinate of color primary 2 (e.g. Blue) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y2: NvU16, + #[doc = "!< x coordinate of white point of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_x: NvU16, + #[doc = "!< y coordinate of white point of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_y: NvU16, + #[doc = "!< Maximum display mastering luminance ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] + pub max_display_mastering_luminance: NvU16, + #[doc = "!< Minimum display mastering luminance ([0x0001-0xFFFF] = [1.0 - 6.55350] cd/m^2)"] + pub min_display_mastering_luminance: NvU16, + #[doc = "!< Maximum Content Light level (MaxCLL) ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] + pub max_content_light_level: NvU16, + #[doc = "!< Maximum Frame-Average Light Level (MaxFALL) ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] + pub max_frame_average_light_level: NvU16, +} +pub type NV_HDR_COLOR_DATA_V2 = _NV_HDR_COLOR_DATA_V2; +pub type NV_HDR_COLOR_DATA = NV_HDR_COLOR_DATA_V2; +#[doc = "!< sRGB IEC 61966-2-1:1999 == DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709"] +pub const _NV_COLORSPACE_TYPE_NV_COLORSPACE_sRGB: _NV_COLORSPACE_TYPE = 0; +#[doc = "!< FP16 linear with sRGB color primaries == DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709"] +pub const _NV_COLORSPACE_TYPE_NV_COLORSPACE_xRGB: _NV_COLORSPACE_TYPE = 1; +#[doc = "!< ITU-R Rec BT.2100 (HDR10) == DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020"] +pub const _NV_COLORSPACE_TYPE_NV_COLORSPACE_REC2100: _NV_COLORSPACE_TYPE = 12; +pub type _NV_COLORSPACE_TYPE = ::std::os::raw::c_int; +pub use self::_NV_COLORSPACE_TYPE as NV_COLORSPACE_TYPE; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_METADATA_V1 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< x coordinate of color primary 0 (e.g. Red) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x0: NvU16, + #[doc = "!< y coordinate of color primary 0 (e.g. Red) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y0: NvU16, + #[doc = "!< x coordinate of color primary 1 (e.g. Green) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x1: NvU16, + #[doc = "!< y coordinate of color primary 1 (e.g. Green) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y1: NvU16, + #[doc = "!< x coordinate of color primary 2 (e.g. Blue) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x2: NvU16, + #[doc = "!< y coordinate of color primary 2 (e.g. Blue) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y2: NvU16, + #[doc = "!< x coordinate of white point of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_x: NvU16, + #[doc = "!< y coordinate of white point of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_y: NvU16, + #[doc = "!< Maximum display mastering luminance ([0x0000-0xFFFF] = [0.0 - 65535.0] cd/m^2, in units of 1 cd/m^2)"] + pub max_display_mastering_luminance: NvU16, + #[doc = "!< Minimum display mastering luminance ([0x0000-0xFFFF] = [0.0 - 6.55350] cd/m^2, in units of 0.0001 cd/m^2)"] + pub min_display_mastering_luminance: NvU16, + #[doc = "!< Maximum Content Light level (MaxCLL) ([0x0000-0xFFFF] = [0.0 - 65535.0] cd/m^2, in units of 1 cd/m^2)"] + pub max_content_light_level: NvU16, + #[doc = "!< Maximum Frame-Average Light Level (MaxFALL) ([0x0000-0xFFFF] = [0.0 - 65535.0] cd/m^2, in units of 1 cd/m^2)"] + pub max_frame_average_light_level: NvU16, +} +pub type NV_HDR_METADATA_V1 = _NV_HDR_METADATA_V1; +pub type NV_HDR_METADATA = NV_HDR_METADATA_V1; +pub const _NV_DISPLAY_OUTPUT_MODE_NV_DISPLAY_OUTPUT_MODE_SDR: _NV_DISPLAY_OUTPUT_MODE = 0; +pub const _NV_DISPLAY_OUTPUT_MODE_NV_DISPLAY_OUTPUT_MODE_HDR10: _NV_DISPLAY_OUTPUT_MODE = 1; +pub const _NV_DISPLAY_OUTPUT_MODE_NV_DISPLAY_OUTPUT_MODE_HDR10PLUS_GAMING: _NV_DISPLAY_OUTPUT_MODE = + 2; +pub type _NV_DISPLAY_OUTPUT_MODE = ::std::os::raw::c_int; +pub use self::_NV_DISPLAY_OUTPUT_MODE as NV_DISPLAY_OUTPUT_MODE; +pub const _NV_HDR_TONEMAPPING_METHOD_NV_HDR_TONEMAPPING_APP: _NV_HDR_TONEMAPPING_METHOD = 0; +pub const _NV_HDR_TONEMAPPING_METHOD_NV_HDR_TONEMAPPING_GPU: _NV_HDR_TONEMAPPING_METHOD = 1; +pub type _NV_HDR_TONEMAPPING_METHOD = ::std::os::raw::c_int; +pub use self::_NV_HDR_TONEMAPPING_METHOD as NV_HDR_TONEMAPPING_METHOD; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_DISPLAY_COLORIMETRY_V1 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< min luminance, cd/m^2"] + pub min_luminance: f32, + #[doc = "!< max 100% frame luminance, cd/m^2"] + pub max_full_frame_luminance: f32, + #[doc = "!< max 10% frame luminance, cd/m^2"] + pub max_luminance: f32, + #[doc = "!< HDR brightness luminance scaling factor applied by GPU on output pixels"] + pub hdrBrightnessLuminanceScalingFactor: f32, + #[doc = "!< red primary chromaticity coordinate x"] + pub red_primary_x: f32, + #[doc = "!< red primary chromaticity coordinate y"] + pub red_primary_y: f32, + #[doc = "!< green primary chromaticity coordinate x"] + pub green_primary_x: f32, + #[doc = "!< green primary chromaticity coordinate y"] + pub green_primary_y: f32, + #[doc = "!< blue primary chromaticity coordinate x"] + pub blue_primary_x: f32, + #[doc = "!< blue primary chromaticity coordinate y"] + pub blue_primary_y: f32, + #[doc = "!< white point chromaticity coordinate x"] + pub white_point_x: f32, + #[doc = "!< white point chromaticity coordinate y"] + pub white_point_y: f32, +} +pub type NV_DISPLAY_COLORIMETRY_V1 = _NV_DISPLAY_COLORIMETRY_V1; +pub type NV_DISPLAY_COLORIMETRY = NV_DISPLAY_COLORIMETRY_V1; +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_DISP_GetTiming()."] +#[repr(C)] +#[repr(align(4))] +#[derive(Copy, Clone)] +pub struct NV_TIMING_FLAG { + pub _bitfield_align_1: [u16; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>, + pub __bindgen_anon_1: NV_TIMING_FLAG__bindgen_ty_1, + pub _bitfield_align_2: [u8; 0], + pub _bitfield_2: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 5usize], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union NV_TIMING_FLAG__bindgen_ty_1 { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>, +} +impl NV_TIMING_FLAG__bindgen_ty_1 { + #[inline] + pub fn tvFormat(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) } + } + #[inline] + pub fn set_tvFormat(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn tvFormat_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_tvFormat_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn ceaId(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 8u8) as u32) } + } + #[inline] + pub fn set_ceaId(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn ceaId_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 8usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_ceaId_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 8usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn nvPsfId(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 8u8) as u32) } + } + #[inline] + pub fn set_nvPsfId(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(16usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn nvPsfId_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 16usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_nvPsfId_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 16usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + tvFormat: NvU32, + ceaId: NvU32, + nvPsfId: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 3usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 8u8, { + let tvFormat: u32 = unsafe { ::std::mem::transmute(tvFormat) }; + tvFormat as u64 + }); + __bindgen_bitfield_unit.set(8usize, 8u8, { + let ceaId: u32 = unsafe { ::std::mem::transmute(ceaId) }; + ceaId as u64 + }); + __bindgen_bitfield_unit.set(16usize, 8u8, { + let nvPsfId: u32 = unsafe { ::std::mem::transmute(nvPsfId) }; + nvPsfId as u64 + }); + __bindgen_bitfield_unit + } +} +impl NV_TIMING_FLAG { + #[inline] + pub fn isInterlaced(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32) } + } + #[inline] + pub fn set_isInterlaced(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn isInterlaced_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 4u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isInterlaced_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved0(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 12u8) as u32) } + } + #[inline] + pub fn set_reserved0(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 12u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved0_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 12u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved0_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 12u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isInterlaced: NvU32, + reserved0: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 2usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 4u8, { + let isInterlaced: u32 = unsafe { ::std::mem::transmute(isInterlaced) }; + isInterlaced as u64 + }); + __bindgen_bitfield_unit.set(4usize, 12u8, { + let reserved0: u32 = unsafe { ::std::mem::transmute(reserved0) }; + reserved0 as u64 + }); + __bindgen_bitfield_unit + } + #[inline] + pub fn scaling(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 8u8) as u32) } + } + #[inline] + pub fn set_scaling(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_2.set(0usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn scaling_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_2), + 0usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_scaling_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 0usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_2(scaling: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 8u8, { + let scaling: u32 = unsafe { ::std::mem::transmute(scaling) }; + scaling as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_DISP_GetTiming()."] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_TIMING_INPUT { + #[doc = "!< (IN) structure version"] + pub version: NvU32, + #[doc = "!< Visible horizontal size"] + pub width: NvU32, + #[doc = "!< Visible vertical size"] + pub height: NvU32, + #[doc = "!< Timing refresh rate"] + pub rr: f32, + #[doc = "!< Flag containing additional info for timing calculation."] + pub flag: NV_TIMING_FLAG, + #[doc = "!< Timing type(formula) to use for calculating the timing"] + pub type_: NV_TIMING_OVERRIDE, +} +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_DISP_GetTiming()."] +pub type NV_TIMING_INPUT = _NV_TIMING_INPUT; +pub const NV_MONITOR_CAPS_TYPE_NV_MONITOR_CAPS_TYPE_HDMI_VSDB: NV_MONITOR_CAPS_TYPE = 4096; +pub const NV_MONITOR_CAPS_TYPE_NV_MONITOR_CAPS_TYPE_HDMI_VCDB: NV_MONITOR_CAPS_TYPE = 4097; +pub const NV_MONITOR_CAPS_TYPE_NV_MONITOR_CAPS_TYPE_GENERIC: NV_MONITOR_CAPS_TYPE = 4098; +#[doc = "! HDMI-related and extended CAPs"] +pub type NV_MONITOR_CAPS_TYPE = ::std::os::raw::c_int; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MONITOR_CAPS_VCDB { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, +} +impl _NV_MONITOR_CAPS_VCDB { + #[inline] + pub fn quantizationRangeYcc(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) } + } + #[inline] + pub fn set_quantizationRangeYcc(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn quantizationRangeYcc_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_quantizationRangeYcc_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn quantizationRangeRgb(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) } + } + #[inline] + pub fn set_quantizationRangeRgb(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn quantizationRangeRgb_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_quantizationRangeRgb_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn scanInfoPreferredVideoFormat(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 2u8) as u8) } + } + #[inline] + pub fn set_scanInfoPreferredVideoFormat(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn scanInfoPreferredVideoFormat_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 2u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_scanInfoPreferredVideoFormat_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn scanInfoITVideoFormats(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 2u8) as u8) } + } + #[inline] + pub fn set_scanInfoITVideoFormats(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn scanInfoITVideoFormats_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 2u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_scanInfoITVideoFormats_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn scanInfoCEVideoFormats(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 2u8) as u8) } + } + #[inline] + pub fn set_scanInfoCEVideoFormats(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn scanInfoCEVideoFormats_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 6usize, + 2u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_scanInfoCEVideoFormats_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + quantizationRangeYcc: NvU8, + quantizationRangeRgb: NvU8, + scanInfoPreferredVideoFormat: NvU8, + scanInfoITVideoFormats: NvU8, + scanInfoCEVideoFormats: NvU8, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let quantizationRangeYcc: u8 = unsafe { ::std::mem::transmute(quantizationRangeYcc) }; + quantizationRangeYcc as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let quantizationRangeRgb: u8 = unsafe { ::std::mem::transmute(quantizationRangeRgb) }; + quantizationRangeRgb as u64 + }); + __bindgen_bitfield_unit.set(2usize, 2u8, { + let scanInfoPreferredVideoFormat: u8 = + unsafe { ::std::mem::transmute(scanInfoPreferredVideoFormat) }; + scanInfoPreferredVideoFormat as u64 + }); + __bindgen_bitfield_unit.set(4usize, 2u8, { + let scanInfoITVideoFormats: u8 = + unsafe { ::std::mem::transmute(scanInfoITVideoFormats) }; + scanInfoITVideoFormats as u64 + }); + __bindgen_bitfield_unit.set(6usize, 2u8, { + let scanInfoCEVideoFormats: u8 = + unsafe { ::std::mem::transmute(scanInfoCEVideoFormats) }; + scanInfoCEVideoFormats as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_MONITOR_CAPS_VCDB = _NV_MONITOR_CAPS_VCDB; +#[doc = "! See NvAPI_DISP_GetMonitorCapabilities()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MONITOR_CAPS_VSDB { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>, + #[doc = "!< Bye 4"] + pub maxTmdsClock: NvU8, + pub _bitfield_align_2: [u8; 0], + pub _bitfield_2: __BindgenBitfieldUnit<[u8; 1usize]>, + #[doc = "!< Byte 6"] + pub videoLatency: NvU8, + #[doc = "!< Byte 7"] + pub audioLatency: NvU8, + #[doc = "!< Byte 8"] + pub interlacedVideoLatency: NvU8, + #[doc = "!< Byte 9"] + pub interlacedAudioLatency: NvU8, + pub _bitfield_align_3: [u8; 0], + pub _bitfield_3: __BindgenBitfieldUnit<[u8; 2usize]>, + #[doc = "!< Keeping maximum length for 3 bits"] + pub hdmi_vic: [NvU8; 7usize], + #[doc = "!< Keeping maximum length for 5 bits"] + pub hdmi_3d: [NvU8; 31usize], +} +impl _NV_MONITOR_CAPS_VSDB { + #[inline] + pub fn sourcePhysicalAddressB(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u8) } + } + #[inline] + pub fn set_sourcePhysicalAddressB(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn sourcePhysicalAddressB_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 4u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_sourcePhysicalAddressB_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn sourcePhysicalAddressA(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u8) } + } + #[inline] + pub fn set_sourcePhysicalAddressA(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn sourcePhysicalAddressA_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 4u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_sourcePhysicalAddressA_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn sourcePhysicalAddressD(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 4u8) as u8) } + } + #[inline] + pub fn set_sourcePhysicalAddressD(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn sourcePhysicalAddressD_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 8usize, + 4u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_sourcePhysicalAddressD_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 8usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn sourcePhysicalAddressC(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 4u8) as u8) } + } + #[inline] + pub fn set_sourcePhysicalAddressC(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(12usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn sourcePhysicalAddressC_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 12usize, + 4u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_sourcePhysicalAddressC_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 12usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn supportDualDviOperation(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u8) } + } + #[inline] + pub fn set_supportDualDviOperation(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(16usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supportDualDviOperation_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 16usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_supportDualDviOperation_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 16usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved6(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 2u8) as u8) } + } + #[inline] + pub fn set_reserved6(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(17usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved6_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 17usize, + 2u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_reserved6_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 17usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn supportDeepColorYCbCr444(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u8) } + } + #[inline] + pub fn set_supportDeepColorYCbCr444(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(19usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supportDeepColorYCbCr444_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 19usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_supportDeepColorYCbCr444_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 19usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn supportDeepColor30bits(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u8) } + } + #[inline] + pub fn set_supportDeepColor30bits(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(20usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supportDeepColor30bits_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 20usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_supportDeepColor30bits_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 20usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn supportDeepColor36bits(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u8) } + } + #[inline] + pub fn set_supportDeepColor36bits(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(21usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supportDeepColor36bits_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 21usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_supportDeepColor36bits_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 21usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn supportDeepColor48bits(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u8) } + } + #[inline] + pub fn set_supportDeepColor48bits(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(22usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supportDeepColor48bits_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 22usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_supportDeepColor48bits_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 22usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn supportAI(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u8) } + } + #[inline] + pub fn set_supportAI(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(23usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supportAI_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 23usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_supportAI_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 23usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + sourcePhysicalAddressB: NvU8, + sourcePhysicalAddressA: NvU8, + sourcePhysicalAddressD: NvU8, + sourcePhysicalAddressC: NvU8, + supportDualDviOperation: NvU8, + reserved6: NvU8, + supportDeepColorYCbCr444: NvU8, + supportDeepColor30bits: NvU8, + supportDeepColor36bits: NvU8, + supportDeepColor48bits: NvU8, + supportAI: NvU8, + ) -> __BindgenBitfieldUnit<[u8; 3usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 4u8, { + let sourcePhysicalAddressB: u8 = + unsafe { ::std::mem::transmute(sourcePhysicalAddressB) }; + sourcePhysicalAddressB as u64 + }); + __bindgen_bitfield_unit.set(4usize, 4u8, { + let sourcePhysicalAddressA: u8 = + unsafe { ::std::mem::transmute(sourcePhysicalAddressA) }; + sourcePhysicalAddressA as u64 + }); + __bindgen_bitfield_unit.set(8usize, 4u8, { + let sourcePhysicalAddressD: u8 = + unsafe { ::std::mem::transmute(sourcePhysicalAddressD) }; + sourcePhysicalAddressD as u64 + }); + __bindgen_bitfield_unit.set(12usize, 4u8, { + let sourcePhysicalAddressC: u8 = + unsafe { ::std::mem::transmute(sourcePhysicalAddressC) }; + sourcePhysicalAddressC as u64 + }); + __bindgen_bitfield_unit.set(16usize, 1u8, { + let supportDualDviOperation: u8 = + unsafe { ::std::mem::transmute(supportDualDviOperation) }; + supportDualDviOperation as u64 + }); + __bindgen_bitfield_unit.set(17usize, 2u8, { + let reserved6: u8 = unsafe { ::std::mem::transmute(reserved6) }; + reserved6 as u64 + }); + __bindgen_bitfield_unit.set(19usize, 1u8, { + let supportDeepColorYCbCr444: u8 = + unsafe { ::std::mem::transmute(supportDeepColorYCbCr444) }; + supportDeepColorYCbCr444 as u64 + }); + __bindgen_bitfield_unit.set(20usize, 1u8, { + let supportDeepColor30bits: u8 = + unsafe { ::std::mem::transmute(supportDeepColor30bits) }; + supportDeepColor30bits as u64 + }); + __bindgen_bitfield_unit.set(21usize, 1u8, { + let supportDeepColor36bits: u8 = + unsafe { ::std::mem::transmute(supportDeepColor36bits) }; + supportDeepColor36bits as u64 + }); + __bindgen_bitfield_unit.set(22usize, 1u8, { + let supportDeepColor48bits: u8 = + unsafe { ::std::mem::transmute(supportDeepColor48bits) }; + supportDeepColor48bits as u64 + }); + __bindgen_bitfield_unit.set(23usize, 1u8, { + let supportAI: u8 = unsafe { ::std::mem::transmute(supportAI) }; + supportAI as u64 + }); + __bindgen_bitfield_unit + } + #[inline] + pub fn cnc0SupportGraphicsTextContent(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 1u8) as u8) } + } + #[inline] + pub fn set_cnc0SupportGraphicsTextContent(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_2.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn cnc0SupportGraphicsTextContent_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_2), + 0usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_cnc0SupportGraphicsTextContent_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn cnc1SupportPhotoContent(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(1usize, 1u8) as u8) } + } + #[inline] + pub fn set_cnc1SupportPhotoContent(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_2.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn cnc1SupportPhotoContent_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_2), + 1usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_cnc1SupportPhotoContent_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn cnc2SupportCinemaContent(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(2usize, 1u8) as u8) } + } + #[inline] + pub fn set_cnc2SupportCinemaContent(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_2.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn cnc2SupportCinemaContent_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_2), + 2usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_cnc2SupportCinemaContent_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn cnc3SupportGameContent(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(3usize, 1u8) as u8) } + } + #[inline] + pub fn set_cnc3SupportGameContent(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_2.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn cnc3SupportGameContent_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_2), + 3usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_cnc3SupportGameContent_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved8(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(4usize, 1u8) as u8) } + } + #[inline] + pub fn set_reserved8(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_2.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved8_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_2), + 4usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_reserved8_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn hasVicEntries(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(5usize, 1u8) as u8) } + } + #[inline] + pub fn set_hasVicEntries(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_2.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn hasVicEntries_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_2), + 5usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_hasVicEntries_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn hasInterlacedLatencyField(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(6usize, 1u8) as u8) } + } + #[inline] + pub fn set_hasInterlacedLatencyField(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_2.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn hasInterlacedLatencyField_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_2), + 6usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_hasInterlacedLatencyField_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 6usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn hasLatencyField(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(7usize, 1u8) as u8) } + } + #[inline] + pub fn set_hasLatencyField(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_2.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn hasLatencyField_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_2), + 7usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_hasLatencyField_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 7usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_2( + cnc0SupportGraphicsTextContent: NvU8, + cnc1SupportPhotoContent: NvU8, + cnc2SupportCinemaContent: NvU8, + cnc3SupportGameContent: NvU8, + reserved8: NvU8, + hasVicEntries: NvU8, + hasInterlacedLatencyField: NvU8, + hasLatencyField: NvU8, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let cnc0SupportGraphicsTextContent: u8 = + unsafe { ::std::mem::transmute(cnc0SupportGraphicsTextContent) }; + cnc0SupportGraphicsTextContent as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let cnc1SupportPhotoContent: u8 = + unsafe { ::std::mem::transmute(cnc1SupportPhotoContent) }; + cnc1SupportPhotoContent as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let cnc2SupportCinemaContent: u8 = + unsafe { ::std::mem::transmute(cnc2SupportCinemaContent) }; + cnc2SupportCinemaContent as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let cnc3SupportGameContent: u8 = + unsafe { ::std::mem::transmute(cnc3SupportGameContent) }; + cnc3SupportGameContent as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let reserved8: u8 = unsafe { ::std::mem::transmute(reserved8) }; + reserved8 as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let hasVicEntries: u8 = unsafe { ::std::mem::transmute(hasVicEntries) }; + hasVicEntries as u64 + }); + __bindgen_bitfield_unit.set(6usize, 1u8, { + let hasInterlacedLatencyField: u8 = + unsafe { ::std::mem::transmute(hasInterlacedLatencyField) }; + hasInterlacedLatencyField as u64 + }); + __bindgen_bitfield_unit.set(7usize, 1u8, { + let hasLatencyField: u8 = unsafe { ::std::mem::transmute(hasLatencyField) }; + hasLatencyField as u64 + }); + __bindgen_bitfield_unit + } + #[inline] + pub fn reserved13(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_3.get(0usize, 7u8) as u8) } + } + #[inline] + pub fn set_reserved13(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_3.set(0usize, 7u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved13_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_3), + 0usize, + 7u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_reserved13_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_3), + 0usize, + 7u8, + val as u64, + ) + } + } + #[inline] + pub fn has3dEntries(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_3.get(7usize, 1u8) as u8) } + } + #[inline] + pub fn set_has3dEntries(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_3.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn has3dEntries_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_3), + 7usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_has3dEntries_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_3), + 7usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn hdmi3dLength(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_3.get(8usize, 5u8) as u8) } + } + #[inline] + pub fn set_hdmi3dLength(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_3.set(8usize, 5u8, val as u64) + } + } + #[inline] + pub unsafe fn hdmi3dLength_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_3), + 8usize, + 5u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_hdmi3dLength_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_3), + 8usize, + 5u8, + val as u64, + ) + } + } + #[inline] + pub fn hdmiVicLength(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_3.get(13usize, 3u8) as u8) } + } + #[inline] + pub fn set_hdmiVicLength(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_3.set(13usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn hdmiVicLength_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_3), + 13usize, + 3u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_hdmiVicLength_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_3), + 13usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_3( + reserved13: NvU8, + has3dEntries: NvU8, + hdmi3dLength: NvU8, + hdmiVicLength: NvU8, + ) -> __BindgenBitfieldUnit<[u8; 2usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 7u8, { + let reserved13: u8 = unsafe { ::std::mem::transmute(reserved13) }; + reserved13 as u64 + }); + __bindgen_bitfield_unit.set(7usize, 1u8, { + let has3dEntries: u8 = unsafe { ::std::mem::transmute(has3dEntries) }; + has3dEntries as u64 + }); + __bindgen_bitfield_unit.set(8usize, 5u8, { + let hdmi3dLength: u8 = unsafe { ::std::mem::transmute(hdmi3dLength) }; + hdmi3dLength as u64 + }); + __bindgen_bitfield_unit.set(13usize, 3u8, { + let hdmiVicLength: u8 = unsafe { ::std::mem::transmute(hdmiVicLength) }; + hdmiVicLength as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! See NvAPI_DISP_GetMonitorCapabilities()."] +pub type NV_MONITOR_CAPS_VSDB = _NV_MONITOR_CAPS_VSDB; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MONITOR_CAPS_GENERIC { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, +} +impl _NV_MONITOR_CAPS_GENERIC { + #[inline] + pub fn supportVRR(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) } + } + #[inline] + pub fn set_supportVRR(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supportVRR_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_supportVRR_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn supportULMB(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) } + } + #[inline] + pub fn set_supportULMB(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supportULMB_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_supportULMB_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isTrueGsync(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) } + } + #[inline] + pub fn set_isTrueGsync(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isTrueGsync_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_isTrueGsync_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isRLACapable(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) } + } + #[inline] + pub fn set_isRLACapable(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isRLACapable_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_isRLACapable_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn currentlyCapableOfVRR(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) } + } + #[inline] + pub fn set_currentlyCapableOfVRR(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn currentlyCapableOfVRR_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_currentlyCapableOfVRR_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isBasicVRR(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) } + } + #[inline] + pub fn set_isBasicVRR(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isBasicVRR_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_isBasicVRR_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 2u8) as u8) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 6usize, + 2u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + supportVRR: NvU8, + supportULMB: NvU8, + isTrueGsync: NvU8, + isRLACapable: NvU8, + currentlyCapableOfVRR: NvU8, + isBasicVRR: NvU8, + reserved: NvU8, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let supportVRR: u8 = unsafe { ::std::mem::transmute(supportVRR) }; + supportVRR as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let supportULMB: u8 = unsafe { ::std::mem::transmute(supportULMB) }; + supportULMB as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let isTrueGsync: u8 = unsafe { ::std::mem::transmute(isTrueGsync) }; + isTrueGsync as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let isRLACapable: u8 = unsafe { ::std::mem::transmute(isRLACapable) }; + isRLACapable as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let currentlyCapableOfVRR: u8 = unsafe { ::std::mem::transmute(currentlyCapableOfVRR) }; + currentlyCapableOfVRR as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let isBasicVRR: u8 = unsafe { ::std::mem::transmute(isBasicVRR) }; + isBasicVRR as u64 + }); + __bindgen_bitfield_unit.set(6usize, 2u8, { + let reserved: u8 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_MONITOR_CAPS_GENERIC = _NV_MONITOR_CAPS_GENERIC; +#[doc = "! See NvAPI_DISP_GetMonitorCapabilities()."] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_MONITOR_CAPABILITIES_V1 { + pub version: NvU32, + pub size: NvU16, + pub infoType: NvU32, + #[doc = "!< Out: VGA, TV, DVI, HDMI, DP"] + pub connectorType: NvU32, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub data: _NV_MONITOR_CAPABILITIES_V1__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union _NV_MONITOR_CAPABILITIES_V1__bindgen_ty_1 { + pub vsdb: NV_MONITOR_CAPS_VSDB, + pub vcdb: NV_MONITOR_CAPS_VCDB, + pub caps: NV_MONITOR_CAPS_GENERIC, +} +impl _NV_MONITOR_CAPABILITIES_V1 { + #[inline] + pub fn bIsValidInfo(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) } + } + #[inline] + pub fn set_bIsValidInfo(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsValidInfo_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_bIsValidInfo_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1(bIsValidInfo: NvU8) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsValidInfo: u8 = unsafe { ::std::mem::transmute(bIsValidInfo) }; + bIsValidInfo as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! See NvAPI_DISP_GetMonitorCapabilities()."] +pub type NV_MONITOR_CAPABILITIES_V1 = _NV_MONITOR_CAPABILITIES_V1; +#[doc = "! See NvAPI_DISP_GetMonitorCapabilities()."] +pub type NV_MONITOR_CAPABILITIES = NV_MONITOR_CAPABILITIES_V1; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MONITOR_COLOR_DATA { + pub version: NvU32, + #[doc = "!< One of the supported color formats"] + pub colorFormat: NV_DP_COLOR_FORMAT, + #[doc = "!< One of the supported bit depths"] + pub backendBitDepths: NV_DP_BPC, +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_MONITOR_COLOR_CAPS_V1 = _NV_MONITOR_COLOR_DATA; +#[doc = "! \\ingroup dispcontrol"] +pub type NV_MONITOR_COLOR_CAPS = NV_MONITOR_COLOR_CAPS_V1; +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_DISP_EnumCustomDisplay() and NvAPI_DISP_TryCustomDisplay()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_CUSTOM_DISPLAY { + pub version: NvU32, + #[doc = "!< Source surface(source mode) width"] + pub width: NvU32, + #[doc = "!< Source surface(source mode) height"] + pub height: NvU32, + #[doc = "!< Source surface color depth.\"0\" means all 8/16/32bpp"] + pub depth: NvU32, + #[doc = "!< Color format (optional)"] + pub colorFormat: NV_FORMAT, + #[doc = "!< For multimon support, should be set to (0,0,1.0,1.0) for now."] + pub srcPartition: NV_VIEWPORTF, + #[doc = "!< Horizontal scaling ratio"] + pub xRatio: f32, + #[doc = "!< Vertical scaling ratio"] + pub yRatio: f32, + #[doc = "!< Timing used to program TMDS/DAC/LVDS/HDMI/TVEncoder, etc."] + pub timing: NV_TIMING, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +impl NV_CUSTOM_DISPLAY { + #[inline] + pub fn hwModeSetOnly(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_hwModeSetOnly(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn hwModeSetOnly_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_hwModeSetOnly_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1(hwModeSetOnly: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let hwModeSetOnly: u32 = unsafe { ::std::mem::transmute(hwModeSetOnly) }; + hwModeSetOnly as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup dispcontrol\n! @{"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_EDID_DATA_V1 { + #[doc = "!< Structure version."] + pub version: NvU32, + #[doc = "!< Pointer to EDID data."] + pub pEDID: *mut NvU8, + #[doc = "!< Size of EDID data."] + pub sizeOfEDID: NvU32, +} +#[doc = "! \\ingroup dispcontrol\n! @{"] +pub type NV_EDID_DATA_V1 = _NV_EDID_DATA_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_EDID_DATA_V2 { + #[doc = "!< Structure version."] + pub version: NvU32, + #[doc = "!< Pointer to EDID data."] + pub pEDID: *mut NvU8, + #[doc = "!< Size of EDID data."] + pub sizeOfEDID: NvU32, + #[doc = "!< Reserved for future use."] + pub reserved: [NvU32; 8usize], +} +pub type NV_EDID_DATA_V2 = _NV_EDID_DATA_V2; +pub type NV_EDID_DATA = NV_EDID_DATA_V2; +#[doc = "! @}"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GET_ADAPTIVE_SYNC_DATA_V1 { + #[doc = "!< [in] structure version"] + pub version: NvU32, + #[doc = "!< [out] maximum frame interval in micro seconds as set previously using NvAPI_DISP_SetAdaptiveSyncData function."] + pub maxFrameInterval: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< [out] Number of times the last flip was shown on the screen"] + pub lastFlipRefreshCount: NvU32, + #[doc = "!< [out] Timestamp for the lastest flip on the screen"] + pub lastFlipTimeStamp: NvU64, + #[doc = "!< reserved for future use."] + pub reservedEx: [NvU32; 4usize], +} +impl _NV_GET_ADAPTIVE_SYNC_DATA_V1 { + #[inline] + pub fn bDisableAdaptiveSync(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bDisableAdaptiveSync(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bDisableAdaptiveSync_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bDisableAdaptiveSync_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bDisableFrameSplitting(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bDisableFrameSplitting(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bDisableFrameSplitting_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bDisableFrameSplitting_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 30u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 30u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 30u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bDisableAdaptiveSync: NvU32, + bDisableFrameSplitting: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bDisableAdaptiveSync: u32 = unsafe { ::std::mem::transmute(bDisableAdaptiveSync) }; + bDisableAdaptiveSync as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bDisableFrameSplitting: u32 = + unsafe { ::std::mem::transmute(bDisableFrameSplitting) }; + bDisableFrameSplitting as u64 + }); + __bindgen_bitfield_unit.set(2usize, 30u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! @}"] +pub type NV_GET_ADAPTIVE_SYNC_DATA_V1 = _NV_GET_ADAPTIVE_SYNC_DATA_V1; +#[doc = "! @}"] +pub type NV_GET_ADAPTIVE_SYNC_DATA = NV_GET_ADAPTIVE_SYNC_DATA_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_SET_ADAPTIVE_SYNC_DATA_V1 { + #[doc = "!< [in] structure version"] + pub version: NvU32, + #[doc = "!< [in] deprecated, please use maxFrameIntervalNs instead\n!< If maxFrameInterval is sent as 0, default values from EDID will be used."] + pub maxFrameInterval: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Ensure the alignment is 8 bytes and reserve it for future use."] + pub reserved1: NvU32, + #[doc = "!< [in] maximum frame interval in nano seconds.\n!< If maxFrameIntervalNs is sent as 0, default values from EDID will be used."] + pub maxFrameIntervalNs: NvU64, + #[doc = "!< reserved for future use."] + pub reservedEx: [NvU32; 4usize], +} +impl _NV_SET_ADAPTIVE_SYNC_DATA_V1 { + #[inline] + pub fn bDisableAdaptiveSync(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bDisableAdaptiveSync(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bDisableAdaptiveSync_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bDisableAdaptiveSync_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bDisableFrameSplitting(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bDisableFrameSplitting(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bDisableFrameSplitting_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bDisableFrameSplitting_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 30u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 30u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 30u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bDisableAdaptiveSync: NvU32, + bDisableFrameSplitting: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bDisableAdaptiveSync: u32 = unsafe { ::std::mem::transmute(bDisableAdaptiveSync) }; + bDisableAdaptiveSync as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bDisableFrameSplitting: u32 = + unsafe { ::std::mem::transmute(bDisableFrameSplitting) }; + bDisableFrameSplitting as u64 + }); + __bindgen_bitfield_unit.set(2usize, 30u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_SET_ADAPTIVE_SYNC_DATA_V1 = _NV_SET_ADAPTIVE_SYNC_DATA_V1; +pub type NV_SET_ADAPTIVE_SYNC_DATA = NV_SET_ADAPTIVE_SYNC_DATA_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GET_VIRTUAL_REFRESH_RATE_DATA_V1 { + #[doc = "!< [in] structure version"] + pub version: NvU32, + #[doc = "!< [out] frame interval in micro seconds if Virtual RR is currently applied"] + pub frameIntervalUs: NvU32, + #[doc = "!< [out] Refresh Rate * 1000"] + pub rrx1k: NvU32, + #[doc = "!< [out] If the content is Gaming"] + pub bIsGamingVrr: NvU32, + #[doc = "!< reserved for future use."] + pub reservedEx: [NvU32; 6usize], +} +pub type NV_GET_VIRTUAL_REFRESH_RATE_DATA_V1 = _NV_GET_VIRTUAL_REFRESH_RATE_DATA_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GET_VIRTUAL_REFRESH_RATE_DATA_V2 { + #[doc = "!< [in] structure version"] + pub version: NvU32, + #[doc = "!< [out] frame interval in micro seconds if Virtual RR is currently applied. This variable is deprecated in V2 and should not be used."] + pub frameIntervalUs: NvU32, + #[doc = "!< [out] Refresh Rate * 1000"] + pub rrx1k: NvU32, + #[doc = "!< [out] If the content is Gaming"] + pub bIsGamingVrr: NvU32, + #[doc = "!< [out] frame interval in nano seconds if Virtual RR is currently applied"] + pub frameIntervalNs: NvU64, + #[doc = "!< reserved for future use."] + pub reservedEx: [NvU32; 4usize], +} +pub type NV_GET_VIRTUAL_REFRESH_RATE_DATA_V2 = _NV_GET_VIRTUAL_REFRESH_RATE_DATA_V2; +pub type NV_GET_VIRTUAL_REFRESH_RATE_DATA = NV_GET_VIRTUAL_REFRESH_RATE_DATA_V2; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_SET_VIRTUAL_REFRESH_RATE_DATA_V1 { + #[doc = "!< [in] structure version"] + pub version: NvU32, + #[doc = "!< [in] frame interval in micro seconds if Virtual RR is currently applied"] + pub frameIntervalUs: NvU32, + #[doc = "!< [in] Refresh Rate * 1000"] + pub rrx1k: NvU32, + #[doc = "!< [in] If the content is Gaming"] + pub bIsGamingVrr: NvU32, + #[doc = "!< reserved for future use."] + pub reservedEx: [NvU32; 6usize], +} +pub type NV_SET_VIRTUAL_REFRESH_RATE_DATA_V1 = _NV_SET_VIRTUAL_REFRESH_RATE_DATA_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_SET_VIRTUAL_REFRESH_RATE_DATA_V2 { + #[doc = "!< [in] structure version"] + pub version: NvU32, + #[doc = "!< [in] frame interval in micro seconds if Virtual RR is currently applied. This variable is deprecated in V2 and should not be used."] + pub frameIntervalUs: NvU32, + #[doc = "!< [in] Refresh Rate * 1000"] + pub rrx1k: NvU32, + #[doc = "!< [in] If the content is Gaming"] + pub bIsGamingVrr: NvU32, + #[doc = "!< [in] frame interval in nano seconds if Virtual RR is currently applied"] + pub frameIntervalNs: NvU64, + #[doc = "!< reserved for future use."] + pub reservedEx: [NvU32; 4usize], +} +pub type NV_SET_VIRTUAL_REFRESH_RATE_DATA_V2 = _NV_SET_VIRTUAL_REFRESH_RATE_DATA_V2; +pub type NV_SET_VIRTUAL_REFRESH_RATE_DATA = NV_SET_VIRTUAL_REFRESH_RATE_DATA_V2; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_SET_PREFERRED_STEREO_DISPLAY_V1 { + #[doc = "!< [in] Structure version"] + pub version: NvU32, + #[doc = "!< [in] Monitor Identifier to be set"] + pub displayId: NvU32, + #[doc = "!< Reserved for future use without adding versioning"] + pub reserved: NvU32, +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_SET_PREFERRED_STEREO_DISPLAY = NV_SET_PREFERRED_STEREO_DISPLAY_V1; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GET_PREFERRED_STEREO_DISPLAY_V1 { + #[doc = "!< [in] Structure version"] + pub version: NvU32, + #[doc = "!< [out] The queried stereo display"] + pub displayId: NvU32, + #[doc = "!< Reserved for future use without adding versioning"] + pub reserved: NvU32, +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_GET_PREFERRED_STEREO_DISPLAY = NV_GET_PREFERRED_STEREO_DISPLAY_V1; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_DISPLAY_ID_INFO_DATA_V1 { + #[doc = "!< [in] Structure version"] + pub version: NvU32, + #[doc = "!< [out] Locally unique ID (LUID) of the display adapter on which the given display is present."] + pub adapterId: LUID, + #[doc = "!< [out] The target identifier of the given display. This is also called AdapterRelativeId."] + pub targetId: NvU32, + #[doc = "!< Reserved for future use."] + pub reserved: [NvU32; 4usize], +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_DISPLAY_ID_INFO_DATA_V1 = _NV_DISPLAY_ID_INFO_DATA_V1; +#[doc = "! \\ingroup dispcontrol"] +pub type NV_DISPLAY_ID_INFO_DATA = NV_DISPLAY_ID_INFO_DATA_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_TARGET_INFO_DATA_V1 { + #[doc = "!< [in] Structure version"] + pub version: NvU32, + #[doc = "!< [in] Locally unique ID (LUID) of the display adapter on which the target is present."] + pub adapterId: LUID, + #[doc = "!< [in] The target identifier. This is also called AdapterRelativeId."] + pub targetId: NvU32, + #[doc = "!< [out] An array of displayIds corresponding to the input adapterId and targetId.\n!< If the input (targetId, adapterId) pair is a display grid (Mosaic/Surround),\n!< then the output contains the displayId of every display that is part of the display grid.\n!< Otherwise, it contains exactly one displayId.\n!< These displayId values are unique to this (targetId, adapterId) pair."] + pub displayId: [NvU32; 128usize], + #[doc = "!< [out] The number of displays returned in displayId array."] + pub displayIdCount: NvU32, + #[doc = "!< Reserved for future use."] + pub reserved: [NvU32; 4usize], +} +pub type NV_TARGET_INFO_DATA_V1 = _NV_TARGET_INFO_DATA_V1; +pub type NV_TARGET_INFO_DATA = NV_TARGET_INFO_DATA_V1; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GET_VRR_INFO_V1 { + #[doc = "!< [in] Structure version"] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Reserved for future use"] + pub reservedEx: [NvU32; 4usize], +} +impl _NV_GET_VRR_INFO_V1 { + #[inline] + pub fn bIsVRREnabled(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsVRREnabled(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsVRREnabled_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsVRREnabled_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsVRRPossible(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsVRRPossible(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsVRRPossible_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsVRRPossible_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsVRRRequested(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsVRRRequested(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsVRRRequested_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsVRRRequested_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsVRRIndicatorEnabled(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsVRRIndicatorEnabled(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsVRRIndicatorEnabled_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsVRRIndicatorEnabled_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsDisplayInVRRMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsDisplayInVRRMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsDisplayInVRRMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsDisplayInVRRMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 27u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 27u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 27u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsVRREnabled: NvU32, + bIsVRRPossible: NvU32, + bIsVRRRequested: NvU32, + bIsVRRIndicatorEnabled: NvU32, + bIsDisplayInVRRMode: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsVRREnabled: u32 = unsafe { ::std::mem::transmute(bIsVRREnabled) }; + bIsVRREnabled as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bIsVRRPossible: u32 = unsafe { ::std::mem::transmute(bIsVRRPossible) }; + bIsVRRPossible as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let bIsVRRRequested: u32 = unsafe { ::std::mem::transmute(bIsVRRRequested) }; + bIsVRRRequested as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let bIsVRRIndicatorEnabled: u32 = + unsafe { ::std::mem::transmute(bIsVRRIndicatorEnabled) }; + bIsVRRIndicatorEnabled as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let bIsDisplayInVRRMode: u32 = unsafe { ::std::mem::transmute(bIsDisplayInVRRMode) }; + bIsDisplayInVRRMode as u64 + }); + __bindgen_bitfield_unit.set(5usize, 27u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_GET_VRR_INFO_V1 = _NV_GET_VRR_INFO_V1; +#[doc = "! \\ingroup dispcontrol"] +pub type NV_GET_VRR_INFO = NV_GET_VRR_INFO_V1; +#[doc = "! This structure defines the topology details."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_MOSAIC_TOPO_DETAILS { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Logical GPU for this topology"] + pub hLogicalGPU: NvLogicalGpuHandle, + #[doc = "!< 0 means topology is valid with the current hardware."] + pub validityMask: NvU32, + #[doc = "!< Number of displays in a row"] + pub rowCount: NvU32, + #[doc = "!< Number of displays in a column"] + pub colCount: NvU32, + pub gpuLayout: [[NV_MOSAIC_TOPO_DETAILS__bindgen_ty_1; 8usize]; 8usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_MOSAIC_TOPO_DETAILS__bindgen_ty_1 { + #[doc = "!< Physical GPU to be used in the topology (0 if GPU missing)"] + pub hPhysicalGPU: NvPhysicalGpuHandle, + #[doc = "!< Connected display target (0 if no display connected)"] + pub displayOutputId: NvU32, + #[doc = "!< Pixels of overlap on left of target: (+overlap, -gap)"] + pub overlapX: NvS32, + #[doc = "!< Pixels of overlap on top of target: (+overlap, -gap)"] + pub overlapY: NvS32, +} +#[doc = "!< All mosaic topologies"] +pub const NV_MOSAIC_TOPO_TYPE_NV_MOSAIC_TOPO_TYPE_ALL: NV_MOSAIC_TOPO_TYPE = 0; +#[doc = "!< Basic Mosaic topologies"] +pub const NV_MOSAIC_TOPO_TYPE_NV_MOSAIC_TOPO_TYPE_BASIC: NV_MOSAIC_TOPO_TYPE = 1; +#[doc = "!< Passive Stereo topologies"] +pub const NV_MOSAIC_TOPO_TYPE_NV_MOSAIC_TOPO_TYPE_PASSIVE_STEREO: NV_MOSAIC_TOPO_TYPE = 2; +#[doc = "!< Not supported at this time"] +pub const NV_MOSAIC_TOPO_TYPE_NV_MOSAIC_TOPO_TYPE_SCALED_CLONE: NV_MOSAIC_TOPO_TYPE = 3; +#[doc = "!< Not supported at this time"] +pub const NV_MOSAIC_TOPO_TYPE_NV_MOSAIC_TOPO_TYPE_PASSIVE_STEREO_SCALED_CLONE: NV_MOSAIC_TOPO_TYPE = + 4; +#[doc = "!< Always leave this at end of the enum"] +pub const NV_MOSAIC_TOPO_TYPE_NV_MOSAIC_TOPO_TYPE_MAX: NV_MOSAIC_TOPO_TYPE = 5; +#[doc = "! These values refer to the different types of Mosaic topologies that are possible. When\n! getting the supported Mosaic topologies, you can specify one of these types to narrow down\n! the returned list to only those that match the given type."] +pub type NV_MOSAIC_TOPO_TYPE = ::std::os::raw::c_int; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_NONE: NV_MOSAIC_TOPO = 0; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_BEGIN_BASIC: NV_MOSAIC_TOPO = 1; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x2_BASIC: NV_MOSAIC_TOPO = 1; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_2x1_BASIC: NV_MOSAIC_TOPO = 2; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x3_BASIC: NV_MOSAIC_TOPO = 3; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_3x1_BASIC: NV_MOSAIC_TOPO = 4; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x4_BASIC: NV_MOSAIC_TOPO = 5; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_4x1_BASIC: NV_MOSAIC_TOPO = 6; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_2x2_BASIC: NV_MOSAIC_TOPO = 7; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_2x3_BASIC: NV_MOSAIC_TOPO = 8; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_2x4_BASIC: NV_MOSAIC_TOPO = 9; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_3x2_BASIC: NV_MOSAIC_TOPO = 10; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_4x2_BASIC: NV_MOSAIC_TOPO = 11; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x5_BASIC: NV_MOSAIC_TOPO = 12; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x6_BASIC: NV_MOSAIC_TOPO = 13; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_7x1_BASIC: NV_MOSAIC_TOPO = 14; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_END_BASIC: NV_MOSAIC_TOPO = 23; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_BEGIN_PASSIVE_STEREO: NV_MOSAIC_TOPO = 24; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x2_PASSIVE_STEREO: NV_MOSAIC_TOPO = 24; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_2x1_PASSIVE_STEREO: NV_MOSAIC_TOPO = 25; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x3_PASSIVE_STEREO: NV_MOSAIC_TOPO = 26; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_3x1_PASSIVE_STEREO: NV_MOSAIC_TOPO = 27; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x4_PASSIVE_STEREO: NV_MOSAIC_TOPO = 28; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_4x1_PASSIVE_STEREO: NV_MOSAIC_TOPO = 29; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_2x2_PASSIVE_STEREO: NV_MOSAIC_TOPO = 30; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_END_PASSIVE_STEREO: NV_MOSAIC_TOPO = 34; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_MAX: NV_MOSAIC_TOPO = 35; +#[doc = "! This is a complete list of supported Mosaic topologies.\n!\n! Using a \"Basic\" topology combines multiple monitors to create a single desktop.\n!\n! Using a \"Passive\" topology combines multiples monitors to create a passive stereo desktop.\n! In passive stereo, two identical topologies combine - one topology is used for the right eye and the other identical //! topology (targeting different displays) is used for the left eye. \\n\n! NOTE: common\\inc\\nvEscDef.h shadows a couple PASSIVE_STEREO enums. If this\n! enum list changes and effects the value of NV_MOSAIC_TOPO_BEGIN_PASSIVE_STEREO\n! please update the corresponding value in nvEscDef.h"] +pub type NV_MOSAIC_TOPO = ::std::os::raw::c_int; +#[doc = "! This is a \"topology brief\" structure. It tells you what you need to know about\n! a topology at a high level. A list of these is returned when you query for the\n! supported Mosaic information.\n!\n! If you need more detailed information about the topology, call\n! NvAPI_Mosaic_GetTopoGroup() with the topology value from this structure."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_MOSAIC_TOPO_BRIEF { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< The topology"] + pub topo: NV_MOSAIC_TOPO, + #[doc = "!< 1 if topo is enabled, else 0"] + pub enabled: NvU32, + #[doc = "!< 1 if topo *can* be enabled, else 0"] + pub isPossible: NvU32, +} +#[doc = "! Basic per-display settings that are used in setting/getting the Mosaic mode"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MOSAIC_DISPLAY_SETTING_V1 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Per-display width"] + pub width: NvU32, + #[doc = "!< Per-display height"] + pub height: NvU32, + #[doc = "!< Bits per pixel"] + pub bpp: NvU32, + #[doc = "!< Display frequency"] + pub freq: NvU32, +} +#[doc = "! Basic per-display settings that are used in setting/getting the Mosaic mode"] +pub type NV_MOSAIC_DISPLAY_SETTING_V1 = _NV_MOSAIC_DISPLAY_SETTING_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_MOSAIC_DISPLAY_SETTING_V2 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Per-display width"] + pub width: NvU32, + #[doc = "!< Per-display height"] + pub height: NvU32, + #[doc = "!< Bits per pixel"] + pub bpp: NvU32, + #[doc = "!< Display frequency"] + pub freq: NvU32, + #[doc = "!< Display frequency in x1k"] + pub rrx1k: NvU32, +} +pub type NV_MOSAIC_DISPLAY_SETTING = NV_MOSAIC_DISPLAY_SETTING_V2; +#[doc = "! This structure is used to contain a list of supported Mosaic topologies\n! along with the display settings that can be used."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MOSAIC_SUPPORTED_TOPO_INFO_V1 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Number of topologies in below array"] + pub topoBriefsCount: NvU32, + #[doc = "!< List of supported topologies with only brief details"] + pub topoBriefs: [NV_MOSAIC_TOPO_BRIEF; 35usize], + #[doc = "!< Number of display settings in below array"] + pub displaySettingsCount: NvU32, + #[doc = "!< List of per display settings possible"] + pub displaySettings: [NV_MOSAIC_DISPLAY_SETTING_V1; 40usize], +} +#[doc = "! This structure is used to contain a list of supported Mosaic topologies\n! along with the display settings that can be used."] +pub type NV_MOSAIC_SUPPORTED_TOPO_INFO_V1 = _NV_MOSAIC_SUPPORTED_TOPO_INFO_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MOSAIC_SUPPORTED_TOPO_INFO_V2 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Number of topologies in below array"] + pub topoBriefsCount: NvU32, + #[doc = "!< List of supported topologies with only brief details"] + pub topoBriefs: [NV_MOSAIC_TOPO_BRIEF; 35usize], + #[doc = "!< Number of display settings in below array"] + pub displaySettingsCount: NvU32, + #[doc = "!< List of per display settings possible"] + pub displaySettings: [NV_MOSAIC_DISPLAY_SETTING_V2; 40usize], +} +pub type NV_MOSAIC_SUPPORTED_TOPO_INFO_V2 = _NV_MOSAIC_SUPPORTED_TOPO_INFO_V2; +pub type NV_MOSAIC_SUPPORTED_TOPO_INFO = NV_MOSAIC_SUPPORTED_TOPO_INFO_V2; +#[doc = "! This structure defines a group of topologies that work together to create one\n! overall layout. All of the supported topologies are represented with this\n! structure.\n!\n! For example, a 'Passive Stereo' topology would be represented with this\n! structure, and would have separate topology details for the left and right eyes.\n! The count would be 2. A 'Basic' topology is also represented by this structure,\n! with a count of 1.\n!\n! The structure is primarily used internally, but is exposed to applications in a\n! read-only fashion because there are some details in it that might be useful\n! (like the number of rows/cols, or connected display information). A user can\n! get the filled-in structure by calling NvAPI_Mosaic_GetTopoGroup().\n!\n! You can then look at the detailed values within the structure. There are no\n! entrypoints which take this structure as input (effectively making it read-only)."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_MOSAIC_TOPO_GROUP { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< The brief details of this topo"] + pub brief: NV_MOSAIC_TOPO_BRIEF, + #[doc = "!< Number of topos in array below"] + pub count: NvU32, + pub topos: [NV_MOSAIC_TOPO_DETAILS; 2usize], +} +#[doc = "! \\ingroup mosaicapi\n! @{"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MOSAIC_GRID_TOPO_DISPLAY_V1 { + #[doc = "!< DisplayID of the display"] + pub displayId: NvU32, + #[doc = "!< (+overlap, -gap)"] + pub overlapX: NvS32, + #[doc = "!< (+overlap, -gap)"] + pub overlapY: NvS32, + #[doc = "!< Rotation of display"] + pub rotation: NV_ROTATE, + #[doc = "!< Reserved, must be 0"] + pub cloneGroup: NvU32, +} +#[doc = "! \\ingroup mosaicapi\n! @{"] +pub type NV_MOSAIC_GRID_TOPO_DISPLAY_V1 = _NV_MOSAIC_GRID_TOPO_DISPLAY_V1; +#[doc = "!< No pixel shift will be applied to this display."] +pub const _NV_PIXEL_SHIFT_TYPE_NV_PIXEL_SHIFT_TYPE_NO_PIXEL_SHIFT: _NV_PIXEL_SHIFT_TYPE = 0; +#[doc = "!< This display will be used to scanout top left pixels in 2x2 PixelShift configuration"] +pub const _NV_PIXEL_SHIFT_TYPE_NV_PIXEL_SHIFT_TYPE_2x2_TOP_LEFT_PIXELS: _NV_PIXEL_SHIFT_TYPE = 1; +#[doc = "!< This display will be used to scanout bottom right pixels in 2x2 PixelShift configuration"] +pub const _NV_PIXEL_SHIFT_TYPE_NV_PIXEL_SHIFT_TYPE_2x2_BOTTOM_RIGHT_PIXELS: _NV_PIXEL_SHIFT_TYPE = + 2; +#[doc = "!< This display will be used to scanout top right pixels in 2x2 PixelShift configuration"] +pub const _NV_PIXEL_SHIFT_TYPE_NV_PIXEL_SHIFT_TYPE_2x2_TOP_RIGHT_PIXELS: _NV_PIXEL_SHIFT_TYPE = 4; +#[doc = "!< This display will be used to scanout bottom left pixels in 2x2 PixelShift configuration"] +pub const _NV_PIXEL_SHIFT_TYPE_NV_PIXEL_SHIFT_TYPE_2x2_BOTTOM_LEFT_PIXELS: _NV_PIXEL_SHIFT_TYPE = 8; +pub type _NV_PIXEL_SHIFT_TYPE = ::std::os::raw::c_int; +pub use self::_NV_PIXEL_SHIFT_TYPE as NV_PIXEL_SHIFT_TYPE; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MOSAIC_GRID_TOPO_DISPLAY_V2 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< DisplayID of the display"] + pub displayId: NvU32, + #[doc = "!< (+overlap, -gap)"] + pub overlapX: NvS32, + #[doc = "!< (+overlap, -gap)"] + pub overlapY: NvS32, + #[doc = "!< Rotation of display"] + pub rotation: NV_ROTATE, + #[doc = "!< Reserved, must be 0"] + pub cloneGroup: NvU32, + #[doc = "!< Type of the pixel shift enabled display"] + pub pixelShiftType: NV_PIXEL_SHIFT_TYPE, +} +pub type NV_MOSAIC_GRID_TOPO_DISPLAY_V2 = _NV_MOSAIC_GRID_TOPO_DISPLAY_V2; +#[doc = "! \\ingroup mosaicapi\n! @{"] +pub type NV_MOSAIC_GRID_TOPO_DISPLAY = NV_MOSAIC_GRID_TOPO_DISPLAY_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MOSAIC_GRID_TOPO_V1 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Number of rows"] + pub rows: NvU32, + #[doc = "!< Number of columns"] + pub columns: NvU32, + #[doc = "!< Number of display details"] + pub displayCount: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Displays are done as [(row * columns) + column]"] + pub displays: [NV_MOSAIC_GRID_TOPO_DISPLAY_V1; 64usize], + #[doc = "!< Display settings"] + pub displaySettings: NV_MOSAIC_DISPLAY_SETTING_V1, +} +impl _NV_MOSAIC_GRID_TOPO_V1 { + #[inline] + pub fn applyWithBezelCorrect(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_applyWithBezelCorrect(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn applyWithBezelCorrect_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_applyWithBezelCorrect_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn immersiveGaming(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_immersiveGaming(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn immersiveGaming_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_immersiveGaming_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn baseMosaic(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_baseMosaic(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn baseMosaic_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_baseMosaic_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn driverReloadAllowed(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_driverReloadAllowed(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn driverReloadAllowed_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_driverReloadAllowed_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn acceleratePrimaryDisplay(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_acceleratePrimaryDisplay(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn acceleratePrimaryDisplay_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_acceleratePrimaryDisplay_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 27u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 27u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 27u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + applyWithBezelCorrect: NvU32, + immersiveGaming: NvU32, + baseMosaic: NvU32, + driverReloadAllowed: NvU32, + acceleratePrimaryDisplay: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let applyWithBezelCorrect: u32 = + unsafe { ::std::mem::transmute(applyWithBezelCorrect) }; + applyWithBezelCorrect as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let immersiveGaming: u32 = unsafe { ::std::mem::transmute(immersiveGaming) }; + immersiveGaming as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let baseMosaic: u32 = unsafe { ::std::mem::transmute(baseMosaic) }; + baseMosaic as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let driverReloadAllowed: u32 = unsafe { ::std::mem::transmute(driverReloadAllowed) }; + driverReloadAllowed as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let acceleratePrimaryDisplay: u32 = + unsafe { ::std::mem::transmute(acceleratePrimaryDisplay) }; + acceleratePrimaryDisplay as u64 + }); + __bindgen_bitfield_unit.set(5usize, 27u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_MOSAIC_GRID_TOPO_V1 = _NV_MOSAIC_GRID_TOPO_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MOSAIC_GRID_TOPO_V2 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Number of rows"] + pub rows: NvU32, + #[doc = "!< Number of columns"] + pub columns: NvU32, + #[doc = "!< Number of display details"] + pub displayCount: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Displays are done as [(row * columns) + column]"] + pub displays: [NV_MOSAIC_GRID_TOPO_DISPLAY_V2; 64usize], + #[doc = "!< Display settings"] + pub displaySettings: NV_MOSAIC_DISPLAY_SETTING_V1, +} +impl _NV_MOSAIC_GRID_TOPO_V2 { + #[inline] + pub fn applyWithBezelCorrect(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_applyWithBezelCorrect(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn applyWithBezelCorrect_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_applyWithBezelCorrect_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn immersiveGaming(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_immersiveGaming(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn immersiveGaming_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_immersiveGaming_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn baseMosaic(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_baseMosaic(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn baseMosaic_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_baseMosaic_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn driverReloadAllowed(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_driverReloadAllowed(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn driverReloadAllowed_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_driverReloadAllowed_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn acceleratePrimaryDisplay(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_acceleratePrimaryDisplay(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn acceleratePrimaryDisplay_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_acceleratePrimaryDisplay_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn pixelShift(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_pixelShift(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn pixelShift_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_pixelShift_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 26u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 26u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 6usize, + 26u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 26u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + applyWithBezelCorrect: NvU32, + immersiveGaming: NvU32, + baseMosaic: NvU32, + driverReloadAllowed: NvU32, + acceleratePrimaryDisplay: NvU32, + pixelShift: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let applyWithBezelCorrect: u32 = + unsafe { ::std::mem::transmute(applyWithBezelCorrect) }; + applyWithBezelCorrect as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let immersiveGaming: u32 = unsafe { ::std::mem::transmute(immersiveGaming) }; + immersiveGaming as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let baseMosaic: u32 = unsafe { ::std::mem::transmute(baseMosaic) }; + baseMosaic as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let driverReloadAllowed: u32 = unsafe { ::std::mem::transmute(driverReloadAllowed) }; + driverReloadAllowed as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let acceleratePrimaryDisplay: u32 = + unsafe { ::std::mem::transmute(acceleratePrimaryDisplay) }; + acceleratePrimaryDisplay as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let pixelShift: u32 = unsafe { ::std::mem::transmute(pixelShift) }; + pixelShift as u64 + }); + __bindgen_bitfield_unit.set(6usize, 26u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_MOSAIC_GRID_TOPO_V2 = _NV_MOSAIC_GRID_TOPO_V2; +pub type NV_MOSAIC_GRID_TOPO = NV_MOSAIC_GRID_TOPO_V2; +#[doc = "! \\ingroup mosaicapi"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_MOSAIC_DISPLAY_TOPO_STATUS { + pub version: NvU32, + #[doc = "!< (OUT) Any of the NV_MOSAIC_DISPLAYTOPO_ERROR_* flags."] + pub errorFlags: NvU32, + #[doc = "!< (OUT) Any of the NV_MOSAIC_DISPLAYTOPO_WARNING_* flags."] + pub warningFlags: NvU32, + #[doc = "!< (OUT) The number of valid entries in the displays array."] + pub displayCount: NvU32, + pub displays: [NV_MOSAIC_DISPLAY_TOPO_STATUS__bindgen_ty_1; 128usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_MOSAIC_DISPLAY_TOPO_STATUS__bindgen_ty_1 { + #[doc = "!< (OUT) The DisplayID of this display."] + pub displayId: NvU32, + #[doc = "!< (OUT) Any of the NV_MOSAIC_DISPLAYCAPS_PROBLEM_* flags."] + pub errorFlags: NvU32, + #[doc = "!< (OUT) Any of the NV_MOSAIC_DISPLAYTOPO_WARNING_* flags."] + pub warningFlags: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl NV_MOSAIC_DISPLAY_TOPO_STATUS__bindgen_ty_1 { + #[inline] + pub fn supportsRotation(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_supportsRotation(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supportsRotation_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_supportsRotation_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + supportsRotation: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let supportsRotation: u32 = unsafe { ::std::mem::transmute(supportsRotation) }; + supportsRotation as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! Used in NvAPI_GetCurrentMosaicTopology() and NvAPI_SetCurrentMosaicTopology()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_MOSAIC_TOPOLOGY { + #[doc = "!< Version number of the mosaic topology"] + pub version: NvU32, + #[doc = "!< Horizontal display count"] + pub rowCount: NvU32, + #[doc = "!< Vertical display count"] + pub colCount: NvU32, + pub gpuLayout: [[NV_MOSAIC_TOPOLOGY__bindgen_ty_1; 8usize]; 8usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_MOSAIC_TOPOLOGY__bindgen_ty_1 { + #[doc = "!< Physical GPU to be used in the topology"] + pub hPhysicalGPU: NvPhysicalGpuHandle, + #[doc = "!< Connected display target"] + pub displayOutputId: NvU32, + #[doc = "!< Pixels of overlap on the left of target: (+overlap, -gap)"] + pub overlapX: NvS32, + #[doc = "!< Pixels of overlap on the top of target: (+overlap, -gap)"] + pub overlapY: NvS32, +} +#[doc = "! Used in NvAPI_GetSupportedMosaicTopologies()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_MOSAIC_SUPPORTED_TOPOLOGIES { + pub version: NvU32, + #[doc = "!< Count of valid topologies"] + pub totalCount: NvU32, + #[doc = "!< Maximum number of topologies"] + pub topos: [NV_MOSAIC_TOPOLOGY; 16usize], +} +#[doc = "! Used in NvAPI_GSync_QueryCapabilities()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GSYNC_CAPABILITIES_V1 { + #[doc = "!< Version of the structure"] + pub version: NvU32, + #[doc = "!< Board ID"] + pub boardId: NvU32, + #[doc = "!< FPGA Revision"] + pub revision: NvU32, + #[doc = "!< Capabilities of the Sync board. Reserved for future use"] + pub capFlags: NvU32, +} +#[doc = "! Used in NvAPI_GSync_QueryCapabilities()."] +pub type NV_GSYNC_CAPABILITIES_V1 = _NV_GSYNC_CAPABILITIES_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GSYNC_CAPABILITIES_V2 { + #[doc = "!< Version of the structure"] + pub version: NvU32, + #[doc = "!< Board ID"] + pub boardId: NvU32, + #[doc = "!< FPGA major revision"] + pub revision: NvU32, + #[doc = "!< Capabilities of the Sync board. Reserved for future use"] + pub capFlags: NvU32, + #[doc = "!< FPGA minor revision"] + pub extendedRevision: NvU32, +} +pub type NV_GSYNC_CAPABILITIES_V2 = _NV_GSYNC_CAPABILITIES_V2; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GSYNC_CAPABILITIES_V3 { + #[doc = "!< Version of the structure"] + pub version: NvU32, + #[doc = "!< Board ID"] + pub boardId: NvU32, + #[doc = "!< FPGA major revision"] + pub revision: NvU32, + #[doc = "!< Capabilities of the Sync board. Reserved for future use"] + pub capFlags: NvU32, + #[doc = "!< FPGA minor revision"] + pub extendedRevision: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< This parameter returns the maximum possible value that can be programmed\n!< for multiplying / dividing house sync. Only valid if bIsMulDivSupported is set to 1."] + pub maxMulDivValue: NvU32, +} +impl _NV_GSYNC_CAPABILITIES_V3 { + #[inline] + pub fn bIsMulDivSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsMulDivSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsMulDivSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsMulDivSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsMulDivSupported: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsMulDivSupported: u32 = unsafe { ::std::mem::transmute(bIsMulDivSupported) }; + bIsMulDivSupported as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_GSYNC_CAPABILITIES_V3 = _NV_GSYNC_CAPABILITIES_V3; +pub type NV_GSYNC_CAPABILITIES = NV_GSYNC_CAPABILITIES_V3; +pub const _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_NONE: + _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR = 0; +pub const _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_PRIMARY: + _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR = 1; +pub const _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_SECONDARY: + _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR = 2; +pub const _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_TERTIARY: + _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR = 3; +pub const _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_QUARTERNARY: + _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR = 4; +#[doc = "! Connector values for a GPU. Used in NV_GSYNC_GPU."] +pub type _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR = ::std::os::raw::c_int; +#[doc = "! Connector values for a GPU. Used in NV_GSYNC_GPU."] +pub use self::_NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR as NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR; +pub const _NVAPI_GSYNC_DISPLAY_SYNC_STATE_NVAPI_GSYNC_DISPLAY_SYNC_STATE_UNSYNCED: + _NVAPI_GSYNC_DISPLAY_SYNC_STATE = 0; +pub const _NVAPI_GSYNC_DISPLAY_SYNC_STATE_NVAPI_GSYNC_DISPLAY_SYNC_STATE_SLAVE: + _NVAPI_GSYNC_DISPLAY_SYNC_STATE = 1; +pub const _NVAPI_GSYNC_DISPLAY_SYNC_STATE_NVAPI_GSYNC_DISPLAY_SYNC_STATE_MASTER: + _NVAPI_GSYNC_DISPLAY_SYNC_STATE = 2; +#[doc = "! Display sync states. Used in NV_GSYNC_DISPLAY."] +pub type _NVAPI_GSYNC_DISPLAY_SYNC_STATE = ::std::os::raw::c_int; +#[doc = "! Display sync states. Used in NV_GSYNC_DISPLAY."] +pub use self::_NVAPI_GSYNC_DISPLAY_SYNC_STATE as NVAPI_GSYNC_DISPLAY_SYNC_STATE; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GSYNC_GPU { + #[doc = "!< Version of the structure"] + pub version: NvU32, + #[doc = "!< GPU handle"] + pub hPhysicalGpu: NvPhysicalGpuHandle, + #[doc = "!< Indicates which connector on the device the GPU is connected to."] + pub connector: NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR, + #[doc = "!< GPU through which hPhysicalGpu is connected to the Sync device (if not directly connected)\n!< - this is NULL otherwise"] + pub hProxyPhysicalGpu: NvPhysicalGpuHandle, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + pub __bindgen_padding_0: u32, +} +impl _NV_GSYNC_GPU { + #[inline] + pub fn isSynced(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isSynced(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isSynced_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isSynced_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1(isSynced: NvU32, reserved: NvU32) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isSynced: u32 = unsafe { ::std::mem::transmute(isSynced) }; + isSynced as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_GSYNC_GPU = _NV_GSYNC_GPU; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GSYNC_DISPLAY { + #[doc = "!< Version of the structure"] + pub version: NvU32, + #[doc = "!< display identifier for displays.The GPU to which it is connected, can be retireved from NvAPI_SYS_GetPhysicalGpuFromDisplayId"] + pub displayId: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Is this display slave/master\n!< (Retrieved with topology or set by caller for enable/disable sync)"] + pub syncState: NVAPI_GSYNC_DISPLAY_SYNC_STATE, +} +impl _NV_GSYNC_DISPLAY { + #[inline] + pub fn isMasterable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMasterable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMasterable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMasterable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isMasterable: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isMasterable: u32 = unsafe { ::std::mem::transmute(isMasterable) }; + isMasterable as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_GSYNC_DISPLAY = _NV_GSYNC_DISPLAY; +pub const _NVAPI_GSYNC_POLARITY_NVAPI_GSYNC_POLARITY_RISING_EDGE: _NVAPI_GSYNC_POLARITY = 0; +pub const _NVAPI_GSYNC_POLARITY_NVAPI_GSYNC_POLARITY_FALLING_EDGE: _NVAPI_GSYNC_POLARITY = 1; +pub const _NVAPI_GSYNC_POLARITY_NVAPI_GSYNC_POLARITY_BOTH_EDGES: _NVAPI_GSYNC_POLARITY = 2; +#[doc = "! Source signal edge to be used for output pulse. See NV_GSYNC_CONTROL_PARAMS."] +pub type _NVAPI_GSYNC_POLARITY = ::std::os::raw::c_int; +#[doc = "! Source signal edge to be used for output pulse. See NV_GSYNC_CONTROL_PARAMS."] +pub use self::_NVAPI_GSYNC_POLARITY as NVAPI_GSYNC_POLARITY; +pub const _NVAPI_GSYNC_VIDEO_MODE_NVAPI_GSYNC_VIDEO_MODE_NONE: _NVAPI_GSYNC_VIDEO_MODE = 0; +pub const _NVAPI_GSYNC_VIDEO_MODE_NVAPI_GSYNC_VIDEO_MODE_TTL: _NVAPI_GSYNC_VIDEO_MODE = 1; +pub const _NVAPI_GSYNC_VIDEO_MODE_NVAPI_GSYNC_VIDEO_MODE_NTSCPALSECAM: _NVAPI_GSYNC_VIDEO_MODE = 2; +pub const _NVAPI_GSYNC_VIDEO_MODE_NVAPI_GSYNC_VIDEO_MODE_HDTV: _NVAPI_GSYNC_VIDEO_MODE = 3; +pub const _NVAPI_GSYNC_VIDEO_MODE_NVAPI_GSYNC_VIDEO_MODE_COMPOSITE: _NVAPI_GSYNC_VIDEO_MODE = 4; +#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] +pub type _NVAPI_GSYNC_VIDEO_MODE = ::std::os::raw::c_int; +#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] +pub use self::_NVAPI_GSYNC_VIDEO_MODE as NVAPI_GSYNC_VIDEO_MODE; +pub const _NVAPI_GSYNC_SYNC_SOURCE_NVAPI_GSYNC_SYNC_SOURCE_VSYNC: _NVAPI_GSYNC_SYNC_SOURCE = 0; +pub const _NVAPI_GSYNC_SYNC_SOURCE_NVAPI_GSYNC_SYNC_SOURCE_HOUSESYNC: _NVAPI_GSYNC_SYNC_SOURCE = 1; +#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] +pub type _NVAPI_GSYNC_SYNC_SOURCE = ::std::os::raw::c_int; +#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] +pub use self::_NVAPI_GSYNC_SYNC_SOURCE as NVAPI_GSYNC_SYNC_SOURCE; +#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GSYNC_DELAY { + #[doc = "!< Version of the structure"] + pub version: NvU32, + #[doc = "!< delay to be induced in number of horizontal lines."] + pub numLines: NvU32, + #[doc = "!< delay to be induced in number of pixels."] + pub numPixels: NvU32, + #[doc = "!< maximum number of lines supported at current display mode to induce delay. Updated by NvAPI_GSync_GetControlParameters(). Read only."] + pub maxLines: NvU32, + #[doc = "!< minimum number of pixels required at current display mode to induce delay. Updated by NvAPI_GSync_GetControlParameters(). Read only."] + pub minPixels: NvU32, +} +#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] +pub type NV_GSYNC_DELAY = _NV_GSYNC_DELAY; +#[doc = "! Used in NvAPI_GSync_GetControlParameters() and NvAPI_GSync_SetControlParameters()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GSYNC_CONTROL_PARAMS_V1 { + #[doc = "!< Version of the structure"] + pub version: NvU32, + #[doc = "!< Leading edge / Falling edge / both"] + pub polarity: NVAPI_GSYNC_POLARITY, + #[doc = "!< None, TTL, NTSCPALSECAM, HDTV"] + pub vmode: NVAPI_GSYNC_VIDEO_MODE, + #[doc = "!< Number of pulses to wait between framelock signal generation"] + pub interval: NvU32, + #[doc = "!< VSync/House sync"] + pub source: NVAPI_GSYNC_SYNC_SOURCE, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< The time delay between the frame sync signal and the GPUs signal."] + pub syncSkew: NV_GSYNC_DELAY, + #[doc = "!< Sync start delay for master."] + pub startupDelay: NV_GSYNC_DELAY, +} +impl _NV_GSYNC_CONTROL_PARAMS_V1 { + #[inline] + pub fn interlaceMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_interlaceMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn interlaceMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_interlaceMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn syncSourceIsOutput(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_syncSourceIsOutput(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn syncSourceIsOutput_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_syncSourceIsOutput_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 30u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 30u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 30u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + interlaceMode: NvU32, + syncSourceIsOutput: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let interlaceMode: u32 = unsafe { ::std::mem::transmute(interlaceMode) }; + interlaceMode as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let syncSourceIsOutput: u32 = unsafe { ::std::mem::transmute(syncSourceIsOutput) }; + syncSourceIsOutput as u64 + }); + __bindgen_bitfield_unit.set(2usize, 30u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! Used in NvAPI_GSync_GetControlParameters() and NvAPI_GSync_SetControlParameters()."] +pub type NV_GSYNC_CONTROL_PARAMS_V1 = _NV_GSYNC_CONTROL_PARAMS_V1; +pub const _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE_NVAPI_GSYNC_UNDEFINED_MODE: + _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE = 0; +pub const _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE_NVAPI_GSYNC_MULTIPLY_MODE: + _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE = 1; +pub const _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE_NVAPI_GSYNC_DIVIDE_MODE: + _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE = 2; +#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] +pub type _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE = ::std::os::raw::c_int; +#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] +pub use self::_NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE as NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GSYNC_CONTROL_PARAMS_V2 { + #[doc = "!< Version of the structure"] + pub version: NvU32, + #[doc = "!< Leading edge / Falling edge / both"] + pub polarity: NVAPI_GSYNC_POLARITY, + #[doc = "!< None, TTL, NTSCPALSECAM, HDTV"] + pub vmode: NVAPI_GSYNC_VIDEO_MODE, + #[doc = "!< Number of pulses to wait between framelock signal generation"] + pub interval: NvU32, + #[doc = "!< VSync/House sync"] + pub source: NVAPI_GSYNC_SYNC_SOURCE, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< The time delay between the frame sync signal and the GPUs signal."] + pub syncSkew: NV_GSYNC_DELAY, + #[doc = "!< Sync start delay for master."] + pub startupDelay: NV_GSYNC_DELAY, + #[doc = "!< Indicates multiplier/divider mode for the housesync signal.\n!< While setting multiplyDivideMode, source needs to be set as NVAPI_GSYNC_SYNC_SOURCE_HOUSESYNC."] + pub multiplyDivideMode: NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE, + #[doc = "!< Indicates the multiplier/divider value for the housesync signal. Only supported if bIsMulDivSupported field of the structure NV_GSYNC_CAPABILITIES is set to 1.\n!< The maximum supported value for this field can be obtained from maxMulDivValue field of the structure NV_GSYNC_CAPABILITIES."] + pub multiplyDivideValue: NvU8, +} +impl _NV_GSYNC_CONTROL_PARAMS_V2 { + #[inline] + pub fn interlaceMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_interlaceMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn interlaceMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_interlaceMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn syncSourceIsOutput(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_syncSourceIsOutput(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn syncSourceIsOutput_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_syncSourceIsOutput_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 30u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 30u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 30u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + interlaceMode: NvU32, + syncSourceIsOutput: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let interlaceMode: u32 = unsafe { ::std::mem::transmute(interlaceMode) }; + interlaceMode as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let syncSourceIsOutput: u32 = unsafe { ::std::mem::transmute(syncSourceIsOutput) }; + syncSourceIsOutput as u64 + }); + __bindgen_bitfield_unit.set(2usize, 30u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_GSYNC_CONTROL_PARAMS_V2 = _NV_GSYNC_CONTROL_PARAMS_V2; +pub type NV_GSYNC_CONTROL_PARAMS = NV_GSYNC_CONTROL_PARAMS_V2; +#[doc = "! Used in NvAPI_GSync_GetSyncStatus()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GSYNC_STATUS { + #[doc = "!< Version of the structure"] + pub version: NvU32, + #[doc = "!< Is timing in sync?"] + pub bIsSynced: NvU32, + #[doc = "!< Does the phase of the timing signal from the GPU = the phase of the master sync signal?"] + pub bIsStereoSynced: NvU32, + #[doc = "!< Is the sync signal available?"] + pub bIsSyncSignalAvailable: NvU32, +} +#[doc = "! Used in NvAPI_GSync_GetSyncStatus()."] +pub type NV_GSYNC_STATUS = _NV_GSYNC_STATUS; +pub const _NVAPI_GSYNC_RJ45_IO_NVAPI_GSYNC_RJ45_OUTPUT: _NVAPI_GSYNC_RJ45_IO = 0; +pub const _NVAPI_GSYNC_RJ45_IO_NVAPI_GSYNC_RJ45_INPUT: _NVAPI_GSYNC_RJ45_IO = 1; +#[doc = "!< This field is used to notify that the framelock is not actually present."] +pub const _NVAPI_GSYNC_RJ45_IO_NVAPI_GSYNC_RJ45_UNUSED: _NVAPI_GSYNC_RJ45_IO = 2; +#[doc = "! Used in NV_GSYNC_STATUS_PARAMS."] +pub type _NVAPI_GSYNC_RJ45_IO = ::std::os::raw::c_int; +#[doc = "! Used in NV_GSYNC_STATUS_PARAMS."] +pub use self::_NVAPI_GSYNC_RJ45_IO as NVAPI_GSYNC_RJ45_IO; +#[doc = "! \\ingroup gsyncapi\n! Used in NvAPI_GSync_GetStatusParameters()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GSYNC_STATUS_PARAMS_V1 { + pub version: NvU32, + #[doc = "!< The refresh rate"] + pub refreshRate: NvU32, + #[doc = "!< Configured as input / output"] + pub RJ45_IO: [NVAPI_GSYNC_RJ45_IO; 2usize], + #[doc = "!< Connected to ethernet hub? [ERRONEOUSLY CONNECTED!]"] + pub RJ45_Ethernet: [NvU32; 2usize], + #[doc = "!< Incoming house sync frequency in Hz"] + pub houseSyncIncoming: NvU32, + #[doc = "!< Is house sync connected?"] + pub bHouseSync: NvU32, +} +#[doc = "! \\ingroup gsyncapi\n! Used in NvAPI_GSync_GetStatusParameters()."] +pub type NV_GSYNC_STATUS_PARAMS_V1 = _NV_GSYNC_STATUS_PARAMS_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GSYNC_STATUS_PARAMS_V2 { + pub version: NvU32, + #[doc = "!< The refresh rate"] + pub refreshRate: NvU32, + #[doc = "!< Configured as input / output"] + pub RJ45_IO: [NVAPI_GSYNC_RJ45_IO; 2usize], + #[doc = "!< Connected to ethernet hub? [ERRONEOUSLY CONNECTED!]"] + pub RJ45_Ethernet: [NvU32; 2usize], + #[doc = "!< Incoming house sync frequency in Hz"] + pub houseSyncIncoming: NvU32, + #[doc = "!< Is house sync connected?"] + pub bHouseSync: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl _NV_GSYNC_STATUS_PARAMS_V2 { + #[inline] + pub fn bInternalSlave(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bInternalSlave(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bInternalSlave_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bInternalSlave_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bInternalSlave: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bInternalSlave: u32 = unsafe { ::std::mem::transmute(bInternalSlave) }; + bInternalSlave as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_GSYNC_STATUS_PARAMS_V2 = _NV_GSYNC_STATUS_PARAMS_V2; +pub type NV_GSYNC_STATUS_PARAMS = NV_GSYNC_STATUS_PARAMS_V2; +pub const _NV_RESOLVE_MODE_NV_RESOLVE_MODE_SAMPLE_0: _NV_RESOLVE_MODE = 0; +#[doc = "! \\ingroup dx\n! Valid modes for NvAPI_D3D11_ResolveSubresourceRegion() and NvAPI_D3D12_ResolveSubresourceRegion"] +pub type _NV_RESOLVE_MODE = ::std::os::raw::c_int; +#[doc = "! \\ingroup dx\n! Valid modes for NvAPI_D3D11_ResolveSubresourceRegion() and NvAPI_D3D12_ResolveSubresourceRegion"] +pub use self::_NV_RESOLVE_MODE as NV_RESOLVE_MODE; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of Single Pass Stereo HW feature\n! \\ingroup dx"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V1 { + pub version: NvU32, + pub bSinglePassStereoSupported: NvU32, +} +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of Single Pass Stereo HW feature\n! \\ingroup dx"] +pub type NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V1 = + _NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V2 { + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl _NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V2 { + #[inline] + pub fn bSinglePassStereoSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bSinglePassStereoSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bSinglePassStereoSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bSinglePassStereoSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bSinglePassStereoXYZWSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bSinglePassStereoXYZWSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bSinglePassStereoXYZWSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bSinglePassStereoXYZWSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 30u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 30u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 30u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bSinglePassStereoSupported: NvU32, + bSinglePassStereoXYZWSupported: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bSinglePassStereoSupported: u32 = + unsafe { ::std::mem::transmute(bSinglePassStereoSupported) }; + bSinglePassStereoSupported as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bSinglePassStereoXYZWSupported: u32 = + unsafe { ::std::mem::transmute(bSinglePassStereoXYZWSupported) }; + bSinglePassStereoXYZWSupported as u64 + }); + __bindgen_bitfield_unit.set(2usize, 30u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V2 = + _NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V2; +pub type NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS = NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V2; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of MultiView HW feature\n! \\ingroup dx"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_QUERY_MULTIVIEW_SUPPORT_PARAMS_V1 { + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl _NV_QUERY_MULTIVIEW_SUPPORT_PARAMS_V1 { + #[inline] + pub fn bMultiViewSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bMultiViewSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bMultiViewSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bMultiViewSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bSinglePassStereoSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bSinglePassStereoSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bSinglePassStereoSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bSinglePassStereoSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bSinglePassStereoXYZWSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_bSinglePassStereoXYZWSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bSinglePassStereoXYZWSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bSinglePassStereoXYZWSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 29u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 29u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 29u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 29u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bMultiViewSupported: NvU32, + bSinglePassStereoSupported: NvU32, + bSinglePassStereoXYZWSupported: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bMultiViewSupported: u32 = unsafe { ::std::mem::transmute(bMultiViewSupported) }; + bMultiViewSupported as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bSinglePassStereoSupported: u32 = + unsafe { ::std::mem::transmute(bSinglePassStereoSupported) }; + bSinglePassStereoSupported as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let bSinglePassStereoXYZWSupported: u32 = + unsafe { ::std::mem::transmute(bSinglePassStereoXYZWSupported) }; + bSinglePassStereoXYZWSupported as u64 + }); + __bindgen_bitfield_unit.set(3usize, 29u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of MultiView HW feature\n! \\ingroup dx"] +pub type NV_QUERY_MULTIVIEW_SUPPORT_PARAMS_V1 = _NV_QUERY_MULTIVIEW_SUPPORT_PARAMS_V1; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of MultiView HW feature\n! \\ingroup dx"] +pub type NV_QUERY_MULTIVIEW_SUPPORT_PARAMS = NV_QUERY_MULTIVIEW_SUPPORT_PARAMS_V1; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used for setting the Mode for MultiView HW Feature.\n! \\ingroup dx"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MULTIVIEW_PARAMS_V1 { + pub version: NvU32, + pub numViews: NvU32, + pub renderTargetIndexOffset: [NvU32; 4usize], + pub independentViewportMaskEnable: NvU8, +} +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used for setting the Mode for MultiView HW Feature.\n! \\ingroup dx"] +pub type NV_MULTIVIEW_PARAMS_V1 = _NV_MULTIVIEW_PARAMS_V1; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used for setting the Mode for MultiView HW Feature.\n! \\ingroup dx"] +pub type NV_MULTIVIEW_PARAMS = NV_MULTIVIEW_PARAMS_V1; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of Lens Matched Shading HW feature\n! \\ingroup dx"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_QUERY_MODIFIED_W_SUPPORT_PARAMS { + pub version: NvU32, + pub bModifiedWSupported: NvU32, +} +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of Lens Matched Shading HW feature\n! \\ingroup dx"] +pub type NV_QUERY_MODIFIED_W_SUPPORT_PARAMS_V1 = _NV_QUERY_MODIFIED_W_SUPPORT_PARAMS; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of Lens Matched Shading HW feature\n! \\ingroup dx"] +pub type NV_QUERY_MODIFIED_W_SUPPORT_PARAMS = NV_QUERY_MODIFIED_W_SUPPORT_PARAMS_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MODIFIED_W_COEFFICIENTS { + pub fA: f32, + pub fB: f32, + pub fAReserved: f32, + pub fBReserved: f32, + pub fReserved: [f32; 2usize], +} +pub type NV_MODIFIED_W_COEFFICIENTS = _NV_MODIFIED_W_COEFFICIENTS; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MODIFIED_W_PARAMS { + pub version: NvU32, + pub numEntries: NvU32, + pub modifiedWCoefficients: [NV_MODIFIED_W_COEFFICIENTS; 16usize], + pub id: NvU32, + pub reserved: [NvU32; 16usize], +} +pub type NV_MODIFIED_W_PARAMS_V1 = _NV_MODIFIED_W_PARAMS; +pub type NV_MODIFIED_W_PARAMS = NV_MODIFIED_W_PARAMS_V1; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to get sleep status\n! \\ingroup dx"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GET_SLEEP_STATUS_PARAMS { + #[doc = "!< (IN) Structure version"] + pub version: NvU32, + #[doc = "!< (OUT) Is low latency mode enabled?"] + pub bLowLatencyMode: NvBool, + #[doc = "!< (OUT) Is fullscreen VRR enabled?"] + pub bFsVrr: NvBool, + #[doc = "!< (OUT) Is Control Panel overriding VSYNC ON?"] + pub bCplVsyncOn: NvBool, + #[doc = "!< (OUT) Latest sleep interval in microseconds."] + pub sleepIntervalUs: NvU32, + #[doc = "!< (OUT) Is NvAPI_D3D_Sleep() being called?"] + pub bUseGameSleep: NvBool, + #[doc = "!< (OUT) Is in fullscreen/iFlip mode?"] + pub bFullscreenIFlip: NvBool, + #[doc = "!< (OUT) Latest Frame Generation multiplier used."] + pub fgMultiplier: NvU8, + #[doc = "!< (IN) Reserved. Must be set to 0s."] + pub rsvd: [NvU8; 119usize], +} +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to get sleep status\n! \\ingroup dx"] +pub type NV_GET_SLEEP_STATUS_PARAMS_V1 = _NV_GET_SLEEP_STATUS_PARAMS; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to get sleep status\n! \\ingroup dx"] +pub type NV_GET_SLEEP_STATUS_PARAMS = NV_GET_SLEEP_STATUS_PARAMS_V1; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to set sleep mode\n! \\ingroup dx"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_SET_SLEEP_MODE_PARAMS { + #[doc = "!< (IN) Structure version"] + pub version: NvU32, + #[doc = "!< (IN) Low latency mode enable/disable."] + pub bLowLatencyMode: NvBool, + #[doc = "!< (IN) Request maximum GPU clock frequency regardless of workload."] + pub bLowLatencyBoost: NvBool, + #[doc = "!< (IN) Minimum frame interval in microseconds. 0 = no frame rate limit."] + pub minimumIntervalUs: NvU32, + #[doc = "!< (IN) Allow latency markers to be used for runtime optimizations."] + pub bUseMarkersToOptimize: NvBool, + #[doc = "!< (IN) Consider all submission overlaps (both in between frames and within each frame)."] + pub bUseMinQueueTime: NvBool, + #[doc = "!< (IN) Reserved. Must be set to 0s."] + pub rsvd: [NvU8; 30usize], +} +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to set sleep mode\n! \\ingroup dx"] +pub type NV_SET_SLEEP_MODE_PARAMS_V1 = _NV_SET_SLEEP_MODE_PARAMS; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to set sleep mode\n! \\ingroup dx"] +pub type NV_SET_SLEEP_MODE_PARAMS = NV_SET_SLEEP_MODE_PARAMS_V1; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to send Reflex Sync data to UMD\n! \\ingroup dx"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_SET_REFLEX_SYNC_PARAMS { + #[doc = "!< (IN) Structure version"] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< (IN) Interval between VBLANKs in microseconds. (0 means N/A)"] + pub vblankIntervalUs: NvU32, + #[doc = "!< (IN) Amount of time in the completed frame queue. Can be negative. (0 means N/A)"] + pub timeInQueueUs: NvS32, + #[doc = "!< (IN) Target amount of time in the completed frame queue. (0 means N/A)"] + pub timeInQueueUsTarget: NvU32, + #[doc = "!< (IN) Specify the frame generation multipler to use. (0 means driver should auto-detect)"] + pub fgMultiplier: NvU8, + #[doc = "!< (IN) Reserved. Must be set to 0s."] + pub rsvd: [NvU8; 27usize], +} +impl _NV_SET_REFLEX_SYNC_PARAMS { + #[inline] + pub fn bEnable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bEnable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bEnable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bEnable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bDisable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bDisable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bDisable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bDisable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn flagsRsvd(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } + } + #[inline] + pub fn set_flagsRsvd(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 30u8, val as u64) + } + } + #[inline] + pub unsafe fn flagsRsvd_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 30u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_flagsRsvd_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 30u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bEnable: NvU32, + bDisable: NvU32, + flagsRsvd: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bEnable: u32 = unsafe { ::std::mem::transmute(bEnable) }; + bEnable as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bDisable: u32 = unsafe { ::std::mem::transmute(bDisable) }; + bDisable as u64 + }); + __bindgen_bitfield_unit.set(2usize, 30u8, { + let flagsRsvd: u32 = unsafe { ::std::mem::transmute(flagsRsvd) }; + flagsRsvd as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to send Reflex Sync data to UMD\n! \\ingroup dx"] +pub type NV_SET_REFLEX_SYNC_PARAMS_V1 = _NV_SET_REFLEX_SYNC_PARAMS; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to send Reflex Sync data to UMD\n! \\ingroup dx"] +pub type NV_SET_REFLEX_SYNC_PARAMS = NV_SET_REFLEX_SYNC_PARAMS_V1; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to get latency report.\n! \\ingroup dx"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LATENCY_RESULT_PARAMS { + #[doc = "!< (IN) Structure version"] + pub version: NvU32, + pub frameReport: [_NV_LATENCY_RESULT_PARAMS_FrameReport; 64usize], + pub rsvd: [NvU8; 32usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LATENCY_RESULT_PARAMS_FrameReport { + #[doc = "!< (OUT)"] + pub frameID: NvU64, + #[doc = "!< (OUT)"] + pub inputSampleTime: NvU64, + #[doc = "!< (OUT)"] + pub simStartTime: NvU64, + #[doc = "!< (OUT)"] + pub simEndTime: NvU64, + #[doc = "!< (OUT)"] + pub renderSubmitStartTime: NvU64, + #[doc = "!< (OUT)"] + pub renderSubmitEndTime: NvU64, + #[doc = "!< (OUT)"] + pub presentStartTime: NvU64, + #[doc = "!< (OUT)"] + pub presentEndTime: NvU64, + #[doc = "!< (OUT)"] + pub driverStartTime: NvU64, + #[doc = "!< (OUT)"] + pub driverEndTime: NvU64, + #[doc = "!< (OUT)"] + pub osRenderQueueStartTime: NvU64, + #[doc = "!< (OUT)"] + pub osRenderQueueEndTime: NvU64, + #[doc = "!< (OUT)"] + pub gpuRenderStartTime: NvU64, + #[doc = "!< (OUT)"] + pub gpuRenderEndTime: NvU64, + #[doc = "!< (OUT) Difference between gpuRenderStartTime and gpuRenderEndTime, excluding the idles in between, in microseconds."] + pub gpuActiveRenderTimeUs: NvU32, + #[doc = "!< (OUT) Difference between previous and current frame's gpuRenderEndTime, in microseconds."] + pub gpuFrameTimeUs: NvU32, + #[doc = "!< (OUT)"] + pub cameraConstructedTime: NvU64, + #[doc = "!< (OUT) Cross adapter copy time in microseconds."] + pub crossAdapterCopyTimeUs: NvU32, + #[doc = "!< (OUT) Frame generation time in microseconds."] + pub aiFrameTimeUs: NvU32, + pub rsvd: [NvU8; 104usize], +} +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to get latency report.\n! \\ingroup dx"] +pub type NV_LATENCY_RESULT_PARAMS_V1 = _NV_LATENCY_RESULT_PARAMS; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to get latency report.\n! \\ingroup dx"] +pub type NV_LATENCY_RESULT_PARAMS = NV_LATENCY_RESULT_PARAMS_V1; +pub const NV_LATENCY_MARKER_TYPE_SIMULATION_START: NV_LATENCY_MARKER_TYPE = 0; +pub const NV_LATENCY_MARKER_TYPE_SIMULATION_END: NV_LATENCY_MARKER_TYPE = 1; +pub const NV_LATENCY_MARKER_TYPE_RENDERSUBMIT_START: NV_LATENCY_MARKER_TYPE = 2; +pub const NV_LATENCY_MARKER_TYPE_RENDERSUBMIT_END: NV_LATENCY_MARKER_TYPE = 3; +pub const NV_LATENCY_MARKER_TYPE_PRESENT_START: NV_LATENCY_MARKER_TYPE = 4; +pub const NV_LATENCY_MARKER_TYPE_PRESENT_END: NV_LATENCY_MARKER_TYPE = 5; +pub const NV_LATENCY_MARKER_TYPE_INPUT_SAMPLE: NV_LATENCY_MARKER_TYPE = 6; +pub const NV_LATENCY_MARKER_TYPE_TRIGGER_FLASH: NV_LATENCY_MARKER_TYPE = 7; +pub const NV_LATENCY_MARKER_TYPE_PC_LATENCY_PING: NV_LATENCY_MARKER_TYPE = 8; +pub const NV_LATENCY_MARKER_TYPE_OUT_OF_BAND_RENDERSUBMIT_START: NV_LATENCY_MARKER_TYPE = 9; +pub const NV_LATENCY_MARKER_TYPE_OUT_OF_BAND_RENDERSUBMIT_END: NV_LATENCY_MARKER_TYPE = 10; +pub const NV_LATENCY_MARKER_TYPE_OUT_OF_BAND_PRESENT_START: NV_LATENCY_MARKER_TYPE = 11; +pub const NV_LATENCY_MARKER_TYPE_OUT_OF_BAND_PRESENT_END: NV_LATENCY_MARKER_TYPE = 12; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used define latency marker type\n! \\ingroup dx"] +pub type NV_LATENCY_MARKER_TYPE = ::std::os::raw::c_int; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used set latency markers\n! \\ingroup dx"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LATENCY_MARKER_PARAMS { + #[doc = "!< (IN) Structure version"] + pub version: NvU32, + pub frameID: NvU64, + pub markerType: NV_LATENCY_MARKER_TYPE, + pub rsvd0: NvU64, + pub rsvd: [NvU8; 56usize], +} +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used set latency markers\n! \\ingroup dx"] +pub type NV_LATENCY_MARKER_PARAMS_V1 = _NV_LATENCY_MARKER_PARAMS; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used set latency markers\n! \\ingroup dx"] +pub type NV_LATENCY_MARKER_PARAMS = NV_LATENCY_MARKER_PARAMS_V1; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used in NvAPI_D3D12_SetAsyncFrameMarker and NvAPI_D3D11_SetAsyncFrameMarker\n! \\ingroup dx"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_ASYNC_FRAME_MARKER_PARAMS_V1 { + #[doc = "!< (IN) Structure version"] + pub version: NvU32, + pub frameID: NvU64, + pub markerType: NV_LATENCY_MARKER_TYPE, + pub presentFrameID: NvU64, + pub vendorInternal: NvBool, + pub rsvd: [NvU8; 55usize], +} +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used in NvAPI_D3D12_SetAsyncFrameMarker and NvAPI_D3D11_SetAsyncFrameMarker\n! \\ingroup dx"] +pub type NV_ASYNC_FRAME_MARKER_PARAMS_V1 = _NV_ASYNC_FRAME_MARKER_PARAMS_V1; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used in NvAPI_D3D12_SetAsyncFrameMarker and NvAPI_D3D11_SetAsyncFrameMarker\n! \\ingroup dx"] +pub type NV_ASYNC_FRAME_MARKER_PARAMS = NV_ASYNC_FRAME_MARKER_PARAMS_V1; +pub const NV_OUT_OF_BAND_CQ_TYPE_OUT_OF_BAND_RENDER: NV_OUT_OF_BAND_CQ_TYPE = 0; +pub const NV_OUT_OF_BAND_CQ_TYPE_OUT_OF_BAND_PRESENT: NV_OUT_OF_BAND_CQ_TYPE = 1; +pub const NV_OUT_OF_BAND_CQ_TYPE_OUT_OF_BAND_IGNORE: NV_OUT_OF_BAND_CQ_TYPE = 2; +pub const NV_OUT_OF_BAND_CQ_TYPE_OUT_OF_BAND_RENDER_PRESENT: NV_OUT_OF_BAND_CQ_TYPE = 3; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used in NvAPI_D3D12_NotifyOutOfBandCommandQueue\n! \\ingroup dx"] +pub type NV_OUT_OF_BAND_CQ_TYPE = ::std::os::raw::c_int; +pub const _NV_D3D12_WORKSTATION_FEATURE_TYPE_NV_D3D12_WORKSTATION_FEATURE_TYPE_PRESENT_BARRIER: + _NV_D3D12_WORKSTATION_FEATURE_TYPE = 1; +pub const _NV_D3D12_WORKSTATION_FEATURE_TYPE_NV_D3D12_WORKSTATION_FEATURE_TYPE_RDMA_BAR1_SUPPORT: + _NV_D3D12_WORKSTATION_FEATURE_TYPE = 2; +#[doc = "! \\ingroup DX"] +pub type _NV_D3D12_WORKSTATION_FEATURE_TYPE = ::std::os::raw::c_int; +#[doc = "! \\ingroup DX"] +pub use self::_NV_D3D12_WORKSTATION_FEATURE_TYPE as NV_D3D12_WORKSTATION_FEATURE_TYPE; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_D3D12_WORKSTATION_FEATURE_RDMA_PROPERTIES { + pub rdmaHeapSize: NvU64, +} +pub type NV_D3D12_WORKSTATION_FEATURE_RDMA_PROPERTIES = + _NV_D3D12_WORKSTATION_FEATURE_RDMA_PROPERTIES; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_INITIALIZED: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 1; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_ENABLED: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 2; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_DLL_EXISTS: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 4; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_DLL_LOADED: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 8; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_DLL_SELECTED: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 16; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_PRESET: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 32; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_PERF_MODE: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 64; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_SCALING_RATIO: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 128; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_OPTIMAL_SETTINGS: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 256; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_CREATED: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 512; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_EVALUATE: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 1024; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_FG_MODE: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 8192; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_SR_DLAA_MODE: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 16384; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_FG_MULTI_FRAME: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 32768; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_ERR_FAILED: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 65536; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_ERR_DENIED: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 131072; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_ERR_DRS: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 262144; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_ERR_NOT_FOUND: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 524288; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_ERR_DLL_LOAD: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 1048576; +pub type NV_NGX_DLSS_OVERRIDE_BITFIELD = ::std::os::raw::c_int; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_NGX_DLSS_OVERRIDE_GET_STATE_PARAMS_V1 { + #[doc = "!< [in] Structure version"] + pub version: NvU32, + #[doc = "!< [in] Process Identifier"] + pub processIdentifier: NvU32, + #[doc = "!< [out] Feedback bits for Super Resolution"] + pub feedbackMaskSR: NvU64, + #[doc = "!< [out] Feedback bits for Ray Reconstruction"] + pub feedbackMaskRR: NvU64, + #[doc = "!< [out] Feedback bits for Frame Generation"] + pub feedbackMaskFG: NvU64, + #[doc = "!< [out] Scaling Ratio"] + pub scalingRatio: NvF32, + #[doc = "!< [out] Performance Mode"] + pub performanceMode: NvU32, + #[doc = "!< [out] Render Preset for SR/RR"] + pub renderPreset: NvU32, + #[doc = "!< [out] FG Override Frame Count Target"] + pub frameGenerationCount: NvU32, + #[doc = "!< [out] Render Preset for FG"] + pub frameGenerationPreset: NvU32, + #[doc = "!< [out] Frame Generation Mode"] + pub frameGenerationMode: NvU32, + #[doc = "!< Reserved for future use. Must be zero."] + pub reserved: [NvU32; 2usize], +} +pub type NV_NGX_DLSS_OVERRIDE_GET_STATE_PARAMS_V1 = _NV_NGX_DLSS_OVERRIDE_GET_STATE_PARAMS_V1; +pub type NV_NGX_DLSS_OVERRIDE_GET_STATE_PARAMS = NV_NGX_DLSS_OVERRIDE_GET_STATE_PARAMS_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_NGX_DLSS_OVERRIDE_SET_STATE_PARAMS_V1 { + #[doc = "!< [in] Structure version"] + pub version: NvU32, + #[doc = "!< [in] Process identifier of caller"] + pub processIdentifier: NvU32, + #[doc = "!< [in] DLSS feature ID"] + pub feature: NvU32, + #[doc = "!< [in] Feedback bits for DLSS feature"] + pub feedbackMask: NvU64, + #[doc = "!< Reserved for future use. Must be zero."] + pub reserved: [NvU64; 4usize], +} +pub type NV_NGX_DLSS_OVERRIDE_SET_STATE_PARAMS_V1 = _NV_NGX_DLSS_OVERRIDE_SET_STATE_PARAMS_V1; +pub type NV_NGX_DLSS_OVERRIDE_SET_STATE_PARAMS = NV_NGX_DLSS_OVERRIDE_SET_STATE_PARAMS_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NVVIOTOPOLOGYTARGET { + #[doc = "!< Handle to Physical GPU (This could be NULL for GVI device if its not binded)"] + pub hPhysicalGpu: NvPhysicalGpuHandle, + #[doc = "!, +} +impl _NV_DISPLAY_DRIVER_INFO { + #[inline] + pub fn bIsDCHDriver(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsDCHDriver(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsDCHDriver_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsDCHDriver_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsNVIDIAStudioPackage(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsNVIDIAStudioPackage(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsNVIDIAStudioPackage_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsNVIDIAStudioPackage_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsNVIDIAGameReadyPackage(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsNVIDIAGameReadyPackage(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsNVIDIAGameReadyPackage_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsNVIDIAGameReadyPackage_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsNVIDIARTXProductionBranchPackage(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsNVIDIARTXProductionBranchPackage(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsNVIDIARTXProductionBranchPackage_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsNVIDIARTXProductionBranchPackage_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsNVIDIARTXNewFeatureBranchPackage(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsNVIDIARTXNewFeatureBranchPackage(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsNVIDIARTXNewFeatureBranchPackage_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsNVIDIARTXNewFeatureBranchPackage_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 27u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 27u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 27u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsDCHDriver: NvU32, + bIsNVIDIAStudioPackage: NvU32, + bIsNVIDIAGameReadyPackage: NvU32, + bIsNVIDIARTXProductionBranchPackage: NvU32, + bIsNVIDIARTXNewFeatureBranchPackage: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsDCHDriver: u32 = unsafe { ::std::mem::transmute(bIsDCHDriver) }; + bIsDCHDriver as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bIsNVIDIAStudioPackage: u32 = + unsafe { ::std::mem::transmute(bIsNVIDIAStudioPackage) }; + bIsNVIDIAStudioPackage as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let bIsNVIDIAGameReadyPackage: u32 = + unsafe { ::std::mem::transmute(bIsNVIDIAGameReadyPackage) }; + bIsNVIDIAGameReadyPackage as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let bIsNVIDIARTXProductionBranchPackage: u32 = + unsafe { ::std::mem::transmute(bIsNVIDIARTXProductionBranchPackage) }; + bIsNVIDIARTXProductionBranchPackage as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let bIsNVIDIARTXNewFeatureBranchPackage: u32 = + unsafe { ::std::mem::transmute(bIsNVIDIARTXNewFeatureBranchPackage) }; + bIsNVIDIARTXNewFeatureBranchPackage as u64 + }); + __bindgen_bitfield_unit.set(5usize, 27u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_DISPLAY_DRIVER_INFO_V1 = _NV_DISPLAY_DRIVER_INFO; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_DISPLAY_DRIVER_INFO_V2 { + #[doc = "!< Structure Version."] + pub version: NvU32, + #[doc = "!< Contains the driver version after successful return."] + pub driverVersion: NvU32, + #[doc = "!< Contains the driver-branch string after successful return."] + pub szBuildBranch: NvAPI_ShortString, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< (OUT) Contains the driver base branch string after successful return."] + pub szBuildBaseBranch: NvAPI_ShortString, + #[doc = "!< Reserved for future use"] + pub reservedEx: NvU32, +} +impl _NV_DISPLAY_DRIVER_INFO_V2 { + #[inline] + pub fn bIsDCHDriver(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsDCHDriver(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsDCHDriver_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsDCHDriver_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsNVIDIAStudioPackage(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsNVIDIAStudioPackage(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsNVIDIAStudioPackage_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsNVIDIAStudioPackage_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsNVIDIAGameReadyPackage(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsNVIDIAGameReadyPackage(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsNVIDIAGameReadyPackage_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsNVIDIAGameReadyPackage_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsNVIDIARTXProductionBranchPackage(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsNVIDIARTXProductionBranchPackage(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsNVIDIARTXProductionBranchPackage_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsNVIDIARTXProductionBranchPackage_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsNVIDIARTXNewFeatureBranchPackage(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsNVIDIARTXNewFeatureBranchPackage(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsNVIDIARTXNewFeatureBranchPackage_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsNVIDIARTXNewFeatureBranchPackage_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 27u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 27u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 27u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsDCHDriver: NvU32, + bIsNVIDIAStudioPackage: NvU32, + bIsNVIDIAGameReadyPackage: NvU32, + bIsNVIDIARTXProductionBranchPackage: NvU32, + bIsNVIDIARTXNewFeatureBranchPackage: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsDCHDriver: u32 = unsafe { ::std::mem::transmute(bIsDCHDriver) }; + bIsDCHDriver as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bIsNVIDIAStudioPackage: u32 = + unsafe { ::std::mem::transmute(bIsNVIDIAStudioPackage) }; + bIsNVIDIAStudioPackage as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let bIsNVIDIAGameReadyPackage: u32 = + unsafe { ::std::mem::transmute(bIsNVIDIAGameReadyPackage) }; + bIsNVIDIAGameReadyPackage as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let bIsNVIDIARTXProductionBranchPackage: u32 = + unsafe { ::std::mem::transmute(bIsNVIDIARTXProductionBranchPackage) }; + bIsNVIDIARTXProductionBranchPackage as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let bIsNVIDIARTXNewFeatureBranchPackage: u32 = + unsafe { ::std::mem::transmute(bIsNVIDIARTXNewFeatureBranchPackage) }; + bIsNVIDIARTXNewFeatureBranchPackage as u64 + }); + __bindgen_bitfield_unit.set(5usize, 27u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_DISPLAY_DRIVER_INFO_V2 = _NV_DISPLAY_DRIVER_INFO_V2; +pub type NV_DISPLAY_DRIVER_INFO = NV_DISPLAY_DRIVER_INFO_V2; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_PHYSICAL_GPU_HANDLE_DATA { + pub hPhysicalGpu: NvPhysicalGpuHandle, + pub adapterType: NV_ADAPTER_TYPE, + pub reserved2: [NvU32; 4usize], +} +pub type NV_PHYSICAL_GPU_HANDLE_DATA = _NV_PHYSICAL_GPU_HANDLE_DATA; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_PHYSICAL_GPUS { + pub version: NvU32, + pub gpuHandleData: [NV_PHYSICAL_GPU_HANDLE_DATA; 64usize], + pub gpuHandleCount: NvU32, + pub reserved: [NvU32; 4usize], +} +pub type NV_PHYSICAL_GPUS_V1 = _NV_PHYSICAL_GPUS; +pub type NV_PHYSICAL_GPUS = NV_PHYSICAL_GPUS_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LOGICAL_GPU_HANDLE_DATA { + pub hLogicalGpu: NvLogicalGpuHandle, + pub adapterType: NV_ADAPTER_TYPE, + pub reserved: [NvU32; 4usize], +} +pub type NV_LOGICAL_GPU_HANDLE_DATA = _NV_LOGICAL_GPU_HANDLE_DATA; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LOGICAL_GPUS { + pub version: NvU32, + pub gpuHandleData: [NV_LOGICAL_GPU_HANDLE_DATA; 64usize], + pub gpuHandleCount: NvU32, + pub reserved: [NvU32; 4usize], +} +pub type NV_LOGICAL_GPUS_V1 = _NV_LOGICAL_GPUS; +pub type NV_LOGICAL_GPUS = NV_LOGICAL_GPUS_V1; +pub const _NV_NGX_DRIVER_FEATURE_ID_NV_NGX_DRIVER_FEATURE_ID_SET_FLIP_CONFIG_V2: + _NV_NGX_DRIVER_FEATURE_ID = 3423695; +pub type _NV_NGX_DRIVER_FEATURE_ID = ::std::os::raw::c_int; +pub use self::_NV_NGX_DRIVER_FEATURE_ID as NV_NGX_DRIVER_FEATURE_ID; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_NGX_DRIVER_FEATURE_SUPPORT_INFO { + #[doc = "!< [IN] Feature ID to query"] + pub featureId: NV_NGX_DRIVER_FEATURE_ID, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Reserved for future use"] + pub reserved2: [NvU32; 2usize], +} +impl _NV_NGX_DRIVER_FEATURE_SUPPORT_INFO { + #[inline] + pub fn bSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved1(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved1(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved1_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved1_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bSupported: NvU32, + reserved1: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bSupported: u32 = unsafe { ::std::mem::transmute(bSupported) }; + bSupported as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved1: u32 = unsafe { ::std::mem::transmute(reserved1) }; + reserved1 as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_NGX_DRIVER_FEATURE_SUPPORT_INFO = _NV_NGX_DRIVER_FEATURE_SUPPORT_INFO; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_NGX_GET_DRIVER_FEATURE_SUPPORT_PARAMS_V1 { + #[doc = "!< [IN] Structure version"] + pub version: NvU32, + #[doc = "!< [IN] Number of features to query (must be <= NVAPI_MAX_NGX_FEATURES_PER_QUERY)"] + pub featureCount: NvU32, + #[doc = "!< [INOUT] Feature query array"] + pub featureSupportInfo: [NV_NGX_DRIVER_FEATURE_SUPPORT_INFO; 16usize], + #[doc = "!< Reserved for future use"] + pub reserved: [NvU32; 6usize], +} +pub type NV_NGX_GET_DRIVER_FEATURE_SUPPORT_PARAMS_V1 = _NV_NGX_GET_DRIVER_FEATURE_SUPPORT_PARAMS_V1; +pub type NV_NGX_GET_DRIVER_FEATURE_SUPPORT_PARAMS = NV_NGX_GET_DRIVER_FEATURE_SUPPORT_PARAMS_V1; +#[doc = " Callback settings common to all client callbacks."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1 { + #[doc = " [in] Generic callback parameter which will be passed to the callback."] + pub pCallbackParam: *mut ::std::os::raw::c_void, + #[doc = " Reserved bytes for future expansion."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Callback settings common to all client callbacks."] +pub type NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1 = _NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1; +#[doc = " Callback settings common to all client callbacks."] +pub type NV_GPU_CLIENT_CALLBACK_SETTINGS_SUPER_V1 = NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1; +#[doc = " Callback settings common to all periodic client callbacks."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_PERIODIC_CALLBACK_SETTINGS_SUPER_V1 { + #[doc = " [in] Super class data."] + pub super_: NV_GPU_CLIENT_CALLBACK_SETTINGS_SUPER_V1, + #[doc = " [in] Minimum interval at which callback will be called.\n\n The callback may be invoked slower than this interval if underlying\n sampling rate does not align precisely to the provided period."] + pub callbackPeriodms: NvU32, + #[doc = " Reserved bytes for future expansion."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Callback settings common to all periodic client callbacks."] +pub type NV_GPU_CLIENT_PERIODIC_CALLBACK_SETTINGS_SUPER_V1 = + _NV_GPU_CLIENT_PERIODIC_CALLBACK_SETTINGS_SUPER_V1; +#[doc = " Callback data common to all client callbacks."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_CALLBACK_DATA_SUPER_V1 { + #[doc = " [out] Generic callback parameter which was passed in at registration time."] + pub pCallbackParam: *mut ::std::os::raw::c_void, + #[doc = " Reserved bytes for future expansion."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Callback data common to all client callbacks."] +pub type NV_GPU_CLIENT_CALLBACK_DATA_SUPER_V1 = _NV_GPU_CLIENT_CALLBACK_DATA_SUPER_V1; +pub const _NV_GPU_CLIENT_UTIL_DOMAIN_ID_NV_GPU_CLIENT_UTIL_DOMAIN_GRAPHICS: + _NV_GPU_CLIENT_UTIL_DOMAIN_ID = 0; +pub const _NV_GPU_CLIENT_UTIL_DOMAIN_ID_NV_GPU_CLIENT_UTIL_DOMAIN_FRAME_BUFFER: + _NV_GPU_CLIENT_UTIL_DOMAIN_ID = 1; +pub const _NV_GPU_CLIENT_UTIL_DOMAIN_ID_NV_GPU_CLIENT_UTIL_DOMAIN_VIDEO: + _NV_GPU_CLIENT_UTIL_DOMAIN_ID = 2; +#[doc = " Reserved for future use."] +pub const _NV_GPU_CLIENT_UTIL_DOMAIN_ID_NV_GPU_CLIENT_UTIL_DOMAIN_RSVD: + _NV_GPU_CLIENT_UTIL_DOMAIN_ID = 3; +#[doc = " Enumeration of different utilization domains"] +pub type _NV_GPU_CLIENT_UTIL_DOMAIN_ID = ::std::os::raw::c_int; +#[doc = " Enumeration of different utilization domains"] +pub use self::_NV_GPU_CLIENT_UTIL_DOMAIN_ID as NV_GPU_CLIENT_UTIL_DOMAIN_ID; +#[doc = " Data specific to a single utilization domain."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_UTILIZATION_DATA_V1 { + #[doc = " [out] Utilization domain identifier."] + pub utilId: NV_GPU_CLIENT_UTIL_DOMAIN_ID, + #[doc = " [out] Percentage of time where the domain is considered busy since the\n last sample. Units of percent*100; i.e. 5000 = 50%."] + pub utilizationPercent: NvU32, + #[doc = " Reserved bytes for future expansion."] + pub rsvd: [NvU8; 61usize], +} +#[doc = " Data specific to a single utilization domain."] +pub type NV_GPU_CLIENT_UTILIZATION_DATA_V1 = _NV_GPU_CLIENT_UTILIZATION_DATA_V1; +#[doc = " Data passed back to callback registered with\n @ref NvAPI_GPU_ClientRegisterForUtilizationSampleUpdates."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_CALLBACK_UTILIZATION_DATA_V1 { + #[doc = " [out] Super struct."] + pub super_: NV_GPU_CLIENT_CALLBACK_DATA_SUPER_V1, + #[doc = " [out] Number of valid entries in `utils` array."] + pub numUtils: NvU32, + #[doc = " [out] Time at which data was collected. Represented as elapsed\n microseconds since 00:00:00 UTC on January 1, 1970."] + pub timestamp: NvU64, + #[doc = " Reserved bytes for future expansion."] + pub rsvd: [NvU8; 64usize], + #[doc = " [out] Status data for each utilization domain."] + pub utils: [NV_GPU_CLIENT_UTILIZATION_DATA_V1; 4usize], +} +#[doc = " Data passed back to callback registered with\n @ref NvAPI_GPU_ClientRegisterForUtilizationSampleUpdates."] +pub type NV_GPU_CLIENT_CALLBACK_UTILIZATION_DATA_V1 = _NV_GPU_CLIENT_CALLBACK_UTILIZATION_DATA_V1; +#[doc = " Function prototype for a periodic utilization data callback that will be registered with NvAPI."] +pub type NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_V1 = ::std::option::Option< + unsafe extern "C" fn( + hPhysicalGpu: NvPhysicalGpuHandle, + pData: *mut NV_GPU_CLIENT_CALLBACK_UTILIZATION_DATA_V1, + ), +>; +#[doc = " Data required to register a periodic callback for utilization data."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_SETTINGS_V1 { + #[doc = " [in] Structure Version, must always be first."] + pub version: NvU32, + #[doc = " [in] Generic callback settings. Some data within will be passed to the\n callback when invoked."] + pub super_: NV_GPU_CLIENT_PERIODIC_CALLBACK_SETTINGS_SUPER_V1, + #[doc = " [in] Callback. Pass in NULL or nullptr to indicate request to unregister."] + pub callback: NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_V1, + #[doc = " Reserved bytes for future expansion."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Data required to register a periodic callback for utilization data."] +pub type NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_SETTINGS_V1 = + _NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_SETTINGS_V1; +#[doc = " Data required to register a periodic callback for utilization data."] +pub type NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_SETTINGS = + NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_SETTINGS_V1; +pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_INVALID: _NV_RISE_CONTENT_TYPE = 0; +pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_TEXT: _NV_RISE_CONTENT_TYPE = 1; +pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_GRAPH: _NV_RISE_CONTENT_TYPE = 2; +pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_CUSTOM_BEHAVIOR: _NV_RISE_CONTENT_TYPE = 3; +pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_CUSTOM_BEHAVIOR_RESULT: _NV_RISE_CONTENT_TYPE = + 4; +pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_INSTALLING: _NV_RISE_CONTENT_TYPE = 5; +pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_PROGRESS_UPDATE: _NV_RISE_CONTENT_TYPE = 6; +pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_READY: _NV_RISE_CONTENT_TYPE = 7; +pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_DOWNLOAD_REQUEST: _NV_RISE_CONTENT_TYPE = 8; +pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_UPDATE_INFO: _NV_RISE_CONTENT_TYPE = 9; +#[doc = " Enumeration of different RISE content types."] +pub type _NV_RISE_CONTENT_TYPE = ::std::os::raw::c_int; +#[doc = " Enumeration of different RISE content types."] +pub use self::_NV_RISE_CONTENT_TYPE as NV_RISE_CONTENT_TYPE; +#[doc = " Data passed back to callback."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_RISE_CALLBACK_DATA_V1 { + #[doc = " Super struct."] + pub super_: NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1, + #[doc = " RISE type of content"] + pub contentType: NV_RISE_CONTENT_TYPE, + #[doc = " RISE content."] + pub content: NvAPI_String, + #[doc = " Is this the last in the batch?"] + pub completed: NvBool, +} +#[doc = " Data passed back to callback."] +pub type NV_RISE_CALLBACK_DATA_V1 = _NV_RISE_CALLBACK_DATA_V1; +#[doc = " Callback for RISE update callbacks."] +pub type NV_RISE_CALLBACK_V1 = + ::std::option::Option; +#[doc = " Data required to register an update callback from the RISE."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_RISE_CALLBACK_SETTINGS_V1 { + #[doc = " [in] Structure Version, must always be first."] + pub version: NvU32, + #[doc = " [in] Generic callback parameter which will be passed to the callback."] + pub super_: NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1, + #[doc = " [in] Callback. Pass in NULL or nullptr to indicate request to unregister."] + pub callback: NV_RISE_CALLBACK_V1, + #[doc = " Reserved, must be set to zero by client."] + pub reserved: [NvU8; 32usize], +} +#[doc = " Data required to register an update callback from the RISE."] +pub type NV_RISE_CALLBACK_SETTINGS_V1 = _NV_RISE_CALLBACK_SETTINGS_V1; +#[doc = " Data required to register an update callback from the RISE."] +pub type NV_RISE_CALLBACK_SETTINGS = NV_RISE_CALLBACK_SETTINGS_V1; +#[doc = " Request contents sent to RISE."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_REQUEST_RISE_SETTINGS_V1 { + #[doc = " [in] Structure Version, must always be first."] + pub version: NvU32, + #[doc = " RISE type of content"] + pub contentType: NV_RISE_CONTENT_TYPE, + #[doc = " RISE request content."] + pub content: NvAPI_String, + #[doc = " Is the request fully sent?"] + pub completed: NvBool, + #[doc = " Reserved, must be set to zero by client."] + pub reserved: [NvU8; 32usize], +} +#[doc = " Request contents sent to RISE."] +pub type NV_REQUEST_RISE_SETTINGS_V1 = _NV_REQUEST_RISE_SETTINGS_V1; +#[doc = " Request contents sent to RISE."] +pub type NV_REQUEST_RISE_SETTINGS = NV_REQUEST_RISE_SETTINGS_V1; +#[doc = " Request contents sent to RISE."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_UNINSTALL_RISE_SETTINGS_V1 { + #[doc = " [in] Structure Version, must always be first."] + pub version: NvU32, + #[doc = " Reserved, must be set to zero by client."] + pub reserved: [NvU8; 32usize], +} +#[doc = " Request contents sent to RISE."] +pub type NV_UNINSTALL_RISE_SETTINGS_V1 = _NV_UNINSTALL_RISE_SETTINGS_V1; +#[doc = " Request contents sent to RISE."] +pub type NV_UNINSTALL_RISE_SETTINGS = NV_UNINSTALL_RISE_SETTINGS_V1; From 801b48c0f5d3dfeadc49e4d017b34b246d45aab2 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Mon, 20 Apr 2026 23:35:24 -0700 Subject: [PATCH 16/85] Revert "Show return value of nvapi functions" This reverts commit 0f06b7a43311ec9dd06dfa2a1e52ba2344947207. --- nvapi_trace/src/lib.rs | 25 +++++++++++++------------ zluda_trace_common/src/lib.rs | 18 ++++++++++++++++++ 2 files changed, 31 insertions(+), 12 deletions(-) diff --git a/nvapi_trace/src/lib.rs b/nvapi_trace/src/lib.rs index 5dfd87568..9b5d2cea4 100644 --- a/nvapi_trace/src/lib.rs +++ b/nvapi_trace/src/lib.rs @@ -37,7 +37,7 @@ impl GlobalState { fn get_thunk( &mut self, original: *mut c_void, - report_fn: unsafe extern "system" fn(u32, i32), + report_fn: unsafe extern "system" fn(u32), interface: u32, ) -> *mut c_void { match self.thunks.entry(interface) { @@ -629,29 +629,32 @@ pub unsafe extern "C" fn nvapi_QueryInterface(interface: u32) -> *mut c_void { } } -unsafe extern "system" fn report_fn(interface: u32, result: i32) { +unsafe extern "system" fn report_fn(interface: u32) { + use zluda_trace_common::Unknown; let export_table = unwrap_or::unwrap_some_or!(::zluda_trace_common::get_export_table(), return); let format_args = dark_api::FnFfiWrapper(|| dark_api::ByteVecFfi::new("(...)".as_bytes().to_vec())); - let underlying_fn = dark_api::FnFfiWrapper(|| ReprUsize::to_usize(result)); + let underlying_fn = dark_api::FnFfiWrapper(|| 0); let (fn_name, interface) = match interface_to_name(interface) { Some(name) => (name, 0), - None => ("", interface), + None => { + ("", interface) + } }; export_table.logged_call( cglue::slice::CSliceRef::from_str(fn_name), interface, cglue::trait_obj!(&format_args as dark_api::FnFfi), cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), - ::INTERNAL_ERROR, - ::format_status, + ::INTERNAL_ERROR, + ::format_status, ); } #[cfg(target_arch = "x86")] pub fn get_thunk( original_fn: *mut c_void, - report_fn: unsafe extern "system" fn(u32, i32), + report_fn: unsafe extern "system" fn(u32), interface: u32, ) -> *mut c_void { use dynasmrt::{dynasm, DynasmApi}; @@ -659,13 +662,11 @@ pub fn get_thunk( let start = ops.offset(); dynasm!(ops ; .arch x86 - ; mov eax, original_fn as i32 - ; call eax - ; push eax ; push interface as i32 ; mov eax, report_fn as i32 ; call eax - ; ret + ; mov eax, original_fn as i32 + ; jmp eax ; int 3 ); let exe_buf = ops.finalize().unwrap(); @@ -677,7 +678,7 @@ pub fn get_thunk( #[cfg(target_arch = "x86_64")] pub fn get_thunk( _original_fn: *mut c_void, - _report_fn: unsafe extern "system" fn(u32, i32), + _report_fn: unsafe extern "system" fn(u32), _interface: u32, ) -> *mut c_void { todo!() diff --git a/zluda_trace_common/src/lib.rs b/zluda_trace_common/src/lib.rs index 1646db0f5..2bccda0bb 100644 --- a/zluda_trace_common/src/lib.rs +++ b/zluda_trace_common/src/lib.rs @@ -472,3 +472,21 @@ impl ReprUsize for cuda_types::nvml::nvmlReturn_t { ByteVecFfi::new(writer) } } + +pub struct Unknown; + +impl ReprUsize for Unknown { + fn to_usize(self) -> usize { + 0 + } + + fn from_usize(_: usize) -> Self { + Self + } + + const INTERNAL_ERROR: usize = usize::MAX; + + extern "C" fn format_status(_: usize) -> ByteVecFfi { + ByteVecFfi::new(b"UNKNOWN".to_vec()) + } +} From edd3ffafc3d225af93ac16b36289625ae767f93f Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Tue, 21 Apr 2026 00:15:35 -0700 Subject: [PATCH 17/85] Show return value of nvapi functions, this time properly --- nvapi_trace/src/lib.rs | 45 +++++++++++++++++++++++++---------- zluda_trace_common/src/lib.rs | 18 -------------- 2 files changed, 32 insertions(+), 31 deletions(-) diff --git a/nvapi_trace/src/lib.rs b/nvapi_trace/src/lib.rs index 9b5d2cea4..9fcc8dd06 100644 --- a/nvapi_trace/src/lib.rs +++ b/nvapi_trace/src/lib.rs @@ -37,7 +37,7 @@ impl GlobalState { fn get_thunk( &mut self, original: *mut c_void, - report_fn: unsafe extern "system" fn(u32), + report_fn: unsafe extern "C" fn(i32, u32), interface: u32, ) -> *mut c_void { match self.thunks.entry(interface) { @@ -629,32 +629,29 @@ pub unsafe extern "C" fn nvapi_QueryInterface(interface: u32) -> *mut c_void { } } -unsafe extern "system" fn report_fn(interface: u32) { - use zluda_trace_common::Unknown; +unsafe extern "C" fn report_fn(result: i32, interface: u32) { let export_table = unwrap_or::unwrap_some_or!(::zluda_trace_common::get_export_table(), return); let format_args = dark_api::FnFfiWrapper(|| dark_api::ByteVecFfi::new("(...)".as_bytes().to_vec())); - let underlying_fn = dark_api::FnFfiWrapper(|| 0); + let underlying_fn = dark_api::FnFfiWrapper(|| ReprUsize::to_usize(result)); let (fn_name, interface) = match interface_to_name(interface) { Some(name) => (name, 0), - None => { - ("", interface) - } + None => ("", interface), }; export_table.logged_call( cglue::slice::CSliceRef::from_str(fn_name), interface, cglue::trait_obj!(&format_args as dark_api::FnFfi), cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), - ::INTERNAL_ERROR, - ::format_status, + ::INTERNAL_ERROR, + ::format_status, ); } #[cfg(target_arch = "x86")] pub fn get_thunk( original_fn: *mut c_void, - report_fn: unsafe extern "system" fn(u32), + report_fn: unsafe extern "C" fn(i32, u32), interface: u32, ) -> *mut c_void { use dynasmrt::{dynasm, DynasmApi}; @@ -662,11 +659,33 @@ pub fn get_thunk( let start = ops.offset(); dynasm!(ops ; .arch x86 + ; push ebp + ; mov ebp, esp + ; push DWORD [ebp+68] + ; push DWORD [ebp+64] + ; push DWORD [ebp+60] + ; push DWORD [ebp+56] + ; push DWORD [ebp+52] + ; push DWORD [ebp+48] + ; push DWORD [ebp+44] + ; push DWORD [ebp+40] + ; push DWORD [ebp+36] + ; push DWORD [ebp+32] + ; push DWORD [ebp+28] + ; push DWORD [ebp+24] + ; push DWORD [ebp+20] + ; push DWORD [ebp+16] + ; push DWORD [ebp+12] + ; push DWORD [ebp+8] + ; mov eax, original_fn as i32 + ; call eax ; push interface as i32 + ; push eax ; mov eax, report_fn as i32 ; call eax - ; mov eax, original_fn as i32 - ; jmp eax + ; pop eax + ; leave + ; ret ; int 3 ); let exe_buf = ops.finalize().unwrap(); @@ -678,7 +697,7 @@ pub fn get_thunk( #[cfg(target_arch = "x86_64")] pub fn get_thunk( _original_fn: *mut c_void, - _report_fn: unsafe extern "system" fn(u32), + _report_fn: unsafe extern "C" fn(i32, u32), _interface: u32, ) -> *mut c_void { todo!() diff --git a/zluda_trace_common/src/lib.rs b/zluda_trace_common/src/lib.rs index 2bccda0bb..1646db0f5 100644 --- a/zluda_trace_common/src/lib.rs +++ b/zluda_trace_common/src/lib.rs @@ -472,21 +472,3 @@ impl ReprUsize for cuda_types::nvml::nvmlReturn_t { ByteVecFfi::new(writer) } } - -pub struct Unknown; - -impl ReprUsize for Unknown { - fn to_usize(self) -> usize { - 0 - } - - fn from_usize(_: usize) -> Self { - Self - } - - const INTERNAL_ERROR: usize = usize::MAX; - - extern "C" fn format_status(_: usize) -> ByteVecFfi { - ByteVecFfi::new(b"UNKNOWN".to_vec()) - } -} From 7492b3833b752fe01e95e42a3c6c92e14257356a Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Tue, 21 Apr 2026 20:35:03 -0700 Subject: [PATCH 18/85] more nvapi --- nvapi/src/lib.rs | 27 ++++++++++++++++++++++----- 1 file changed, 22 insertions(+), 5 deletions(-) diff --git a/nvapi/src/lib.rs b/nvapi/src/lib.rs index 4d2491fb3..328a9f867 100644 --- a/nvapi/src/lib.rs +++ b/nvapi/src/lib.rs @@ -33,7 +33,7 @@ interface_to_name!( // { NvAPI_SetView, 0x0957d7b6 }, // { NvAPI_SetViewEx, 0x06b89e68 }, { NvAPI_GetDisplayDriverVersion, 0xf951a4d1 }, - // { NvAPI_SYS_GetDriverAndBranchVersion, 0x2926aaad }, + { NvAPI_SYS_GetDriverAndBranchVersion, 0x2926aaad }, // { NvAPI_GPU_GetMemoryInfo, 0x07f9b368 }, // { NvAPI_GPU_GetMemoryInfoEx, 0xc0599498 }, // { NvAPI_OGL_ExpertModeSet, 0x3805ef7a }, @@ -48,8 +48,8 @@ interface_to_name!( // { NvAPI_GetLogicalGPUFromDisplay, 0xee1370cf }, // { NvAPI_GetLogicalGPUFromPhysicalGPU, 0xadd604d1 }, // { NvAPI_GetPhysicalGPUsFromLogicalGPU, 0xaea3fa32 }, - // { NvAPI_GetPhysicalGPUFromGPUID, 0x5380ad1a }, - // { NvAPI_GetGPUIDfromPhysicalGPU, 0x6533ea3e }, + { NvAPI_GetPhysicalGPUFromGPUID, 0x5380ad1a }, + { NvAPI_GetGPUIDfromPhysicalGPU, 0x6533ea3e }, // { NvAPI_GPU_GetShaderSubPipeCount, 0x0be17923 }, // { NvAPI_GPU_GetGpuCoreCount, 0xc7026a87 }, // { NvAPI_GPU_GetAllOutputs, 0x7d554f8e }, @@ -88,7 +88,7 @@ interface_to_name!( // { NvAPI_GPU_WorkstationFeatureSetup, 0x6c1f3fe4 }, // { NvAPI_GPU_WorkstationFeatureQuery, 0x004537df }, // { NvAPI_GPU_GetHDCPSupportStatus, 0xf089eef5 }, - // { NvAPI_GPU_CudaEnumComputeCapableGpus, 0x5786cc6e }, + { NvAPI_GPU_CudaEnumComputeCapableGpus, 0x5786cc6e }, // { NvAPI_GPU_GetTachReading, 0x5f608315 }, // { NvAPI_GPU_GetECCStatusInfo, 0xca1ddaf3 }, // { NvAPI_GPU_GetECCErrorInfo, 0xc71f85a6 }, @@ -564,10 +564,27 @@ unsafe extern "C" fn NvAPI_GetDisplayDriverVersion( display: NvDisplayHandle, pVersion: *mut NV_DISPLAY_DRIVER_VERSION, ) -> i32 { + // return 0; let version = pVersion.as_mut(); let version = unwrap_or::unwrap_some_or!(version, return _NvAPI_Status_NVAPI_INVALID_ARGUMENT); if version.version != make_nvapi_version::(1) { - return _NvAPI_Status_NVAPI_INVALID_ARGUMENT; + return _NvAPI_Status_NVAPI_INCOMPATIBLE_STRUCT_VERSION; } _NvAPI_Status_NVAPI_NO_IMPLEMENTATION } + +unsafe extern "C" fn NvAPI_GPU_CudaEnumComputeCapableGpus(compute_topo: *mut NV_COMPUTE_GPU_TOPOLOGY) -> i32 { + -1 +} + +unsafe extern "C" fn NvAPI_GetGPUIDfromPhysicalGPU(physical_gpu: NvPhysicalGpuHandle, pGpuId: *mut NvU32) -> i32 { + -1 +} + +unsafe extern "C" fn NvAPI_GetPhysicalGPUFromGPUID(gpuId: NvU32, pPhysicalGPU: *mut NvPhysicalGpuHandle) -> i32 { + -1 +} + +unsafe extern "C" fn NvAPI_SYS_GetDriverAndBranchVersion(pDriverVersion: *mut NvU32, szBuildBranchString: NvAPI_ShortString) -> i32 { + -1 +} From 905b33bf996b8bafa45c16752010e012e2a1f827 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Tue, 21 Apr 2026 21:48:31 -0700 Subject: [PATCH 19/85] Implement more nvapi --- nvapi/src/lib.rs | 90 +++++++++++++++++++++++++++++++++++++++++------- 1 file changed, 78 insertions(+), 12 deletions(-) diff --git a/nvapi/src/lib.rs b/nvapi/src/lib.rs index 328a9f867..43b427481 100644 --- a/nvapi/src/lib.rs +++ b/nvapi/src/lib.rs @@ -542,9 +542,18 @@ interface_to_name!( // { NvAPI_UninstallRise, 0xab8d09f6 }, ); +const NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_CAPABLE: u32 = 1 << 0; +const NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_ENABLE: u32 = 1 << 1; +// const NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_DEDICATED: u32 = 1 << 2; +const NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_RECOMMENDED: u32 = 1 << 3; +const NV_COMPUTE_GPU_TOPOLOGY_CUDA_AVAILABLE: u32 = 1 << 4; +const NV_COMPUTE_GPU_TOPOLOGY_CUDA_CAPABLE: u32 = 1 << 16; +// const NV_COMPUTE_GPU_TOPOLOGY_CUDA_DISABLED: u32 = 1 << 17; +const NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_AVAILABLE: u32 = 1 << 21; + fn make_nvapi_version(ver: u32) -> u32 { let size = std::mem::size_of::() as u32; - (size << 16) | ver + size | (ver << 16) } #[no_mangle] @@ -552,39 +561,96 @@ pub unsafe extern "C" fn nvapi_QueryInterface(interface: u32) -> *mut c_void { interface_to_fn(interface).unwrap_or(std::ptr::null_mut()) } +#[allow(non_snake_case)] unsafe extern "C" fn NvAPI_Initialize() -> i32 { 0 } +#[allow(non_snake_case)] unsafe extern "C" fn NvAPI_Unload() -> i32 { 0 } +#[allow(non_snake_case)] unsafe extern "C" fn NvAPI_GetDisplayDriverVersion( - display: NvDisplayHandle, - pVersion: *mut NV_DISPLAY_DRIVER_VERSION, + _display: NvDisplayHandle, + version: *mut NV_DISPLAY_DRIVER_VERSION, ) -> i32 { // return 0; - let version = pVersion.as_mut(); + let version = version.as_mut(); let version = unwrap_or::unwrap_some_or!(version, return _NvAPI_Status_NVAPI_INVALID_ARGUMENT); if version.version != make_nvapi_version::(1) { return _NvAPI_Status_NVAPI_INCOMPATIBLE_STRUCT_VERSION; } - _NvAPI_Status_NVAPI_NO_IMPLEMENTATION + version.drvVersion = 99999; + version.bldChangeListNum = 0; + version.szBuildBranchString.fill(0); + version.szAdapterString.fill(0); + let device_name = b"ZLUDA Graphics Device"; + std::ptr::copy_nonoverlapping( + device_name.as_ptr() as _, + version.szAdapterString.as_mut_ptr() as _, + device_name.len(), + ); + 0 } -unsafe extern "C" fn NvAPI_GPU_CudaEnumComputeCapableGpus(compute_topo: *mut NV_COMPUTE_GPU_TOPOLOGY) -> i32 { - -1 +#[allow(non_snake_case)] +unsafe extern "C" fn NvAPI_GPU_CudaEnumComputeCapableGpus( + compute_topo: *mut NV_COMPUTE_GPU_TOPOLOGY_V1, +) -> i32 { + let compute_topo = compute_topo.as_mut(); + let compute_topo = + unwrap_or::unwrap_some_or!(compute_topo, return _NvAPI_Status_NVAPI_INVALID_ARGUMENT); + if compute_topo.version != make_nvapi_version::(1) { + return _NvAPI_Status_NVAPI_INCOMPATIBLE_STRUCT_VERSION; + } + compute_topo.gpuCount = 1; + compute_topo.computeGpus[0] = NV_COMPUTE_GPU_TOPOLOGY_V1__bindgen_ty_1 { + hPhysicalGpu: 1 as _, + flags: NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_CAPABLE + | NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_ENABLE + | NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_RECOMMENDED + | NV_COMPUTE_GPU_TOPOLOGY_CUDA_AVAILABLE + | NV_COMPUTE_GPU_TOPOLOGY_CUDA_CAPABLE + | NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_AVAILABLE, + }; + 0 } -unsafe extern "C" fn NvAPI_GetGPUIDfromPhysicalGPU(physical_gpu: NvPhysicalGpuHandle, pGpuId: *mut NvU32) -> i32 { - -1 +#[allow(non_snake_case)] +unsafe extern "C" fn NvAPI_GetGPUIDfromPhysicalGPU( + physical_gpu: NvPhysicalGpuHandle, + gpu_id: *mut NvU32, +) -> i32 { + if physical_gpu != 1 as _ { + return _NvAPI_Status_NVAPI_INVALID_ARGUMENT; + } + let gpu_id = gpu_id.as_mut(); + let gpu_id = unwrap_or::unwrap_some_or!(gpu_id, return _NvAPI_Status_NVAPI_INVALID_ARGUMENT); + *gpu_id = 1; + 0 } -unsafe extern "C" fn NvAPI_GetPhysicalGPUFromGPUID(gpuId: NvU32, pPhysicalGPU: *mut NvPhysicalGpuHandle) -> i32 { - -1 +#[allow(non_snake_case)] +unsafe extern "C" fn NvAPI_GetPhysicalGPUFromGPUID( + gpu_id: NvU32, + physical_gpu: *mut NvPhysicalGpuHandle, +) -> i32 { + if gpu_id != 1 { + return _NvAPI_Status_NVAPI_INVALID_ARGUMENT; + } + let physical_gpu = physical_gpu.as_mut(); + let physical_gpu = + unwrap_or::unwrap_some_or!(physical_gpu, return _NvAPI_Status_NVAPI_INVALID_ARGUMENT); + *physical_gpu = 1 as _; + 0 } -unsafe extern "C" fn NvAPI_SYS_GetDriverAndBranchVersion(pDriverVersion: *mut NvU32, szBuildBranchString: NvAPI_ShortString) -> i32 { +#[allow(non_snake_case)] +unsafe extern "C" fn NvAPI_SYS_GetDriverAndBranchVersion( + _driver_version: *mut NvU32, + _build_branch_string: *mut NvAPI_ShortString, +) -> i32 { -1 } From b7454f4be6aa5ae464d36f0fa568d06f8f67b32f Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Tue, 21 Apr 2026 22:12:52 -0700 Subject: [PATCH 20/85] Add cuDeviceGetCount --- zluda32/src/ipc.rs | 7 ++++++- zluda64_server/src/main.rs | 18 +++++++++++++++++- 2 files changed, 23 insertions(+), 2 deletions(-) diff --git a/zluda32/src/ipc.rs b/zluda32/src/ipc.rs index c1603b8f1..2569f9638 100644 --- a/zluda32/src/ipc.rs +++ b/zluda32/src/ipc.rs @@ -98,14 +98,19 @@ impl Server { ) .map_err(|_| CUerror::UNKNOWN)?; this.pipe.write_all(&slice).map_err(|_| CUerror::UNKNOWN)?; + this.buffer.clear(); read_return_code(this)?; + this.buffer.resize(mem::size_of::(), 0); + this.pipe + .read_exact(&mut this.buffer) + .map_err(|_| CUerror::UNKNOWN)?; let output = unsafe { rkyv::access_unchecked::(&this.buffer) }; Ok(output.clone()) } } fn read_return_code(this: &mut Server) -> Result<(), CUerror> { - let mut code_buffer = [0; 4]; + let mut code_buffer = [0u8; 4]; this.pipe .read_exact(&mut code_buffer) .map_err(|_| CUerror::UNKNOWN)?; diff --git a/zluda64_server/src/main.rs b/zluda64_server/src/main.rs index 22e21425f..acd96001f 100644 --- a/zluda64_server/src/main.rs +++ b/zluda64_server/src/main.rs @@ -47,6 +47,14 @@ async fn main() -> std::io::Result<()> { ) .await?; } + Some(Opcode::cuDeviceGetCount) => { + buffer = handle_cuda_function::( + &mut client, + buffer, + cu_device_get_count, + ) + .await?; + } _ => { client.write_u32_le(CUerror::NOT_SUPPORTED.0.get()).await?; return Err(std::io::Error::new( @@ -63,6 +71,14 @@ fn cu_init(input: &ArchivedcuInitIn) -> Result { Ok(cuInitOut {}) } +fn cu_device_get_count( + _input: &ArchivedcuDeviceGetCountIn, +) -> Result { + let mut count = 0; + unsafe { cuDeviceGetCount(&mut count) }?; + Ok(cuDeviceGetCountOut { count }) +} + async fn handle_cuda_function( client: &mut NamedPipeClient, mut buffer: AlignedVecBuffer, @@ -197,7 +213,7 @@ cuda_function_declarations! { // cuDeviceComputeCapability, // cuDeviceGet, // cuDeviceGetAttribute, - // cuDeviceGetCount, + cuDeviceGetCount, // cuDeviceGetName, // cuDeviceGetProperties, // cuDeviceTotalMem_v2, From edd082f9b80af12730506faedf2cfdcebd175543 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Wed, 22 Apr 2026 23:29:27 -0700 Subject: [PATCH 21/85] More functions --- Cargo.lock | 1 + zluda32/Cargo.toml | 1 + zluda32/src/ipc.rs | 50 +++++++-- zluda32/src/lib.rs | 224 ++++++++++++++++++++++++++++++++++--- zluda64_server/src/main.rs | 166 +++++++++++++++++++++++++-- 5 files changed, 411 insertions(+), 31 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 14e03dfec..4e1921b51 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -5654,6 +5654,7 @@ dependencies = [ "bitcode", "cuda_macros", "cuda_types", + "dark_api", "ipc-channel", "paste", "postcard", diff --git a/zluda32/Cargo.toml b/zluda32/Cargo.toml index be256a5e0..c8e8bfd6e 100644 --- a/zluda32/Cargo.toml +++ b/zluda32/Cargo.toml @@ -13,6 +13,7 @@ cuda_types = { path = "../cuda_types" } cuda_macros = { path = "../cuda_macros" } zluda_windows = { path = "../zluda_windows" } zluda_server_common = { path = "../zluda_server_common" } +dark_api = { path = "../dark_api" } paste = "1.0" ipc-channel = "^0.21.0" windows = { version = "0.62.2", features = [ diff --git a/zluda32/src/ipc.rs b/zluda32/src/ipc.rs index 2569f9638..082f00047 100644 --- a/zluda32/src/ipc.rs +++ b/zluda32/src/ipc.rs @@ -1,10 +1,12 @@ use cuda_types::cuda::CUerror; use rand::distr::{Alphanumeric, SampleString}; use rkyv::api::high::HighSerializer; +use rkyv::de::Pool; +use rkyv::rancor::{Failure, Strategy}; use rkyv::rend::u32_le; use rkyv::ser::allocator::ArenaHandle; use rkyv::util::AlignedVec; -use rkyv::{rancor, Portable, Serialize}; +use rkyv::{rancor, Archive, Deserialize, Portable, Serialize}; use std::io::{Read, Write}; use std::os::windows::io::{AsHandle, AsRawHandle, FromRawHandle}; // use rkyv::util::AlignedVec; @@ -81,7 +83,7 @@ impl Server { .map_err(|_| CUerror::UNKNOWN) } - pub(crate) fn remote_call( + pub(crate) fn remote_call_zero_copy( opcode: Opcode, data: impl for<'a, 'b> Serialize< HighSerializer<&'a mut AlignedVec, ArenaHandle<'b>, rkyv::rancor::Failure>, @@ -98,7 +100,6 @@ impl Server { ) .map_err(|_| CUerror::UNKNOWN)?; this.pipe.write_all(&slice).map_err(|_| CUerror::UNKNOWN)?; - this.buffer.clear(); read_return_code(this)?; this.buffer.resize(mem::size_of::(), 0); this.pipe @@ -107,16 +108,51 @@ impl Server { let output = unsafe { rkyv::access_unchecked::(&this.buffer) }; Ok(output.clone()) } + + pub(crate) fn remote_call_framed( + opcode: Opcode, + data: impl for<'a, 'b> Serialize< + HighSerializer<&'a mut AlignedVec, ArenaHandle<'b>, rkyv::rancor::Failure>, + >, + ) -> Result + where + ::Archived: Deserialize>, + { + let this = &mut *Self::get()?.lock().map_err(|_| CUerror::UNKNOWN)?; + this.buffer.clear(); + let slice = rkyv::api::high::to_bytes_in::<_, rkyv::rancor::Failure>( + &Envelope { + code: opcode as u32, + data, + }, + &mut this.buffer, + ) + .map_err(|_| CUerror::UNKNOWN)?; + this.pipe.write_all(&slice).map_err(|_| CUerror::UNKNOWN)?; + read_return_code(this)?; + let out_size = read_u32(this)?; + this.buffer.resize(out_size as usize, 0); + this.pipe + .read_exact(&mut this.buffer) + .map_err(|_| CUerror::UNKNOWN)?; + unsafe { rkyv::from_bytes_unchecked::(&this.buffer) } + .map_err(|_| CUerror::UNKNOWN) + } } fn read_return_code(this: &mut Server) -> Result<(), CUerror> { + let code = read_u32(this)?; + match NonZeroU32::new(code) { + None => Ok(()), + Some(code) => Err(CUerror(code)), + } +} + +fn read_u32(this: &mut Server) -> Result { let mut code_buffer = [0u8; 4]; this.pipe .read_exact(&mut code_buffer) .map_err(|_| CUerror::UNKNOWN)?; let code = u32::from_le_bytes(code_buffer); - match NonZeroU32::new(code) { - None => Ok(()), - Some(code) => Err(CUerror(code)), - } + Ok(code) } diff --git a/zluda32/src/lib.rs b/zluda32/src/lib.rs index e758955b5..28e729b76 100644 --- a/zluda32/src/lib.rs +++ b/zluda32/src/lib.rs @@ -1,5 +1,6 @@ use cuda_macros::cuda_function_declarations; use cuda_types::cuda::*; +use dark_api::cuda::CudaDarkApi; use paste::paste; use std::sync::{Mutex, OnceLock}; use zluda_server_common::*; @@ -83,7 +84,7 @@ cuda_function_declarations! { } pub(crate) fn cu_init(flags: u32) -> Result<(), CUerror> { - ipc::Server::remote_call::(Opcode::cuInit, cuInitIn { Flags: flags })?; + ipc::Server::remote_call_zero_copy::(Opcode::cuInit, cuInitIn { Flags: flags })?; Ok(()) } @@ -94,7 +95,7 @@ pub(crate) fn cu_ctx_create_v2( ) -> Result<(), CUerror> { let ctx = unsafe { pctx.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; *ctx = CudaEncode::decode( - ipc::Server::remote_call::( + ipc::Server::remote_call_zero_copy::( Opcode::cuCtxCreate_v2, cuCtxCreate_v2In { flags, dev }, )? @@ -139,9 +140,11 @@ pub(crate) fn cu_device_get( ordinal: ::core::ffi::c_int, ) -> Result<(), CUerror> { let device = unsafe { device.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - *device = - ipc::Server::remote_call::(Opcode::cuDeviceGet, cuDeviceGetIn { ordinal })? - .device; + *device = ipc::Server::remote_call_zero_copy::( + Opcode::cuDeviceGet, + cuDeviceGetIn { ordinal }, + )? + .device; Ok(()) } @@ -151,7 +154,7 @@ pub(crate) fn cu_device_get_attribute( dev: CUdevice, ) -> Result<(), CUerror> { let pi = unsafe { pi.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - *pi = ipc::Server::remote_call::( + *pi = ipc::Server::remote_call_zero_copy::( Opcode::cuDeviceGetAttribute, cuDeviceGetAttributeIn { attrib: CudaEncode::encode(attrib), @@ -164,7 +167,7 @@ pub(crate) fn cu_device_get_attribute( pub(crate) fn cu_device_get_count(count: *mut ::core::ffi::c_int) -> Result<(), CUerror> { let count = unsafe { count.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - *count = ipc::Server::remote_call::( + *count = ipc::Server::remote_call_zero_copy::( Opcode::cuDeviceGetCount, cuDeviceGetCountIn {}, )? @@ -177,7 +180,21 @@ pub(crate) fn cu_device_get_name( len: ::core::ffi::c_int, dev: CUdevice, ) -> Result<(), CUerror> { - todo!() + if name.is_null() { + return Err(CUerror::INVALID_VALUE); + } + let name_out = ipc::Server::remote_call_framed::( + Opcode::cuDeviceGetName, + cuDeviceGetNameIn { len, dev }, + )?; + unsafe { + std::ptr::copy_nonoverlapping( + name_out.name.as_ptr() as *const i8, + name, + (len as usize).min(name_out.name.len()), + ) + }; + Ok(()) } pub(crate) fn cu_device_get_properties(prop: *mut CUdevprop, dev: CUdevice) -> Result<(), CUerror> { @@ -188,9 +205,11 @@ pub(crate) fn cu_device_total_mem_v2(bytes: *mut usize, dev: CUdevice) -> Result todo!() } -pub(crate) fn cu_driver_get_version(driverVersion: *mut ::core::ffi::c_int) -> Result<(), CUerror> { - let driverVersion = unsafe { driverVersion.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - *driverVersion = ipc::Server::remote_call::( +pub(crate) fn cu_driver_get_version( + driver_version: *mut ::core::ffi::c_int, +) -> Result<(), CUerror> { + let driver_version = unsafe { driver_version.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + *driver_version = ipc::Server::remote_call_zero_copy::( Opcode::cuDriverGetVersion, cuDriverGetVersionIn {}, )? @@ -209,11 +228,25 @@ pub(crate) fn cu_event_destroy_v2(hEvent: CUevent) -> Result<(), CUerror> { todo!() } +static EXPORT_TABLE: ::dark_api::cuda::CudaDarkApiGlobalTable = + ::dark_api::cuda::CudaDarkApiGlobalTable::new::(); + pub(crate) fn cu_get_export_table( - ppExportTable: *mut *const ::core::ffi::c_void, - pExportTableId: *const CUuuid, + pp_export_table: *mut *const ::core::ffi::c_void, + p_export_table_id: *const CUuuid, ) -> Result<(), CUerror> { - todo!() + if let (Some(result), Some(guid)) = + unsafe { (pp_export_table.as_mut(), p_export_table_id.as_ref()) } + { + if let Some(table) = EXPORT_TABLE.get(guid) { + *result = table.start(); + cuda_types::cuda::CUresult::SUCCESS + } else { + cuda_types::cuda::CUresult::ERROR_NOT_SUPPORTED + } + } else { + cuda_types::cuda::CUresult::ERROR_INVALID_VALUE + } } pub(crate) fn cu_launch_kernel( @@ -398,3 +431,166 @@ pub(crate) fn cu_tex_ref_set_mipmap_level_clamp( ) -> Result<(), CUerror> { todo!() } + +struct DarkApi32; + +impl CudaDarkApi for DarkApi32 { + unsafe extern "system" fn get_module_from_cubin( + module: *mut cuda_types::cuda::CUmodule, + fatbinc_wrapper: *const cuda_types::dark_api::FatbincWrapper, + ) -> cuda_types::cuda::CUresult { + todo!() + } + + unsafe extern "system" fn cudart_interface_fn2( + pctx: *mut cuda_types::cuda::CUcontext, + _dev: cuda_types::cuda::CUdevice, + ) -> cuda_types::cuda::CUresult { + let ctx = unsafe { pctx.as_mut() }.ok_or(cuda_types::cuda::CUerror::INVALID_VALUE)?; + *ctx = CUcontext(0xDEADBEEFu32 as _); + cuda_types::cuda::CUresult::SUCCESS + } + + unsafe extern "system" fn get_module_from_cubin_ext1( + result: *mut cuda_types::cuda::CUmodule, + fatbinc_wrapper: *const cuda_types::dark_api::FatbincWrapper, + arg3: *mut std::ffi::c_void, + arg4: *mut std::ffi::c_void, + arg5: u32, + ) -> cuda_types::cuda::CUresult { + todo!() + } + + unsafe extern "system" fn cudart_interface_fn7(arg1: usize) -> () { + todo!() + } + + unsafe extern "system" fn get_module_from_cubin_ext2( + fatbin_header: *const cuda_types::dark_api::FatbinHeader, + result: *mut cuda_types::cuda::CUmodule, + arg3: *mut std::ffi::c_void, + arg4: *mut std::ffi::c_void, + arg5: u32, + ) -> cuda_types::cuda::CUresult { + todo!() + } + + unsafe extern "system" fn load_compilers() -> cuda_types::cuda::CUresult { + todo!() + } + + unsafe extern "system" fn get_unknown_buffer1( + ptr: *mut *mut std::ffi::c_void, + size: *mut usize, + ) -> () { + todo!() + } + + unsafe extern "system" fn get_unknown_buffer2( + ptr: *mut *mut std::ffi::c_void, + size: *mut usize, + ) -> () { + todo!() + } + + unsafe extern "system" fn context_local_storage_put( + context: cuda_types::cuda::CUcontext, + key: *mut std::ffi::c_void, + value: *mut std::ffi::c_void, + dtor_cb: Option< + extern "system" fn( + cuda_types::cuda::CUcontext, + *mut std::ffi::c_void, + *mut std::ffi::c_void, + ), + >, + ) -> cuda_types::cuda::CUresult { + todo!() + } + + unsafe extern "system" fn context_local_storage_delete( + context: cuda_types::cuda::CUcontext, + key: *mut std::ffi::c_void, + ) -> cuda_types::cuda::CUresult { + todo!() + } + + unsafe extern "system" fn context_local_storage_get( + value: *mut *mut std::ffi::c_void, + cu_ctx: cuda_types::cuda::CUcontext, + key: *mut std::ffi::c_void, + ) -> cuda_types::cuda::CUresult { + todo!() + } + + unsafe extern "system" fn ctx_create_v2_bypass( + pctx: *mut cuda_types::cuda::CUcontext, + flags: ::std::os::raw::c_uint, + dev: cuda_types::cuda::CUdevice, + ) -> cuda_types::cuda::CUresult { + cu_ctx_create_v2(pctx, flags, dev) + } + + unsafe extern "system" fn heap_alloc( + heap_alloc_record_ptr: *mut *const std::ffi::c_void, + arg2: usize, + arg3: usize, + ) -> cuda_types::cuda::CUresult { + todo!() + } + + unsafe extern "system" fn heap_free( + heap_alloc_record_ptr: *const std::ffi::c_void, + arg2: *mut usize, + ) -> cuda_types::cuda::CUresult { + todo!() + } + + unsafe extern "system" fn device_get_attribute_ext( + dev: cuda_types::cuda::CUdevice, + attribute: std::ffi::c_uint, + unknown: std::ffi::c_int, + result: *mut [usize; 2], + ) -> cuda_types::cuda::CUresult { + todo!() + } + + unsafe extern "system" fn device_get_something( + result: *mut std::ffi::c_uchar, + dev: cuda_types::cuda::CUdevice, + ) -> cuda_types::cuda::CUresult { + todo!() + } + + unsafe extern "system" fn integrity_check( + version: u32, + unix_seconds: u64, + result: *mut [u64; 2], + ) -> cuda_types::cuda::CUresult { + todo!() + } + + unsafe extern "system" fn context_check( + ctx_in: cuda_types::cuda::CUcontext, + result1: *mut u32, + result2: *mut *const std::ffi::c_void, + ) -> cuda_types::cuda::CUresult { + todo!() + } + + unsafe extern "system" fn check_fn3() -> u32 { + todo!() + } + + unsafe extern "system" fn hybrid_runtime_load_get_proc_address( + name: *const std::ffi::c_char, + fn_ptr: *mut *const std::ffi::c_void, + token: *mut usize, + ) -> cuda_types::cuda::CUresult { + todo!() + } + + unsafe extern "system" fn hybrid_runtime_free(token: usize) -> cuda_types::cuda::CUresult { + todo!() + } +} diff --git a/zluda64_server/src/main.rs b/zluda64_server/src/main.rs index acd96001f..780fe9696 100644 --- a/zluda64_server/src/main.rs +++ b/zluda64_server/src/main.rs @@ -2,7 +2,7 @@ #![windows_subsystem = "windows"] use compio::{ - buf::{IoBuf, IoBufMut, ReserveError, ReserveExactError, SetLen}, + buf::{buf_try, IoBuf, IoBufMut, ReserveError, ReserveExactError, SetLen}, fs::named_pipe::{ClientOptions, NamedPipeClient}, io::{AsyncRead, AsyncReadExt, AsyncReadManaged, AsyncWrite, AsyncWriteExt}, BufResult, @@ -22,6 +22,21 @@ struct State { handles: Slab, } +impl State { + fn insert(&mut self, handle: *mut T) -> u32 { + (self.handles.insert(handle as usize) as u32) + 1 + } + + fn get(&self, id: u32) -> Option<*mut T> { + if id == 0 { + return None; + } + self.handles + .get((id - 1) as usize) + .map(|&handle| handle as *mut T) + } +} + #[compio::main] async fn main() -> std::io::Result<()> { let pipe_name = std::env::args_os().nth(1).ok_or(std::io::Error::new( @@ -35,6 +50,9 @@ async fn main() -> std::io::Result<()> { .open(pipe_name) .await?; let mut buffer = AlignedVecBuffer(AlignedVec::new()); + let mut state = State { + handles: Slab::new(), + }; loop { let opcode = client.read_u32_le().await?; // Read the length prefix buffer.clear(); @@ -55,6 +73,47 @@ async fn main() -> std::io::Result<()> { ) .await?; } + Some(Opcode::cuDeviceGetAttribute) => { + buffer = handle_cuda_function::< + ArchivedcuDeviceGetAttributeIn, + cuDeviceGetAttributeOut, + >(&mut client, buffer, cu_device_get_attribute) + .await?; + } + Some(Opcode::cuDeviceGet) => { + buffer = handle_cuda_function::( + &mut client, + buffer, + cu_device_get, + ) + .await?; + } + Some(Opcode::cuCtxCreate_v2) => { + buffer = handle_cuda_function::( + &mut client, + buffer, + |input| cu_ctx_create_v2(input, &mut state), + ) + .await?; + } + Some(Opcode::cuDriverGetVersion) => { + buffer = + handle_cuda_function::( + &mut client, + buffer, + cu_driver_get_version, + ) + .await?; + } + Some(Opcode::cuDeviceGetName) => { + buffer = + handle_cuda_function_framed::( + &mut client, + buffer, + cu_device_get_name, + ) + .await?; + } _ => { client.write_u32_le(CUerror::NOT_SUPPORTED.0.get()).await?; return Err(std::io::Error::new( @@ -79,7 +138,62 @@ fn cu_device_get_count( Ok(cuDeviceGetCountOut { count }) } -async fn handle_cuda_function( +fn cu_device_get_attribute( + input: &ArchivedcuDeviceGetAttributeIn, +) -> Result { + let mut pi = 0; + unsafe { + cuDeviceGetAttribute( + &mut pi, + CUdevice_attribute_enum(input.attrib.to_native()), + input.dev.to_native(), + ) + }?; + Ok(cuDeviceGetAttributeOut { pi }) +} + +fn cu_device_get(input: &ArchivedcuDeviceGetIn) -> Result { + let mut device = 0; + unsafe { cuDeviceGet(&mut device, input.ordinal.to_native()) }?; + Ok(cuDeviceGetOut { device }) +} + +fn cu_device_get_name(input: &ArchivedcuDeviceGetNameIn) -> Result { + let mut name = vec![0u8; input.len.to_native() as usize]; + unsafe { + cuDeviceGetName( + name.as_mut_ptr().cast(), + input.len.to_native(), + input.dev.to_native(), + ) + }?; + if let Some(pos) = name.iter().copied().position(|c| c == 0) { + name.truncate(pos); + } + Ok(cuDeviceGetNameOut { name }) +} + +fn cu_ctx_create_v2( + input: &ArchivedcuCtxCreate_v2In, + state: &mut State, +) -> Result { + let mut pctx = unsafe { mem::zeroed() }; + unsafe { cuCtxCreate_v2(&mut pctx, input.flags.to_native(), input.dev.to_native()) }?; + let pctx = state.insert(pctx.0); + Ok(cuCtxCreate_v2Out { pctx }) +} + +fn cu_driver_get_version( + _input: &ArchivedcuDriverGetVersionIn, +) -> Result { + let mut driver_version = 0; + unsafe { cuDriverGetVersion(&mut driver_version) }?; + Ok(cuDriverGetVersionOut { + driverVersion: driver_version, + }) +} + +async fn handle_cuda_function( client: &mut NamedPipeClient, mut buffer: AlignedVecBuffer, handler: impl FnOnce(&In) -> Result, @@ -104,12 +218,43 @@ where .map_err(|_| { std::io::Error::new(std::io::ErrorKind::Other, "Failed to serialize response") })?; - let BufResult(result, new_buffer) = client.write_all(buffer).await; - result?; + let ((), new_buffer) = buf_try!(@try client.write_all(buffer).await); Ok(new_buffer) } Err(e) => { + client.write_u32_le(e.0.get()).await?; + Ok(buffer) + } + } +} + +async fn handle_cuda_function_framed( + client: &mut NamedPipeClient, + mut buffer: AlignedVecBuffer, + handler: impl FnOnce(&In) -> Result, +) -> std::io::Result +where + Out: for<'a, 'b> Serialize< + HighSerializer<&'a mut AlignedVec, ArenaHandle<'b>, rkyv::rancor::Failure>, + >, +{ + buffer = read_all::(buffer, client).await?; + let input = unsafe { rkyv::access_unchecked::(buffer.as_init()) }; + match handler(input) { + Ok(output) => { buffer.clear(); + rkyv::api::high::to_bytes_in::<_, rkyv::rancor::Failure>(&output, &mut buffer.0) + .map_err(|_| { + std::io::Error::new(std::io::ErrorKind::Other, "Failed to serialize response") + })?; + let code_and_len = unsafe { + std::mem::transmute::<(u32, u32), [u8; 8]>((0u32, buffer.0.len() as u32)) + }; + client.write_all(code_and_len).await.0?; + let ((), new_buffer) = buf_try!(@try client.write_all(buffer).await); + Ok(new_buffer) + } + Err(e) => { client.write_u32_le(e.0.get()).await?; Ok(buffer) } @@ -121,6 +266,7 @@ async fn read_all( client: &mut NamedPipeClient, ) -> std::io::Result { let mut remaining_read = mem::size_of::(); + buffer.clear(); buffer.reserve(remaining_read)?; while remaining_read > 0 { let BufResult(read_result, new_buffer) = client.append(buffer).await; @@ -204,23 +350,23 @@ macro_rules! implemented { cuda_function_declarations! { nop, implemented <= [ - // cuCtxCreate_v2, + cuCtxCreate_v2, // cuCtxDetach, // cuCtxGetApiVersion, // cuCtxGetCurrent, // cuCtxGetDevice, // cuCtxSynchronize, // cuDeviceComputeCapability, - // cuDeviceGet, - // cuDeviceGetAttribute, + cuDeviceGet, + cuDeviceGetAttribute, cuDeviceGetCount, - // cuDeviceGetName, + cuDeviceGetName, // cuDeviceGetProperties, // cuDeviceTotalMem_v2, - // cuDriverGetVersion, + cuDriverGetVersion, // cuEventCreate, // cuEventDestroy_v2, - // cuGetExportTable, + cuGetExportTable, cuInit, // cuLaunchKernel, // cuMemAlloc_v2, From efc73f31418357265777ebd973373f67873cd39c Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Wed, 22 Apr 2026 23:29:38 -0700 Subject: [PATCH 22/85] Add missing file --- zluda_server_common/src/lib.rs | 43 +++++++++++++++++----------------- 1 file changed, 21 insertions(+), 22 deletions(-) diff --git a/zluda_server_common/src/lib.rs b/zluda_server_common/src/lib.rs index f39292522..159dfc74e 100644 --- a/zluda_server_common/src/lib.rs +++ b/zluda_server_common/src/lib.rs @@ -30,7 +30,7 @@ macro_rules! noop { ($($abi:literal fn $fn_name:ident( $($arg_id:ident : $arg_type:ty),* ) -> $ret_type:ty;)*) => {}; } -macro_rules! generate_messages { +macro_rules! generate_messages_inout { ($($abi:literal fn $fn_name:ident( $($arg_id:ident : $arg_type:ty),* ) -> $ret_type:ty;)*) => { $( generate_input_struct!($fn_name, $($arg_id : $arg_type),*); @@ -44,13 +44,22 @@ macro_rules! generate_messages { $( $fn_name, )* + cuDeviceGetName, } }; } +macro_rules! generate_messages_in { + ($($abi:literal fn $fn_name:ident( $($arg_id:ident : $arg_type:ty),* ) -> $ret_type:ty;)*) => { + $( + generate_input_struct!($fn_name, $($arg_id : $arg_type),*); + )* + }; +} + cuda_function_declarations! { noop, - generate_messages <= [ + generate_messages_inout <= [ cuCtxCreate_v2, cuCtxDetach, cuCtxGetApiVersion, @@ -61,7 +70,6 @@ cuda_function_declarations! { cuDeviceGet, cuDeviceGetAttribute, cuDeviceGetCount, - cuDeviceGetName, cuDeviceGetProperties, cuDeviceTotalMem_v2, cuDriverGetVersion, @@ -79,9 +87,9 @@ cuda_function_declarations! { //cuMemcpyDtoHAsync_v2, //cuMemcpyHtoDAsync_v2, cuMemsetD8_v2, - cuModuleGetFunction, - cuModuleGetGlobal_v2, - cuModuleGetTexRef, + // cuModuleGetFunction, + // cuModuleGetGlobal_v2, + // cuModuleGetTexRef, cuStreamCreate, cuStreamDestroy_v2, cuTexRefSetAddressMode, @@ -93,6 +101,9 @@ cuda_function_declarations! { cuTexRefSetMipmapFilterMode, cuTexRefSetMipmapLevelBias, cuTexRefSetMipmapLevelClamp, + ], + generate_messages_in <= [ + cuDeviceGetName, ] } @@ -144,17 +155,6 @@ macro_rules! encode_as_u32 { }; } -impl CudaEncode for *const i8 { - type WireObject = Vec; - fn encode(self) -> Vec { - unsafe { CStr::from_ptr(self) }.to_bytes_with_nul().to_vec() - } - fn decode(o: Self::WireObject) -> Self { - let c_string = CString::from_vec_with_nul(o).unwrap(); - c_string.into_raw() - } -} - encode_as_self!(u8); encode_as_self!(i8); encode_as_self!(u32); @@ -193,9 +193,8 @@ pub struct CUdevprop_v1_Wire { unsafe impl Portable for CUdevprop_v1_Wire {} -#[derive(Archive, Deserialize, Serialize, Debug, PartialEq)] #[repr(C)] -pub struct Foobar { - pub text: String, - pub buff: Vec, -} +#[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct cuDeviceGetNameOut { + pub name: Vec +} \ No newline at end of file From 4a8c0c2ec85aa6b26c26d1377ceef25682b0c1e0 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Thu, 23 Apr 2026 01:57:51 -0700 Subject: [PATCH 23/85] One more funciton and bugfixes --- zluda32/src/ipc.rs | 30 ++++++++++-------------- zluda32/src/lib.rs | 10 +++++++- zluda64_server/src/main.rs | 43 +++++++++++++++++++++++----------- zluda_server_common/src/lib.rs | 41 ++++++++++++-------------------- 4 files changed, 66 insertions(+), 58 deletions(-) diff --git a/zluda32/src/ipc.rs b/zluda32/src/ipc.rs index 082f00047..7aff6c120 100644 --- a/zluda32/src/ipc.rs +++ b/zluda32/src/ipc.rs @@ -18,7 +18,7 @@ use widestring::{u16str, U16CString}; use windows::core::{Error, Owned, PCSTR}; use windows::Win32::Foundation::*; use windows::Win32::System::Pipes::*; -use zluda_server_common::{Envelope, Opcode}; +use zluda_server_common::Opcode; fn server_path() -> &'static str { if cfg!(debug_assertions) { @@ -91,14 +91,12 @@ impl Server { ) -> Result { let this = &mut *Self::get()?.lock().map_err(|_| CUerror::UNKNOWN)?; this.buffer.clear(); - let slice = rkyv::api::high::to_bytes_in::<_, rkyv::rancor::Failure>( - &Envelope { - code: opcode as u32, - data, - }, - &mut this.buffer, - ) - .map_err(|_| CUerror::UNKNOWN)?; + this.pipe + .write_all(&(opcode as u32).to_le_bytes()[..]) + .map_err(|_| CUerror::UNKNOWN)?; + let slice = + rkyv::api::high::to_bytes_in::<_, rkyv::rancor::Failure>(&data, &mut this.buffer) + .map_err(|_| CUerror::UNKNOWN)?; this.pipe.write_all(&slice).map_err(|_| CUerror::UNKNOWN)?; read_return_code(this)?; this.buffer.resize(mem::size_of::(), 0); @@ -120,14 +118,12 @@ impl Server { { let this = &mut *Self::get()?.lock().map_err(|_| CUerror::UNKNOWN)?; this.buffer.clear(); - let slice = rkyv::api::high::to_bytes_in::<_, rkyv::rancor::Failure>( - &Envelope { - code: opcode as u32, - data, - }, - &mut this.buffer, - ) - .map_err(|_| CUerror::UNKNOWN)?; + this.pipe + .write_all(&(opcode as u32).to_le_bytes()[..]) + .map_err(|_| CUerror::UNKNOWN)?; + let slice = + rkyv::api::high::to_bytes_in::<_, rkyv::rancor::Failure>(&data, &mut this.buffer) + .map_err(|_| CUerror::UNKNOWN)?; this.pipe.write_all(&slice).map_err(|_| CUerror::UNKNOWN)?; read_return_code(this)?; let out_size = read_u32(this)?; diff --git a/zluda32/src/lib.rs b/zluda32/src/lib.rs index 28e729b76..4a6f06fdb 100644 --- a/zluda32/src/lib.rs +++ b/zluda32/src/lib.rs @@ -202,7 +202,15 @@ pub(crate) fn cu_device_get_properties(prop: *mut CUdevprop, dev: CUdevice) -> R } pub(crate) fn cu_device_total_mem_v2(bytes: *mut usize, dev: CUdevice) -> Result<(), CUerror> { - todo!() + let bytes = unsafe { bytes.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + *bytes = ipc::Server::remote_call_zero_copy::( + Opcode::cuDeviceTotalMem_v2, + cuDeviceTotalMem_v2In { dev }, + )? + .bytes + .to_native() + .min(u32::MAX as u64) as usize; + Ok(()) } pub(crate) fn cu_driver_get_version( diff --git a/zluda64_server/src/main.rs b/zluda64_server/src/main.rs index 780fe9696..42058e35a 100644 --- a/zluda64_server/src/main.rs +++ b/zluda64_server/src/main.rs @@ -10,11 +10,14 @@ use compio::{ use cuda_macros::cuda_function_declarations; use cuda_types::cuda::*; use rkyv::{ - api::high::HighSerializer, ser::allocator::ArenaHandle, util::AlignedVec, Archive, Portable, - Serialize, + api::high::HighSerializer, rend::u64_le, ser::allocator::ArenaHandle, util::AlignedVec, + Archive, Portable, Serialize, }; use slab::Slab; -use std::mem; +use std::{ + io::{self, Write}, + mem, +}; use windows_sys::Win32::Foundation::ERROR_MORE_DATA; use zluda_server_common::*; @@ -114,6 +117,13 @@ async fn main() -> std::io::Result<()> { ) .await?; } + Some(Opcode::cuDeviceTotalMem_v2) => { + buffer = handle_cuda_function::< + ArchivedcuDeviceTotalMem_v2In, + cuDeviceTotalMem_v2Out, + >(&mut client, buffer, cu_device_total_mem_v2) + .await?; + } _ => { client.write_u32_le(CUerror::NOT_SUPPORTED.0.get()).await?; return Err(std::io::Error::new( @@ -183,6 +193,16 @@ fn cu_ctx_create_v2( Ok(cuCtxCreate_v2Out { pctx }) } +fn cu_device_total_mem_v2( + input: &ArchivedcuDeviceTotalMem_v2In, +) -> Result { + let mut bytes = 0usize; + unsafe { cuDeviceTotalMem_v2(&mut bytes, input.dev.to_native()) }?; + Ok(cuDeviceTotalMem_v2Out { + bytes: u64_le::from_native(bytes as u64), + }) +} + fn cu_driver_get_version( _input: &ArchivedcuDriverGetVersionIn, ) -> Result { @@ -208,16 +228,11 @@ where match handler(input) { Ok(output) => { buffer.clear(); - rkyv::api::high::to_bytes_in::<_, rkyv::rancor::Failure>( - &Envelope { - code: 0, - data: output, - }, - &mut buffer.0, - ) - .map_err(|_| { - std::io::Error::new(std::io::ErrorKind::Other, "Failed to serialize response") - })?; + client.write_u32_le(0).await?; + rkyv::api::high::to_bytes_in::<_, rkyv::rancor::Failure>(&output, &mut buffer.0) + .map_err(|_| { + std::io::Error::new(std::io::ErrorKind::Other, "Failed to serialize response") + })?; let ((), new_buffer) = buf_try!(@try client.write_all(buffer).await); Ok(new_buffer) } @@ -362,7 +377,7 @@ cuda_function_declarations! { cuDeviceGetCount, cuDeviceGetName, // cuDeviceGetProperties, - // cuDeviceTotalMem_v2, + cuDeviceTotalMem_v2, cuDriverGetVersion, // cuEventCreate, // cuEventDestroy_v2, diff --git a/zluda_server_common/src/lib.rs b/zluda_server_common/src/lib.rs index 159dfc74e..416f045cd 100644 --- a/zluda_server_common/src/lib.rs +++ b/zluda_server_common/src/lib.rs @@ -2,30 +2,13 @@ use bincode::{Decode, Encode}; use cuda_macros::{cuda_function_declarations, generate_input_struct, generate_output_struct}; use cuda_types::cuda::*; use paste::paste; +use rkyv::rend::u64_le; use rkyv::{rend, Archive, Deserialize, Portable, Serialize}; use std::ffi::CString; use std::num::NonZeroU32; use std::{ffi::CStr, num::NonZero}; use strum_macros::FromRepr; -#[derive(Archive, Deserialize, Serialize, Debug, PartialEq)] -#[repr(C)] -pub struct Envelope { - pub code: u32, - pub data: T, -} - -unsafe impl Portable for Envelope {} - -impl Envelope { - pub fn result(&self) -> Result<(), CUerror> { - match NonZeroU32::new(self.code) { - None => Ok(()), - Some(code) => Err(CUerror(code)), - } - } -} - macro_rules! noop { ($($abi:literal fn $fn_name:ident( $($arg_id:ident : $arg_type:ty),* ) -> $ret_type:ty;)*) => {}; } @@ -45,6 +28,7 @@ macro_rules! generate_messages_inout { $fn_name, )* cuDeviceGetName, + cuDeviceTotalMem_v2, } }; } @@ -71,29 +55,28 @@ cuda_function_declarations! { cuDeviceGetAttribute, cuDeviceGetCount, cuDeviceGetProperties, - cuDeviceTotalMem_v2, cuDriverGetVersion, cuEventCreate, cuEventDestroy_v2, //cuGetExportTable, cuInit, //cuLaunchKernel, - cuMemAlloc_v2, + // cuMemAlloc_v2, //cuMemFreeHost, //cuMemFree_v2, - cuMemGetAddressRange_v2, + // cuMemGetAddressRange_v2, //cuMemHostAlloc, //cuMemcpyDtoDAsync_v2, //cuMemcpyDtoHAsync_v2, //cuMemcpyHtoDAsync_v2, - cuMemsetD8_v2, + // cuMemsetD8_v2, // cuModuleGetFunction, // cuModuleGetGlobal_v2, // cuModuleGetTexRef, cuStreamCreate, cuStreamDestroy_v2, cuTexRefSetAddressMode, - cuTexRefSetAddress_v2, + // cuTexRefSetAddress_v2, cuTexRefSetFilterMode, cuTexRefSetFlags, cuTexRefSetFormat, @@ -104,6 +87,7 @@ cuda_function_declarations! { ], generate_messages_in <= [ cuDeviceGetName, + cuDeviceTotalMem_v2 ] } @@ -167,7 +151,6 @@ encode_as_proxy!(CUfilter_mode, u32); encode_as_proxy!(CUaddress_mode, u32); encode_as_proxy!(CUarray_format, u32); -encode_as_u32!(usize); encode_as_u32!(CUcontext); encode_as_u32!(CUdeviceptr_v2); encode_as_u32!(CUevent); @@ -196,5 +179,11 @@ unsafe impl Portable for CUdevprop_v1_Wire {} #[repr(C)] #[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] pub struct cuDeviceGetNameOut { - pub name: Vec -} \ No newline at end of file + pub name: Vec, +} + +#[repr(C)] +#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct cuDeviceTotalMem_v2Out { + pub bytes: u64_le, +} From dc80dd5fce1106ad3c4d5cbe000e3aec4f244d06 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Fri, 24 Apr 2026 00:05:46 -0700 Subject: [PATCH 24/85] More functions --- Cargo.lock | 1 + zluda32/src/lib.rs | 209 ++++++++++++++++++++++++--------- zluda64_server/Cargo.toml | 1 + zluda64_server/src/main.rs | 88 ++++++++++++-- zluda_server_common/src/lib.rs | 29 ++++- 5 files changed, 262 insertions(+), 66 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 4e1921b51..8beada521 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -5674,6 +5674,7 @@ dependencies = [ "compio", "cuda_macros", "cuda_types", + "dark_api", "rkyv", "slab", "windows-sys 0.61.2", diff --git a/zluda32/src/lib.rs b/zluda32/src/lib.rs index 4a6f06fdb..747843e5c 100644 --- a/zluda32/src/lib.rs +++ b/zluda32/src/lib.rs @@ -3,11 +3,12 @@ use cuda_types::cuda::*; use dark_api::cuda::CudaDarkApi; use paste::paste; use std::sync::{Mutex, OnceLock}; +use std::{cell::RefCell, ffi::c_void, ptr}; use zluda_server_common::*; mod ipc; -macro_rules! unimplemented { +macro_rules! not_implemented { ($($abi:literal fn $fn_name:ident( $($arg_id:ident : $arg_type:ty),* ) -> $ret_type:ty;)*) => { $( #[cfg_attr(not(test), no_mangle)] @@ -36,7 +37,7 @@ macro_rules! implemented { } cuda_function_declarations! { - unimplemented, + not_implemented, implemented <= [ cuCtxCreate_v2, cuCtxDetach, @@ -83,6 +84,39 @@ cuda_function_declarations! { ] } +thread_local! { + pub(crate) static CONTEXT_STACK: ContextStack = ContextStack::new(); +} + +struct ContextStack(RefCell>); + +impl ContextStack { + fn new() -> Self { + ContextStack(RefCell::new(Vec::new())) + } + + fn push(&self, ctx: CUcontext) { + self.0.borrow_mut().push(ctx); + } + + fn unwrap(&self, ctx: CUcontext) -> Result { + if ctx.0.is_null() { + let stack = self.0.borrow(); + stack.last().copied().ok_or(CUerror::INVALID_VALUE) + } else { + Ok(ctx) + } + } + + fn current(&self) -> CUcontext { + self.0 + .borrow() + .last() + .copied() + .unwrap_or(CUcontext(ptr::null_mut())) + } +} + pub(crate) fn cu_init(flags: u32) -> Result<(), CUerror> { ipc::Server::remote_call_zero_copy::(Opcode::cuInit, cuInitIn { Flags: flags })?; Ok(()) @@ -93,38 +127,55 @@ pub(crate) fn cu_ctx_create_v2( flags: ::core::ffi::c_uint, dev: CUdevice, ) -> Result<(), CUerror> { - let ctx = unsafe { pctx.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - *ctx = CudaEncode::decode( + let ctx_ref = unsafe { pctx.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + let cu_ctx = CudaEncode::decode( ipc::Server::remote_call_zero_copy::( Opcode::cuCtxCreate_v2, cuCtxCreate_v2In { flags, dev }, )? .pctx, ); + CONTEXT_STACK.with(|stack| { + stack.push(cu_ctx); + }); + *ctx_ref = cu_ctx; Ok(()) } pub(crate) fn cu_ctx_detach(ctx: CUcontext) -> Result<(), CUerror> { - todo!() + unimplemented!() } pub(crate) fn cu_ctx_get_api_version( ctx: CUcontext, version: *mut ::core::ffi::c_uint, ) -> Result<(), CUerror> { - todo!() + let version = unsafe { version.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + let ctx = CONTEXT_STACK.with(|s| s.unwrap(ctx))?; + *version = CudaEncode::decode( + ipc::Server::remote_call_zero_copy::( + Opcode::cuCtxGetApiVersion, + cuCtxGetApiVersionIn { + ctx: CudaEncode::encode(ctx), + }, + )? + .version, + ); + Ok(()) } pub(crate) fn cu_ctx_get_current(pctx: *mut CUcontext) -> Result<(), CUerror> { - todo!() + let pctx = unsafe { pctx.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + *pctx = CONTEXT_STACK.with(|s| s.current()); + Ok(()) } pub(crate) fn cu_ctx_get_device(device: *mut CUdevice) -> Result<(), CUerror> { - todo!() + unimplemented!() } pub(crate) fn cu_ctx_synchronize() -> Result<(), CUerror> { - todo!() + unimplemented!() } pub(crate) fn cu_device_compute_capability( @@ -132,7 +183,7 @@ pub(crate) fn cu_device_compute_capability( minor: *mut ::core::ffi::c_int, dev: CUdevice, ) -> Result<(), CUerror> { - todo!() + unimplemented!() } pub(crate) fn cu_device_get( @@ -198,7 +249,7 @@ pub(crate) fn cu_device_get_name( } pub(crate) fn cu_device_get_properties(prop: *mut CUdevprop, dev: CUdevice) -> Result<(), CUerror> { - todo!() + unimplemented!() } pub(crate) fn cu_device_total_mem_v2(bytes: *mut usize, dev: CUdevice) -> Result<(), CUerror> { @@ -229,11 +280,11 @@ pub(crate) fn cu_event_create( phEvent: *mut CUevent, Flags: ::core::ffi::c_uint, ) -> Result<(), CUerror> { - todo!() + unimplemented!() } pub(crate) fn cu_event_destroy_v2(hEvent: CUevent) -> Result<(), CUerror> { - todo!() + unimplemented!() } static EXPORT_TABLE: ::dark_api::cuda::CudaDarkApiGlobalTable = @@ -270,19 +321,19 @@ pub(crate) fn cu_launch_kernel( kernelParams: *mut *mut ::core::ffi::c_void, extra: *mut *mut ::core::ffi::c_void, ) -> Result<(), CUerror> { - todo!() + unimplemented!() } pub(crate) fn cu_mem_alloc_v2(dptr: *mut CUdeviceptr, bytesize: usize) -> Result<(), CUerror> { - todo!() + unimplemented!() } pub(crate) fn cu_mem_free_host(p: *mut ::core::ffi::c_void) -> Result<(), CUerror> { - todo!() + unimplemented!() } pub(crate) fn cu_mem_free_v2(dptr: CUdeviceptr) -> Result<(), CUerror> { - todo!() + unimplemented!() } pub(crate) fn cu_mem_get_address_range_v2( @@ -290,7 +341,7 @@ pub(crate) fn cu_mem_get_address_range_v2( psize: *mut usize, dptr: CUdeviceptr, ) -> Result<(), CUerror> { - todo!() + unimplemented!() } pub(crate) fn cu_mem_host_alloc( @@ -298,7 +349,7 @@ pub(crate) fn cu_mem_host_alloc( bytesize: usize, Flags: ::core::ffi::c_uint, ) -> Result<(), CUerror> { - todo!() + unimplemented!() } pub(crate) fn cu_memcpy_dto_d_async_v2( @@ -307,7 +358,7 @@ pub(crate) fn cu_memcpy_dto_d_async_v2( ByteCount: usize, hStream: CUstream, ) -> Result<(), CUerror> { - todo!() + unimplemented!() } pub(crate) fn cu_memcpy_dto_h_async_v2( @@ -316,7 +367,7 @@ pub(crate) fn cu_memcpy_dto_h_async_v2( ByteCount: usize, hStream: CUstream, ) -> Result<(), CUerror> { - todo!() + unimplemented!() } pub(crate) fn cu_memcpy_hto_d_async_v2( @@ -325,7 +376,7 @@ pub(crate) fn cu_memcpy_hto_d_async_v2( ByteCount: usize, hStream: CUstream, ) -> Result<(), CUerror> { - todo!() + unimplemented!() } pub(crate) fn cu_memset_d8_v2( @@ -333,7 +384,7 @@ pub(crate) fn cu_memset_d8_v2( uc: ::core::ffi::c_uchar, N: usize, ) -> Result<(), CUerror> { - todo!() + unimplemented!() } pub(crate) fn cu_module_get_function( @@ -341,7 +392,7 @@ pub(crate) fn cu_module_get_function( hmod: CUmodule, name: *const ::core::ffi::c_char, ) -> Result<(), CUerror> { - todo!() + unimplemented!() } pub(crate) fn cu_module_get_global_v2( @@ -350,7 +401,7 @@ pub(crate) fn cu_module_get_global_v2( hmod: CUmodule, name: *const ::core::ffi::c_char, ) -> Result<(), CUerror> { - todo!() + unimplemented!() } pub(crate) fn cu_module_get_tex_ref( @@ -358,18 +409,18 @@ pub(crate) fn cu_module_get_tex_ref( hmod: CUmodule, name: *const ::core::ffi::c_char, ) -> Result<(), CUerror> { - todo!() + unimplemented!() } pub(crate) fn cu_stream_create( phStream: *mut CUstream, Flags: ::core::ffi::c_uint, ) -> Result<(), CUerror> { - todo!() + unimplemented!() } pub(crate) fn cu_stream_destroy_v2(hStream: CUstream) -> Result<(), CUerror> { - todo!() + unimplemented!() } pub(crate) fn cu_tex_ref_set_address_mode( @@ -377,7 +428,7 @@ pub(crate) fn cu_tex_ref_set_address_mode( dim: ::core::ffi::c_int, am: CUaddress_mode, ) -> Result<(), CUerror> { - todo!() + unimplemented!() } pub(crate) fn cu_tex_ref_set_address_v2( @@ -386,21 +437,21 @@ pub(crate) fn cu_tex_ref_set_address_v2( dptr: CUdeviceptr, bytes: usize, ) -> Result<(), CUerror> { - todo!() + unimplemented!() } pub(crate) fn cu_tex_ref_set_filter_mode( hTexRef: CUtexref, fm: CUfilter_mode, ) -> Result<(), CUerror> { - todo!() + unimplemented!() } pub(crate) fn cu_tex_ref_set_flags( hTexRef: CUtexref, Flags: ::core::ffi::c_uint, ) -> Result<(), CUerror> { - todo!() + unimplemented!() } pub(crate) fn cu_tex_ref_set_format( @@ -408,28 +459,28 @@ pub(crate) fn cu_tex_ref_set_format( fmt: CUarray_format, NumPackedComponents: ::core::ffi::c_int, ) -> Result<(), CUerror> { - todo!() + unimplemented!() } pub(crate) fn cu_tex_ref_set_max_anisotropy( hTexRef: CUtexref, maxAniso: ::core::ffi::c_uint, ) -> Result<(), CUerror> { - todo!() + unimplemented!() } pub(crate) fn cu_tex_ref_set_mipmap_filter_mode( hTexRef: CUtexref, fm: CUfilter_mode, ) -> Result<(), CUerror> { - todo!() + unimplemented!() } pub(crate) fn cu_tex_ref_set_mipmap_level_bias( hTexRef: CUtexref, bias: f32, ) -> Result<(), CUerror> { - todo!() + unimplemented!() } pub(crate) fn cu_tex_ref_set_mipmap_level_clamp( @@ -437,9 +488,29 @@ pub(crate) fn cu_tex_ref_set_mipmap_level_clamp( minMipmapLevelClamp: f32, maxMipmapLevelClamp: f32, ) -> Result<(), CUerror> { - todo!() + unimplemented!() +} + +struct UnknownBuffer { + buffer: std::cell::UnsafeCell<[u32; S]>, } +impl UnknownBuffer { + const fn new() -> Self { + UnknownBuffer { + buffer: std::cell::UnsafeCell::new([0; S]), + } + } + const fn len(&self) -> usize { + S + } +} + +unsafe impl Sync for UnknownBuffer {} + +static UNKNOWN_BUFFER1: UnknownBuffer<1024> = UnknownBuffer::new(); +static UNKNOWN_BUFFER2: UnknownBuffer<14> = UnknownBuffer::new(); + struct DarkApi32; impl CudaDarkApi for DarkApi32 { @@ -447,7 +518,7 @@ impl CudaDarkApi for DarkApi32 { module: *mut cuda_types::cuda::CUmodule, fatbinc_wrapper: *const cuda_types::dark_api::FatbincWrapper, ) -> cuda_types::cuda::CUresult { - todo!() + unimplemented!() } unsafe extern "system" fn cudart_interface_fn2( @@ -466,11 +537,11 @@ impl CudaDarkApi for DarkApi32 { arg4: *mut std::ffi::c_void, arg5: u32, ) -> cuda_types::cuda::CUresult { - todo!() + unimplemented!() } unsafe extern "system" fn cudart_interface_fn7(arg1: usize) -> () { - todo!() + unimplemented!() } unsafe extern "system" fn get_module_from_cubin_ext2( @@ -480,32 +551,34 @@ impl CudaDarkApi for DarkApi32 { arg4: *mut std::ffi::c_void, arg5: u32, ) -> cuda_types::cuda::CUresult { - todo!() + unimplemented!() } unsafe extern "system" fn load_compilers() -> cuda_types::cuda::CUresult { - todo!() + unimplemented!() } unsafe extern "system" fn get_unknown_buffer1( ptr: *mut *mut std::ffi::c_void, size: *mut usize, ) -> () { - todo!() + *ptr = UNKNOWN_BUFFER1.buffer.get() as *mut std::ffi::c_void; + *size = UNKNOWN_BUFFER1.len(); } unsafe extern "system" fn get_unknown_buffer2( ptr: *mut *mut std::ffi::c_void, size: *mut usize, ) -> () { - todo!() + *ptr = UNKNOWN_BUFFER2.buffer.get() as *mut std::ffi::c_void; + *size = UNKNOWN_BUFFER2.len(); } unsafe extern "system" fn context_local_storage_put( - context: cuda_types::cuda::CUcontext, + cu_ctx: cuda_types::cuda::CUcontext, key: *mut std::ffi::c_void, value: *mut std::ffi::c_void, - dtor_cb: Option< + _dtor_cb: Option< extern "system" fn( cuda_types::cuda::CUcontext, *mut std::ffi::c_void, @@ -513,14 +586,23 @@ impl CudaDarkApi for DarkApi32 { ), >, ) -> cuda_types::cuda::CUresult { - todo!() + let cu_ctx = CONTEXT_STACK.with(|s| s.unwrap(cu_ctx))?; + ipc::Server::remote_call_zero_copy::( + Opcode::ContextLocalStoragePut, + ContextLocalStoragePutIn { + cu_ctx: cu_ctx.encode().into(), + key: (key as u32).into(), + value: (value as u32).into(), + }, + )?; + Ok(()) } unsafe extern "system" fn context_local_storage_delete( context: cuda_types::cuda::CUcontext, key: *mut std::ffi::c_void, ) -> cuda_types::cuda::CUresult { - todo!() + unimplemented!() } unsafe extern "system" fn context_local_storage_get( @@ -528,7 +610,18 @@ impl CudaDarkApi for DarkApi32 { cu_ctx: cuda_types::cuda::CUcontext, key: *mut std::ffi::c_void, ) -> cuda_types::cuda::CUresult { - todo!() + let value = unsafe { value.as_mut() }.ok_or(cuda_types::cuda::CUerror::INVALID_VALUE)?; + let cu_ctx = CONTEXT_STACK.with(|s| s.unwrap(cu_ctx))?; + *value = ipc::Server::remote_call_zero_copy::( + Opcode::ContextLocalStorageGet, + ContextLocalStorageGetIn { + cu_ctx: cu_ctx.encode().into(), + key: (key as u32).into(), + }, + )? + .value + .to_native() as _; + Ok(()) } unsafe extern "system" fn ctx_create_v2_bypass( @@ -544,14 +637,14 @@ impl CudaDarkApi for DarkApi32 { arg2: usize, arg3: usize, ) -> cuda_types::cuda::CUresult { - todo!() + unimplemented!() } unsafe extern "system" fn heap_free( heap_alloc_record_ptr: *const std::ffi::c_void, arg2: *mut usize, ) -> cuda_types::cuda::CUresult { - todo!() + unimplemented!() } unsafe extern "system" fn device_get_attribute_ext( @@ -560,14 +653,14 @@ impl CudaDarkApi for DarkApi32 { unknown: std::ffi::c_int, result: *mut [usize; 2], ) -> cuda_types::cuda::CUresult { - todo!() + unimplemented!() } unsafe extern "system" fn device_get_something( result: *mut std::ffi::c_uchar, dev: cuda_types::cuda::CUdevice, ) -> cuda_types::cuda::CUresult { - todo!() + unimplemented!() } unsafe extern "system" fn integrity_check( @@ -575,7 +668,7 @@ impl CudaDarkApi for DarkApi32 { unix_seconds: u64, result: *mut [u64; 2], ) -> cuda_types::cuda::CUresult { - todo!() + unimplemented!() } unsafe extern "system" fn context_check( @@ -583,11 +676,11 @@ impl CudaDarkApi for DarkApi32 { result1: *mut u32, result2: *mut *const std::ffi::c_void, ) -> cuda_types::cuda::CUresult { - todo!() + unimplemented!() } unsafe extern "system" fn check_fn3() -> u32 { - todo!() + unimplemented!() } unsafe extern "system" fn hybrid_runtime_load_get_proc_address( @@ -595,10 +688,10 @@ impl CudaDarkApi for DarkApi32 { fn_ptr: *mut *const std::ffi::c_void, token: *mut usize, ) -> cuda_types::cuda::CUresult { - todo!() + unimplemented!() } unsafe extern "system" fn hybrid_runtime_free(token: usize) -> cuda_types::cuda::CUresult { - todo!() + unimplemented!() } } diff --git a/zluda64_server/Cargo.toml b/zluda64_server/Cargo.toml index 04d91290e..a36c1d579 100644 --- a/zluda64_server/Cargo.toml +++ b/zluda64_server/Cargo.toml @@ -12,6 +12,7 @@ path = "src/main.rs" cuda_types = { path = "../cuda_types" } cuda_macros = { path = "../cuda_macros" } zluda_server_common = { path = "../zluda_server_common" } +dark_api = { path = "../dark_api" } windows-sys = { version = "0.61.2", features = ["Win32_Foundation"] } compio = { version = "0.18.0", features = ["macros", "fs"] } slab = "0.4.12" diff --git a/zluda64_server/src/main.rs b/zluda64_server/src/main.rs index 42058e35a..9b2434491 100644 --- a/zluda64_server/src/main.rs +++ b/zluda64_server/src/main.rs @@ -10,33 +10,54 @@ use compio::{ use cuda_macros::cuda_function_declarations; use cuda_types::cuda::*; use rkyv::{ - api::high::HighSerializer, rend::u64_le, ser::allocator::ArenaHandle, util::AlignedVec, + api::high::HighSerializer, + rend::{u32_le, u64_le}, + ser::allocator::ArenaHandle, + util::AlignedVec, Archive, Portable, Serialize, }; use slab::Slab; use std::{ io::{self, Write}, - mem, + mem, ptr, }; use windows_sys::Win32::Foundation::ERROR_MORE_DATA; use zluda_server_common::*; struct State { handles: Slab, + dark_api: dark_api::cuda::ContextLocalStorageInterfaceV0301, } impl State { + fn new() -> Result { + unsafe { cuInit(0) }?; + let mut table_ptr = std::ptr::null(); + unsafe { + cuGetExportTable( + &mut table_ptr, + &dark_api::cuda::ContextLocalStorageInterfaceV0301::GUID, + ) + }?; + let dark_api = unsafe { dark_api::cuda::ContextLocalStorageInterfaceV0301::new(table_ptr) }; + Ok(Self { + handles: Slab::new(), + dark_api, + }) + } + fn insert(&mut self, handle: *mut T) -> u32 { (self.handles.insert(handle as usize) as u32) + 1 } - fn get(&self, id: u32) -> Option<*mut T> { + fn get(&self, id: u32) -> Result<*mut T, CUerror> { if id == 0 { - return None; + return Err(CUerror::INVALID_VALUE); } self.handles .get((id - 1) as usize) .map(|&handle| handle as *mut T) + .ok_or(CUerror::INVALID_VALUE) } } @@ -53,9 +74,12 @@ async fn main() -> std::io::Result<()> { .open(pipe_name) .await?; let mut buffer = AlignedVecBuffer(AlignedVec::new()); - let mut state = State { - handles: Slab::new(), - }; + let mut state = State::new().map_err(|_| { + std::io::Error::new( + std::io::ErrorKind::Other, + "Failed to initialize CUDA context", + ) + })?; loop { let opcode = client.read_u32_le().await?; // Read the length prefix buffer.clear(); @@ -124,6 +148,24 @@ async fn main() -> std::io::Result<()> { >(&mut client, buffer, cu_device_total_mem_v2) .await?; } + Some(Opcode::ContextLocalStoragePut) => { + buffer = handle_cuda_function::< + ArchivedContextLocalStoragePutIn, + ContextLocalStoragePutOut, + >(&mut client, buffer, |input| { + context_local_storage_put(&mut state, input) + }) + .await?; + } + Some(Opcode::ContextLocalStorageGet) => { + buffer = handle_cuda_function::< + ArchivedContextLocalStorageGetIn, + ContextLocalStorageGetOut, + >(&mut client, buffer, |input| { + context_local_storage_get(&mut state, input) + }) + .await?; + } _ => { client.write_u32_le(CUerror::NOT_SUPPORTED.0.get()).await?; return Err(std::io::Error::new( @@ -213,6 +255,38 @@ fn cu_driver_get_version( }) } +fn context_local_storage_put( + state: &mut State, + input: &ArchivedContextLocalStoragePutIn, +) -> Result { + unsafe { + state.dark_api.context_local_storage_put( + CUcontext(state.get(input.cu_ctx.to_native())?), + input.key.to_native() as _, + input.value.to_native() as _, + None, + ) + }?; + Ok(ContextLocalStoragePutOut {}) +} + +fn context_local_storage_get( + state: &mut State, + input: &ArchivedContextLocalStorageGetIn, +) -> Result { + let mut value = ptr::null_mut(); + unsafe { + state.dark_api.context_local_storage_get( + &mut value, + CUcontext(state.get(input.cu_ctx.to_native())?), + input.key.to_native() as _, + ) + }?; + Ok(ContextLocalStorageGetOut { + value: u32_le::from_native(value as u32), + }) +} + async fn handle_cuda_function( client: &mut NamedPipeClient, mut buffer: AlignedVecBuffer, diff --git a/zluda_server_common/src/lib.rs b/zluda_server_common/src/lib.rs index 416f045cd..4c1880d64 100644 --- a/zluda_server_common/src/lib.rs +++ b/zluda_server_common/src/lib.rs @@ -2,7 +2,7 @@ use bincode::{Decode, Encode}; use cuda_macros::{cuda_function_declarations, generate_input_struct, generate_output_struct}; use cuda_types::cuda::*; use paste::paste; -use rkyv::rend::u64_le; +use rkyv::rend::{u32_le, u64_le}; use rkyv::{rend, Archive, Deserialize, Portable, Serialize}; use std::ffi::CString; use std::num::NonZeroU32; @@ -29,6 +29,8 @@ macro_rules! generate_messages_inout { )* cuDeviceGetName, cuDeviceTotalMem_v2, + ContextLocalStoragePut, + ContextLocalStorageGet, } }; } @@ -187,3 +189,28 @@ pub struct cuDeviceGetNameOut { pub struct cuDeviceTotalMem_v2Out { pub bytes: u64_le, } + +#[repr(C)] +#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct ContextLocalStoragePutIn { + pub cu_ctx: u32_le, + pub key: u32_le, + pub value: u32_le, +} + +#[repr(C)] +#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct ContextLocalStoragePutOut {} + +#[repr(C)] +#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct ContextLocalStorageGetIn { + pub cu_ctx: u32_le, + pub key: u32_le, +} + +#[repr(C)] +#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct ContextLocalStorageGetOut { + pub value: u32_le, +} From 2c98b6f224f08a03e9e89acd32737593e2828696 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Sat, 25 Apr 2026 18:38:12 -0700 Subject: [PATCH 25/85] More functions --- zluda32/src/lib.rs | 42 ++++++++++++++++++++++++++++---------- zluda64_server/src/main.rs | 21 ++++++++++++++++++- 2 files changed, 51 insertions(+), 12 deletions(-) diff --git a/zluda32/src/lib.rs b/zluda32/src/lib.rs index 747843e5c..bd9581b8c 100644 --- a/zluda32/src/lib.rs +++ b/zluda32/src/lib.rs @@ -88,32 +88,35 @@ thread_local! { pub(crate) static CONTEXT_STACK: ContextStack = ContextStack::new(); } -struct ContextStack(RefCell>); +struct ContextStack(RefCell>); impl ContextStack { fn new() -> Self { ContextStack(RefCell::new(Vec::new())) } - fn push(&self, ctx: CUcontext) { - self.0.borrow_mut().push(ctx); + fn push(&self, ctx: CUcontext, dev: CUdevice) { + self.0.borrow_mut().push((ctx, dev)); } fn unwrap(&self, ctx: CUcontext) -> Result { if ctx.0.is_null() { let stack = self.0.borrow(); - stack.last().copied().ok_or(CUerror::INVALID_VALUE) + stack + .last() + .map(|(ctx, _)| *ctx) + .ok_or(CUerror::INVALID_VALUE) } else { Ok(ctx) } } - fn current(&self) -> CUcontext { + fn current(&self) -> (CUcontext, CUdevice) { self.0 .borrow() .last() .copied() - .unwrap_or(CUcontext(ptr::null_mut())) + .unwrap_or((CUcontext(ptr::null_mut()), 0)) } } @@ -136,7 +139,7 @@ pub(crate) fn cu_ctx_create_v2( .pctx, ); CONTEXT_STACK.with(|stack| { - stack.push(cu_ctx); + stack.push(cu_ctx, dev); }); *ctx_ref = cu_ctx; Ok(()) @@ -166,12 +169,15 @@ pub(crate) fn cu_ctx_get_api_version( pub(crate) fn cu_ctx_get_current(pctx: *mut CUcontext) -> Result<(), CUerror> { let pctx = unsafe { pctx.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - *pctx = CONTEXT_STACK.with(|s| s.current()); + *pctx = CONTEXT_STACK.with(|s| s.current()).0; Ok(()) } pub(crate) fn cu_ctx_get_device(device: *mut CUdevice) -> Result<(), CUerror> { - unimplemented!() + let device = unsafe { device.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + let (_, dev) = CONTEXT_STACK.with(|s| s.current()); + *device = dev; + Ok(()) } pub(crate) fn cu_ctx_synchronize() -> Result<(), CUerror> { @@ -513,6 +519,12 @@ static UNKNOWN_BUFFER2: UnknownBuffer<14> = UnknownBuffer::new(); struct DarkApi32; +#[repr(C)] +struct AllocRecord { + x: usize, + y: usize, +} + impl CudaDarkApi for DarkApi32 { unsafe extern "system" fn get_module_from_cubin( module: *mut cuda_types::cuda::CUmodule, @@ -637,14 +649,22 @@ impl CudaDarkApi for DarkApi32 { arg2: usize, arg3: usize, ) -> cuda_types::cuda::CUresult { - unimplemented!() + let heap_alloc_record_ptr = heap_alloc_record_ptr as *mut *mut AllocRecord; + let alloc_record = Box::into_raw(Box::new(AllocRecord { x: arg2, y: arg3 })); + *heap_alloc_record_ptr = alloc_record; + Ok(()) } unsafe extern "system" fn heap_free( heap_alloc_record_ptr: *const std::ffi::c_void, arg2: *mut usize, ) -> cuda_types::cuda::CUresult { - unimplemented!() + let heap_alloc_record_ptr = heap_alloc_record_ptr as *mut AllocRecord; + let record = Box::from_raw(heap_alloc_record_ptr); + if !arg2.is_null() { + *arg2 = record.y; + } + Ok(()) } unsafe extern "system" fn device_get_attribute_ext( diff --git a/zluda64_server/src/main.rs b/zluda64_server/src/main.rs index 9b2434491..6aadad627 100644 --- a/zluda64_server/src/main.rs +++ b/zluda64_server/src/main.rs @@ -166,6 +166,15 @@ async fn main() -> std::io::Result<()> { }) .await?; } + Some(Opcode::cuCtxGetApiVersion) => { + buffer = + handle_cuda_function::( + &mut client, + buffer, + |input| cu_ctx_get_api_version(&mut state, input), + ) + .await?; + } _ => { client.write_u32_le(CUerror::NOT_SUPPORTED.0.get()).await?; return Err(std::io::Error::new( @@ -255,6 +264,16 @@ fn cu_driver_get_version( }) } +fn cu_ctx_get_api_version( + state: &mut State, + input: &ArchivedcuCtxGetApiVersionIn, +) -> Result { + let ctx = CUcontext(state.get(input.ctx.to_native())?); + let mut version = 0; + unsafe { cuCtxGetApiVersion(ctx, &mut version) }?; + Ok(cuCtxGetApiVersionOut { version }) +} + fn context_local_storage_put( state: &mut State, input: &ArchivedContextLocalStoragePutIn, @@ -441,7 +460,7 @@ cuda_function_declarations! { implemented <= [ cuCtxCreate_v2, // cuCtxDetach, - // cuCtxGetApiVersion, + cuCtxGetApiVersion, // cuCtxGetCurrent, // cuCtxGetDevice, // cuCtxSynchronize, From 3c192a688398a1e4a41a3336811625648dde9b67 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Sun, 26 Apr 2026 16:37:44 -0700 Subject: [PATCH 26/85] Add pass for 32 bit memory conversion --- ptx/src/pass/convert_32bit_to_64bit.rs | 196 +++++++++++++++++++++ ptx/src/pass/insert_explicit_load_store.rs | 1 + ptx/src/pass/mod.rs | 7 +- ptx_parser/src/ast.rs | 5 +- ptx_parser/src/lib.rs | 44 +++-- zluda/src/impl/module.rs | 1 + 6 files changed, 236 insertions(+), 18 deletions(-) create mode 100644 ptx/src/pass/convert_32bit_to_64bit.rs diff --git a/ptx/src/pass/convert_32bit_to_64bit.rs b/ptx/src/pass/convert_32bit_to_64bit.rs new file mode 100644 index 000000000..c4325391a --- /dev/null +++ b/ptx/src/pass/convert_32bit_to_64bit.rs @@ -0,0 +1,196 @@ +use crate::{ + pass::{ + error_todo, Directive2, Function2, GlobalStringIdentResolver2, PtrAccess, SpirvWord, + Statement, + }, + TranslateError, +}; +use ptx_parser::{self as ast, CvtDetails, LdDetails}; + +pub(super) fn run<'a, 'input>( + resolver: &mut GlobalStringIdentResolver2<'input>, + directives: Vec, SpirvWord>>, +) -> Result, SpirvWord>>, TranslateError> { + directives + .into_iter() + .map(|directive| run_directive(resolver, directive)) + .collect::, _>>() +} + +fn run_directive<'a, 'input>( + resolver: &mut GlobalStringIdentResolver2<'input>, + directive: Directive2, SpirvWord>, +) -> Result, SpirvWord>, TranslateError> { + Ok(match directive { + var @ Directive2::Variable(..) => var, + Directive2::Method(method) => Directive2::Method(run_method(resolver, method)?), + }) +} + +fn run_method<'a, 'input>( + resolver: &mut GlobalStringIdentResolver2<'input>, + mut method: Function2, SpirvWord>, +) -> Result, SpirvWord>, TranslateError> { + let is_kernel = method.is_kernel(); + if let Some(ref mut body) = method.body { + if !is_kernel { + return Err(error_todo()); + } + let hidden_ptr_param = resolver.register_unnamed(Some(( + ast::Type::Scalar(ast::ScalarType::B64), + ast::StateSpace::ParamEntry, + ))); + method.input_arguments.push(ast::Variable { + name: hidden_ptr_param, + info: ast::VariableInfo { + align: None, + v_type: ast::Type::Scalar(ast::ScalarType::B64), + state_space: ast::StateSpace::ParamEntry, + array_init: Vec::new(), + }, + }); + let mut result = Vec::with_capacity(body.len()); + let hidden_ptr = resolver.register_unnamed(Some(( + ast::Type::Scalar(ast::ScalarType::B64), + ast::StateSpace::Reg, + ))); + let mut old_body = std::mem::take(body).into_iter().peekable(); + while let Some(Statement::Label(_)) = old_body.peek() { + result.push(old_body.next().unwrap()); + } + result.push(Statement::Instruction(ast::Instruction::Ld { + data: LdDetails { + qualifier: ast::LdStQualifier::Weak, + state_space: ast::StateSpace::ParamEntry, + caching: ast::LdCacheOperator::Cached, + typ: ast::Type::Scalar(ast::ScalarType::B64), + non_coherent: false, + }, + arguments: ast::LdArgs { + dst: hidden_ptr, + src: hidden_ptr_param, + }, + })); + for statement in old_body { + match statement { + Statement::Instruction(ast::Instruction::Ld { + data, + mut arguments, + }) => { + if is_global_memory(data.state_space) { + replace_with_ptr_access( + resolver, + hidden_ptr, + &mut result, + (data.state_space, data.typ.clone()), + &mut arguments.src, + )?; + } + result.push(Statement::Instruction(ast::Instruction::Ld { + data, + arguments, + })); + } + Statement::Instruction(ast::Instruction::St { + data, + mut arguments, + }) => { + if is_global_memory(data.state_space) { + replace_with_ptr_access( + resolver, + hidden_ptr, + &mut result, + (data.state_space, data.typ.clone()), + &mut arguments.src1, + )?; + } + result.push(Statement::Instruction(ast::Instruction::St { + data, + arguments, + })); + } + Statement::PtrAccess(PtrAccess { + underlying_type, + state_space, + dst, + mut ptr_src, + offset_src, + }) => { + if is_global_memory(state_space) { + replace_with_ptr_access( + resolver, + hidden_ptr, + &mut result, + (state_space, underlying_type.clone()), + &mut ptr_src, + )?; + } + result.push(Statement::PtrAccess(PtrAccess { + underlying_type, + state_space, + dst, + ptr_src, + offset_src, + })); + } + s => result.push(s), + } + } + *body = result; + } + Ok(method) +} + +fn replace_with_ptr_access<'input>( + resolver: &mut GlobalStringIdentResolver2<'input>, + hidden_ptr: SpirvWord, + result: &mut Vec, SpirvWord>>, + (state_space, type_): (ast::StateSpace, ast::Type), + offset: &mut SpirvWord, +) -> Result<(), TranslateError> { + // Offset is either a 32 bit scalar or a variable in the right state space + // If it's a scalar then we bitcast it, if it's a variable it will + // be resolved later, during implicit conversion + let (_, offset_space) = resolver.get_typed(*offset)?; + let converted_src = match offset_space { + ast::StateSpace::Reg => { + let zext_dst = resolver.register_unnamed(Some(( + ast::Type::Scalar(ast::ScalarType::B64), + ast::StateSpace::Reg, + ))); + let zext = Statement::Instruction(ast::Instruction::Cvt { + data: CvtDetails { + from: ast::ScalarType::B32, + to: ast::ScalarType::B64, + mode: ast::CvtMode::ZeroExtend, + }, + arguments: ast::CvtArgs { + dst: zext_dst, + src: *offset, + src2: None, + }, + }); + result.push(zext); + zext_dst + } + _ => *offset, + }; + let dst = resolver.register_unnamed(Some((type_.clone(), state_space))); + let ptr_access = Statement::PtrAccess(PtrAccess { + underlying_type: type_, + state_space: state_space, + dst, + ptr_src: hidden_ptr, + offset_src: converted_src, + }); + result.push(ptr_access); + *offset = dst; + Ok(()) +} + +fn is_global_memory(state_space: ast::StateSpace) -> bool { + matches!( + state_space, + ast::StateSpace::Global | ast::StateSpace::Generic | ast::StateSpace::Const + ) +} diff --git a/ptx/src/pass/insert_explicit_load_store.rs b/ptx/src/pass/insert_explicit_load_store.rs index d9e213e3e..5e60aff6c 100644 --- a/ptx/src/pass/insert_explicit_load_store.rs +++ b/ptx/src/pass/insert_explicit_load_store.rs @@ -317,6 +317,7 @@ impl<'a, 'input> InsertMemSSAVisitor<'a, 'input> { data: ast::CvtaDetails { state_space: *new_space, direction: ast::CvtaDirection::ExplicitToGeneric, + size: 64, }, arguments: ast::CvtaArgs { dst: generic_var, diff --git a/ptx/src/pass/mod.rs b/ptx/src/pass/mod.rs index 9230228d0..7d23b604d 100644 --- a/ptx/src/pass/mod.rs +++ b/ptx/src/pass/mod.rs @@ -11,6 +11,7 @@ use std::{ use strum::IntoEnumIterator; use strum_macros::EnumIter; +mod convert_32bit_to_64bit; mod deparamize_functions; mod expand_operands; mod fix_special_registers; @@ -94,8 +95,12 @@ pub fn to_llvm_module<'input>( on_pass_end("remove_unreachable_basic_blocks"); let directives = instruction_mode_to_global_mode::run(&mut flat_resolver, directives)?; on_pass_end("instruction_mode_to_global_mode"); - let directives = insert_explicit_load_store::run(&mut flat_resolver, directives)?; + let mut directives = insert_explicit_load_store::run(&mut flat_resolver, directives)?; on_pass_end("insert_explicit_load_store"); + if ast.address_size == 32 { + directives = convert_32bit_to_64bit::run(&mut flat_resolver, directives)?; + on_pass_end("convert_32bit_to_64bit"); + } let directives = insert_implicit_conversions::run(&mut flat_resolver, directives)?; on_pass_end("insert_implicit_conversions"); let directives = replace_instructions_with_functions::run(&mut flat_resolver, directives)?; diff --git a/ptx_parser/src/ast.rs b/ptx_parser/src/ast.rs index df9ecb9f3..9cef1096f 100644 --- a/ptx_parser/src/ast.rs +++ b/ptx_parser/src/ast.rs @@ -312,7 +312,7 @@ ptx_parser_macros::generate_instruction_type!( }, Cvta { data: CvtaDetails, - type: { Type::Scalar(ScalarType::B64) }, + type: { if data.size == 64 { Type::Scalar(ScalarType::B64) } else { Type::Scalar(ScalarType::B32) } }, arguments: { dst: T, src: T, @@ -1962,6 +1962,7 @@ pub struct Module<'input> { pub sm_version: u32, pub directives: Vec>>, pub invalid_directives: usize, + pub address_size: u8, } impl Module<'_> { @@ -1971,6 +1972,7 @@ impl Module<'_> { sm_version: 0, directives: Vec::new(), invalid_directives: usize::MAX, + address_size: 64, } } } @@ -2555,6 +2557,7 @@ pub enum RightShiftKind { pub struct CvtaDetails { pub state_space: StateSpace, pub direction: CvtaDirection, + pub size: u8 } pub enum CvtaDirection { diff --git a/ptx_parser/src/lib.rs b/ptx_parser/src/lib.rs index 2620c64fc..903ebfcab 100644 --- a/ptx_parser/src/lib.rs +++ b/ptx_parser/src/lib.rs @@ -509,20 +509,26 @@ fn module<'a, 'input>(stream: &mut PtxParser<'a, 'input>) -> PResult(stream: &mut PtxParser<'a, 'input>) -> PResult<()> { - (Token::DotAddressSize, u8_literal(64)) - .void() +fn address_size<'a, 'input>(stream: &mut PtxParser<'a, 'input>) -> PResult { + ( + Token::DotAddressSize, + alt((u8_literal(64).value(64u8), u8_literal(32).value(32u8))), + ) + .map(|(_, size)| size) .parse_next(stream) } @@ -2702,12 +2708,15 @@ derive_parser!( // https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-cvta cvta.space.size p, a => { - if size != ScalarType::U64 { - state.errors.push(PtxError::Unsupported32Bit); - } + let size = match size { + ScalarType::U32 => 32, + ScalarType::U64 => 64, + _ => unreachable!() + }; let data = ast::CvtaDetails { state_space: space, - direction: ast::CvtaDirection::ExplicitToGeneric + direction: ast::CvtaDirection::ExplicitToGeneric, + size, }; let arguments = ast::CvtaArgs { dst: p, src: a @@ -2717,12 +2726,15 @@ derive_parser!( } } cvta.to.space.size p, a => { - if size != ScalarType::U64 { - state.errors.push(PtxError::Unsupported32Bit); - } + let size = match size { + ScalarType::U32 => 32, + ScalarType::U64 => 64, + _ => unreachable!() + }; let data = ast::CvtaDetails { state_space: space, - direction: ast::CvtaDirection::GenericToExplicit + direction: ast::CvtaDirection::GenericToExplicit, + size, }; let arguments = ast::CvtaArgs { dst: p, src: a diff --git a/zluda/src/impl/module.rs b/zluda/src/impl/module.rs index 90dc17d69..3dfb291d4 100644 --- a/zluda/src/impl/module.rs +++ b/zluda/src/impl/module.rs @@ -147,6 +147,7 @@ fn get_best_ptx_and_compile( sm_version: 0, directives: Vec::new(), invalid_directives: usize::MAX, + address_size: 64, }, ) } From d991bc3610f379907f22a58a14d431437900dc72 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Mon, 27 Apr 2026 22:51:41 -0700 Subject: [PATCH 27/85] Wrap up compiler passes (without propagating metadata) --- ptx/src/pass/convert_32bit_to_64bit.rs | 377 +++++++++++++----- ptx/src/pass/deparamize_functions.rs | 6 +- ptx/src/pass/expand_operands.rs | 7 +- ptx/src/pass/fix_special_registers.rs | 3 +- ptx/src/pass/hoist_globals.rs | 106 ++--- ptx/src/pass/insert_explicit_load_store.rs | 6 +- ptx/src/pass/insert_implicit_conversions.rs | 15 +- ptx/src/pass/insert_post_saturation.rs | 6 +- .../instruction_mode_to_global_mode/mod.rs | 14 +- .../instruction_mode_to_global_mode/test.rs | 2 +- ptx/src/pass/llvm/emit.rs | 2 +- ptx/src/pass/mod.rs | 28 +- ptx/src/pass/normalize_basic_blocks.rs | 2 +- ptx/src/pass/normalize_identifiers.rs | 3 +- ptx/src/pass/normalize_predicates.rs | 3 +- .../pass/remove_unreachable_basic_blocks.rs | 4 +- .../replace_instructions_with_functions.rs | 3 +- ...instructions_with_functions_fp_required.rs | 10 +- ptx/src/pass/resolve_function_pointers.rs | 2 +- ptx/src/pass/test/mod.rs | 4 +- 20 files changed, 397 insertions(+), 206 deletions(-) diff --git a/ptx/src/pass/convert_32bit_to_64bit.rs b/ptx/src/pass/convert_32bit_to_64bit.rs index c4325391a..3f38773cc 100644 --- a/ptx/src/pass/convert_32bit_to_64bit.rs +++ b/ptx/src/pass/convert_32bit_to_64bit.rs @@ -1,146 +1,313 @@ use crate::{ pass::{ - error_todo, Directive2, Function2, GlobalStringIdentResolver2, PtrAccess, SpirvWord, - Statement, + error_todo, error_unreachable, Directive2, Function, GlobalStringIdentResolver2, Module32, + PtrAccess, SpirvWord, Statement, }, TranslateError, }; -use ptx_parser::{self as ast, CvtDetails, LdDetails}; +use ptx_parser::{self as ast, CvtDetails, LdDetails, RegOrImmediate}; +use rustc_hash::FxHashMap; +use std::alloc::Layout; -pub(super) fn run<'a, 'input>( +pub(super) fn run<'input>( resolver: &mut GlobalStringIdentResolver2<'input>, directives: Vec, SpirvWord>>, -) -> Result, SpirvWord>>, TranslateError> { - directives +) -> Result< + ( + Vec, SpirvWord>>, + Module32, + ), + TranslateError, +> { + let globals = collect_globals(resolver, &directives)?; + let directives = directives + .into_iter() + .map(|directive| run_directive(resolver, directive, &globals)) + .collect::, _>>()?; + let globals = globals .into_iter() - .map(|directive| run_directive(resolver, directive)) + .map(|(_, name, layout)| (name, layout)) + .collect(); + Ok((directives, Module32 { globals })) +} + +pub(super) fn collect_globals<'a, 'input>( + resolver: &mut GlobalStringIdentResolver2<'input>, + directives: &[Directive2, SpirvWord>], +) -> Result, TranslateError> { + directives + .iter() + .filter_map(|directive| match directive { + Directive2::Variable( + _, + ast::Variable { + info: + ast::VariableInfo { + align, + v_type: + ast::Type::Array( + None, + ast::ScalarType::U8 | ast::ScalarType::B8 | ast::ScalarType::S8, + array_dims, + ), + state_space: ast::StateSpace::Const | ast::StateSpace::Global, + array_init, + }, + name, + }, + ) if array_dims.len() == 1 + && array_init.iter().all(|x| { + matches!( + x, + RegOrImmediate::Imm(ptx_parser::ImmediateValue::U64(0)) + | RegOrImmediate::Imm(ptx_parser::ImmediateValue::S64(0)) + ) + }) => + { + Some(get_name_layout(resolver, align, array_dims, name)) + } + Directive2::Variable( + _, + ast::Variable { + info: + ast::VariableInfo { + state_space: ast::StateSpace::Shared, + .. + }, + .. + }, + ) + | Directive2::Variable( + _, + ast::Variable { + info: + ast::VariableInfo { + v_type: ast::Type::Texref, + .. + }, + .. + }, + ) + | Directive2::Method(..) => None, + _ => Some(Err(error_todo())), + }) .collect::, _>>() } -fn run_directive<'a, 'input>( +fn get_name_layout<'input>( + resolver: &mut GlobalStringIdentResolver2<'input>, + align: &Option, + array_dims: &Vec, + name: &SpirvWord, +) -> Result<(SpirvWord, String, Layout), TranslateError> { + let entry = resolver.ident_map.get(name).ok_or_else(error_unreachable)?; + let text_name = entry + .name + .as_ref() + .ok_or_else(error_unreachable)? + .to_string(); + Ok(( + *name, + text_name, + Layout::from_size_align(array_dims[0] as usize, align.unwrap_or(1) as usize) + .map_err(|_| error_unreachable())?, + )) +} + +fn run_directive<'input>( resolver: &mut GlobalStringIdentResolver2<'input>, directive: Directive2, SpirvWord>, + globals: &[(SpirvWord, String, Layout)], ) -> Result, SpirvWord>, TranslateError> { Ok(match directive { var @ Directive2::Variable(..) => var, - Directive2::Method(method) => Directive2::Method(run_method(resolver, method)?), + Directive2::Method(method) => Directive2::Method(run_method(resolver, method, globals)?), }) } -fn run_method<'a, 'input>( +fn run_method<'input>( resolver: &mut GlobalStringIdentResolver2<'input>, - mut method: Function2, SpirvWord>, -) -> Result, SpirvWord>, TranslateError> { + mut method: Function, SpirvWord>, + globals: &[(SpirvWord, String, Layout)], +) -> Result, SpirvWord>, TranslateError> { let is_kernel = method.is_kernel(); if let Some(ref mut body) = method.body { if !is_kernel { return Err(error_todo()); } - let hidden_ptr_param = resolver.register_unnamed(Some(( - ast::Type::Scalar(ast::ScalarType::B64), - ast::StateSpace::ParamEntry, - ))); - method.input_arguments.push(ast::Variable { - name: hidden_ptr_param, - info: ast::VariableInfo { - align: None, - v_type: ast::Type::Scalar(ast::ScalarType::B64), - state_space: ast::StateSpace::ParamEntry, - array_init: Vec::new(), - }, - }); let mut result = Vec::with_capacity(body.len()); - let hidden_ptr = resolver.register_unnamed(Some(( - ast::Type::Scalar(ast::ScalarType::B64), - ast::StateSpace::Reg, - ))); let mut old_body = std::mem::take(body).into_iter().peekable(); while let Some(Statement::Label(_)) = old_body.peek() { result.push(old_body.next().unwrap()); } - result.push(Statement::Instruction(ast::Instruction::Ld { - data: LdDetails { - qualifier: ast::LdStQualifier::Weak, - state_space: ast::StateSpace::ParamEntry, - caching: ast::LdCacheOperator::Cached, - typ: ast::Type::Scalar(ast::ScalarType::B64), - non_coherent: false, - }, - arguments: ast::LdArgs { - dst: hidden_ptr, - src: hidden_ptr_param, - }, - })); + let hidden_ptr = add_hidden_argument( + resolver, + ast::ScalarType::B64, + &mut method.input_arguments, + &mut result, + ); + let globals_remapping = globals + .iter() + .map(|(name, _, _)| { + ( + *name, + add_hidden_argument( + resolver, + ast::ScalarType::B32, + &mut method.input_arguments, + &mut result, + ), + ) + }) + .collect::>(); for statement in old_body { - match statement { - Statement::Instruction(ast::Instruction::Ld { - data, - mut arguments, - }) => { - if is_global_memory(data.state_space) { - replace_with_ptr_access( - resolver, - hidden_ptr, - &mut result, - (data.state_space, data.typ.clone()), - &mut arguments.src, - )?; - } - result.push(Statement::Instruction(ast::Instruction::Ld { - data, - arguments, - })); - } - Statement::Instruction(ast::Instruction::St { - data, - mut arguments, - }) => { - if is_global_memory(data.state_space) { - replace_with_ptr_access( - resolver, - hidden_ptr, - &mut result, - (data.state_space, data.typ.clone()), - &mut arguments.src1, - )?; - } - result.push(Statement::Instruction(ast::Instruction::St { - data, - arguments, - })); - } - Statement::PtrAccess(PtrAccess { - underlying_type, - state_space, - dst, - mut ptr_src, - offset_src, - }) => { - if is_global_memory(state_space) { - replace_with_ptr_access( - resolver, - hidden_ptr, - &mut result, - (state_space, underlying_type.clone()), - &mut ptr_src, - )?; - } - result.push(Statement::PtrAccess(PtrAccess { - underlying_type, - state_space, - dst, - ptr_src, - offset_src, - })); - } - s => result.push(s), - } + run_statement( + resolver, + &mut result, + hidden_ptr, + &globals_remapping, + statement, + )?; } *body = result; } Ok(method) } +fn run_statement<'input>( + resolver: &mut GlobalStringIdentResolver2<'input>, + result: &mut Vec, SpirvWord>>, + hidden_ptr: SpirvWord, + globals_remapping: &FxHashMap, + statement: Statement, SpirvWord>, +) -> Result<(), TranslateError> { + let statement = + statement.visit_map(&mut |arg: SpirvWord, + _type_space: Option<(&ast::Type, ast::StateSpace)>, + _is_dst: bool, + _relaxed_type_check: bool| { + Ok(globals_remapping.get(&arg).copied().unwrap_or(arg)) + })?; + Ok(match statement { + Statement::Instruction(ast::Instruction::Ld { + data, + mut arguments, + }) => { + if is_global_memory(data.state_space) { + replace_with_ptr_access( + resolver, + hidden_ptr, + result, + (data.state_space, data.typ.clone()), + &mut arguments.src, + )?; + } + result.push(Statement::Instruction(ast::Instruction::Ld { + data, + arguments, + })); + } + Statement::Instruction(ast::Instruction::St { + data, + mut arguments, + }) => { + if is_global_memory(data.state_space) { + replace_with_ptr_access( + resolver, + hidden_ptr, + result, + (data.state_space, data.typ.clone()), + &mut arguments.src1, + )?; + } + result.push(Statement::Instruction(ast::Instruction::St { + data, + arguments, + })); + } + Statement::PtrAccess(PtrAccess { + underlying_type, + state_space, + dst, + mut ptr_src, + offset_src, + }) => { + if is_global_memory(state_space) { + replace_with_ptr_access( + resolver, + hidden_ptr, + result, + (state_space, underlying_type.clone()), + &mut ptr_src, + )?; + } + result.push(Statement::PtrAccess(PtrAccess { + underlying_type, + state_space, + dst, + ptr_src, + offset_src, + })); + } + Statement::Instruction(ast::Instruction::Atom { + data, + mut arguments, + }) => { + if is_global_memory(data.space) { + replace_with_ptr_access( + resolver, + hidden_ptr, + result, + (data.space, data.type_.clone()), + &mut arguments.src1, + )?; + } + result.push(Statement::Instruction(ast::Instruction::Atom { + data, + arguments, + })); + } + s => result.push(s), + }) +} + +fn add_hidden_argument<'input>( + resolver: &mut GlobalStringIdentResolver2<'input>, + type_: ast::ScalarType, + input_arguments: &mut Vec>, + body: &mut Vec, SpirvWord>>, +) -> SpirvWord { + let implicit_argument_param = resolver.register_unnamed(Some(( + ast::Type::Scalar(type_), + ast::StateSpace::ParamEntry, + ))); + input_arguments.push(ast::Variable { + name: implicit_argument_param, + info: ast::VariableInfo { + align: None, + v_type: ast::Type::Scalar(type_), + state_space: ast::StateSpace::ParamEntry, + array_init: Vec::new(), + }, + }); + let implicit_argument = + resolver.register_unnamed(Some((ast::Type::Scalar(type_), ast::StateSpace::Reg))); + body.push(Statement::Instruction(ast::Instruction::Ld { + data: LdDetails { + qualifier: ast::LdStQualifier::Weak, + state_space: ast::StateSpace::ParamEntry, + caching: ast::LdCacheOperator::Cached, + typ: ast::Type::Scalar(type_), + non_coherent: false, + }, + arguments: ast::LdArgs { + dst: implicit_argument, + src: implicit_argument_param, + }, + })); + implicit_argument +} + fn replace_with_ptr_access<'input>( resolver: &mut GlobalStringIdentResolver2<'input>, hidden_ptr: SpirvWord, diff --git a/ptx/src/pass/deparamize_functions.rs b/ptx/src/pass/deparamize_functions.rs index 538e3437e..f822b245d 100644 --- a/ptx/src/pass/deparamize_functions.rs +++ b/ptx/src/pass/deparamize_functions.rs @@ -22,8 +22,8 @@ fn run_directive<'input>( fn run_method<'input>( resolver: &mut GlobalStringIdentResolver2, - mut method: Function2, SpirvWord>, -) -> Result, SpirvWord>, TranslateError> { + mut method: Function, SpirvWord>, +) -> Result, SpirvWord>, TranslateError> { let is_declaration = method.body.is_none(); let mut body = Vec::new(); let mut remap_returns = Vec::new(); @@ -99,7 +99,7 @@ fn run_method<'input>( Ok::<_, TranslateError>(body) }) .transpose()?; - Ok(Function2 { body, ..method }) + Ok(Function { body, ..method }) } fn run_statement<'input>( diff --git a/ptx/src/pass/expand_operands.rs b/ptx/src/pass/expand_operands.rs index 2a6a7c336..d63343ca5 100644 --- a/ptx/src/pass/expand_operands.rs +++ b/ptx/src/pass/expand_operands.rs @@ -25,11 +25,11 @@ fn run_directive<'input>( fn run_method<'input>( resolver: &mut GlobalStringIdentResolver2<'input>, - method: Function2< + method: Function< ast::Instruction>, ast::ParsedOperand, >, -) -> Result, SpirvWord>, TranslateError> { +) -> Result, SpirvWord>, TranslateError> { let body = method .body .map(|statements| { @@ -40,7 +40,7 @@ fn run_method<'input>( Ok::<_, TranslateError>(result) }) .transpose()?; - Ok(Function2 { + Ok(Function { body, return_arguments: method.return_arguments, name: method.name, @@ -49,6 +49,7 @@ fn run_method<'input>( tuning: method.tuning, linkage: method.linkage, kernel_attributes: method.kernel_attributes, + kernel_meta32: method.kernel_meta32, }) } diff --git a/ptx/src/pass/fix_special_registers.rs b/ptx/src/pass/fix_special_registers.rs index 183cf575a..d438442b9 100644 --- a/ptx/src/pass/fix_special_registers.rs +++ b/ptx/src/pass/fix_special_registers.rs @@ -20,6 +20,7 @@ pub(super) fn run<'a, 'input>( tuning: Vec::new(), linkage: ast::LinkingDirective::EXTERN, kernel_attributes: None, + kernel_meta32: None, })); sreg_to_function.insert(sreg, name); }, @@ -60,7 +61,7 @@ fn run_method<'a, 'input>( Ok::<_, TranslateError>(result) }) .transpose()?; - Ok(Function2 { body, ..method }) + Ok(Function { body, ..method }) } fn run_statement<'a, 'input>( diff --git a/ptx/src/pass/hoist_globals.rs b/ptx/src/pass/hoist_globals.rs index 097dff198..b1a7c5ce0 100644 --- a/ptx/src/pass/hoist_globals.rs +++ b/ptx/src/pass/hoist_globals.rs @@ -1,53 +1,53 @@ -use super::*; - -pub(super) fn run<'input>( - directives: Vec, SpirvWord>>, -) -> Result, SpirvWord>>, TranslateError> { - let mut result = Vec::with_capacity(directives.len()); - for mut directive in directives.into_iter() { - run_directive(&mut result, &mut directive)?; - result.push(directive); - } - Ok(result) -} - -fn run_directive<'input>( - result: &mut Vec, SpirvWord>>, - directive: &mut Directive2, SpirvWord>, -) -> Result<(), TranslateError> { - match directive { - Directive2::Variable(..) => {} - Directive2::Method(function2) => run_function(result, function2), - } - Ok(()) -} - -fn run_function<'input>( - result: &mut Vec, SpirvWord>>, - function: &mut Function2, SpirvWord>, -) { - function.body = function.body.take().map(|statements| { - statements - .into_iter() - .filter_map(|statement| match statement { - Statement::Variable( - var @ ast::Variable { - info: - ast::VariableInfo { - state_space: - ast::StateSpace::Global - | ast::StateSpace::Const - | ast::StateSpace::Shared, - .. - }, - .. - }, - ) => { - result.push(Directive2::Variable(ast::LinkingDirective::NONE, var)); - None - } - s => Some(s), - }) - .collect() - }); -} +use super::*; + +pub(super) fn run<'input>( + directives: Vec, SpirvWord>>, +) -> Result, SpirvWord>>, TranslateError> { + let mut result = Vec::with_capacity(directives.len()); + for mut directive in directives.into_iter() { + run_directive(&mut result, &mut directive)?; + result.push(directive); + } + Ok(result) +} + +fn run_directive<'input>( + result: &mut Vec, SpirvWord>>, + directive: &mut Directive2, SpirvWord>, +) -> Result<(), TranslateError> { + match directive { + Directive2::Variable(..) => {} + Directive2::Method(function2) => run_function(result, function2), + } + Ok(()) +} + +fn run_function<'input>( + result: &mut Vec, SpirvWord>>, + function: &mut Function, SpirvWord>, +) { + function.body = function.body.take().map(|statements| { + statements + .into_iter() + .filter_map(|statement| match statement { + Statement::Variable( + var @ ast::Variable { + info: + ast::VariableInfo { + state_space: + ast::StateSpace::Global + | ast::StateSpace::Const + | ast::StateSpace::Shared, + .. + }, + .. + }, + ) => { + result.push(Directive2::Variable(ast::LinkingDirective::NONE, var)); + None + } + s => Some(s), + }) + .collect() + }); +} diff --git a/ptx/src/pass/insert_explicit_load_store.rs b/ptx/src/pass/insert_explicit_load_store.rs index 5e60aff6c..f662741ac 100644 --- a/ptx/src/pass/insert_explicit_load_store.rs +++ b/ptx/src/pass/insert_explicit_load_store.rs @@ -34,8 +34,8 @@ fn run_directive<'a, 'input>( fn run_method<'a, 'input>( mut visitor: InsertMemSSAVisitor<'a, 'input>, - mut method: Function2, SpirvWord>, -) -> Result, SpirvWord>, TranslateError> { + mut method: Function, SpirvWord>, +) -> Result, SpirvWord>, TranslateError> { if method.is_kernel() { for arg in method.input_arguments.iter_mut() { let old_name = arg.name; @@ -63,7 +63,7 @@ fn run_method<'a, 'input>( Ok::<_, TranslateError>(result) }) .transpose()?; - Ok(Function2 { body, ..method }) + Ok(Function { body, ..method }) } fn run_statement<'a, 'input>( diff --git a/ptx/src/pass/insert_implicit_conversions.rs b/ptx/src/pass/insert_implicit_conversions.rs index c9c05eb97..384beef6e 100644 --- a/ptx/src/pass/insert_implicit_conversions.rs +++ b/ptx/src/pass/insert_implicit_conversions.rs @@ -158,8 +158,10 @@ fn default_implicit_conversion( if valid_vector_scalar_bitcast(operand_type, instruction_type) { return Ok(Some(ConversionKind::Default)); } - } else if is_addressable(operand_space) { - return Ok(Some(ConversionKind::AddressOf)); + } else if let Some(byte_width) = is_addressable(operand_space) { + if byte_width <= instruction_type.layout().map(|l| l.size()).unwrap_or(0) { + return Ok(Some(ConversionKind::AddressOf)); + } } } if instruction_space != operand_space { @@ -171,15 +173,14 @@ fn default_implicit_conversion( } } -fn is_addressable(this: ast::StateSpace) -> bool { +fn is_addressable(this: ast::StateSpace) -> Option { match this { ast::StateSpace::Const | ast::StateSpace::Generic | ast::StateSpace::Global - | ast::StateSpace::Local - | ast::StateSpace::Shared - | ast::StateSpace::ParamEntry => true, - ast::StateSpace::Param | ast::StateSpace::Reg => false, + | ast::StateSpace::ParamEntry => Some(8), + ast::StateSpace::Local | ast::StateSpace::Shared => Some(4), + ast::StateSpace::Param | ast::StateSpace::Reg => None, ast::StateSpace::SharedCluster | ast::StateSpace::SharedCta | ast::StateSpace::ParamFunc => todo!(), diff --git a/ptx/src/pass/insert_post_saturation.rs b/ptx/src/pass/insert_post_saturation.rs index b0c8003a5..e3e03a33d 100644 --- a/ptx/src/pass/insert_post_saturation.rs +++ b/ptx/src/pass/insert_post_saturation.rs @@ -23,8 +23,8 @@ fn run_directive<'input>( fn run_method<'input>( resolver: &mut GlobalStringIdentResolver2, - method: Function2, SpirvWord>, -) -> Result, SpirvWord>, TranslateError> { + method: Function, SpirvWord>, +) -> Result, SpirvWord>, TranslateError> { let mut new_statements = Vec::new(); let body = method .body @@ -35,7 +35,7 @@ fn run_method<'input>( Ok::<_, TranslateError>(new_statements) }) .transpose()?; - Ok(Function2 { body, ..method }) + Ok(Function { body, ..method }) } fn run_statement<'input>( diff --git a/ptx/src/pass/instruction_mode_to_global_mode/mod.rs b/ptx/src/pass/instruction_mode_to_global_mode/mod.rs index 637f4cf60..99315d480 100644 --- a/ptx/src/pass/instruction_mode_to_global_mode/mod.rs +++ b/ptx/src/pass/instruction_mode_to_global_mode/mod.rs @@ -1,6 +1,6 @@ use super::BranchCondition; use super::Directive2; -use super::Function2; +use super::Function; use super::GlobalStringIdentResolver2; use super::ModeRegister; use super::SpirvWord; @@ -750,7 +750,7 @@ fn create_control_flow_graph( let mut cfg = ControlFlowGraph::new(); for directive in directives.iter() { match directive { - super::Directive2::Method(Function2 { + super::Directive2::Method(Function { name, body: Some(body), kernel_attributes, @@ -883,7 +883,7 @@ fn join_modes( let functions_exit_modes = directives .iter() .filter_map(|directive| match directive { - Directive2::Method(Function2 { + Directive2::Method(Function { name, body: None, kernel_attributes: None, @@ -902,7 +902,7 @@ fn join_modes( }; Some(Ok((*name, modes))) } - Directive2::Method(Function2 { + Directive2::Method(Function { name, body: Some(_), kernel_attributes: None, @@ -963,11 +963,11 @@ fn apply_global_mode_controls( .into_iter() .map(|directive| { let (mut method, initial_mode) = match directive { - Directive2::Variable(..) | Directive2::Method(Function2 { body: None, .. }) => { + Directive2::Variable(..) | Directive2::Method(Function { body: None, .. }) => { return Ok(directive); } Directive2::Method( - mut method @ Function2 { + mut method @ Function { name, body: Some(_), .. @@ -1076,7 +1076,7 @@ fn apply_global_mode_controls( } fn check_function_prelude( - method: &Function2, SpirvWord>, + method: &Function, SpirvWord>, global_modes: &FullModeInsertion, ) -> Result<(), TranslateError> { let fn_mode_state = global_modes diff --git a/ptx/src/pass/instruction_mode_to_global_mode/test.rs b/ptx/src/pass/instruction_mode_to_global_mode/test.rs index e40578298..245f311cb 100644 --- a/ptx/src/pass/instruction_mode_to_global_mode/test.rs +++ b/ptx/src/pass/instruction_mode_to_global_mode/test.rs @@ -214,7 +214,7 @@ fn fold_denormal() { )); } -fn compile_methods(ptx: &str) -> Vec, SpirvWord>> { +fn compile_methods(ptx: &str) -> Vec, SpirvWord>> { use crate::pass::*; let module = ptx_parser::parse_module_checked(ptx).unwrap(); diff --git a/ptx/src/pass/llvm/emit.rs b/ptx/src/pass/llvm/emit.rs index 07f71868b..99247abae 100644 --- a/ptx/src/pass/llvm/emit.rs +++ b/ptx/src/pass/llvm/emit.rs @@ -116,7 +116,7 @@ impl<'a, 'input> ModuleEmitContext<'a, 'input> { fn emit_method( &mut self, - method: Function2, SpirvWord>, + method: Function, SpirvWord>, ) -> Result<(), TranslateError> { let name = method .import_as diff --git a/ptx/src/pass/mod.rs b/ptx/src/pass/mod.rs index 7d23b604d..264579395 100644 --- a/ptx/src/pass/mod.rs +++ b/ptx/src/pass/mod.rs @@ -1,6 +1,7 @@ use ptx_parser as ast; use quick_error::quick_error; use rustc_hash::FxHashMap; +use std::alloc::Layout; use std::hash::Hash; use std::{ borrow::Cow, @@ -97,8 +98,12 @@ pub fn to_llvm_module<'input>( on_pass_end("instruction_mode_to_global_mode"); let mut directives = insert_explicit_load_store::run(&mut flat_resolver, directives)?; on_pass_end("insert_explicit_load_store"); + let mut module32 = None; if ast.address_size == 32 { - directives = convert_32bit_to_64bit::run(&mut flat_resolver, directives)?; + let (new_directives, new_module32) = + convert_32bit_to_64bit::run(&mut flat_resolver, directives)?; + directives = new_directives; + module32 = Some(new_module32); on_pass_end("convert_32bit_to_64bit"); } let directives = insert_implicit_conversions::run(&mut flat_resolver, directives)?; @@ -117,6 +122,7 @@ pub fn to_llvm_module<'input>( kernel_info: HashMap::new(), context, metadata: kernel_metadata::KernelMetadataV1::new(sm_version), + module32, }) } @@ -126,6 +132,7 @@ pub struct Module { pub kernel_info: HashMap, pub context: llvm_zluda::utils::Context, pub metadata: kernel_metadata::KernelMetadataV1, + pub module32: Option, } impl Module { @@ -134,6 +141,10 @@ impl Module { } } +struct Module32 { + globals: Vec<(String, Layout)>, +} + pub struct KernelInfo { pub arguments_sizes: Vec<(usize, bool)>, pub uses_shared_mem: bool, @@ -758,7 +769,7 @@ type NormalizedStatement = Statement< enum Directive2 { Variable(ast::LinkingDirective, ast::Variable), - Method(Function2), + Method(Function), } struct KernelAttributes { @@ -768,7 +779,7 @@ struct KernelAttributes { rounding_mode_f16f64: ast::RoundingMode, } -struct Function2 { +struct Function { pub return_arguments: Vec>, pub name: Operand::Ident, pub input_arguments: Vec>, @@ -777,9 +788,14 @@ struct Function2 { import_as: Option, tuning: Vec, linkage: ast::LinkingDirective, + kernel_meta32: Option, +} + +struct Function32 { + global_pointer_position: u32, } -impl Function2 { +impl Function { fn is_kernel(&self) -> bool { self.kernel_attributes.is_some() } @@ -793,7 +809,7 @@ type NormalizedDirective2 = Directive2< ast::ParsedOperand, >; -type NormalizedFunction2 = Function2< +type NormalizedFunction2 = Function< ( Option>, ast::Instruction>, @@ -805,7 +821,7 @@ type UnconditionalDirective = Directive2>, ast::ParsedOperand>; type UnconditionalFunction = - Function2>, ast::ParsedOperand>; + Function>, ast::ParsedOperand>; struct GlobalStringIdentResolver2<'input> { pub(crate) current_id: SpirvWord, diff --git a/ptx/src/pass/normalize_basic_blocks.rs b/ptx/src/pass/normalize_basic_blocks.rs index f51a17551..3c392c0c3 100644 --- a/ptx/src/pass/normalize_basic_blocks.rs +++ b/ptx/src/pass/normalize_basic_blocks.rs @@ -21,7 +21,7 @@ pub(crate) fn run( ) -> Result, SpirvWord>>, TranslateError> { for directive in directives.iter_mut() { let (body_ref, is_kernel) = match directive { - Directive2::Method(Function2 { + Directive2::Method(Function { body: Some(body), kernel_attributes, .. diff --git a/ptx/src/pass/normalize_identifiers.rs b/ptx/src/pass/normalize_identifiers.rs index 807e98b93..6a19ac92b 100644 --- a/ptx/src/pass/normalize_identifiers.rs +++ b/ptx/src/pass/normalize_identifiers.rs @@ -46,7 +46,7 @@ fn run_method<'input, 'b>( }) .transpose()?; resolver.end_scope(); - Ok(Function2 { + Ok(Function { return_arguments, name, input_arguments, @@ -60,6 +60,7 @@ fn run_method<'input, 'b>( rounding_mode_f16f64: ptx_parser::RoundingMode::NearestEven, }), tuning: method.tuning, + kernel_meta32: None, }) } diff --git a/ptx/src/pass/normalize_predicates.rs b/ptx/src/pass/normalize_predicates.rs index 02d3f7d27..e98fe5705 100644 --- a/ptx/src/pass/normalize_predicates.rs +++ b/ptx/src/pass/normalize_predicates.rs @@ -35,7 +35,7 @@ fn run_method<'input>( Ok::<_, TranslateError>(result) }) .transpose()?; - Ok(Function2 { + Ok(Function { body, return_arguments: method.return_arguments, name: method.name, @@ -44,6 +44,7 @@ fn run_method<'input>( tuning: method.tuning, linkage: method.linkage, kernel_attributes: method.kernel_attributes, + kernel_meta32: method.kernel_meta32, }) } diff --git a/ptx/src/pass/remove_unreachable_basic_blocks.rs b/ptx/src/pass/remove_unreachable_basic_blocks.rs index ebc48a2c8..75f93ceff 100644 --- a/ptx/src/pass/remove_unreachable_basic_blocks.rs +++ b/ptx/src/pass/remove_unreachable_basic_blocks.rs @@ -12,7 +12,7 @@ pub(crate) fn run( let mut reachable_funcs = FxHashSet::default(); for directive in directives.iter_mut() { match directive { - Directive2::Method(Function2 { + Directive2::Method(Function { body: Some(body), .. }) => { let old_body = std::mem::replace(body, Vec::new()); @@ -73,7 +73,7 @@ pub(crate) fn run( .into_iter() .filter(|directive| match directive { Directive2::Variable(..) => true, - Directive2::Method(Function2 { + Directive2::Method(Function { name, kernel_attributes, .. diff --git a/ptx/src/pass/replace_instructions_with_functions.rs b/ptx/src/pass/replace_instructions_with_functions.rs index c08aa0852..e7c368b7d 100644 --- a/ptx/src/pass/replace_instructions_with_functions.rs +++ b/ptx/src/pass/replace_instructions_with_functions.rs @@ -15,7 +15,7 @@ pub(super) fn run<'input>( let mut result = fn_declarations .into_iter() .map(|(_, (return_arguments, name, input_arguments))| { - Directive2::Method(Function2 { + Directive2::Method(Function { return_arguments, name: name, input_arguments, @@ -24,6 +24,7 @@ pub(super) fn run<'input>( tuning: Vec::new(), linkage: ast::LinkingDirective::EXTERN, kernel_attributes: None, + kernel_meta32: None, }) }) .collect::>(); diff --git a/ptx/src/pass/replace_instructions_with_functions_fp_required.rs b/ptx/src/pass/replace_instructions_with_functions_fp_required.rs index bb3bfee3b..832a5b4fe 100644 --- a/ptx/src/pass/replace_instructions_with_functions_fp_required.rs +++ b/ptx/src/pass/replace_instructions_with_functions_fp_required.rs @@ -26,7 +26,7 @@ pub(crate) fn run<'input>( Some(imports) => { let mut result = Vec::with_capacity(directives.len() + 2); result.extend([ - Directive2::Method(Function2 { + Directive2::Method(Function { return_arguments: vec![ ast::Variable { name: resolver.register_unnamed(Some(( @@ -109,8 +109,9 @@ pub(crate) fn run<'input>( tuning: Vec::new(), linkage: ast::LinkingDirective::EXTERN, kernel_attributes: None, + kernel_meta32: None, }), - Directive2::Method(Function2 { + Directive2::Method(Function { return_arguments: vec![ast::Variable { name: resolver.register_unnamed(Some(( ast::Type::Scalar(ast::ScalarType::F32), @@ -203,6 +204,7 @@ pub(crate) fn run<'input>( tuning: Vec::new(), linkage: ast::LinkingDirective::EXTERN, kernel_attributes: None, + kernel_meta32: None, }), ]); result.extend(directives); @@ -225,9 +227,9 @@ fn run_directive<'input>( fn run_method<'input>( resolver: &mut GlobalStringIdentResolver2<'input>, - mut method: Function2, SpirvWord>, + mut method: Function, SpirvWord>, imports: &mut Option, -) -> Result, SpirvWord>, TranslateError> { +) -> Result, SpirvWord>, TranslateError> { method.body = method.body.map(|body| { body.into_iter() .flat_map(|stmt| run_statement(resolver, stmt, imports)) diff --git a/ptx/src/pass/resolve_function_pointers.rs b/ptx/src/pass/resolve_function_pointers.rs index c2ed52266..a5a67f2c3 100644 --- a/ptx/src/pass/resolve_function_pointers.rs +++ b/ptx/src/pass/resolve_function_pointers.rs @@ -40,7 +40,7 @@ fn run_method<'input>( .collect::, _>>() }) .transpose()?; - Ok(Function2 { body, ..method }) + Ok(Function { body, ..method }) } fn run_statement<'input>( diff --git a/ptx/src/pass/test/mod.rs b/ptx/src/pass/test/mod.rs index ac095c061..65a3522a8 100644 --- a/ptx/src/pass/test/mod.rs +++ b/ptx/src/pass/test/mod.rs @@ -37,7 +37,7 @@ pub(crate) use test_pass; use crate::pass::IdentEntry; -use super::{Directive2, Function2, GlobalStringIdentResolver2, SpirvWord, Statement}; +use super::{Directive2, Function, GlobalStringIdentResolver2, SpirvWord, Statement}; fn directive2_vec_to_string( resolver: &GlobalStringIdentResolver2, @@ -69,7 +69,7 @@ fn directive_to_string( fn function_to_string( resolver: &GlobalStringIdentResolver2, - function: Function2, SpirvWord>, + function: Function, SpirvWord>, ) -> String { if function.import_as.is_some() || function.tuning.len() > 0 { todo!("Figure out some way of representing these in text"); From 9d514e23e3330020b5ab6605f8f6345b3bfbb8bf Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Sat, 2 May 2026 20:45:58 -0700 Subject: [PATCH 28/85] try different compiler approach --- ptx/src/pass/convert_32bit_to_64bit.rs | 77 ++++++++++++++++---- ptx/src/pass/insert_implicit_conversions.rs | 44 +++++++---- ptx/src/pass/llvm/emit.rs | 81 +++++++++++++++++---- ptx/src/pass/mod.rs | 7 +- 4 files changed, 165 insertions(+), 44 deletions(-) diff --git a/ptx/src/pass/convert_32bit_to_64bit.rs b/ptx/src/pass/convert_32bit_to_64bit.rs index 3f38773cc..178ec8734 100644 --- a/ptx/src/pass/convert_32bit_to_64bit.rs +++ b/ptx/src/pass/convert_32bit_to_64bit.rs @@ -1,7 +1,7 @@ use crate::{ pass::{ - error_todo, error_unreachable, Directive2, Function, GlobalStringIdentResolver2, Module32, - PtrAccess, SpirvWord, Statement, + error_todo, error_unreachable, Directive2, Function, Function32, + GlobalStringIdentResolver2, Module32, PtrAccess, SpirvWord, Statement, }, TranslateError, }; @@ -140,7 +140,8 @@ fn run_method<'input>( while let Some(Statement::Label(_)) = old_body.peek() { result.push(old_body.next().unwrap()); } - let hidden_ptr = add_hidden_argument( + let global_pointer_position = method.input_arguments.len(); + add_hidden_argument( resolver, ast::ScalarType::B64, &mut method.input_arguments, @@ -161,33 +162,34 @@ fn run_method<'input>( }) .collect::>(); for statement in old_body { - run_statement( - resolver, - &mut result, - hidden_ptr, - &globals_remapping, - statement, - )?; + run_statement(&mut result, &globals_remapping, statement)?; } *body = result; + method.kernel_meta32 = Some(Function32 { + global_pointer_position, + }); } Ok(method) } fn run_statement<'input>( - resolver: &mut GlobalStringIdentResolver2<'input>, result: &mut Vec, SpirvWord>>, - hidden_ptr: SpirvWord, globals_remapping: &FxHashMap, statement: Statement, SpirvWord>, ) -> Result<(), TranslateError> { let statement = - statement.visit_map(&mut |arg: SpirvWord, + statement.visit_map(&mut |mut arg: SpirvWord, _type_space: Option<(&ast::Type, ast::StateSpace)>, _is_dst: bool, _relaxed_type_check: bool| { - Ok(globals_remapping.get(&arg).copied().unwrap_or(arg)) + if let Some(new_arg) = globals_remapping.get(&arg) { + arg = *new_arg; + } + Ok(arg) })?; + result.push(statement); + Ok(()) + /* Ok(match statement { Statement::Instruction(ast::Instruction::Ld { data, @@ -269,6 +271,7 @@ fn run_statement<'input>( } s => result.push(s), }) + */ } fn add_hidden_argument<'input>( @@ -308,6 +311,52 @@ fn add_hidden_argument<'input>( implicit_argument } +fn ptr_access<'input>( + resolver: &mut GlobalStringIdentResolver2<'input>, + hidden_ptr: SpirvWord, + result: &mut Vec, SpirvWord>>, + (state_space, type_): (ast::StateSpace, ast::Type), + old_name: SpirvWord, +) -> Result { + // Offset is either a 32 bit scalar or a variable in the right state space + // If it's a scalar then we bitcast it, if it's a variable it will + // be resolved later, during implicit conversion + let (_, offset_space) = resolver.get_typed(old_name)?; + let converted_src = match offset_space { + ast::StateSpace::Reg => { + let zext_dst = resolver.register_unnamed(Some(( + ast::Type::Scalar(ast::ScalarType::B64), + ast::StateSpace::Reg, + ))); + let zext = Statement::Instruction(ast::Instruction::Cvt { + data: CvtDetails { + from: ast::ScalarType::B32, + to: ast::ScalarType::B64, + mode: ast::CvtMode::ZeroExtend, + }, + arguments: ast::CvtArgs { + dst: zext_dst, + src: old_name, + src2: None, + }, + }); + result.push(zext); + zext_dst + } + _ => old_name, + }; + let dst = resolver.register_unnamed(Some((type_.clone(), state_space))); + let ptr_access = Statement::PtrAccess(PtrAccess { + underlying_type: type_, + state_space: state_space, + dst, + ptr_src: hidden_ptr, + offset_src: converted_src, + }); + result.push(ptr_access); + Ok(dst) +} + fn replace_with_ptr_access<'input>( resolver: &mut GlobalStringIdentResolver2<'input>, hidden_ptr: SpirvWord, diff --git a/ptx/src/pass/insert_implicit_conversions.rs b/ptx/src/pass/insert_implicit_conversions.rs index 384beef6e..a361b19cd 100644 --- a/ptx/src/pass/insert_implicit_conversions.rs +++ b/ptx/src/pass/insert_implicit_conversions.rs @@ -18,16 +18,18 @@ use ptx_parser as ast; b64/u64/s64, which is bitcast to a pointer */ pub(super) fn run<'input>( + is_32bit: bool, resolver: &mut GlobalStringIdentResolver2<'input>, directives: Vec, SpirvWord>>, ) -> Result, SpirvWord>>, TranslateError> { directives .into_iter() - .map(|directive| run_directive(resolver, directive)) + .map(|directive| run_directive(is_32bit, resolver, directive)) .collect::, _>>() } fn run_directive<'a, 'input>( + is_32bit: bool, resolver: &mut GlobalStringIdentResolver2<'input>, directive: Directive2, SpirvWord>, ) -> Result, SpirvWord>, TranslateError> { @@ -36,7 +38,7 @@ fn run_directive<'a, 'input>( Directive2::Method(mut method) => { method.body = method .body - .map(|statements| run_statements(resolver, statements)) + .map(|statements| run_statements(is_32bit, resolver, statements)) .transpose()?; Directive2::Method(method) } @@ -44,17 +46,19 @@ fn run_directive<'a, 'input>( } fn run_statements<'input>( + is_32bit: bool, resolver: &mut GlobalStringIdentResolver2<'input>, func: Vec, ) -> Result, TranslateError> { let mut result = Vec::with_capacity(func.len()); for s in func.into_iter() { - insert_implicit_conversions_impl(resolver, &mut result, s)?; + insert_implicit_conversions_impl(is_32bit, resolver, &mut result, s)?; } Ok(result) } fn insert_implicit_conversions_impl<'input>( + is_32bit: bool, resolver: &mut GlobalStringIdentResolver2<'input>, func: &mut Vec, mut stmt: ExpandedStatement, @@ -100,6 +104,7 @@ fn insert_implicit_conversions_impl<'input>( match conversion_fn( (*operand_space, &operand_type), (instruction_space, instr_type), + is_32bit, )? { Some(conv_kind) => { let conv_output = if is_dst { &mut post_conv } else { &mut *func }; @@ -152,6 +157,7 @@ fn valid_vector_scalar_bitcast(operand_type: &ast::Type, instruction_type: &ast: fn default_implicit_conversion( (operand_space, operand_type): (ast::StateSpace, &ast::Type), (instruction_space, instruction_type): (ast::StateSpace, &ast::Type), + is_32bit: bool, ) -> Result, TranslateError> { if instruction_space == ast::StateSpace::Reg { if operand_space == ast::StateSpace::Reg { @@ -159,13 +165,17 @@ fn default_implicit_conversion( return Ok(Some(ConversionKind::Default)); } } else if let Some(byte_width) = is_addressable(operand_space) { - if byte_width <= instruction_type.layout().map(|l| l.size()).unwrap_or(0) { - return Ok(Some(ConversionKind::AddressOf)); - } + //if byte_width <= instruction_type.layout().map(|l| l.size()).unwrap_or(0) { + return Ok(Some(ConversionKind::AddressOf)); + //} } } if instruction_space != operand_space { - default_implicit_conversion_space((operand_space, operand_type), instruction_space) + default_implicit_conversion_space( + (operand_space, operand_type), + instruction_space, + is_32bit, + ) } else if instruction_type != operand_type { default_implicit_conversion_type(instruction_space, operand_type, instruction_type) } else { @@ -191,17 +201,21 @@ fn is_addressable(this: ast::StateSpace) -> Option { fn default_implicit_conversion_space( (operand_space, operand_type): (ast::StateSpace, &ast::Type), instruction_space: ast::StateSpace, + is_32bit: bool, ) -> Result, TranslateError> { if (instruction_space == ast::StateSpace::Generic && coerces_to_generic(operand_space)) || (operand_space == ast::StateSpace::Generic && coerces_to_generic(instruction_space)) { Ok(Some(ConversionKind::PtrToPtr)) } else if operand_space == ast::StateSpace::Reg { - match operand_type { + match (operand_type, is_32bit) { // TODO: 32 bit - ast::Type::Scalar(ast::ScalarType::B64) - | ast::Type::Scalar(ast::ScalarType::U64) - | ast::Type::Scalar(ast::ScalarType::S64) => match instruction_space { + (ast::Type::Scalar(ast::ScalarType::B64), false) + | (ast::Type::Scalar(ast::ScalarType::U64), false) + | (ast::Type::Scalar(ast::ScalarType::S64), false) + | (ast::Type::Scalar(ast::ScalarType::B32), true) + | (ast::Type::Scalar(ast::ScalarType::U32), true) + | (ast::Type::Scalar(ast::ScalarType::S32), true) => match instruction_space { ast::StateSpace::Global | ast::StateSpace::Generic | ast::StateSpace::Const @@ -210,9 +224,9 @@ fn default_implicit_conversion_space( | ast::StateSpace::Param => Ok(Some(ConversionKind::BitToPtr)), _ => Err(error_mismatched_type()), }, - ast::Type::Scalar(ast::ScalarType::B32) - | ast::Type::Scalar(ast::ScalarType::U32) - | ast::Type::Scalar(ast::ScalarType::S32) => match instruction_space { + (ast::Type::Scalar(ast::ScalarType::B32), _) + | (ast::Type::Scalar(ast::ScalarType::U32), _) + | (ast::Type::Scalar(ast::ScalarType::S32), _) => match instruction_space { ast::StateSpace::Local | ast::StateSpace::Shared => { Ok(Some(ConversionKind::BitToPtr)) } @@ -289,6 +303,7 @@ fn should_bitcast(instr: &ast::Type, operand: &ast::Type) -> bool { pub(crate) fn should_convert_relaxed_dst_wrapper( (operand_space, operand_type): (ast::StateSpace, &ast::Type), (instruction_space, instruction_type): (ast::StateSpace, &ast::Type), + _is_32bit: bool, ) -> Result, TranslateError> { if operand_space != instruction_space { return Err(error_mismatched_type()); @@ -367,6 +382,7 @@ fn should_convert_relaxed_dst( pub(crate) fn should_convert_relaxed_src_wrapper( (operand_space, operand_type): (ast::StateSpace, &ast::Type), (instruction_space, instruction_type): (ast::StateSpace, &ast::Type), + _is_32bit: bool, ) -> Result, TranslateError> { if operand_space != instruction_space { return Err(error_mismatched_type()); diff --git a/ptx/src/pass/llvm/emit.rs b/ptx/src/pass/llvm/emit.rs index 99247abae..01dfeef4b 100644 --- a/ptx/src/pass/llvm/emit.rs +++ b/ptx/src/pass/llvm/emit.rs @@ -66,13 +66,14 @@ pub(crate) fn run<'input>( context: &Context, id_defs: GlobalStringIdentResolver2<'input>, directives: Vec, SpirvWord>>, + is_32bit: bool, ) -> Result { let module = llvm::Module::new(context, LLVM_UNNAMED); - let mut emit_ctx = ModuleEmitContext::new(context, &module, &id_defs); + let mut emit_ctx = ModuleEmitContext::new(context, &module, &id_defs, is_32bit); for directive in directives { match directive { Directive2::Variable(linking, variable) => emit_ctx.emit_global(linking, variable)?, - Directive2::Method(method) => emit_ctx.emit_method(method)?, + Directive2::Method(method) => emit_ctx.emit_method(method, is_32bit)?, } } if cfg!(debug_assertions) { @@ -89,6 +90,7 @@ struct ModuleEmitContext<'a, 'input> { builder: Builder, id_defs: &'a GlobalStringIdentResolver2<'input>, resolver: ResolveIdent, + is_32bit: bool, } impl<'a, 'input> ModuleEmitContext<'a, 'input> { @@ -96,6 +98,7 @@ impl<'a, 'input> ModuleEmitContext<'a, 'input> { context: &Context, module: &llvm::Module, id_defs: &'a GlobalStringIdentResolver2<'input>, + is_32bit: bool, ) -> Self { ModuleEmitContext { context: context.get(), @@ -103,6 +106,7 @@ impl<'a, 'input> ModuleEmitContext<'a, 'input> { builder: Builder::new(context), id_defs, resolver: ResolveIdent::new(&id_defs), + is_32bit, } } @@ -117,6 +121,7 @@ impl<'a, 'input> ModuleEmitContext<'a, 'input> { fn emit_method( &mut self, method: Function, SpirvWord>, + is_32bit: bool, ) -> Result<(), TranslateError> { let name = method .import_as @@ -211,7 +216,12 @@ impl<'a, 'input> ModuleEmitContext<'a, 'input> { let real_bb = unsafe { LLVMAppendBasicBlockInContext(self.context, fn_, LLVM_UNNAMED.as_ptr()) }; unsafe { LLVMPositionBuilderAtEnd(self.builder.get(), real_bb) }; - let mut method_emitter = MethodEmitContext::new(self, fn_, variables_builder); + let base_32bit_memory = method + .kernel_meta32 + .as_ref() + .map(|m| unsafe { LLVMGetParam(fn_, m.global_pointer_position as u32) }); + let mut method_emitter = + MethodEmitContext::new(self, fn_, variables_builder, base_32bit_memory); for var in method.return_arguments { method_emitter.emit_variable(var)?; } @@ -463,6 +473,7 @@ struct MethodEmitContext<'a> { variables_builder: Builder, resolver: &'a mut ResolveIdent, carry_flag: Option, + base_32bit_memory: Option, } impl<'a> MethodEmitContext<'a> { @@ -470,6 +481,7 @@ impl<'a> MethodEmitContext<'a> { parent: &'a mut ModuleEmitContext, method: LLVMValueRef, variables_builder: Builder, + base_32bit_memory: Option, ) -> MethodEmitContext<'a> { MethodEmitContext { context: parent.context, @@ -479,6 +491,7 @@ impl<'a> MethodEmitContext<'a> { resolver: &mut parent.resolver, method, carry_flag: None, + base_32bit_memory: base_32bit_memory, } } @@ -724,10 +737,35 @@ impl<'a> MethodEmitContext<'a> { } ConversionKind::BitToPtr => { let src = self.resolver.value(conversion.src)?; - let type_ = get_pointer_type(self.context, conversion.to_space)?; - self.resolver.with_result(conversion.dst, |dst| unsafe { - LLVMBuildIntToPtr(builder, src, type_, dst) - }); + let ptr_type = get_pointer_type(self.context, conversion.to_space)?; + if let ( + Some(base32_ptr), + ast::StateSpace::Global | ast::StateSpace::Generic | ast::StateSpace::Const, + ) = (self.base_32bit_memory, conversion.to_space) + { + let i8_type = get_scalar_type(self.context, ast::ScalarType::B8); + let i64_type = get_scalar_type(self.context, ast::ScalarType::B64); + let base32 = unsafe { + LLVMBuildLoad2(builder, i64_type, base32_ptr, LLVM_UNNAMED.as_ptr()) + }; + let base32_typed = unsafe { + LLVMBuildIntToPtr(builder, base32, ptr_type, LLVM_UNNAMED.as_ptr()) + }; + self.resolver.with_result(conversion.dst, |dst| unsafe { + LLVMBuildInBoundsGEP2( + builder, + i8_type, + base32_typed, + [src].as_mut_ptr(), + 1, + dst, + ) + }); + } else { + self.resolver.with_result(conversion.dst, |dst| unsafe { + LLVMBuildIntToPtr(builder, src, ptr_type, dst) + }); + }; Ok(()) } ConversionKind::PtrToPtr => { @@ -741,9 +779,26 @@ impl<'a> MethodEmitContext<'a> { ConversionKind::AddressOf => { let src = self.resolver.value(conversion.src)?; let dst_type = get_type(self.context, &conversion.to_type)?; - self.resolver.with_result(conversion.dst, |dst| unsafe { - LLVMBuildPtrToInt(self.builder, src, dst_type, dst) - }); + if let ( + Some(base32_ptr), + ast::StateSpace::Global | ast::StateSpace::Generic | ast::StateSpace::Const, + ) = (self.base_32bit_memory, conversion.to_space) + { + let i64_type = get_scalar_type(self.context, ast::ScalarType::B64); + let base32 = unsafe { + LLVMBuildLoad2(builder, i64_type, base32_ptr, LLVM_UNNAMED.as_ptr()) + }; + let src_int = + unsafe { LLVMBuildPtrToInt(builder, src, i64_type, LLVM_UNNAMED.as_ptr()) }; + unsafe { LLVMBuildSub(builder, src_int, base32, LLVM_UNNAMED.as_ptr()) }; + self.resolver.with_result(conversion.dst, |dst| unsafe { + LLVMBuildTruncOrBitCast(builder, src, dst_type, dst) + }); + } else { + self.resolver.with_result(conversion.dst, |dst| unsafe { + LLVMBuildPtrToInt(builder, src, dst_type, dst) + }); + } Ok(()) } } @@ -3727,7 +3782,7 @@ fn get_function_type_impl<'a>( context: LLVMContextRef, mut return_args: impl DoubleEndedIterator + ExactSizeIterator, - input_args: impl ExactSizeIterator>, + input_args: impl Iterator>, struct_kind: StructKind, ) -> Result { let mut input_args = input_args.collect::, _>>()?; @@ -3754,7 +3809,7 @@ fn get_function_type<'a>( context: LLVMContextRef, return_args: impl DoubleEndedIterator + ExactSizeIterator, - input_args: impl ExactSizeIterator>, + input_args: impl Iterator>, ) -> Result { get_function_type_impl(context, return_args, input_args, StructKind::Named) } @@ -3763,7 +3818,7 @@ fn get_intrinsic_type<'a>( context: LLVMContextRef, return_args: impl DoubleEndedIterator + ExactSizeIterator, - input_args: impl ExactSizeIterator>, + input_args: impl Iterator>, ) -> Result { get_function_type_impl(context, return_args, input_args, StructKind::Anonymous) } diff --git a/ptx/src/pass/mod.rs b/ptx/src/pass/mod.rs index 264579395..e047904df 100644 --- a/ptx/src/pass/mod.rs +++ b/ptx/src/pass/mod.rs @@ -106,14 +106,15 @@ pub fn to_llvm_module<'input>( module32 = Some(new_module32); on_pass_end("convert_32bit_to_64bit"); } - let directives = insert_implicit_conversions::run(&mut flat_resolver, directives)?; + let directives = + insert_implicit_conversions::run(ast.address_size == 32, &mut flat_resolver, directives)?; on_pass_end("insert_implicit_conversions"); let directives = replace_instructions_with_functions::run(&mut flat_resolver, directives)?; on_pass_end("replace_instructions_with_functions"); let directives = hoist_globals::run(directives)?; on_pass_end("hoist_globals"); let context = llvm_zluda::utils::Context::new(); - let llvm_ir = llvm::emit::run(&context, flat_resolver, directives)?; + let llvm_ir = llvm::emit::run(&context, flat_resolver, directives, ast.address_size == 32)?; let attributes_ir = llvm::attributes::run(&context, attributes)?; on_pass_end("emit_llvm"); Ok(Module { @@ -792,7 +793,7 @@ struct Function { } struct Function32 { - global_pointer_position: u32, + global_pointer_position: usize, } impl Function { From 0eb85b55ec96cd8032cf04e6d9cbe0c855644e7d Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Mon, 11 May 2026 20:11:19 -0700 Subject: [PATCH 29/85] Add end-to-end 32bit compiler --- compiler/src/main.rs | 5 +- kernel_metadata/src/lib.rs | 176 ++++++--- llvm_zluda/src/compile.rs | 43 ++- llvm_zluda/src/utils.rs | 16 +- ptx/src/pass/convert_32bit_to_64bit.rs | 346 ++++++------------ ptx/src/pass/insert_implicit_conversions.rs | 13 +- ptx/src/pass/llvm/emit.rs | 34 +- ptx/src/pass/mod.rs | 31 +- .../test/insert_implicit_conversions/mod.rs | 3 +- ptx/src/test/spirv_run/32/activemask.ptx | 18 + ptx/src/test/spirv_run/32/add.ptx | 22 ++ ptx/src/test/spirv_run/32/atom_add.ptx | 28 ++ ptx/src/test/spirv_run/32/atom_add_float.ptx | 28 ++ ptx/src/test/spirv_run/32/const.ptx | 31 ++ ptx/src/test/spirv_run/32/extern_shared.ptx | 24 ++ ptx/src/test/spirv_run/32/shared_variable.ptx | 26 ++ ptx/src/test/spirv_run/mod.rs | 243 +++++++++++- zluda/src/impl/module.rs | 5 +- 18 files changed, 714 insertions(+), 378 deletions(-) create mode 100644 ptx/src/test/spirv_run/32/activemask.ptx create mode 100644 ptx/src/test/spirv_run/32/add.ptx create mode 100644 ptx/src/test/spirv_run/32/atom_add.ptx create mode 100644 ptx/src/test/spirv_run/32/atom_add_float.ptx create mode 100644 ptx/src/test/spirv_run/32/const.ptx create mode 100644 ptx/src/test/spirv_run/32/extern_shared.ptx create mode 100644 ptx/src/test/spirv_run/32/shared_variable.ptx diff --git a/compiler/src/main.rs b/compiler/src/main.rs index b208c8497..136d1e4ad 100644 --- a/compiler/src/main.rs +++ b/compiler/src/main.rs @@ -92,6 +92,7 @@ fn main_core() -> Result<(), CompilerError> { &llvm.linked_bitcode, llvm.attributes, llvm.metadata, + llvm.metadata32, Some(&compiler_hook), )?; report_pass_time("compile_bitcode", &mut start); @@ -127,6 +128,7 @@ fn ptx_to_llvm(ignore_errors: bool, ptx: &str) -> Result, llvm_ir: Vec, - metadata: kernel_metadata::KernelMetadataV1, + metadata: kernel_metadata::ModuleMetadataV1, + metadata32: Option, } fn get_gpu_arch(runtime: &hip::Runtime) -> Result { diff --git a/kernel_metadata/src/lib.rs b/kernel_metadata/src/lib.rs index 5aa8532bc..d4db9baf3 100644 --- a/kernel_metadata/src/lib.rs +++ b/kernel_metadata/src/lib.rs @@ -1,84 +1,138 @@ use object::read::elf::FileHeader as _; use object::write::elf as elf_write; use object::{elf, Endian, Endianness, Object, ObjectSection}; -use rkyv::{rancor, Archive, Deserialize, Serialize}; +use rkyv::api::high::HighSerializer; +use rkyv::ser::allocator::ArenaHandle; +use rkyv::util::AlignedVec; +use rkyv::{Archive, Deserialize, Portable, Serialize}; use static_assertions::assert_eq_align; use std::{io, mem}; #[derive(Archive, Serialize, Deserialize, Debug, PartialEq)] -pub struct KernelMetadataV1 { +pub struct ModuleMetadataV1 { pub sm_version: u32, } // If the alignment is larger than u64, then we need different padding -assert_eq_align!(ArchivedKernelMetadataV1, u32); +assert_eq_align!(ArchivedModuleMetadataV1, u32); -impl KernelMetadataV1 { +impl ModuleMetadataV1 { pub fn new(sm_version: u32) -> Self { Self { sm_version } } const SECTION: &'static str = "zluda"; + const VERSION: u64 = 1; pub fn write_object(&self, main_elf: &[u8], writer: &mut impl io::Write) -> io::Result<()> { - let main_header = elf::FileHeader64::::parse(main_elf) - .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e.to_string()))?; - let endian = main_header - .endian() - .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e.to_string()))?; - let data = rkyv::to_bytes::(self) - .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?; - let mut buf = Vec::new(); - let mut writer_elf = elf_write::Writer::new(endian, true, &mut buf); - writer_elf.reserve_file_header(); - let section_name = writer_elf.add_section_name(Self::SECTION.as_bytes()); - writer_elf.reserve_section_index(); - let section_offset = writer_elf.reserve(data.len() + mem::size_of::(), 8); - writer_elf.reserve_shstrtab_section_index(); - writer_elf.reserve_shstrtab(); - writer_elf.reserve_section_headers(); - writer_elf - .write_file_header(&elf_write::FileHeader { - os_abi: main_header.e_ident().os_abi, - abi_version: main_header.e_ident().abi_version, - e_type: main_header.e_type.get(endian), - e_machine: main_header.e_machine.get(endian), - e_entry: 0, - e_flags: main_header.e_flags.get(endian), - }) - .map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?; - writer_elf.write_align(8); - writer_elf.write(&endian.write_u64_bytes(1)); - writer_elf.write(&data); - writer_elf.write_shstrtab(); - writer_elf.write_null_section_header(); - writer_elf.write_section_header(&elf_write::SectionHeader { - name: Some(section_name), - sh_type: elf::SHT_PROGBITS, - sh_flags: 0, - sh_addr: 0, - sh_offset: section_offset as u64, - sh_size: (data.len() + mem::size_of::()) as u64, - sh_link: 0, - sh_info: 0, - sh_addralign: 8, - sh_entsize: 0, - }); - writer_elf.write_shstrtab_section_header(); - writer.write_all(&buf) + write_object(self, Self::SECTION, Self::VERSION, main_elf, writer) } - pub fn read_object(elf_bytes: &[u8]) -> Option { - let elf_file = object::read::elf::ElfFile64::::parse(elf_bytes).ok()?; - let zluda_section = elf_file.section_by_name(Self::SECTION)?; - let data = zluda_section.data().ok()?; - if data.len() < 8 { - return None; - } - let version = u64::from_le_bytes(data[..8].try_into().unwrap()); - if version != 1 { - return None; - } - rkyv::from_bytes::(&data[8..]).ok() + pub fn read_object<'a>(elf_bytes: &'a [u8]) -> Option<&'a ArchivedModuleMetadataV1> { + read_object(elf_bytes, Self::SECTION, Self::VERSION) } } + +#[derive(Archive, Serialize, Deserialize, Debug)] +pub struct Global32Bit { + pub name: String, + pub initializer: Vec, + pub align: u32, +} + +#[derive(Archive, Serialize, Deserialize, Debug)] +pub struct ModuleMetadata32Bit { + pub globals: Vec, + pub explicit_arg_count: Vec<(String, u32)>, +} + +// If the alignment is larger than u64, then we need different padding +assert_eq_align!(ArchivedModuleMetadata32Bit, u32); + +impl ModuleMetadata32Bit { + const SECTION: &'static str = "zluda32"; + const VERSION: u64 = 1; + + pub fn write_object(&self, main_elf: &[u8], writer: &mut impl io::Write) -> io::Result<()> { + write_object(self, Self::SECTION, Self::VERSION, main_elf, writer) + } + + pub fn read_object<'a>(elf_bytes: &'a [u8]) -> Option<&'a ArchivedModuleMetadata32Bit> { + read_object(elf_bytes, Self::SECTION, Self::VERSION) + } + + pub fn copy_object<'a>(elf_bytes: &'a [u8]) -> Option { + read_object::(elf_bytes, Self::SECTION, Self::VERSION) + .and_then(|archived| rkyv::deserialize::<_, rkyv::rancor::Failure>(archived).ok()) + } +} + +pub fn write_object( + this: &impl for<'a, 'b> Serialize< + HighSerializer, rkyv::rancor::Failure>, + >, + section: &str, + version: u64, + main_elf: &[u8], + writer: &mut impl io::Write, +) -> io::Result<()> { + let main_header = elf::FileHeader64::::parse(main_elf) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e.to_string()))?; + let endian = main_header + .endian() + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e.to_string()))?; + let data = rkyv::to_bytes::(this) + .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?; + let mut buf = Vec::new(); + let mut writer_elf = elf_write::Writer::new(endian, true, &mut buf); + writer_elf.reserve_file_header(); + let section_name = writer_elf.add_section_name(section.as_bytes()); + writer_elf.reserve_section_index(); + let section_offset = writer_elf.reserve(data.len() + mem::size_of::(), 8); + writer_elf.reserve_shstrtab_section_index(); + writer_elf.reserve_shstrtab(); + writer_elf.reserve_section_headers(); + writer_elf + .write_file_header(&elf_write::FileHeader { + os_abi: main_header.e_ident().os_abi, + abi_version: main_header.e_ident().abi_version, + e_type: main_header.e_type.get(endian), + e_machine: main_header.e_machine.get(endian), + e_entry: 0, + e_flags: main_header.e_flags.get(endian), + }) + .map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?; + writer_elf.write_align(8); + writer_elf.write(&endian.write_u64_bytes(version)); + writer_elf.write(&data); + writer_elf.write_shstrtab(); + writer_elf.write_null_section_header(); + writer_elf.write_section_header(&elf_write::SectionHeader { + name: Some(section_name), + sh_type: elf::SHT_PROGBITS, + sh_flags: 0, + sh_addr: 0, + sh_offset: section_offset as u64, + sh_size: (data.len() + mem::size_of::()) as u64, + sh_link: 0, + sh_info: 0, + sh_addralign: 8, + sh_entsize: 0, + }); + writer_elf.write_shstrtab_section_header(); + writer.write_all(&buf) +} + +fn read_object<'a, T: Portable>(elf_bytes: &'a [u8], section: &str, version: u64) -> Option<&'a T> { + let elf_file = object::read::elf::ElfFile64::::parse(elf_bytes).ok()?; + let zluda_section = elf_file.section_by_name(section)?; + let data = zluda_section.data().ok()?; + if data.len() < 8 { + return None; + } + let in_section_version = u64::from_le_bytes(data[..8].try_into().unwrap()); + if in_section_version != version { + return None; + } + Some(unsafe { rkyv::access_unchecked::(&data[8..]) }) +} diff --git a/llvm_zluda/src/compile.rs b/llvm_zluda/src/compile.rs index 8bb291a02..288dfa49d 100644 --- a/llvm_zluda/src/compile.rs +++ b/llvm_zluda/src/compile.rs @@ -15,8 +15,8 @@ use llvm_sys::{ }; use llvm_sys::{LLVMLinkage, LLVMVisibility}; use std::ffi::{CStr, CString}; -use std::fs; use std::sync::OnceLock; +use std::{fs, ptr}; use tempfile::NamedTempFile; const OCKL_MODULE: &[u8] = include_bytes!("device-libs/ockl.bc"); @@ -94,7 +94,8 @@ pub fn compile( main: Module, ptx_impl: &[u8], attributes: Module, - metadata: kernel_metadata::KernelMetadataV1, + metadata: kernel_metadata::ModuleMetadataV1, + metadata32: Option, compiler_hook: Option<&dyn Fn(&Vec, String)>, ) -> Result, String> { init_globals()?; @@ -197,17 +198,49 @@ pub fn compile( metadata .write_object(&object_file, section_path.as_file_mut()) .map_err(|e| format!("Failed to write metadata section: {}", e))?; + let section32_path = if let Some(metadata32) = metadata32 { + let mut section32_path = NamedTempFile::with_prefix("zluda32_section") + .map_err(|e| format!("Failed to create temporary file: {}", e))?; + metadata32 + .write_object(&object_file, section32_path.as_file_mut()) + .map_err(|e| format!("Failed to write 32-bit metadata section: {}", e))?; + Some(section32_path) + } else { + None + }; let object_path_cstr = path_to_cstring(&object_path)?; let section_path_cstr = path_to_cstring(section_path.as_ref())?; + let section32_path_cstr = section32_path + .as_ref() + .map(|p| path_to_cstring(p.as_ref())) + .transpose()?; let executable_path_cstr = path_to_cstring(&executable_path)?; - let inputs = [object_path_cstr.as_ptr(), section_path_cstr.as_ptr()]; + let (inputs, inputs_len) = if let Some(ref section32_path_cstr) = section32_path_cstr { + ( + [ + object_path_cstr.as_ptr(), + section_path_cstr.as_ptr(), + section32_path_cstr.as_ptr(), + ], + 3, + ) + } else { + ( + [ + object_path_cstr.as_ptr(), + section_path_cstr.as_ptr(), + ptr::null(), + ], + 2, + ) + }; let mut err = std::ptr::null_mut(); let result = unsafe { LLVMZludaLinkWithLLD( - inputs.len() as u32, + inputs_len, inputs.as_ptr(), executable_path_cstr.as_ptr(), &mut err, @@ -278,5 +311,5 @@ fn init_globals() -> Result<(), String> { }) .as_ref() .map(|()| ()) - .map_err(|e| e.to_str().to_owned()) + .map_err(|e| e.to_str().to_string()) } diff --git a/llvm_zluda/src/utils.rs b/llvm_zluda/src/utils.rs index 26efcd16b..f407bbb0e 100644 --- a/llvm_zluda/src/utils.rs +++ b/llvm_zluda/src/utils.rs @@ -1,7 +1,3 @@ -use std::ffi::CStr; -use std::ops::Deref; -use std::{mem, ptr}; - use llvm_sys::analysis::{LLVMVerifierFailureAction, LLVMVerifyModule}; use llvm_sys::bit_reader::LLVMParseBitcodeInContext2; use llvm_sys::bit_writer::LLVMWriteBitcodeToMemoryBuffer; @@ -18,6 +14,10 @@ use llvm_sys::target_machine::{ use llvm_sys::transforms::pass_builder::{ LLVMCreatePassBuilderOptions, LLVMDisposePassBuilderOptions, LLVMPassBuilderOptionsRef, }; +use std::borrow::Cow; +use std::ffi::CStr; +use std::ops::Deref; +use std::{mem, ptr}; pub struct Context(LLVMContextRef); @@ -83,7 +83,7 @@ impl Module { }; if error == 1 && err != ptr::null_mut() { let message = Message(unsafe { CStr::from_ptr(err) }); - Err(message.to_str().to_owned()) + Err(message.to_str().to_string()) } else { Ok(()) } @@ -162,8 +162,8 @@ impl Message { self.0.to_bytes() } - pub fn to_str(&self) -> &str { - self.0.to_str().unwrap().trim() + pub fn to_str<'a>(&'a self) -> Cow<'a, str> { + self.0.to_string_lossy() } } pub struct MemoryBuffer(LLVMMemoryBufferRef); @@ -239,7 +239,7 @@ impl TargetMachine { }; if status != 0 { let message = Message(unsafe { CStr::from_ptr(err) }); - Err(message.to_str().to_owned()) + Err(message.to_str().to_string()) } else { Ok(MemoryBuffer(buffer)) } diff --git a/ptx/src/pass/convert_32bit_to_64bit.rs b/ptx/src/pass/convert_32bit_to_64bit.rs index 178ec8734..5798f5071 100644 --- a/ptx/src/pass/convert_32bit_to_64bit.rs +++ b/ptx/src/pass/convert_32bit_to_64bit.rs @@ -1,13 +1,24 @@ +// This pass modifies modifies 32 bit module to run on 64 bit implementation +// It extracts each global variable (except `.shared`) and then goes through +// every global and: +// * If it's a global variable it gets erased +// * If it's a kernel: +// * We injects new arguments +// * 64 bit pointer to the global memory +// * For each global variable, a 32 bit pseudo-pointer +// A later pass will transform all loads from 32 bit pseudo-pointers into loads +// from the 64 bit pointer with an offset + use crate::{ pass::{ error_todo, error_unreachable, Directive2, Function, Function32, - GlobalStringIdentResolver2, Module32, PtrAccess, SpirvWord, Statement, + GlobalStringIdentResolver2, SpirvWord, Statement, }, TranslateError, }; -use ptx_parser::{self as ast, CvtDetails, LdDetails, RegOrImmediate}; +use kernel_metadata::{Global32Bit, ModuleMetadata32Bit}; +use ptx_parser::{self as ast, LdDetails, RegOrImmediate, Variable}; use rustc_hash::FxHashMap; -use std::alloc::Layout; pub(super) fn run<'input>( resolver: &mut GlobalStringIdentResolver2<'input>, @@ -15,27 +26,32 @@ pub(super) fn run<'input>( ) -> Result< ( Vec, SpirvWord>>, - Module32, + ModuleMetadata32Bit, ), TranslateError, > { - let globals = collect_globals(resolver, &directives)?; + let (global_ids, globals) = collect_globals(resolver, &directives)?; + let mut explicit_arg_count = Vec::new(); let directives = directives .into_iter() - .map(|directive| run_directive(resolver, directive, &globals)) + .filter_map(|directive| { + run_directive(resolver, directive, &global_ids, &mut explicit_arg_count).transpose() + }) .collect::, _>>()?; - let globals = globals - .into_iter() - .map(|(_, name, layout)| (name, layout)) - .collect(); - Ok((directives, Module32 { globals })) + Ok(( + directives, + ModuleMetadata32Bit { + globals, + explicit_arg_count, + }, + )) } pub(super) fn collect_globals<'a, 'input>( resolver: &mut GlobalStringIdentResolver2<'input>, directives: &[Directive2, SpirvWord>], -) -> Result, TranslateError> { - directives +) -> Result<(Vec, Vec), TranslateError> { + let (ids, globals): (Vec, Vec) = directives .iter() .filter_map(|directive| match directive { Directive2::Variable( @@ -47,7 +63,7 @@ pub(super) fn collect_globals<'a, 'input>( v_type: ast::Type::Array( None, - ast::ScalarType::U8 | ast::ScalarType::B8 | ast::ScalarType::S8, + ast::ScalarType::U8 | ast::ScalarType::B8, array_dims, ), state_space: ast::StateSpace::Const | ast::StateSpace::Global, @@ -59,76 +75,88 @@ pub(super) fn collect_globals<'a, 'input>( && array_init.iter().all(|x| { matches!( x, - RegOrImmediate::Imm(ptx_parser::ImmediateValue::U64(0)) - | RegOrImmediate::Imm(ptx_parser::ImmediateValue::S64(0)) + RegOrImmediate::Imm( + ptx_parser::ImmediateValue::U64(_) | ptx_parser::ImmediateValue::S64(_) + ) ) }) => { - Some(get_name_layout(resolver, align, array_dims, name)) + Some(get_global_details(resolver, align, array_init, *name)) } - Directive2::Variable( - _, - ast::Variable { - info: - ast::VariableInfo { - state_space: ast::StateSpace::Shared, - .. - }, - .. - }, - ) - | Directive2::Variable( - _, - ast::Variable { - info: - ast::VariableInfo { - v_type: ast::Type::Texref, - .. - }, - .. - }, - ) - | Directive2::Method(..) => None, + Directive2::Variable(_, var) if pass_through_variable(var) => None, + Directive2::Method(..) => None, _ => Some(Err(error_todo())), }) - .collect::, _>>() + .collect::, _>>()? + .into_iter() + .unzip(); + Ok((ids, globals)) +} + +fn pass_through_variable(variable: &Variable) -> bool { + matches!(variable.info.state_space, ast::StateSpace::Shared) + || matches!(variable.info.v_type, ast::Type::Texref) } -fn get_name_layout<'input>( +fn get_global_details<'input>( resolver: &mut GlobalStringIdentResolver2<'input>, align: &Option, - array_dims: &Vec, - name: &SpirvWord, -) -> Result<(SpirvWord, String, Layout), TranslateError> { - let entry = resolver.ident_map.get(name).ok_or_else(error_unreachable)?; + array_init: &Vec>, + name: SpirvWord, +) -> Result<(SpirvWord, Global32Bit), TranslateError> { + let entry = resolver + .ident_map + .get(&name) + .ok_or_else(error_unreachable)?; let text_name = entry .name .as_ref() .ok_or_else(error_unreachable)? .to_string(); + let align = align.unwrap_or(1); + let initializer = array_init + .iter() + .map(|x| match x { + RegOrImmediate::Imm(ptx_parser::ImmediateValue::U64(x)) => Ok(*x as u8), + RegOrImmediate::Imm(ptx_parser::ImmediateValue::S64(x)) => Ok(*x as u8), + _ => Err(error_unreachable()), + }) + .collect::, _>>()?; Ok(( - *name, - text_name, - Layout::from_size_align(array_dims[0] as usize, align.unwrap_or(1) as usize) - .map_err(|_| error_unreachable())?, + name, + Global32Bit { + name: text_name, + align, + initializer, + }, )) } fn run_directive<'input>( resolver: &mut GlobalStringIdentResolver2<'input>, directive: Directive2, SpirvWord>, - globals: &[(SpirvWord, String, Layout)], -) -> Result, SpirvWord>, TranslateError> { + globals_ids: &[SpirvWord], + explicit_arg_count: &mut Vec<(String, u32)>, +) -> Result, SpirvWord>>, TranslateError> { Ok(match directive { - var @ Directive2::Variable(..) => var, - Directive2::Method(method) => Directive2::Method(run_method(resolver, method, globals)?), + Directive2::Variable(linking, varinfo) if pass_through_variable(&varinfo) => { + Some(Directive2::Variable(linking, varinfo)) + } + Directive2::Method(method) => Some(Directive2::Method(run_method( + resolver, + method, + globals_ids, + explicit_arg_count, + )?)), + _ => None, }) } fn run_method<'input>( resolver: &mut GlobalStringIdentResolver2<'input>, mut method: Function, SpirvWord>, - globals: &[(SpirvWord, String, Layout)], + globals_ids: &[SpirvWord], + explicit_arg_count: &mut Vec<(String, u32)>, ) -> Result, SpirvWord>, TranslateError> { let is_kernel = method.is_kernel(); if let Some(ref mut body) = method.body { @@ -140,18 +168,31 @@ fn run_method<'input>( while let Some(Statement::Label(_)) = old_body.peek() { result.push(old_body.next().unwrap()); } - let global_pointer_position = method.input_arguments.len(); - add_hidden_argument( + let text_name = method + .import_as + .as_deref() + .or_else(|| { + resolver + .ident_map + .get(&method.name)? + .name + .as_ref() + .map(|x| x.as_ref()) + }) + .ok_or_else(error_unreachable)? + .to_string(); + explicit_arg_count.push((text_name, method.input_arguments.len() as u32)); + let implicit_memory_ptr = add_hidden_argument( resolver, ast::ScalarType::B64, &mut method.input_arguments, &mut result, ); - let globals_remapping = globals + let globals_remapping = globals_ids .iter() - .map(|(name, _, _)| { + .map(|&id| { ( - *name, + id, add_hidden_argument( resolver, ast::ScalarType::B32, @@ -166,7 +207,7 @@ fn run_method<'input>( } *body = result; method.kernel_meta32 = Some(Function32 { - global_pointer_position, + implicit_memory_ptr, }); } Ok(method) @@ -189,89 +230,6 @@ fn run_statement<'input>( })?; result.push(statement); Ok(()) - /* - Ok(match statement { - Statement::Instruction(ast::Instruction::Ld { - data, - mut arguments, - }) => { - if is_global_memory(data.state_space) { - replace_with_ptr_access( - resolver, - hidden_ptr, - result, - (data.state_space, data.typ.clone()), - &mut arguments.src, - )?; - } - result.push(Statement::Instruction(ast::Instruction::Ld { - data, - arguments, - })); - } - Statement::Instruction(ast::Instruction::St { - data, - mut arguments, - }) => { - if is_global_memory(data.state_space) { - replace_with_ptr_access( - resolver, - hidden_ptr, - result, - (data.state_space, data.typ.clone()), - &mut arguments.src1, - )?; - } - result.push(Statement::Instruction(ast::Instruction::St { - data, - arguments, - })); - } - Statement::PtrAccess(PtrAccess { - underlying_type, - state_space, - dst, - mut ptr_src, - offset_src, - }) => { - if is_global_memory(state_space) { - replace_with_ptr_access( - resolver, - hidden_ptr, - result, - (state_space, underlying_type.clone()), - &mut ptr_src, - )?; - } - result.push(Statement::PtrAccess(PtrAccess { - underlying_type, - state_space, - dst, - ptr_src, - offset_src, - })); - } - Statement::Instruction(ast::Instruction::Atom { - data, - mut arguments, - }) => { - if is_global_memory(data.space) { - replace_with_ptr_access( - resolver, - hidden_ptr, - result, - (data.space, data.type_.clone()), - &mut arguments.src1, - )?; - } - result.push(Statement::Instruction(ast::Instruction::Atom { - data, - arguments, - })); - } - s => result.push(s), - }) - */ } fn add_hidden_argument<'input>( @@ -310,103 +268,3 @@ fn add_hidden_argument<'input>( })); implicit_argument } - -fn ptr_access<'input>( - resolver: &mut GlobalStringIdentResolver2<'input>, - hidden_ptr: SpirvWord, - result: &mut Vec, SpirvWord>>, - (state_space, type_): (ast::StateSpace, ast::Type), - old_name: SpirvWord, -) -> Result { - // Offset is either a 32 bit scalar or a variable in the right state space - // If it's a scalar then we bitcast it, if it's a variable it will - // be resolved later, during implicit conversion - let (_, offset_space) = resolver.get_typed(old_name)?; - let converted_src = match offset_space { - ast::StateSpace::Reg => { - let zext_dst = resolver.register_unnamed(Some(( - ast::Type::Scalar(ast::ScalarType::B64), - ast::StateSpace::Reg, - ))); - let zext = Statement::Instruction(ast::Instruction::Cvt { - data: CvtDetails { - from: ast::ScalarType::B32, - to: ast::ScalarType::B64, - mode: ast::CvtMode::ZeroExtend, - }, - arguments: ast::CvtArgs { - dst: zext_dst, - src: old_name, - src2: None, - }, - }); - result.push(zext); - zext_dst - } - _ => old_name, - }; - let dst = resolver.register_unnamed(Some((type_.clone(), state_space))); - let ptr_access = Statement::PtrAccess(PtrAccess { - underlying_type: type_, - state_space: state_space, - dst, - ptr_src: hidden_ptr, - offset_src: converted_src, - }); - result.push(ptr_access); - Ok(dst) -} - -fn replace_with_ptr_access<'input>( - resolver: &mut GlobalStringIdentResolver2<'input>, - hidden_ptr: SpirvWord, - result: &mut Vec, SpirvWord>>, - (state_space, type_): (ast::StateSpace, ast::Type), - offset: &mut SpirvWord, -) -> Result<(), TranslateError> { - // Offset is either a 32 bit scalar or a variable in the right state space - // If it's a scalar then we bitcast it, if it's a variable it will - // be resolved later, during implicit conversion - let (_, offset_space) = resolver.get_typed(*offset)?; - let converted_src = match offset_space { - ast::StateSpace::Reg => { - let zext_dst = resolver.register_unnamed(Some(( - ast::Type::Scalar(ast::ScalarType::B64), - ast::StateSpace::Reg, - ))); - let zext = Statement::Instruction(ast::Instruction::Cvt { - data: CvtDetails { - from: ast::ScalarType::B32, - to: ast::ScalarType::B64, - mode: ast::CvtMode::ZeroExtend, - }, - arguments: ast::CvtArgs { - dst: zext_dst, - src: *offset, - src2: None, - }, - }); - result.push(zext); - zext_dst - } - _ => *offset, - }; - let dst = resolver.register_unnamed(Some((type_.clone(), state_space))); - let ptr_access = Statement::PtrAccess(PtrAccess { - underlying_type: type_, - state_space: state_space, - dst, - ptr_src: hidden_ptr, - offset_src: converted_src, - }); - result.push(ptr_access); - *offset = dst; - Ok(()) -} - -fn is_global_memory(state_space: ast::StateSpace) -> bool { - matches!( - state_space, - ast::StateSpace::Global | ast::StateSpace::Generic | ast::StateSpace::Const - ) -} diff --git a/ptx/src/pass/insert_implicit_conversions.rs b/ptx/src/pass/insert_implicit_conversions.rs index a361b19cd..1007bccdc 100644 --- a/ptx/src/pass/insert_implicit_conversions.rs +++ b/ptx/src/pass/insert_implicit_conversions.rs @@ -164,10 +164,8 @@ fn default_implicit_conversion( if valid_vector_scalar_bitcast(operand_type, instruction_type) { return Ok(Some(ConversionKind::Default)); } - } else if let Some(byte_width) = is_addressable(operand_space) { - //if byte_width <= instruction_type.layout().map(|l| l.size()).unwrap_or(0) { + } else if is_addressable(operand_space) { return Ok(Some(ConversionKind::AddressOf)); - //} } } if instruction_space != operand_space { @@ -183,14 +181,15 @@ fn default_implicit_conversion( } } -fn is_addressable(this: ast::StateSpace) -> Option { +fn is_addressable(this: ast::StateSpace) -> bool { match this { ast::StateSpace::Const | ast::StateSpace::Generic | ast::StateSpace::Global - | ast::StateSpace::ParamEntry => Some(8), - ast::StateSpace::Local | ast::StateSpace::Shared => Some(4), - ast::StateSpace::Param | ast::StateSpace::Reg => None, + | ast::StateSpace::ParamEntry + | ast::StateSpace::Local + | ast::StateSpace::Shared => true, + ast::StateSpace::Param | ast::StateSpace::Reg => false, ast::StateSpace::SharedCluster | ast::StateSpace::SharedCta | ast::StateSpace::ParamFunc => todo!(), diff --git a/ptx/src/pass/llvm/emit.rs b/ptx/src/pass/llvm/emit.rs index 01dfeef4b..3b4e71acf 100644 --- a/ptx/src/pass/llvm/emit.rs +++ b/ptx/src/pass/llvm/emit.rs @@ -66,14 +66,13 @@ pub(crate) fn run<'input>( context: &Context, id_defs: GlobalStringIdentResolver2<'input>, directives: Vec, SpirvWord>>, - is_32bit: bool, ) -> Result { let module = llvm::Module::new(context, LLVM_UNNAMED); - let mut emit_ctx = ModuleEmitContext::new(context, &module, &id_defs, is_32bit); + let mut emit_ctx = ModuleEmitContext::new(context, &module, &id_defs); for directive in directives { match directive { Directive2::Variable(linking, variable) => emit_ctx.emit_global(linking, variable)?, - Directive2::Method(method) => emit_ctx.emit_method(method, is_32bit)?, + Directive2::Method(method) => emit_ctx.emit_method(method)?, } } if cfg!(debug_assertions) { @@ -90,7 +89,6 @@ struct ModuleEmitContext<'a, 'input> { builder: Builder, id_defs: &'a GlobalStringIdentResolver2<'input>, resolver: ResolveIdent, - is_32bit: bool, } impl<'a, 'input> ModuleEmitContext<'a, 'input> { @@ -98,7 +96,6 @@ impl<'a, 'input> ModuleEmitContext<'a, 'input> { context: &Context, module: &llvm::Module, id_defs: &'a GlobalStringIdentResolver2<'input>, - is_32bit: bool, ) -> Self { ModuleEmitContext { context: context.get(), @@ -106,7 +103,6 @@ impl<'a, 'input> ModuleEmitContext<'a, 'input> { builder: Builder::new(context), id_defs, resolver: ResolveIdent::new(&id_defs), - is_32bit, } } @@ -121,7 +117,6 @@ impl<'a, 'input> ModuleEmitContext<'a, 'input> { fn emit_method( &mut self, method: Function, SpirvWord>, - is_32bit: bool, ) -> Result<(), TranslateError> { let name = method .import_as @@ -216,10 +211,7 @@ impl<'a, 'input> ModuleEmitContext<'a, 'input> { let real_bb = unsafe { LLVMAppendBasicBlockInContext(self.context, fn_, LLVM_UNNAMED.as_ptr()) }; unsafe { LLVMPositionBuilderAtEnd(self.builder.get(), real_bb) }; - let base_32bit_memory = method - .kernel_meta32 - .as_ref() - .map(|m| unsafe { LLVMGetParam(fn_, m.global_pointer_position as u32) }); + let base_32bit_memory = method.kernel_meta32.as_ref().map(|m| m.implicit_memory_ptr); let mut method_emitter = MethodEmitContext::new(self, fn_, variables_builder, base_32bit_memory); for var in method.return_arguments { @@ -473,7 +465,7 @@ struct MethodEmitContext<'a> { variables_builder: Builder, resolver: &'a mut ResolveIdent, carry_flag: Option, - base_32bit_memory: Option, + base_32bit_memory: Option, } impl<'a> MethodEmitContext<'a> { @@ -481,7 +473,7 @@ impl<'a> MethodEmitContext<'a> { parent: &'a mut ModuleEmitContext, method: LLVMValueRef, variables_builder: Builder, - base_32bit_memory: Option, + base_32bit_memory: Option, ) -> MethodEmitContext<'a> { MethodEmitContext { context: parent.context, @@ -739,15 +731,15 @@ impl<'a> MethodEmitContext<'a> { let src = self.resolver.value(conversion.src)?; let ptr_type = get_pointer_type(self.context, conversion.to_space)?; if let ( - Some(base32_ptr), + Some(base32), ast::StateSpace::Global | ast::StateSpace::Generic | ast::StateSpace::Const, ) = (self.base_32bit_memory, conversion.to_space) { let i8_type = get_scalar_type(self.context, ast::ScalarType::B8); let i64_type = get_scalar_type(self.context, ast::ScalarType::B64); - let base32 = unsafe { - LLVMBuildLoad2(builder, i64_type, base32_ptr, LLVM_UNNAMED.as_ptr()) - }; + let src_64 = + unsafe { LLVMBuildZExt(builder, src, i64_type, LLVM_UNNAMED.as_ptr()) }; + let base32 = self.resolver.value(base32)?; let base32_typed = unsafe { LLVMBuildIntToPtr(builder, base32, ptr_type, LLVM_UNNAMED.as_ptr()) }; @@ -756,7 +748,7 @@ impl<'a> MethodEmitContext<'a> { builder, i8_type, base32_typed, - [src].as_mut_ptr(), + [src_64].as_mut_ptr(), 1, dst, ) @@ -780,14 +772,12 @@ impl<'a> MethodEmitContext<'a> { let src = self.resolver.value(conversion.src)?; let dst_type = get_type(self.context, &conversion.to_type)?; if let ( - Some(base32_ptr), + Some(base32), ast::StateSpace::Global | ast::StateSpace::Generic | ast::StateSpace::Const, ) = (self.base_32bit_memory, conversion.to_space) { let i64_type = get_scalar_type(self.context, ast::ScalarType::B64); - let base32 = unsafe { - LLVMBuildLoad2(builder, i64_type, base32_ptr, LLVM_UNNAMED.as_ptr()) - }; + let base32 = self.resolver.value(base32)?; let src_int = unsafe { LLVMBuildPtrToInt(builder, src, i64_type, LLVM_UNNAMED.as_ptr()) }; unsafe { LLVMBuildSub(builder, src_int, base32, LLVM_UNNAMED.as_ptr()) }; diff --git a/ptx/src/pass/mod.rs b/ptx/src/pass/mod.rs index e047904df..04bceefb6 100644 --- a/ptx/src/pass/mod.rs +++ b/ptx/src/pass/mod.rs @@ -1,7 +1,6 @@ use ptx_parser as ast; use quick_error::quick_error; use rustc_hash::FxHashMap; -use std::alloc::Layout; use std::hash::Hash; use std::{ borrow::Cow, @@ -98,12 +97,12 @@ pub fn to_llvm_module<'input>( on_pass_end("instruction_mode_to_global_mode"); let mut directives = insert_explicit_load_store::run(&mut flat_resolver, directives)?; on_pass_end("insert_explicit_load_store"); - let mut module32 = None; + let mut metadata32 = None; if ast.address_size == 32 { let (new_directives, new_module32) = convert_32bit_to_64bit::run(&mut flat_resolver, directives)?; directives = new_directives; - module32 = Some(new_module32); + metadata32 = Some(new_module32); on_pass_end("convert_32bit_to_64bit"); } let directives = @@ -114,26 +113,24 @@ pub fn to_llvm_module<'input>( let directives = hoist_globals::run(directives)?; on_pass_end("hoist_globals"); let context = llvm_zluda::utils::Context::new(); - let llvm_ir = llvm::emit::run(&context, flat_resolver, directives, ast.address_size == 32)?; + let llvm_ir = llvm::emit::run(&context, flat_resolver, directives)?; let attributes_ir = llvm::attributes::run(&context, attributes)?; on_pass_end("emit_llvm"); Ok(Module { llvm_ir, attributes_ir, - kernel_info: HashMap::new(), context, - metadata: kernel_metadata::KernelMetadataV1::new(sm_version), - module32, + metadata: kernel_metadata::ModuleMetadataV1::new(sm_version), + metadata32, }) } pub struct Module { pub llvm_ir: llvm_zluda::utils::Module, pub attributes_ir: llvm_zluda::utils::Module, - pub kernel_info: HashMap, pub context: llvm_zluda::utils::Context, - pub metadata: kernel_metadata::KernelMetadataV1, - pub module32: Option, + pub metadata: kernel_metadata::ModuleMetadataV1, + pub metadata32: Option, } impl Module { @@ -142,15 +139,6 @@ impl Module { } } -struct Module32 { - globals: Vec<(String, Layout)>, -} - -pub struct KernelInfo { - pub arguments_sizes: Vec<(usize, bool)>, - pub uses_shared_mem: bool, -} - #[derive(Ord, PartialOrd, Eq, PartialEq, Hash, Copy, Clone, EnumIter)] enum PtxSpecialRegister { Tid, @@ -792,8 +780,11 @@ struct Function { kernel_meta32: Option, } +// We transform the method so that it takes an implicit pointer to memory as an +// additional argument, and all explicit memory accesses are done through that +// pointer struct Function32 { - global_pointer_position: usize, + implicit_memory_ptr: SpirvWord, } impl Function { diff --git a/ptx/src/pass/test/insert_implicit_conversions/mod.rs b/ptx/src/pass/test/insert_implicit_conversions/mod.rs index f36adb3db..92329ee80 100644 --- a/ptx/src/pass/test/insert_implicit_conversions/mod.rs +++ b/ptx/src/pass/test/insert_implicit_conversions/mod.rs @@ -15,7 +15,8 @@ fn run_insert_implicit_conversions(ptx: ptx_parser::Module) -> String { let directives = normalize_identifiers::run(&mut scoped_resolver, ptx.directives).unwrap(); let directives = normalize_predicates::run(&mut flat_resolver, directives).unwrap(); let directives = expand_operands::run(&mut flat_resolver, directives).unwrap(); - let directives = insert_implicit_conversions::run(&mut flat_resolver, directives).unwrap(); + let directives = + insert_implicit_conversions::run(false, &mut flat_resolver, directives).unwrap(); directive2_vec_to_string(&flat_resolver, directives) } diff --git a/ptx/src/test/spirv_run/32/activemask.ptx b/ptx/src/test/spirv_run/32/activemask.ptx new file mode 100644 index 000000000..d53031d62 --- /dev/null +++ b/ptx/src/test/spirv_run/32/activemask.ptx @@ -0,0 +1,18 @@ +.version 6.5 +.target sm_30 +.address_size 32 + +.visible .entry activemask( + .param .u32 input, + .param .u32 output +) +{ + .reg .u32 out_addr; + .reg .b32 temp; + + ld.param.u32 out_addr, [output]; + + activemask.b32 temp; + st.u32 [out_addr], temp; + ret; +} diff --git a/ptx/src/test/spirv_run/32/add.ptx b/ptx/src/test/spirv_run/32/add.ptx new file mode 100644 index 000000000..93e644318 --- /dev/null +++ b/ptx/src/test/spirv_run/32/add.ptx @@ -0,0 +1,22 @@ +.version 6.5 +.target sm_30 +.address_size 32 + +.visible .entry add( + .param .u32 input, + .param .u32 output +) +{ + .reg .u32 in_addr; + .reg .u32 out_addr; + .reg .u64 temp; + .reg .u64 temp2; + + ld.param.u32 in_addr, [input]; + ld.param.u32 out_addr, [output]; + + ld.u64 temp, [in_addr]; + add.u64 temp2, temp, 1; + st.u64 [out_addr], temp2; + ret; +} diff --git a/ptx/src/test/spirv_run/32/atom_add.ptx b/ptx/src/test/spirv_run/32/atom_add.ptx new file mode 100644 index 000000000..d70648113 --- /dev/null +++ b/ptx/src/test/spirv_run/32/atom_add.ptx @@ -0,0 +1,28 @@ +.version 6.5 +.target sm_30 +.address_size 32 + +.visible .entry atom_add( + .param .u32 input, + .param .u32 output +) +{ + .shared .align 4 .b8 shared_mem[1024]; + + .reg .u32 in_addr; + .reg .u32 out_addr; + .reg .u32 temp1; + .reg .u32 temp2; + + ld.param.u32 in_addr, [input]; + ld.param.u32 out_addr, [output]; + + ld.u32 temp1, [in_addr]; + ld.u32 temp2, [in_addr+4]; + st.shared.u32 [shared_mem], temp1; + atom.shared.add.u32 temp1, [shared_mem], temp2; + ld.shared.u32 temp2, [shared_mem]; + st.u32 [out_addr], temp1; + st.u32 [out_addr+4], temp2; + ret; +} diff --git a/ptx/src/test/spirv_run/32/atom_add_float.ptx b/ptx/src/test/spirv_run/32/atom_add_float.ptx new file mode 100644 index 000000000..94967ed61 --- /dev/null +++ b/ptx/src/test/spirv_run/32/atom_add_float.ptx @@ -0,0 +1,28 @@ +.version 6.5 +.target sm_30 +.address_size 32 + +.visible .entry atom_add_float( + .param .u32 input, + .param .u32 output +) +{ + .shared .align 4 .b8 shared_mem[1024]; + + .reg .u32 in_addr; + .reg .u32 out_addr; + .reg .f32 temp1; + .reg .f32 temp2; + + ld.param.u32 in_addr, [input]; + ld.param.u32 out_addr, [output]; + + ld.f32 temp1, [in_addr]; + ld.f32 temp2, [in_addr+4]; + st.shared.f32 [shared_mem], temp1; + atom.shared.add.f32 temp1, [shared_mem], temp2; + ld.shared.f32 temp2, [shared_mem]; + st.f32 [out_addr], temp1; + st.f32 [out_addr+4], temp2; + ret; +} diff --git a/ptx/src/test/spirv_run/32/const.ptx b/ptx/src/test/spirv_run/32/const.ptx new file mode 100644 index 000000000..d5a1eb294 --- /dev/null +++ b/ptx/src/test/spirv_run/32/const.ptx @@ -0,0 +1,31 @@ +.version 6.5 +.target sm_30 +.address_size 32 + +.const .align 8 .b8 constparams[4] = { 10, 20, 30, 40 }; + +.visible .entry const( + .param .u32 input, + .param .u32 output +) +{ + .reg .u32 in_addr; + .reg .u32 out_addr; + .reg .b16 temp1; + .reg .b16 temp2; + .reg .b16 temp3; + .reg .b16 temp4; + + ld.param.u32 in_addr, [input]; + ld.param.u32 out_addr, [output]; + + ld.const.b8 temp1, [constparams]; + ld.const.b8 temp2, [constparams+1]; + ld.const.b8 temp3, [constparams+2]; + ld.const.b8 temp4, [constparams+3]; + st.u16 [out_addr], temp1; + st.u16 [out_addr+2], temp2; + st.u16 [out_addr+4], temp3; + st.u16 [out_addr+6], temp4; + ret; +} diff --git a/ptx/src/test/spirv_run/32/extern_shared.ptx b/ptx/src/test/spirv_run/32/extern_shared.ptx new file mode 100644 index 000000000..5831ff7d1 --- /dev/null +++ b/ptx/src/test/spirv_run/32/extern_shared.ptx @@ -0,0 +1,24 @@ +.version 6.5 +.target sm_30 +.address_size 32 + +.extern .shared .b32 shared_mem []; + +.visible .entry extern_shared( + .param .u32 input, + .param .u32 output +) +{ + .reg .u32 in_addr; + .reg .u32 out_addr; + .reg .u64 temp; + + ld.param.u32 in_addr, [input]; + ld.param.u32 out_addr, [output]; + + ld.global.u64 temp, [in_addr]; + st.shared.u64 [shared_mem], temp; + ld.shared.u64 temp, [shared_mem]; + st.global.u64 [out_addr], temp; + ret; +} diff --git a/ptx/src/test/spirv_run/32/shared_variable.ptx b/ptx/src/test/spirv_run/32/shared_variable.ptx new file mode 100644 index 000000000..1e795d275 --- /dev/null +++ b/ptx/src/test/spirv_run/32/shared_variable.ptx @@ -0,0 +1,26 @@ +.version 6.5 +.target sm_30 +.address_size 32 + + +.visible .entry shared_variable( + .param .u32 input, + .param .u32 output +) +{ + .shared .align 4 .b8 shared_mem1[128]; + + .reg .u32 in_addr; + .reg .u32 out_addr; + .reg .u64 temp1; + .reg .u64 temp2; + + ld.param.u32 in_addr, [input]; + ld.param.u32 out_addr, [output]; + + ld.global.u64 temp1, [in_addr]; + st.shared.u64 [shared_mem1], temp1; + ld.shared.u64 temp2, [shared_mem1]; + st.global.u64 [out_addr], temp2; + ret; +} diff --git a/ptx/src/test/spirv_run/mod.rs b/ptx/src/test/spirv_run/mod.rs index 7aa0e8add..a0fed6eaa 100644 --- a/ptx/src/test/spirv_run/mod.rs +++ b/ptx/src/test/spirv_run/mod.rs @@ -2,14 +2,20 @@ use super::read_test_file; use crate::pass; use cuda_types::cuda::CUstream; use hip_runtime_sys::hipError_t; +use hip_runtime_sys::hipStream_t; +use kernel_metadata::ArchivedModuleMetadata32Bit; use pretty_assertions; +use std::alloc::Layout; +use std::borrow::Cow; use std::env; use std::error; use std::ffi::{CStr, CString}; use std::fmt::{self, Debug, Display, Formatter}; use std::fs::{self, File}; use std::io::Write; +use std::iter; use std::mem; +use std::os::raw::c_void; use std::path::Path; use std::ptr; use std::str; @@ -57,6 +63,46 @@ macro_rules! test_ptx { }; } +macro_rules! test_ptx_with_32 { + ($fn_name:ident, $input:expr, $output:expr) => { + paste::item! { + #[test] + fn [<$fn_name _amdgpu>]() -> Result<(), Box> { + let ptx = read_test_file!(concat!(stringify!($fn_name), ".ptx")); + let input = $input; + let output = $output; + test_hip_assert(stringify!($fn_name), &ptx, Some(&input), &output, 1) + } + } + + paste::item! { + #[test] + fn [<$fn_name _cuda>]() -> Result<(), Box> { + let ptx = read_test_file!(concat!(stringify!($fn_name), ".ptx")); + let input = $input; + let output = $output; + test_cuda_assert(stringify!($fn_name), &ptx, Some(&input), &output, 1) + } + } + + test_ptx_llvm!($fn_name); + + paste::item! { + #[test] + fn [<$fn_name _amdgpu32>]() -> Result<(), Box> { + let ptx = read_test_file!(concat!("32/", stringify!($fn_name), ".ptx")); + let input = $input; + let output = $output; + test_zluda32_assert(stringify!($fn_name), &ptx, Some(&input), &output, 1) + } + } + }; + + ($fn_name:ident) => { + test_ptx_llvm!($fn_name); + }; +} + macro_rules! test_ptx_warp { ($fn_name:ident, $output:expr) => { paste::item! { @@ -86,7 +132,7 @@ test_ptx!(ld_st_implicit, [0.5f32, 0.25f32], [0.5f32]); test_ptx!(mov, [1u64], [1u64]); test_ptx!(mul_lo, [1u64], [2u64]); test_ptx!(mul_hi, [u64::max_value()], [1u64]); -test_ptx!(add, [1u64], [2u64]); +test_ptx_with_32!(add, [1u64], [2u64]); test_ptx!( add_extended, [ @@ -220,7 +266,7 @@ test_ptx!(min_nan_f16); test_ptx!(max, [555i32, 444i32], [555i32]); test_ptx!(global_array, [0xDEADu32], [1u32]); test_ptx!(global_array_f32, [0x0], [0f32]); -test_ptx!(extern_shared, [127u64], [127u64]); +test_ptx_with_32!(extern_shared, [127u64], [127u64]); test_ptx!(extern_shared_call, [121u64], [123u64]); test_ptx!(rcp, [2f32], [0.5f32]); // 0b1_00000000_10000000000000000000000u32 is a large denormal @@ -252,11 +298,11 @@ test_ptx!( [0x40004040, 0x40404080, 0x40A04040], [1183860456u32] ); -test_ptx!(shared_variable, [513u64], [513u64]); +test_ptx_with_32!(shared_variable, [513u64], [513u64]); test_ptx!(shared_ptr_32, [513u64], [513u64]); test_ptx!(atom_cas, [91u32, 91u32], [91u32, 100u32]); test_ptx!(atom_inc, [100u32], [100u32, 101u32, 0u32]); -test_ptx!(atom_add, [2u32, 4u32], [2u32, 6u32]); +test_ptx_with_32!(atom_add, [2u32, 4u32], [2u32, 6u32]); test_ptx!(div_approx, [1f32, 2f32], [0.5f32]); test_ptx!(sqrt, [0.25f32], [0.5f32]); test_ptx!(sqrt_rn_ftz, [0x1u32], [0x0u32]); @@ -312,7 +358,7 @@ test_ptx!(cvt_s64_s32, [-1i32], [-1i64]); test_ptx!(add_tuning, [2u64], [3u64]); test_ptx!(add_non_coherent, [3u64], [4u64]); test_ptx!(sign_extend, [-1i16], [-1i32]); -test_ptx!(atom_add_float, [1.25f32, 0.5f32], [1.25f32, 1.75f32]); +test_ptx_with_32!(atom_add_float, [1.25f32, 0.5f32], [1.25f32, 1.75f32]); test_ptx!( setp_nan, [ @@ -343,7 +389,7 @@ test_ptx!( ); test_ptx!(non_scalar_ptr_offset, [1u32, 2u32, 3u32, 4u32], [7u32]); test_ptx!(stateful_neg_offset, [1237518u64], [1237518u64]); -test_ptx!(const, [0u16], [10u16, 20, 30, 40]); +test_ptx_with_32!(const, [0u16], [10u16, 20, 30, 40]); test_ptx!(const_ident, [0u16], [0u64, 0u64]); test_ptx!(cvt_s16_s8, [0x139231C2u32], [0xFFFFFFC2u32]); test_ptx!(cvt_f64_f32, [0.125f32], [0.125f64]); @@ -358,7 +404,7 @@ test_ptx!( [0x0100FE80u32, 0x00000000u32], [0x800080FFu32] ); -test_ptx!(activemask, [0u32], [1u32]); +test_ptx_with_32!(activemask, [0u32], [1u32]); test_ptx!(membar, [152731u32], [152731u32]); test_ptx!(shared_unify_extern, [7681u64, 7682u64], [15363u64]); test_ptx!(shared_unify_local, [16752u64, 714u64], [17466u64]); @@ -1148,6 +1194,32 @@ fn test_hip_assert< Ok(()) } +fn test_zluda32_assert< + Input: From + Debug + Copy + PartialEq, + Output: From + Debug + Copy + PartialEq + Default, +>( + name: &str, + ptx_text: &str, + input: Option<&[Input]>, + output: &[Output], + block_dim_x: u32, +) -> Result<(), Box> { + let ast = ptx_parser::parse_module_checked(&*ptx_text).unwrap(); + let name = CString::new(name)?; + let llvm_ir = pass::to_llvm_module( + ast, + pass::Attributes { + clock_rate: 2124000, + }, + |_| {}, + ) + .unwrap(); + let result = run_zluda32(name.as_c_str(), llvm_ir, input, output, block_dim_x) + .map_err(|err| DisplayError { err })?; + assert_eq!(result.as_slice(), output); + Ok(()) +} + fn test_llvm_assert( name: &str, ptx_text: &str, @@ -1173,7 +1245,7 @@ fn test_llvm_assert( Ok(()) } -fn compare_llvm(name: &str, actual_ll: &str, expected_ll: &str) { +fn compare_llvm(name: &str, actual_ll: Cow, expected_ll: &str) { if actual_ll != expected_ll { let output_dir = env::var("TEST_PTX_LLVM_FAIL_DIR"); if let Ok(output_dir) = output_dir { @@ -1355,6 +1427,7 @@ fn run_hip + Copy + Debug, Output: From + Copy + Debug + Def ptx_impl, module.attributes_ir, module.metadata, + module.metadata32, None, ) .unwrap(); @@ -1419,6 +1492,160 @@ fn run_hip + Copy + Debug, Output: From + Copy + Debug + Def Ok(result) } +fn run_zluda32 + Copy + Debug, Output: From + Copy + Debug + Default>( + name: &CStr, + module: pass::Module, + input: Option<&[Input]>, + output: &[Output], + block_dim_x: u32, +) -> Result, hipError_t> { + use hip_runtime_sys::*; + unsafe { hipInit(0) }.unwrap(); + let mut result = vec![0u8.into(); output.len()]; + { + let dev = 0; + let mut stream = unsafe { mem::zeroed() }; + unsafe { hipStreamCreate(&mut stream) }.unwrap(); + let mut dev_props = unsafe { mem::zeroed() }; + unsafe { hipGetDevicePropertiesR0600(&mut dev_props, dev) }.unwrap(); + let ptx_impl = module.linked_bitcode(); + let elf_module = llvm_zluda::compile( + &module.context, + unsafe { CStr::from_ptr(dev_props.gcnArchName.as_ptr()) } + .to_str() + .unwrap(), + module.llvm_ir, + ptx_impl, + module.attributes_ir, + module.metadata, + module.metadata32, + None, + ) + .unwrap(); + let zluda32 = kernel_metadata::ModuleMetadata32Bit::read_object(&elf_module).unwrap(); + assert_eq!(zluda32.explicit_arg_count.len(), 1); + assert_eq!(zluda32.explicit_arg_count[0].0, name.to_str().unwrap()); + assert_eq!(zluda32.explicit_arg_count[0].1, 2); + let mut module = unsafe { mem::zeroed() }; + unsafe { hipModuleLoadData(&mut module, elf_module.as_ptr() as _) }.unwrap(); + let mut kernel = unsafe { mem::zeroed() }; + unsafe { hipModuleGetFunction(&mut kernel, module, name.as_ptr()) }.unwrap(); + let mut buffer = ptr::null_mut(); + let argument_values = create_args32(&mut buffer, stream, zluda32, output, input); + let mut args = argument_values + .iter() + .map(|offset| std::ptr::from_ref(offset).cast::()) + .collect::>(); + unsafe { + hipModuleLaunchKernel( + kernel, + 1, + 1, + 1, + block_dim_x, + 1, + 1, + 1024, + stream, + args.as_mut_ptr().cast(), + ptr::null_mut(), + ) + } + .unwrap(); + unsafe { + hipMemcpyAsync( + result.as_mut_ptr() as _, + buffer.add(argument_values[if input.is_some() { 1 } else { 0 }]), + output.len() * mem::size_of::(), + hipMemcpyKind::hipMemcpyDeviceToHost, + stream, + ) + } + .unwrap(); + unsafe { hipStreamSynchronize(stream) }.unwrap(); + unsafe { hipFree(buffer) }.unwrap(); + unsafe { hipModuleUnload(module) }.unwrap(); + } + Ok(result) +} + +fn create_args32 + Copy + Debug, Output: From + Copy + Debug + Default>( + buffer: &mut *mut c_void, + stream: hipStream_t, + zluda32: &ArchivedModuleMetadata32Bit, + output: &[Output], + input: Option<&[Input]>, +) -> Vec { + use hip_runtime_sys::*; + let input_iter = input + .iter() + .map(|input| input.len() * mem::size_of::()); + let output = iter::once(output.len() * mem::size_of::()); + let globals = zluda32.globals.iter().map(|g| g.initializer.len()); + let layouts = compute_layouts(input_iter.chain(output).chain(iter::once(0)).chain(globals)) + .collect::>(); + let total_size = layouts.last().unwrap().0.size(); + // allocate buffer + unsafe { hipMalloc(buffer, total_size) }.unwrap(); + unsafe { hipMemset(*buffer, 0xff, total_size) }.unwrap(); + let mut args = layouts + .into_iter() + .map(|(_, offset)| offset) + .collect::>(); + // set input + if let Some(input) = input { + unsafe { + hipMemcpyWithStream( + (*buffer).add(args[0]), + input.as_ptr() as _, + input.len() * mem::size_of::(), + hipMemcpyKind::hipMemcpyHostToDevice, + stream, + ) + } + .unwrap(); + } + // set hidden memory ptr + let buffer_arg_index = if input.is_some() { 2 } else { 1 }; + args[buffer_arg_index] = *buffer as usize; + // set globals + for (offset, global) in args + .iter() + .skip(buffer_arg_index + 1) + .zip(zluda32.globals.iter()) + { + unsafe { + hipMemcpyWithStream( + (*buffer).add(*offset), + global.initializer.as_ptr().cast(), + global.initializer.len(), + hipMemcpyKind::hipMemcpyHostToDevice, + stream, + ) + } + .unwrap(); + } + args +} + +fn compute_layouts(sizes: impl Iterator) -> impl Iterator { + const ALIGN: usize = 128; + sizes.scan( + (Layout::from_size_align(ALIGN, ALIGN).unwrap(), 0usize), + |(layout, offset), size| { + if size == 0 { + return Some((*layout, 0)); + } + let (new_layout, new_offset) = layout + .extend(Layout::from_size_align(size, ALIGN).unwrap()) + .unwrap(); + *layout = new_layout; + *offset = new_offset; + Some((*layout, *offset)) + }, + ) +} + pub fn verify_symbols(test_name: &str, ctx: &llvm_zluda::utils::Context, elf_module: &[u8]) { // TODO: fix tests to not use public symbols for global arrays if [ diff --git a/zluda/src/impl/module.rs b/zluda/src/impl/module.rs index 3dfb291d4..c49051ddd 100644 --- a/zluda/src/impl/module.rs +++ b/zluda/src/impl/module.rs @@ -233,7 +233,9 @@ fn load_cached_binary( let binary = cache_with_key .as_mut() .and_then(|(c, key)| c.get_module_binary(key))?; - let sm_version = kernel_metadata::KernelMetadataV1::read_object(&binary)?.sm_version; + let sm_version = kernel_metadata::ModuleMetadataV1::read_object(&binary)? + .sm_version + .to_native(); Some((binary, sm_version)) } @@ -260,6 +262,7 @@ fn compile_and_cache( ptx_impl, llvm_module.attributes_ir, llvm_module.metadata, + llvm_module.metadata32, None, ) .map_err(|_| CUerror::UNKNOWN)?; From 30ffbc0f3e35a1c57f54405f5d38f74e1a92d2e9 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Sat, 18 Apr 2026 22:37:20 -0700 Subject: [PATCH 30/85] Add more cuSPARSE functions (#624) --- Cargo.lock | 1 + cuda_check/src/win.rs | 3 - ptx/src/pass/llvm/emit.rs | 93 +++++---- ptx/src/test/ll/set_gt_f16x2.ll | 51 +++++ ptx/src/test/spirv_run/mod.rs | 10 + ptx/src/test/spirv_run/set_gt_f16x2.ptx | 23 +++ ptx_parser/src/lib.rs | 5 +- ptx_parser_macros/src/lib.rs | 8 +- zluda/src/impl/memory.rs | 8 + zluda/src/lib.rs | 1 + zluda_blas/src/impl.rs | 32 ++-- zluda_blaslt/src/impl.rs | 24 ++- zluda_common/src/lib.rs | 62 ++++++ zluda_dnn/src/impl.rs | 4 + zluda_sparse/Cargo.toml | 1 + zluda_sparse/src/impl.rs | 244 +++++++++++++++++++++--- zluda_sparse/src/lib.rs | 58 +++++- 17 files changed, 542 insertions(+), 86 deletions(-) create mode 100644 ptx/src/test/ll/set_gt_f16x2.ll create mode 100644 ptx/src/test/spirv_run/set_gt_f16x2.ptx diff --git a/Cargo.lock b/Cargo.lock index 8beada521..1976b0fa8 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -5890,6 +5890,7 @@ dependencies = [ "embed-resource", "libloading", "rocsparse-sys", + "unwrap_or", "zluda_common", "zluda_windows", ] diff --git a/cuda_check/src/win.rs b/cuda_check/src/win.rs index cd5a9ffb6..b058ceaad 100644 --- a/cuda_check/src/win.rs +++ b/cuda_check/src/win.rs @@ -177,9 +177,6 @@ unsafe fn check_cusparse(library: libloading::Library) -> Result {} - Err(cuda_types::cusparse::cusparseError_t::NOT_SUPPORTED) => { - return Ok(hip_path()); - } Err(err) => { return Err(Error::Initialization( "cusparseCreate".to_string(), diff --git a/ptx/src/pass/llvm/emit.rs b/ptx/src/pass/llvm/emit.rs index 3b4e71acf..9a6cf1d1d 100644 --- a/ptx/src/pass/llvm/emit.rs +++ b/ptx/src/pass/llvm/emit.rs @@ -3232,39 +3232,66 @@ impl<'a> MethodEmitContext<'a> { }; let setp_result_0 = self.emit_setp_impl(data, None, src1_0, src2_0)?; let setp_result_1 = self.emit_setp_impl(data, None, src1_1, src2_1)?; - if dtype != ast::ScalarType::U32 { - return Err(error_unreachable()); - } - let setp_result_0 = self.setp_to_set(ast::ScalarType::U16, setp_result_0)?; - let setp_result_1 = self.setp_to_set(ast::ScalarType::U16, setp_result_1)?; - let vector_result = unsafe { - LLVMBuildInsertElement( - self.builder, - LLVMGetPoison(get_type( - self.context, - &ast::Type::Vector(2, ast::ScalarType::U16), - )?), - setp_result_0, - zero, - LLVM_UNNAMED.as_ptr(), - ) - }; - let vector_result = unsafe { - LLVMBuildInsertElement( - self.builder, - vector_result, - setp_result_1, - one, - LLVM_UNNAMED.as_ptr(), - ) - }; - unsafe { - LLVMBuildBitCast( - self.builder, - vector_result, - get_scalar_type(self.context, dtype), - LLVM_UNNAMED.as_ptr(), - ) + match dtype { + ast::ScalarType::U32 => { + let setp_result_0 = self.setp_to_set(ast::ScalarType::U16, setp_result_0)?; + let setp_result_1 = self.setp_to_set(ast::ScalarType::U16, setp_result_1)?; + let vector_result = unsafe { + LLVMBuildInsertElement( + self.builder, + LLVMGetPoison(get_type( + self.context, + &ast::Type::Vector(2, ast::ScalarType::U16), + )?), + setp_result_0, + zero, + LLVM_UNNAMED.as_ptr(), + ) + }; + let vector_result = unsafe { + LLVMBuildInsertElement( + self.builder, + vector_result, + setp_result_1, + one, + LLVM_UNNAMED.as_ptr(), + ) + }; + unsafe { + LLVMBuildBitCast( + self.builder, + vector_result, + get_scalar_type(self.context, dtype), + LLVM_UNNAMED.as_ptr(), + ) + } + } + ast::ScalarType::F16x2 => { + let setp_result_0 = self.setp_to_set(ast::ScalarType::F16, setp_result_0)?; + let setp_result_1 = self.setp_to_set(ast::ScalarType::F16, setp_result_1)?; + let vector_result = unsafe { + LLVMBuildInsertElement( + self.builder, + LLVMGetPoison(get_type( + self.context, + &ast::Type::Vector(2, ast::ScalarType::F16), + )?), + setp_result_0, + zero, + LLVM_UNNAMED.as_ptr(), + ) + }; + unsafe { + LLVMBuildInsertElement( + self.builder, + vector_result, + setp_result_1, + one, + LLVM_UNNAMED.as_ptr(), + ) + } + } + _ => return Err(error_unreachable()), } } else { let setp_result = self.emit_setp_impl(data.base, None, src1, src2)?; diff --git a/ptx/src/test/ll/set_gt_f16x2.ll b/ptx/src/test/ll/set_gt_f16x2.ll new file mode 100644 index 000000000..981d1ce90 --- /dev/null +++ b/ptx/src/test/ll/set_gt_f16x2.ll @@ -0,0 +1,51 @@ +define amdgpu_kernel void @set_gt_f16x2(ptr addrspace(4) byref(i64) %"46", ptr addrspace(4) byref(i64) %"47") #0 { + %"48" = alloca i64, align 8, addrspace(5) + %"49" = alloca i64, align 8, addrspace(5) + %"50" = alloca i32, align 4, addrspace(5) + %"51" = alloca i32, align 4, addrspace(5) + %"52" = alloca i32, align 4, addrspace(5) + %"53" = alloca <2 x half>, align 4, addrspace(5) + br label %1 + +1: ; preds = %0 + br label %"45" + +"45": ; preds = %1 + %2 = load i64, ptr addrspace(4) %"46", align 8 + store i64 %2, ptr addrspace(5) %"48", align 8 + %3 = load i64, ptr addrspace(4) %"47", align 8 + store i64 %3, ptr addrspace(5) %"49", align 8 + %4 = load i64, ptr addrspace(5) %"48", align 8 + %"65" = inttoptr i64 %4 to ptr + %"42" = getelementptr inbounds i8, ptr %"65", i64 4 + %5 = load i32, ptr %"42", align 4 + store i32 %5, ptr addrspace(5) %"50", align 4 + %6 = load i64, ptr addrspace(5) %"48", align 8 + %"66" = inttoptr i64 %6 to ptr + %"44" = getelementptr inbounds i8, ptr %"66", i64 8 + %7 = load i32, ptr %"44", align 4 + store i32 %7, ptr addrspace(5) %"51", align 4 + %8 = load i32, ptr addrspace(5) %"50", align 4 + %9 = load i32, ptr addrspace(5) %"51", align 4 + %"68" = bitcast i32 %8 to <2 x half> + %"69" = bitcast i32 %9 to <2 x half> + %10 = extractelement <2 x half> %"68", i8 0 + %11 = extractelement <2 x half> %"68", i8 1 + %12 = extractelement <2 x half> %"69", i8 0 + %13 = extractelement <2 x half> %"69", i8 1 + %14 = fcmp ogt half %10, %12 + %15 = fcmp ogt half %11, %13 + %16 = select i1 %14, half 0xH3C00, half 0xH0000 + %17 = select i1 %15, half 0xH3C00, half 0xH0000 + %18 = insertelement <2 x half> poison, half %16, i8 0 + %19 = insertelement <2 x half> %18, half %17, i8 1 + %"60" = bitcast <2 x half> %19 to i32 + store i32 %"60", ptr addrspace(5) %"52", align 4 + %20 = load i64, ptr addrspace(5) %"49", align 8 + %21 = load i32, ptr addrspace(5) %"52", align 4 + %"70" = inttoptr i64 %20 to ptr + store i32 %21, ptr %"70", align 4 + ret void +} + +attributes #0 = { "amdgpu-ieee"="false" "amdgpu-unsafe-fp-atomics"="true" "denormal-fp-math"="preserve-sign" "denormal-fp-math-f32"="preserve-sign" "no-trapping-math"="true" "target-features"="+wavefrontsize32,-wavefrontsize64,+cumode,+precise-memory" "uniform-work-group-size"="true" } diff --git a/ptx/src/test/spirv_run/mod.rs b/ptx/src/test/spirv_run/mod.rs index a0fed6eaa..1e81cddec 100644 --- a/ptx/src/test/spirv_run/mod.rs +++ b/ptx/src/test/spirv_run/mod.rs @@ -507,6 +507,16 @@ test_ptx!( ], [4294967295u32, 65535] ); +test_ptx!( + set_gt_f16x2, + [ + half::f16::from_f32(-0.0), + half::f16::from_bits(0x38d3), + half::f16::from_f32(0.0), + half::f16::from_bits(0x35aa), + ], + [1006632960u32] +); test_ptx!(uint_to_fp_bf16, [1u32, 3u32], [0x3F80u32]); test_ptx!(sad_s64, [12i64, -38, 915], [965i64, 965]); diff --git a/ptx/src/test/spirv_run/set_gt_f16x2.ptx b/ptx/src/test/spirv_run/set_gt_f16x2.ptx new file mode 100644 index 000000000..909e4aaf4 --- /dev/null +++ b/ptx/src/test/spirv_run/set_gt_f16x2.ptx @@ -0,0 +1,23 @@ +.version 6.5 +.target sm_60 +.address_size 64 + +.visible .entry set_gt_f16x2( + .param .u64 input, + .param .u64 output +) +{ + .reg .u64 in_addr; + .reg .u64 out_addr; + .reg .b32 in32_<3>; + .reg .f16x2 result; + + ld.param.u64 in_addr, [input]; + ld.param.u64 out_addr, [output]; + + ld.b32 in32_0, [in_addr+4]; + ld.b32 in32_1, [in_addr+8]; + set.gt.f16x2.f16x2 in32_2, in32_0, in32_1; + st.u32 [out_addr], in32_2; + ret; +} diff --git a/ptx_parser/src/lib.rs b/ptx_parser/src/lib.rs index 903ebfcab..7274c4a61 100644 --- a/ptx_parser/src/lib.rs +++ b/ptx_parser/src/lib.rs @@ -2516,11 +2516,11 @@ derive_parser!( } } - set.CmpOp{.ftz}.u32.f16x2 d, a, b => { + set.CmpOp{.ftz}.dtype_f16x2.f16x2 d, a, b => { let base = ast::SetpData::try_parse(state, cmpop, ftz, ScalarType::F16x2); let data = ast::SetData { base, - dtype: ScalarType::U32 + dtype: dtype_f16x2 }; ast::Instruction::Set { data, @@ -2550,6 +2550,7 @@ derive_parser!( .equ, .neu, .ltu, .leu, .gtu, .geu, .num, .nan }; // float-only .BoolOp: SetpBoolPostOp = { .and, .or, .xor }; .dtype: ScalarType = { .u32, .s32, .f32 }; + .dtype_f16x2: ScalarType = { .u32, .f16x2 }; .stype: ScalarType = { .b16, .b32, .b64, .u16, .u32, .u64, .s16, .s32, .s64, .f16, .f32, .f64 }; diff --git a/ptx_parser_macros/src/lib.rs b/ptx_parser_macros/src/lib.rs index 6c65af6f4..9000b74c5 100644 --- a/ptx_parser_macros/src/lib.rs +++ b/ptx_parser_macros/src/lib.rs @@ -315,7 +315,6 @@ impl SingleOpcodeDefinition { } Some(DotModifierRef::Indirect { value, .. }) => { let type_ = value.type_.to_token_stream().to_string(); - //panic!("{} {}", type_, POSTFIX_TYPES.contains(&&*type_)); POSTFIX_TYPES.contains(&&*type_) } None => break, @@ -326,6 +325,13 @@ impl SingleOpcodeDefinition { break; } } + // Observably, if there's a single type specifier it can be passed + // out of order. E.g. nonsense like "lg2.f32.ftz.approx" is fine + if result.len() == 1 { + unordered_modifiers.push(result.pop().unwrap()); + } + // If all modifiers are ordered, move single unordered modifier to + // the ordered list for better performance if unordered_modifiers.len() == 1 { result.push(unordered_modifiers.pop().unwrap()); } diff --git a/zluda/src/impl/memory.rs b/zluda/src/impl/memory.rs index 755f4977d..800fad641 100644 --- a/zluda/src/impl/memory.rs +++ b/zluda/src/impl/memory.rs @@ -319,6 +319,14 @@ pub(crate) unsafe fn copy_hto_a_v2( hipMemcpyHtoA(dst_array, dst_offset, src_host, byte_count) } +pub(crate) unsafe fn copy_dto_d_v2( + dst_device: hipDeviceptr_t, + src_device: hipDeviceptr_t, + byte_count: usize, +) -> hipError_t { + hipMemcpyDtoD(dst_device, src_device, byte_count) +} + pub(crate) unsafe fn copy_3d_v2(memcpy: HIP_MEMCPY3D) -> hipError_t { hipDrvMemcpy3D(&memcpy) } diff --git a/zluda/src/lib.rs b/zluda/src/lib.rs index 8be5e47d4..5fe1a5c62 100644 --- a/zluda/src/lib.rs +++ b/zluda/src/lib.rs @@ -145,6 +145,7 @@ cuda_macros::cuda_function_declarations!( cuMemcpy2DUnaligned_v2, cuMemcpy3D_v2, cuMemcpyAsync, + cuMemcpyDtoD_v2, cuMemcpyDtoDAsync_v2, cuMemcpyDtoH_v2_ptds, cuMemcpyDtoH_v2, diff --git a/zluda_blas/src/impl.rs b/zluda_blas/src/impl.rs index 3b2abe325..671e24b8f 100644 --- a/zluda_blas/src/impl.rs +++ b/zluda_blas/src/impl.rs @@ -91,25 +91,27 @@ pub(crate) fn create_v2(handle: &mut cublasHandle_t) -> cublasStatus_t { Ok(()) } -pub(crate) fn get_status_name(_status: cublasStatus_t) -> *const ::core::ffi::c_char { - todo!() +pub(crate) fn get_status_name(status: cublasStatus_t) -> *const ::core::ffi::c_char { + match status { + cublasStatus_t::SUCCESS => c"CUBLAS_STATUS_SUCCESS".as_ptr(), + cublasStatus_t::ERROR_NOT_INITIALIZED => c"CUBLAS_STATUS_NOT_INITIALIZED".as_ptr(), + cublasStatus_t::ERROR_ALLOC_FAILED => c"CUBLAS_STATUS_ALLOC_FAILED".as_ptr(), + cublasStatus_t::ERROR_INVALID_VALUE => c"CUBLAS_STATUS_INVALID_VALUE".as_ptr(), + cublasStatus_t::ERROR_ARCH_MISMATCH => c"CUBLAS_STATUS_ARCH_MISMATCH".as_ptr(), + cublasStatus_t::ERROR_MAPPING_ERROR => c"CUBLAS_STATUS_MAPPING_ERROR".as_ptr(), + cublasStatus_t::ERROR_EXECUTION_FAILED => c"CUBLAS_STATUS_EXECUTION_FAILED".as_ptr(), + cublasStatus_t::ERROR_INTERNAL_ERROR => c"CUBLAS_STATUS_INTERNAL_ERROR".as_ptr(), + cublasStatus_t::ERROR_NOT_SUPPORTED => c"CUBLAS_STATUS_NOT_SUPPORTED".as_ptr(), + cublasStatus_t::ERROR_LICENSE_ERROR => c"CUBLAS_STATUS_LICENSE_ERROR".as_ptr(), + _ => c"CUBLAS_STATUS_UNKNOWN".as_ptr(), + } } pub(crate) fn get_status_string(status: cublasStatus_t) -> *const ::core::ffi::c_char { - match status { - cublasStatus_t::SUCCESS => "CUBLAS_STATUS_SUCCESS\0", - cublasStatus_t::ERROR_NOT_INITIALIZED => "CUBLAS_STATUS_NOT_INITIALIZED\0", - cublasStatus_t::ERROR_ALLOC_FAILED => "CUBLAS_STATUS_ALLOC_FAILED\0", - cublasStatus_t::ERROR_INVALID_VALUE => "CUBLAS_STATUS_INVALID_VALUE\0", - cublasStatus_t::ERROR_ARCH_MISMATCH => "CUBLAS_STATUS_ARCH_MISMATCH\0", - cublasStatus_t::ERROR_MAPPING_ERROR => "CUBLAS_STATUS_MAPPING_ERROR\0", - cublasStatus_t::ERROR_EXECUTION_FAILED => "CUBLAS_STATUS_EXECUTION_FAILED\0", - cublasStatus_t::ERROR_INTERNAL_ERROR => "CUBLAS_STATUS_INTERNAL_ERROR\0", - cublasStatus_t::ERROR_NOT_SUPPORTED => "CUBLAS_STATUS_NOT_SUPPORTED\0", - cublasStatus_t::ERROR_LICENSE_ERROR => "CUBLAS_STATUS_LICENSE_ERROR\0", - _ => "CUBLAS_STATUS_UNKNOWN\0", + if cfg!(windows) && status.is_err() && status.err() == rocblas().err().map(Into::into) { + return c"rocblas.dll could not be found. Please install HIP SDK: https://zluda.readthedocs.io/latest/hip_sdk.html".as_ptr(); } - .as_ptr() as *const ::core::ffi::c_char + get_status_name(status) } pub(crate) fn xerbla(_sr_name: *const ::core::ffi::c_char, _info: ::core::ffi::c_int) -> () { diff --git a/zluda_blaslt/src/impl.rs b/zluda_blaslt/src/impl.rs index 8dcc476ff..b5cb70c41 100644 --- a/zluda_blaslt/src/impl.rs +++ b/zluda_blaslt/src/impl.rs @@ -85,12 +85,28 @@ pub(crate) fn unimplemented() -> cublasStatus_t { cublasStatus_t::ERROR_NOT_SUPPORTED } -pub(crate) fn get_status_name(_status: cublasStatus_t) -> *const ::core::ffi::c_char { - todo!() +// Same as in zluda_blas +pub(crate) fn get_status_name(status: cublasStatus_t) -> *const ::core::ffi::c_char { + match status { + cublasStatus_t::SUCCESS => c"CUBLAS_STATUS_SUCCESS".as_ptr(), + cublasStatus_t::ERROR_NOT_INITIALIZED => c"CUBLAS_STATUS_NOT_INITIALIZED".as_ptr(), + cublasStatus_t::ERROR_ALLOC_FAILED => c"CUBLAS_STATUS_ALLOC_FAILED".as_ptr(), + cublasStatus_t::ERROR_INVALID_VALUE => c"CUBLAS_STATUS_INVALID_VALUE".as_ptr(), + cublasStatus_t::ERROR_ARCH_MISMATCH => c"CUBLAS_STATUS_ARCH_MISMATCH".as_ptr(), + cublasStatus_t::ERROR_MAPPING_ERROR => c"CUBLAS_STATUS_MAPPING_ERROR".as_ptr(), + cublasStatus_t::ERROR_EXECUTION_FAILED => c"CUBLAS_STATUS_EXECUTION_FAILED".as_ptr(), + cublasStatus_t::ERROR_INTERNAL_ERROR => c"CUBLAS_STATUS_INTERNAL_ERROR".as_ptr(), + cublasStatus_t::ERROR_NOT_SUPPORTED => c"CUBLAS_STATUS_NOT_SUPPORTED".as_ptr(), + cublasStatus_t::ERROR_LICENSE_ERROR => c"CUBLAS_STATUS_LICENSE_ERROR".as_ptr(), + _ => c"CUBLAS_STATUS_UNKNOWN".as_ptr(), + } } -pub(crate) fn get_status_string(_status: cublasStatus_t) -> *const ::core::ffi::c_char { - todo!() +pub(crate) fn get_status_string(status: cublasStatus_t) -> *const ::core::ffi::c_char { + if cfg!(windows) && status.is_err() && status.err() == hipblaslt().err().map(Into::into) { + return c"Neither hipblaslt.dll nor libhipblaslt.dll could be found. Please install HIP SDK: https://zluda.readthedocs.io/latest/hip_sdk.html".as_ptr(); + } + get_status_name(status) } pub(crate) fn get_version() -> usize { diff --git a/zluda_common/src/lib.rs b/zluda_common/src/lib.rs index 4d76b3c93..02fa9817a 100644 --- a/zluda_common/src/lib.rs +++ b/zluda_common/src/lib.rs @@ -279,6 +279,13 @@ from_cuda_transmute!( cudnn9::cudnnFilterDescriptor_t => miopenTensorDescriptor_t, cudnn9::cudnnConvolutionDescriptor_t => miopenConvolutionDescriptor_t, cusparseHandle_t => rocsparse_handle, + cusparseMatrixType_t => rocsparse_matrix_type, + cusparseConstSpMatDescr_t => rocsparse_const_spmat_descr, + cusparseDnMatDescr_t => rocsparse_dnmat_descr, + cusparseConstDnMatDescr_t => rocsparse_const_dnmat_descr, + cusparseIndexType_t => rocsparse_indextype, + cusparseIndexBase_t => rocsparse_index_base, + cusparseMatDescr_t => rocsparse_mat_descr, CUtexObject => hipTextureObject_t, CUDA_RESOURCE_DESC => HIP_RESOURCE_DESC, CUDA_TEXTURE_DESC => HIP_TEXTURE_DESC, @@ -333,6 +340,45 @@ fn from_memory_type(cuda: CUmemorytype) -> Result FromCuda<'a, cusparseSpMMAlg_t, E> for rocsparse_spmm_alg { + fn from_cuda(alg: &'a cusparseSpMMAlg_t) -> Result { + Ok(match *alg { + cusparseSpMMAlg_t::CUSPARSE_SPMM_BLOCKED_ELL_ALG1 => { + rocsparse_spmm_alg::rocsparse_spmm_alg_default + } + cusparseSpMMAlg_t::CUSPARSE_SPMM_BSR_ALG1 => rocsparse_spmm_alg::rocsparse_spmm_alg_bsr, + _ => rocsparse_spmm_alg::rocsparse_spmm_alg_default, + }) + } +} + +impl<'a, E: CudaErrorType> FromCuda<'a, cusparseOperation_t, E> for rocsparse_operation { + fn from_cuda(operation: &'a cusparseOperation_t) -> Result { + Ok(match *operation { + cusparseOperation_t::CUSPARSE_OPERATION_NON_TRANSPOSE => { + rocsparse_operation::rocsparse_operation_none + } + cusparseOperation_t::CUSPARSE_OPERATION_TRANSPOSE => { + rocsparse_operation::rocsparse_operation_transpose + } + cusparseOperation_t::CUSPARSE_OPERATION_CONJUGATE_TRANSPOSE => { + rocsparse_operation::rocsparse_operation_conjugate_transpose + } + _ => return Err(E::NOT_SUPPORTED), + }) + } +} + +impl<'a, E: CudaErrorType> FromCuda<'a, cusparseOrder_t, E> for rocsparse_order { + fn from_cuda(order: &'a cusparseOrder_t) -> Result { + Ok(match *order { + cusparseOrder_t::CUSPARSE_ORDER_COL => rocsparse_order::rocsparse_order_column, + cusparseOrder_t::CUSPARSE_ORDER_ROW => rocsparse_order::rocsparse_order_row, + _ => return Err(E::NOT_SUPPORTED), + }) + } +} + impl<'a, E: CudaErrorType> FromCuda<'a, CUjit_option, E> for hipJitOption { fn from_cuda(option: &'a CUjit_option) -> Result { Ok(match *option { @@ -384,6 +430,22 @@ impl<'a, E: CudaErrorType> FromCuda<'a, CUjit_option, E> for hipJitOption { } } +impl<'a, E: CudaErrorType> FromCuda<'a, cudaDataType, E> for rocsparse_datatype { + fn from_cuda(type_: &'a cudaDataType) -> Result { + Ok(match *type_ { + cudaDataType::CUDA_R_32F => rocsparse_datatype::rocsparse_datatype_f32_r, + cudaDataType::CUDA_R_64F => rocsparse_datatype::rocsparse_datatype_f64_r, + cudaDataType::CUDA_C_32F => rocsparse_datatype::rocsparse_datatype_f32_c, + cudaDataType::CUDA_C_64F => rocsparse_datatype::rocsparse_datatype_f64_c, + cudaDataType::CUDA_R_8I => rocsparse_datatype::rocsparse_datatype_i8_r, + cudaDataType::CUDA_R_8U => rocsparse_datatype::rocsparse_datatype_u8_r, + cudaDataType::CUDA_R_32I => rocsparse_datatype::rocsparse_datatype_i32_r, + cudaDataType::CUDA_R_32U => rocsparse_datatype::rocsparse_datatype_u32_r, + _ => return Err(E::NOT_SUPPORTED), + }) + } +} + impl<'a, E: CudaErrorType> FromCuda<'a, CUlimit, E> for hipLimit_t { fn from_cuda(limit: &'a CUlimit) -> Result { Ok(match *limit { diff --git a/zluda_dnn/src/impl.rs b/zluda_dnn/src/impl.rs index 92ad81cf1..45ec0ed9e 100644 --- a/zluda_dnn/src/impl.rs +++ b/zluda_dnn/src/impl.rs @@ -1481,6 +1481,10 @@ pub mod dnn9 { } pub(crate) fn get_error_string(status: cudnnStatus_t) -> *const ::core::ffi::c_char { + if cfg!(windows) && status.is_err() && status.err() == super::miopen().err().map(Into::into) + { + return c"MIOpen.dll could not be found. Please install HIP SDK: https://zluda.readthedocs.io/latest/hip_sdk.html".as_ptr(); + } match status { Ok(()) => c"CUDNN_STATUS_SUCCESS", Err(err) => match err { diff --git a/zluda_sparse/Cargo.toml b/zluda_sparse/Cargo.toml index bad3ce7da..a6614c907 100644 --- a/zluda_sparse/Cargo.toml +++ b/zluda_sparse/Cargo.toml @@ -12,6 +12,7 @@ cuda_macros = { path = "../cuda_macros" } cuda_types = { path = "../cuda_types" } rocsparse-sys = { path = "../ext/rocsparse-sys" } zluda_common = { path = "../zluda_common" } +unwrap_or = "1.0.1" [package.metadata.zluda] linux_symlinks = ["libcusparse.so.10", "libcusparse.so.11", "libcusparse.so.12"] diff --git a/zluda_sparse/src/impl.rs b/zluda_sparse/src/impl.rs index ade0c0740..ead861435 100644 --- a/zluda_sparse/src/impl.rs +++ b/zluda_sparse/src/impl.rs @@ -1,6 +1,7 @@ use cuda_types::cusparse::*; use rocsparse_sys::*; -use std::sync::OnceLock; +use std::{ptr, sync::OnceLock}; +use unwrap_or::unwrap_ok_or; fn rocsparse() -> Result<&'static super::RocsparseVtable, rocsparse_error> { static LOCK: OnceLock> = OnceLock::new(); @@ -19,46 +20,243 @@ pub(crate) fn unimplemented() -> cusparseStatus_t { cusparseStatus_t::ERROR_NOT_SUPPORTED } -pub(crate) fn get_error_name( - _status: cuda_types::cusparse::cusparseStatus_t, +pub(crate) unsafe fn get_error_name( + status: cuda_types::cusparse::cusparseStatus_t, ) -> *const ::core::ffi::c_char { - todo!() + match status { + Ok(()) => c"CUSPARSE_STATUS_SUCCESS".as_ptr(), + Err(cusparseError_t::NOT_INITIALIZED) => c"CUSPARSE_STATUS_NOT_INITIALIZED".as_ptr(), + Err(cusparseError_t::ALLOC_FAILED) => c"CUSPARSE_STATUS_ALLOC_FAILED".as_ptr(), + Err(cusparseError_t::INVALID_VALUE) => c"CUSPARSE_STATUS_INVALID_VALUE".as_ptr(), + Err(cusparseError_t::ARCH_MISMATCH) => c"CUSPARSE_STATUS_ARCH_MISMATCH".as_ptr(), + Err(cusparseError_t::MAPPING_ERROR) => c"CUSPARSE_STATUS_MAPPING_ERROR".as_ptr(), + Err(cusparseError_t::EXECUTION_FAILED) => c"CUSPARSE_STATUS_EXECUTION_FAILED".as_ptr(), + Err(cusparseError_t::INTERNAL_ERROR) => c"CUSPARSE_STATUS_INTERNAL_ERROR".as_ptr(), + Err(cusparseError_t::MATRIX_TYPE_NOT_SUPPORTED) => { + c"CUSPARSE_STATUS_MATRIX_TYPE_NOT_SUPPORTED".as_ptr() + } + Err(cusparseError_t::ZERO_PIVOT) => c"CUSPARSE_STATUS_ZERO_PIVOT".as_ptr(), + Err(cusparseError_t::NOT_SUPPORTED) => c"CUSPARSE_STATUS_NOT_SUPPORTED".as_ptr(), + Err(cusparseError_t::INSUFFICIENT_RESOURCES) => { + c"CUSPARSE_STATUS_INSUFFICIENT_RESOURCES".as_ptr() + } + Err(_) => c"CUSPARSE_STATUS_INTERNAL_ERROR".as_ptr(), + } } -pub(crate) fn get_error_string( - _status: cuda_types::cusparse::cusparseStatus_t, +pub(crate) unsafe fn get_error_string( + status: cuda_types::cusparse::cusparseStatus_t, ) -> *const ::core::ffi::c_char { - todo!() + if cfg!(windows) && status.is_err() && status.err() == rocsparse().err().map(Into::into) { + return c"rocsparse.dll could not be found. Please install HIP SDK: https://zluda.readthedocs.io/latest/hip_sdk.html".as_ptr(); + } + get_error_name(status) } -pub(crate) fn get_mat_type( - _descr_a: cuda_types::cusparse::cusparseMatDescr_t, -) -> cuda_types::cusparse::cusparseMatrixType_t { - todo!() +pub(crate) unsafe fn get_mat_index_base(descr_a: rocsparse_mat_descr) -> rocsparse_index_base { + let rocsparse = unwrap_ok_or!( + rocsparse(), + _, + return rocsparse_index_base::rocsparse_index_base_zero + ); + rocsparse.rocsparse_get_mat_index_base(descr_a) } -pub(crate) fn get_mat_fill_mode( - _descr_a: cuda_types::cusparse::cusparseMatDescr_t, -) -> cuda_types::cusparse::cusparseFillMode_t { - todo!() +pub(crate) unsafe fn get_mat_type(descr: rocsparse_mat_descr) -> rocsparse_matrix_type { + let rocsparse = unwrap_ok_or!( + rocsparse(), + _, + return rocsparse_matrix_type::rocsparse_matrix_type_general + ); + rocsparse.rocsparse_get_mat_type(descr) } -pub(crate) fn get_mat_diag_type( - _descr_a: cuda_types::cusparse::cusparseMatDescr_t, -) -> cuda_types::cusparse::cusparseDiagType_t { - todo!() +pub(crate) unsafe fn get_mat_fill_mode(descr: rocsparse_mat_descr) -> rocsparse_fill_mode { + let rocsparse = unwrap_ok_or!( + rocsparse(), + _, + return rocsparse_fill_mode::rocsparse_fill_mode_lower + ); + rocsparse.rocsparse_get_mat_fill_mode(descr) } -pub(crate) fn get_mat_index_base( - _descr_a: cuda_types::cusparse::cusparseMatDescr_t, -) -> cuda_types::cusparse::cusparseIndexBase_t { - todo!() +pub(crate) unsafe fn get_mat_diag_type(descr: rocsparse_mat_descr) -> rocsparse_diag_type { + let rocsparse = unwrap_ok_or!( + rocsparse(), + _, + return rocsparse_diag_type::rocsparse_diag_type_non_unit + ); + rocsparse.rocsparse_get_mat_diag_type(descr) } pub(crate) unsafe fn create(context: *mut rocsparse_handle) -> rocsparse_status { rocsparse()?.rocsparse_create_handle(context) } +pub(crate) unsafe fn create_const_coo( + descr: *mut rocsparse_const_spmat_descr, + rows: i64, + cols: i64, + nnz: i64, + coo_row_ind: *const ::core::ffi::c_void, + coo_col_ind: *const ::core::ffi::c_void, + coo_values: *const ::core::ffi::c_void, + idx_type: rocsparse_indextype, + idx_base: rocsparse_index_base, + data_type: rocsparse_datatype, +) -> rocsparse_status { + rocsparse()?.rocsparse_create_const_coo_descr( + descr, + rows, + cols, + nnz, + coo_row_ind as *const _, + coo_col_ind as *const _, + coo_values as *const _, + idx_type, + idx_base, + data_type, + ) +} + +pub(crate) unsafe fn create_const_dn_mat( + descr: *mut rocsparse_const_dnmat_descr, + rows: i64, + cols: i64, + ld: i64, + values: *const ::core::ffi::c_void, + data_type: rocsparse_datatype, + order: rocsparse_order, +) -> rocsparse_status { + rocsparse()?.rocsparse_create_const_dnmat_descr( + descr, + rows, + cols, + ld, + values as *const _, + data_type, + order, + ) +} + +pub(crate) unsafe fn create_dn_mat( + descr: *mut rocsparse_dnmat_descr, + rows: i64, + cols: i64, + ld: i64, + values: *mut ::core::ffi::c_void, + data_type: rocsparse_datatype, + order: rocsparse_order, +) -> rocsparse_status { + rocsparse()?.rocsparse_create_dnmat_descr( + descr, + rows, + cols, + ld, + values as *mut _, + data_type, + order, + ) +} + pub(crate) unsafe fn destroy(context: rocsparse_handle) -> rocsparse_status { rocsparse()?.rocsparse_destroy_handle(context) } + +pub(crate) unsafe fn destroy_dn_mat(descr: rocsparse_const_dnmat_descr) -> rocsparse_status { + rocsparse()?.rocsparse_destroy_dnmat_descr(descr) +} + +pub(crate) unsafe fn destroy_sp_mat(descr: rocsparse_const_spmat_descr) -> rocsparse_status { + rocsparse()?.rocsparse_destroy_spmat_descr(descr) +} + +pub(crate) unsafe fn sp_m_m_buffer_size( + handle: rocsparse_handle, + op_a: rocsparse_operation, + op_b: rocsparse_operation, + alpha: *const ::core::ffi::c_void, + mat_a: rocsparse_const_spmat_descr, + mat_b: rocsparse_const_dnmat_descr, + beta: *const ::core::ffi::c_void, + mat_c: rocsparse_dnmat_descr, + compute_type: rocsparse_datatype, + alg: rocsparse_spmm_alg, + buffer_size: *mut usize, +) -> rocsparse_status { + rocsparse()?.rocsparse_spmm( + handle, + op_a, + op_b, + alpha, + mat_a, + mat_b, + beta, + mat_c, + compute_type, + alg, + rocsparse_spmm_stage::rocsparse_spmm_stage_buffer_size, + buffer_size, + ptr::null_mut(), + ) +} + +pub(crate) unsafe fn sp_m_m_preprocess( + handle: rocsparse_handle, + op_a: rocsparse_operation, + op_b: rocsparse_operation, + alpha: *const ::core::ffi::c_void, + mat_a: rocsparse_const_spmat_descr, + mat_b: rocsparse_const_dnmat_descr, + beta: *const ::core::ffi::c_void, + mat_c: rocsparse_dnmat_descr, + compute_type: rocsparse_datatype, + alg: rocsparse_spmm_alg, + external_buffer: *mut ::core::ffi::c_void, +) -> rocsparse_status { + rocsparse()?.rocsparse_spmm( + handle, + op_a, + op_b, + alpha, + mat_a, + mat_b, + beta, + mat_c, + compute_type, + alg, + rocsparse_spmm_stage::rocsparse_spmm_stage_preprocess, + &mut 0, + external_buffer, + ) +} + +pub(crate) unsafe fn sp_m_m( + handle: rocsparse_handle, + op_a: rocsparse_operation, + op_b: rocsparse_operation, + alpha: *const ::core::ffi::c_void, + mat_a: rocsparse_const_spmat_descr, + mat_b: rocsparse_const_dnmat_descr, + beta: *const ::core::ffi::c_void, + mat_c: rocsparse_dnmat_descr, + compute_type: rocsparse_datatype, + alg: rocsparse_spmm_alg, + external_buffer: *mut ::core::ffi::c_void, +) -> rocsparse_status { + rocsparse()?.rocsparse_spmm( + handle, + op_a, + op_b, + alpha, + mat_a, + mat_b, + beta, + mat_c, + compute_type, + alg, + rocsparse_spmm_stage::rocsparse_spmm_stage_compute, + &mut 0, + external_buffer, + ) +} diff --git a/zluda_sparse/src/lib.rs b/zluda_sparse/src/lib.rs index 5c37aede4..6ae899d90 100644 --- a/zluda_sparse/src/lib.rs +++ b/zluda_sparse/src/lib.rs @@ -41,18 +41,50 @@ macro_rules! implemented_unmapped { }; } +macro_rules! implemented_no_error { + ($($abi:literal fn $fn_name:ident( $($arg_id:ident : $arg_type:ty),* ) -> $ret_type:ty;)*) => { + $( + #[cfg_attr(not(test), no_mangle)] + #[allow(improper_ctypes)] + #[allow(improper_ctypes_definitions)] + pub unsafe extern $abi fn $fn_name ( $( $arg_id : $arg_type),* ) -> $ret_type { + use unwrap_or::unwrap_ok_or; + let result = cuda_macros::cusparse_normalize_fn!( crate::r#impl::$fn_name ) ($( + unwrap_ok_or!( + zluda_common::FromCuda::<_, cuda_types::cusparse::cusparseError_t>::from_cuda(&$arg_id), + _, + return std::mem::zeroed() + ) + ),*); + std::mem::transmute(result) + } + )* + }; +} + cuda_macros::cusparse_function_declarations!( unimplemented, - implemented_unmapped + implemented_unmapped <= [cusparseGetErrorName, cusparseGetErrorString,], + implemented_no_error <= [ - cusparseGetErrorName, - cusparseGetErrorString, cusparseGetMatDiagType, cusparseGetMatFillMode, cusparseGetMatIndexBase, cusparseGetMatType, ], - implemented <= [cusparseCreate, cusparseDestroy,] + implemented + <= [ + cusparseCreate, + cusparseCreateConstCoo, + cusparseCreateConstDnMat, + cusparseCreateDnMat, + cusparseDestroy, + cusparseDestroyDnMat, + cusparseDestroySpMat, + cusparseSpMM_bufferSize, + cusparseSpMM_preprocess, + cusparseSpMM, + ] ); macro_rules! noop { @@ -121,5 +153,21 @@ mod os_macro { cuda_macros::rocsparse_function_declarations!( noop, - os_macro::vtable_impl <= [rocsparse_create_handle, rocsparse_destroy_handle,] + os_macro::vtable_impl + <= [ + rocsparse_create_const_coo_descr, + rocsparse_create_const_dnmat_descr, + rocsparse_create_dnmat_descr, + rocsparse_create_handle, + rocsparse_destroy_dnmat_descr, + rocsparse_destroy_handle, + rocsparse_destroy_spmat_descr, + rocsparse_get_mat_diag_type, + rocsparse_get_mat_fill_mode, + rocsparse_get_mat_index_base, + rocsparse_get_mat_type, + rocsparse_spmm_buffer_size, + rocsparse_spmm_preprocess, + rocsparse_spmm, + ] ); From c8fc9360f38af7ca70ddaf683a14e2096275b65d Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Sun, 26 Apr 2026 12:23:21 -0700 Subject: [PATCH 31/85] Support vshr.u32.u32.u32.clamp.add (#629) --- ptx/src/pass/insert_post_saturation.rs | 3 +- .../instruction_mode_to_global_mode/mod.rs | 3 +- ptx/src/pass/llvm/emit.rs | 50 ++++++++++++++++ ptx/src/test/ll/vshr_clamp.ll | 58 +++++++++++++++++++ ptx/src/test/spirv_run/mod.rs | 5 ++ ptx/src/test/spirv_run/vshr_clamp.ptx | 25 ++++++++ ptx_parser/src/ast.rs | 18 +++++- ptx_parser/src/lib.rs | 56 ++++++++++++++++++ 8 files changed, 215 insertions(+), 3 deletions(-) create mode 100644 ptx/src/test/ll/vshr_clamp.ll create mode 100644 ptx/src/test/spirv_run/vshr_clamp.ptx diff --git a/ptx/src/pass/insert_post_saturation.rs b/ptx/src/pass/insert_post_saturation.rs index e3e03a33d..1a7e7fbf6 100644 --- a/ptx/src/pass/insert_post_saturation.rs +++ b/ptx/src/pass/insert_post_saturation.rs @@ -209,7 +209,8 @@ fn run_instruction<'input>( | ast::Instruction::Sad { .. } | ast::Instruction::Dp2a { .. } | ast::Instruction::Tex { .. } - | ast::Instruction::Mma { .. } => result.push(Statement::Instruction(instruction)), + | ast::Instruction::Mma { .. } + | ast::Instruction::Vshr { .. } => result.push(Statement::Instruction(instruction)), ast::Instruction::Add { data: ast::ArithDetails::Float(ast::ArithFloat { diff --git a/ptx/src/pass/instruction_mode_to_global_mode/mod.rs b/ptx/src/pass/instruction_mode_to_global_mode/mod.rs index 99315d480..899e8824c 100644 --- a/ptx/src/pass/instruction_mode_to_global_mode/mod.rs +++ b/ptx/src/pass/instruction_mode_to_global_mode/mod.rs @@ -2201,7 +2201,8 @@ fn get_modes(inst: &ast::Instruction) -> InstructionModes { | ast::Instruction::Div { data: ast::DivDetails::Signed(..) | ast::DivDetails::Unsigned(..), .. - } => InstructionModes::none(), + } + | ast::Instruction::Vshr { .. } => InstructionModes::none(), ast::Instruction::Fma { data, .. } | ast::Instruction::Sub { data: ast::ArithDetails::Float(data), diff --git a/ptx/src/pass/llvm/emit.rs b/ptx/src/pass/llvm/emit.rs index 9a6cf1d1d..eaebaac76 100644 --- a/ptx/src/pass/llvm/emit.rs +++ b/ptx/src/pass/llvm/emit.rs @@ -647,6 +647,7 @@ impl<'a> MethodEmitContext<'a> { self.emit_createpolicy_fractional(data, arguments) } ast::Instruction::Sad { data, arguments } => self.emit_sad(data, arguments), + ast::Instruction::Vshr { data, arguments } => self.emit_vshr(data, arguments), ast::Instruction::CpAsyncCommitGroup {} => Ok(()), // nop ast::Instruction::CpAsyncWaitGroup { .. } => Ok(()), // nop ast::Instruction::CpAsyncWaitAll { .. } => Ok(()), // nop @@ -3487,6 +3488,55 @@ impl<'a> MethodEmitContext<'a> { Ok(()) } + fn emit_vshr( + &mut self, + data: ast::VshData, + arguments: ast::VshrArgs, + ) -> Result<(), TranslateError> { + let src1 = self.resolver.value(arguments.src1)?; + let shift_amount = self.resolver.value(arguments.src2)?; + let shifted = match data.mode { + ast::FunnelShiftMode::Clamp => { + let pre_shifted = unsafe { + LLVMBuildLShr(self.builder, src1, shift_amount, LLVM_UNNAMED.as_ptr()) + }; + let llvm_i32 = get_scalar_type(self.context, ast::ScalarType::B32); + let const_32 = unsafe { LLVMConstInt(llvm_i32, 32, 0) }; + let const_0 = unsafe { LLVMConstInt(llvm_i32, 0, 0) }; + let should_clamp = unsafe { + LLVMBuildICmp( + self.builder, + LLVMIntPredicate::LLVMIntUGE, + shift_amount, + const_32, + LLVM_UNNAMED.as_ptr(), + ) + }; + unsafe { + LLVMBuildSelect( + self.builder, + should_clamp, + const_0, + pre_shifted, + LLVM_UNNAMED.as_ptr(), + ) + } + } + ast::FunnelShiftMode::Wrap => { + return Err(error_todo()); + } + }; + match data.op2 { + ast::VshOp::Add => { + let src3 = self.resolver.value(arguments.src3)?; + self.resolver.with_result(arguments.dst, |dst| unsafe { + LLVMBuildAdd(self.builder, shifted, src3, dst) + }); + } + } + Ok(()) + } + /* // Currently unused, LLVM 18 (ROCm 6.2) does not support `llvm.set.rounding` // Should be available in LLVM 19 diff --git a/ptx/src/test/ll/vshr_clamp.ll b/ptx/src/test/ll/vshr_clamp.ll new file mode 100644 index 000000000..d8c599b0e --- /dev/null +++ b/ptx/src/test/ll/vshr_clamp.ll @@ -0,0 +1,58 @@ +define amdgpu_kernel void @vshr_clamp(ptr addrspace(4) byref(i64) %"49", ptr addrspace(4) byref(i64) %"50") #0 { + %"51" = alloca i64, align 8, addrspace(5) + %"52" = alloca i64, align 8, addrspace(5) + %"53" = alloca i32, align 4, addrspace(5) + %"54" = alloca i32, align 4, addrspace(5) + %"55" = alloca i32, align 4, addrspace(5) + %"56" = alloca i32, align 4, addrspace(5) + br label %1 + +1: ; preds = %0 + br label %"48" + +"48": ; preds = %1 + %2 = load i64, ptr addrspace(4) %"49", align 8 + store i64 %2, ptr addrspace(5) %"51", align 8 + %3 = load i64, ptr addrspace(4) %"50", align 8 + store i64 %3, ptr addrspace(5) %"52", align 8 + %4 = load i64, ptr addrspace(5) %"51", align 8 + %"76" = inttoptr i64 %4 to ptr + %5 = load i32, ptr %"76", align 4 + store i32 %5, ptr addrspace(5) %"54", align 4 + %6 = load i64, ptr addrspace(5) %"51", align 8 + %"77" = inttoptr i64 %6 to ptr + %"42" = getelementptr inbounds i8, ptr %"77", i64 4 + %7 = load i32, ptr %"42", align 4 + store i32 %7, ptr addrspace(5) %"55", align 4 + %8 = load i64, ptr addrspace(5) %"51", align 8 + %"78" = inttoptr i64 %8 to ptr + %"44" = getelementptr inbounds i8, ptr %"78", i64 8 + %9 = load i32, ptr %"44", align 4 + store i32 %9, ptr addrspace(5) %"56", align 4 + %10 = load i32, ptr addrspace(5) %"54", align 4 + %11 = load i32, ptr addrspace(5) %"55", align 4 + %12 = load i32, ptr addrspace(5) %"56", align 4 + %13 = lshr i32 %10, %11 + %14 = icmp uge i32 %11, 32 + %15 = select i1 %14, i32 0, i32 %13 + %"65" = add i32 %15, %12 + store i32 %"65", ptr addrspace(5) %"53", align 4 + %16 = load i64, ptr addrspace(5) %"52", align 8 + %17 = load i32, ptr addrspace(5) %"53", align 4 + %"79" = inttoptr i64 %16 to ptr + store i32 %17, ptr %"79", align 4 + %18 = load i32, ptr addrspace(5) %"54", align 4 + %19 = load i32, ptr addrspace(5) %"56", align 4 + %20 = lshr i32 %18, 32 + %21 = select i1 true, i32 0, i32 %20 + %"71" = add i32 %21, %19 + store i32 %"71", ptr addrspace(5) %"53", align 4 + %22 = load i64, ptr addrspace(5) %"52", align 8 + %"80" = inttoptr i64 %22 to ptr + %"47" = getelementptr inbounds i8, ptr %"80", i64 4 + %23 = load i32, ptr addrspace(5) %"53", align 4 + store i32 %23, ptr %"47", align 4 + ret void +} + +attributes #0 = { "amdgpu-ieee"="false" "amdgpu-unsafe-fp-atomics"="true" "denormal-fp-math"="preserve-sign" "denormal-fp-math-f32"="preserve-sign" "no-trapping-math"="true" "target-features"="+wavefrontsize32,-wavefrontsize64,+cumode,+precise-memory" "uniform-work-group-size"="true" } diff --git a/ptx/src/test/spirv_run/mod.rs b/ptx/src/test/spirv_run/mod.rs index 1e81cddec..4764021b6 100644 --- a/ptx/src/test/spirv_run/mod.rs +++ b/ptx/src/test/spirv_run/mod.rs @@ -480,6 +480,11 @@ test_ptx!( [0x8e2da590u32, 0xedeaee14, 0x248a9f70], [614127545u32] ); +test_ptx!( + vshr_clamp, + [0x8e2da590u32, 16, 0x248a9f70], + [613100957, 613064560] +); test_ptx!(param_is_addressable, [0xDEAD], [0u64]); // TODO: re-enable when we have a patched LLVM //test_ptx!( diff --git a/ptx/src/test/spirv_run/vshr_clamp.ptx b/ptx/src/test/spirv_run/vshr_clamp.ptx new file mode 100644 index 000000000..7a64805e1 --- /dev/null +++ b/ptx/src/test/spirv_run/vshr_clamp.ptx @@ -0,0 +1,25 @@ +.version 6.5 +.target sm_30 +.address_size 64 + +.visible .entry vshr_clamp( + .param .u64 input, + .param .u64 output +) +{ + .reg .u64 in_addr; + .reg .u64 out_addr; + .reg .u32 temp<4>; + + ld.param.u64 in_addr, [input]; + ld.param.u64 out_addr, [output]; + + ld.u32 temp1, [in_addr]; + ld.u32 temp2, [in_addr+4]; + ld.u32 temp3, [in_addr+8]; + vshr.u32.u32.u32.clamp.add temp0, temp1, temp2, temp3; + st.u32 [out_addr], temp0; + vshr.u32.u32.u32.clamp.add temp0, temp1, 32, temp3; + st.u32 [out_addr+4], temp0; + ret; +} diff --git a/ptx_parser/src/ast.rs b/ptx_parser/src/ast.rs index 9cef1096f..e2ddfbb60 100644 --- a/ptx_parser/src/ast.rs +++ b/ptx_parser/src/ast.rs @@ -5,7 +5,7 @@ use super::{ use crate::{ BmskMode, CacheLevel, EvictionPriority, FunnelShiftMode, MatrixLayout, MatrixNumber, MatrixShape, Mul24Control, PtxError, PtxParserState, Reduction, ShiftDirection, ShuffleMode, - VoteMode, + VoteMode, VshOp, }; use bitflags::bitflags; use derive_more::Display; @@ -888,6 +888,16 @@ ptx_parser_macros::generate_instruction_type!( } } }, + Vshr { + type: Type::Scalar(ScalarType::U32), + data: VshData, + arguments: { + dst: T, + src1: T, + src2: T, + src3: T + } + }, Tex { type: !, data: TexData, @@ -2866,3 +2876,9 @@ pub enum TexType { Texref, Texobj, } + +#[derive(Clone, Copy, PartialEq, Eq, Hash)] +pub struct VshData { + pub mode: FunnelShiftMode, + pub op2: VshOp, +} diff --git a/ptx_parser/src/lib.rs b/ptx_parser/src/lib.rs index 7274c4a61..34feb839e 100644 --- a/ptx_parser/src/lib.rs +++ b/ptx_parser/src/lib.rs @@ -1765,6 +1765,42 @@ fn empty_call<'input>( } } +fn vshr<'a, 'input>( + stream: &mut PtxParser<'a, 'input>, + ctor: impl FnOnce( + FunnelShiftMode, + VshOp, + ParsedOperandStr<'input>, + ParsedOperandStr<'input>, + ParsedOperandStr<'input>, + ParsedOperandStr<'input>, + ) -> ast::Instruction>, +) -> PResult>> { + // vshr.u32.u32.u32.mode.op2 d, a, b, c + let ((), (), (), mode, op2, d, (), a, (), b, (), c) = trace( + "vshr", + ( + Token::DotU32.void(), + Token::DotU32.void(), + Token::DotU32.void(), + alt(( + Token::DotClamp.map(|_| FunnelShiftMode::Clamp), + Token::DotWrap.map(|_| FunnelShiftMode::Wrap), + )), + Token::DotAdd.map(|_| VshOp::Add), + ParsedOperandStr::parse, + Token::Comma.void(), + ParsedOperandStr::parse, + Token::Comma.void(), + ParsedOperandStr::parse, + Token::Comma.void(), + ParsedOperandStr::parse, + ), + ) + .parse_next(stream)?; + Ok(ctor(mode, op2, d, a, b, c)) +} + type ParsedOperandStr<'input> = ast::ParsedOperand<&'input str>; #[derive(Clone, PartialEq, Default, Debug, Display)] @@ -2030,6 +2066,11 @@ derive_parser!( #[derive(Copy, Clone, Display, PartialEq, Eq, Hash)] pub enum EvictionPriority { } + #[derive(Copy, Clone, Display, PartialEq, Eq, Hash)] + pub enum VshOp { + Add + } + // https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-mov mov{.vec}.type d, a => { Instruction::Mov { @@ -4307,6 +4348,21 @@ derive_parser!( .mode: RawMulIntControl = { .lo, .hi }; .type: ScalarType = { .u32, .s32, .u64, .s64 }; + // https://docs.nvidia.com/cuda/parallel-thread-execution/#scalar-video-instructions-vshl-vshr + // This one gets custom handling because the type modifiers are at the start + // of the instruction instead of all being before the registers + vshr <= { + vshr(stream, |mode, op2, d, a, b, c| { + Instruction::Vshr { + data: VshData { + mode: mode, + op2: op2, + }, + arguments: VshrArgs { dst: d, src1: a, src2: b, src3: c } + } + }) + } + // https://docs.nvidia.com/cuda/parallel-thread-execution/#texture-instructions-tex tex.1d.v4.dtype.ctype d, [a, c] => { Instruction::Tex { From 2501cd8bc5ac4784c64ea32f789cf1af65989ae5 Mon Sep 17 00:00:00 2001 From: Hemang Joshi Date: Sun, 3 May 2026 09:37:58 +0530 Subject: [PATCH 32/85] Refactor emit_brev to use emit_intrinsic helper (#631) Same cleanup as #610 did for emit_clz: replaces the hand-rolled LLVMGetNamedFunction/LLVMAddFunction/LLVMBuildCall2 sequence with a call to the existing emit_intrinsic helper. Output IR is unchanged, the brev_llvm test fixture already expects the standard @llvm.bitreverse.iN intrinsic call form that emit_intrinsic produces. --- ptx/src/pass/llvm/emit.rs | 18 ++++++------------ 1 file changed, 6 insertions(+), 12 deletions(-) diff --git a/ptx/src/pass/llvm/emit.rs b/ptx/src/pass/llvm/emit.rs index eaebaac76..782841605 100644 --- a/ptx/src/pass/llvm/emit.rs +++ b/ptx/src/pass/llvm/emit.rs @@ -1338,20 +1338,14 @@ impl<'a> MethodEmitContext<'a> { 8 => c"llvm.bitreverse.i64", _ => return Err(error_unreachable()), }; - let mut fn_ = unsafe { LLVMGetNamedFunction(self.module, llvm_fn.as_ptr()) }; let type_ = get_scalar_type(self.context, data); - let fn_type = get_function_type( - self.context, - iter::once(&data.into()), - iter::once(Ok(type_)), + let src = self.resolver.value(arguments.src)?; + self.emit_intrinsic( + llvm_fn, + Some(arguments.dst), + vec![&data.into()], + vec![(src, type_)], )?; - if fn_ == ptr::null_mut() { - fn_ = unsafe { LLVMAddFunction(self.module, llvm_fn.as_ptr(), fn_type) }; - } - let mut src = self.resolver.value(arguments.src)?; - self.resolver.with_result(arguments.dst, |dst| unsafe { - LLVMBuildCall2(self.builder, fn_type, fn_, &mut src, 1, dst) - }); Ok(()) } From 158d473de088f8e73243b9ed6859ce15666d1d51 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Sun, 3 May 2026 22:36:52 -0700 Subject: [PATCH 33/85] Update tests (#632) --- ptx/src/test/ll/extern_func.ll | 8 ++++---- ptx/src/test/ll/set_gt_f16x2.ll | 4 ++-- ptx/src/test/spirv_run/set_gt_f16x2.ptx | 4 ++-- 3 files changed, 8 insertions(+), 8 deletions(-) diff --git a/ptx/src/test/ll/extern_func.ll b/ptx/src/test/ll/extern_func.ll index 50d65f8b6..b5a8414a9 100644 --- a/ptx/src/test/ll/extern_func.ll +++ b/ptx/src/test/ll/extern_func.ll @@ -1,4 +1,4 @@ -declare hidden [16 x i8] @foobar(i64) #0 +declare hidden [4 x i32] @foobar(i64) #0 define amdgpu_kernel void @extern_func(ptr addrspace(4) byref(i64) %"53", ptr addrspace(4) byref(i64) %"54") #1 { %"55" = alloca i64, align 8, addrspace(5) @@ -6,7 +6,7 @@ define amdgpu_kernel void @extern_func(ptr addrspace(4) byref(i64) %"53", ptr ad %"57" = alloca i64, align 8, addrspace(5) %"58" = alloca i64, align 8, addrspace(5) %"63" = alloca i64, align 8, addrspace(5) - %"66" = alloca [16 x i8], align 16, addrspace(5) + %"66" = alloca [4 x i32], align 16, addrspace(5) br label %1 1: ; preds = %0 @@ -25,11 +25,11 @@ define amdgpu_kernel void @extern_func(ptr addrspace(4) byref(i64) %"53", ptr ad %6 = load i64, ptr addrspace(5) %"57", align 8 store i64 %6, ptr addrspace(5) %"64", align 8 %7 = load i64, ptr addrspace(5) %"63", align 8 - %"49" = call [16 x i8] @foobar(i64 %7) + %"49" = call [4 x i32] @foobar(i64 %7) br label %"51" "51": ; preds = %"50" - store [16 x i8] %"49", ptr addrspace(5) %"66", align 1 + store [4 x i32] %"49", ptr addrspace(5) %"66", align 4 %8 = load i64, ptr addrspace(5) %"66", align 8 store i64 %8, ptr addrspace(5) %"58", align 8 %9 = load i64, ptr addrspace(5) %"56", align 8 diff --git a/ptx/src/test/ll/set_gt_f16x2.ll b/ptx/src/test/ll/set_gt_f16x2.ll index 981d1ce90..28e3bac44 100644 --- a/ptx/src/test/ll/set_gt_f16x2.ll +++ b/ptx/src/test/ll/set_gt_f16x2.ll @@ -17,12 +17,12 @@ define amdgpu_kernel void @set_gt_f16x2(ptr addrspace(4) byref(i64) %"46", ptr a store i64 %3, ptr addrspace(5) %"49", align 8 %4 = load i64, ptr addrspace(5) %"48", align 8 %"65" = inttoptr i64 %4 to ptr - %"42" = getelementptr inbounds i8, ptr %"65", i64 4 + %"42" = getelementptr inbounds i8, ptr %"65", i64 0 %5 = load i32, ptr %"42", align 4 store i32 %5, ptr addrspace(5) %"50", align 4 %6 = load i64, ptr addrspace(5) %"48", align 8 %"66" = inttoptr i64 %6 to ptr - %"44" = getelementptr inbounds i8, ptr %"66", i64 8 + %"44" = getelementptr inbounds i8, ptr %"66", i64 4 %7 = load i32, ptr %"44", align 4 store i32 %7, ptr addrspace(5) %"51", align 4 %8 = load i32, ptr addrspace(5) %"50", align 4 diff --git a/ptx/src/test/spirv_run/set_gt_f16x2.ptx b/ptx/src/test/spirv_run/set_gt_f16x2.ptx index 909e4aaf4..32600c8ce 100644 --- a/ptx/src/test/spirv_run/set_gt_f16x2.ptx +++ b/ptx/src/test/spirv_run/set_gt_f16x2.ptx @@ -15,8 +15,8 @@ ld.param.u64 in_addr, [input]; ld.param.u64 out_addr, [output]; - ld.b32 in32_0, [in_addr+4]; - ld.b32 in32_1, [in_addr+8]; + ld.b32 in32_0, [in_addr+0]; + ld.b32 in32_1, [in_addr+4]; set.gt.f16x2.f16x2 in32_2, in32_0, in32_1; st.u32 [out_addr], in32_2; ret; From b7093995443fe67d55b150f0059691833a022b1d Mon Sep 17 00:00:00 2001 From: Hemang Joshi Date: Mon, 4 May 2026 21:59:44 +0530 Subject: [PATCH 34/85] Fix typo: vec_acccess -> vector_read in emit_vector_read (#633) Rename the parameter to match the function name and align with the sibling functions emit_vector_write and emit_vector_repack which name their parameters after their argument types/intent. No behavior change. --- ptx/src/pass/llvm/emit.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/ptx/src/pass/llvm/emit.rs b/ptx/src/pass/llvm/emit.rs index 782841605..905930bc4 100644 --- a/ptx/src/pass/llvm/emit.rs +++ b/ptx/src/pass/llvm/emit.rs @@ -1542,17 +1542,17 @@ impl<'a> MethodEmitContext<'a> { Ok(()) } - fn emit_vector_read(&mut self, vec_acccess: VectorRead) -> Result<(), TranslateError> { - let src = self.resolver.value(vec_acccess.vector_src)?; + fn emit_vector_read(&mut self, vector_read: VectorRead) -> Result<(), TranslateError> { + let src = self.resolver.value(vector_read.vector_src)?; let index = unsafe { LLVMConstInt( get_scalar_type(self.context, ast::ScalarType::B8), - vec_acccess.member as _, + vector_read.member as _, 0, ) }; self.resolver - .with_result(vec_acccess.scalar_dst, |dst| unsafe { + .with_result(vector_read.scalar_dst, |dst| unsafe { LLVMBuildExtractElement(self.builder, src, index, dst) }); Ok(()) From 36ff319b9e4b6cfed9d9efed493b8506d95dbc61 Mon Sep 17 00:00:00 2001 From: Hemang Joshi Date: Mon, 11 May 2026 03:00:10 +0530 Subject: [PATCH 35/85] Remove redundant map_err(CompilerError::from) calls in compiler (#635) The `?` operator already converts the error type via the `From` trait, and `CompilerError` has `#[from]` impls (or explicit From impls) for `io::Error`, `Utf8Error`, `Vec>`, `TranslateError`, and trivially for `CompilerError` itself. The explicit map_err calls are no-ops. No behavior change. --- compiler/src/main.rs | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/compiler/src/main.rs b/compiler/src/main.rs index 136d1e4ad..8d1209bad 100644 --- a/compiler/src/main.rs +++ b/compiler/src/main.rs @@ -73,9 +73,9 @@ fn main_core() -> Result<(), CompilerError> { .unwrap_or_else(|_| DEFAULT_ARCH.to_owned()), }; - let ptx = fs::read(&ptx_path).map_err(CompilerError::from)?; - let ptx = str::from_utf8(&ptx).map_err(CompilerError::from)?; - let llvm = ptx_to_llvm(opts.ignore_errors, ptx).map_err(CompilerError::from)?; + let ptx = fs::read(&ptx_path)?; + let ptx = str::from_utf8(&ptx)?; + let llvm = ptx_to_llvm(opts.ignore_errors, ptx)?; write_to_file(&llvm.llvm_ir, output_path.with_extension("ll").as_path())?; @@ -104,7 +104,7 @@ fn ptx_to_llvm(ignore_errors: bool, ptx: &str) -> Result Result Date: Tue, 12 May 2026 19:55:32 -0700 Subject: [PATCH 36/85] 32 bit support in the compiler (#637) This does not add full 32 bit support, just support in the compiler for a special 32bit on 64 bit mode. I expected the changes to be much smaller, but since they are so wide-reaching I prefer to get this piece out as soon as possible --- Cargo.lock | 1304 +- Cargo.toml | 5 - cuda_check/Cargo.toml | 2 +- cuda_macros/src/lib.rs | 92 +- dark_api/src/lib.rs | 1 - nvapi/Cargo.toml | 26 - nvapi/src/lib.rs | 656 - nvapi/src/nvapi.rs | 19879 ------------------- nvapi_trace/Cargo.toml | 29 - nvapi_trace/src/lib.rs | 704 - ptx/src/pass/convert_32bit_to_64bit.rs | 2 +- ptx/src/pass/hoist_globals.rs | 106 +- ptx/src/pass/llvm/emit.rs | 12 +- ptx/src/pass/mod.rs | 1 - ptx/src/test/spirv_run/32/global_array.ptx | 22 + ptx/src/test/spirv_run/mod.rs | 13 +- ptx_parser/src/ast.rs | 2 +- xtask/src/main.rs | 78 +- zluda32/Cargo.toml | 41 - zluda32/src/ipc.rs | 154 - zluda32/src/lib.rs | 717 - zluda64_server/Cargo.toml | 23 - zluda64_server/src/main.rs | 504 - zluda_common/src/constants.rs | 1 - zluda_common/src/lib.rs | 1 - zluda_inject/Cargo.toml | 2 +- zluda_inject/src/bin.rs | 22 +- zluda_redirect/Cargo.toml | 1 - zluda_server_common/Cargo.toml | 16 - zluda_server_common/src/lib.rs | 216 - zluda_trace/Cargo.toml | 6 +- zluda_trace/src/lib.rs | 8 +- zluda_trace/src/log.rs | 4 - zluda_trace_blas/src/lib.rs | 1 - zluda_trace_blaslt/src/lib.rs | 1 - zluda_trace_dnn8/src/lib.rs | 1 - zluda_trace_dnn9/src/lib.rs | 1 - zluda_trace_fft/src/lib.rs | 1 - zluda_trace_nvml/src/lib.rs | 1 - zluda_trace_sparse/src/lib.rs | 1 - zluda_windows/src/lib.rs | 58 +- 41 files changed, 291 insertions(+), 24424 deletions(-) delete mode 100644 nvapi/Cargo.toml delete mode 100644 nvapi/src/lib.rs delete mode 100644 nvapi/src/nvapi.rs delete mode 100644 nvapi_trace/Cargo.toml delete mode 100644 nvapi_trace/src/lib.rs create mode 100644 ptx/src/test/spirv_run/32/global_array.ptx delete mode 100644 zluda32/Cargo.toml delete mode 100644 zluda32/src/ipc.rs delete mode 100644 zluda32/src/lib.rs delete mode 100644 zluda64_server/Cargo.toml delete mode 100644 zluda64_server/src/main.rs delete mode 100644 zluda_server_common/Cargo.toml delete mode 100644 zluda_server_common/src/lib.rs diff --git a/Cargo.lock b/Cargo.lock index 1976b0fa8..eb27ec012 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -84,7 +84,7 @@ dependencies = [ "argh_shared", "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -108,21 +108,6 @@ version = "0.7.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50" -[[package]] -name = "async-task" -version = "4.7.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de" - -[[package]] -name = "atomic-polyfill" -version = "1.0.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8cf2bce30dfe09ef0bfaef228b9d414faaf7e563035494d7fe092dba54b300f4" -dependencies = [ - "critical-section", -] - [[package]] name = "autocfg" version = "1.4.0" @@ -135,33 +120,13 @@ version = "0.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3a8241f3ebb85c056b509d4327ad0358fbbba6ffb340bf388f26350aeda225b1" -[[package]] -name = "bincode" -version = "2.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "36eaf5d7b090263e8150820482d5d93cd964a81e4019913c972f4edcc6edb740" -dependencies = [ - "bincode_derive", - "serde", - "unty", -] - -[[package]] -name = "bincode_derive" -version = "2.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bf95709a440f45e986983918d0e8a1f30a9b1df04918fc828670606804ac3c09" -dependencies = [ - "virtue", -] - [[package]] name = "bindgen" version = "0.70.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f49d8fed880d473ea71efb9bf597651e77201bdd4893efe54c9e5d65ae04ce6f" dependencies = [ - "bitflags 2.11.1", + "bitflags 2.9.1", "cexpr", "clang-sys", "itertools 0.13.0", @@ -172,7 +137,7 @@ dependencies = [ "regex", "rustc-hash 1.1.0", "shlex", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -181,7 +146,7 @@ version = "0.71.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5f58bf3d7db68cfbac37cfc485a8d711e87e064c3d0fe0435b92f7a407f9d6b3" dependencies = [ - "bitflags 2.11.1", + "bitflags 2.9.1", "cexpr", "clang-sys", "itertools 0.13.0", @@ -192,7 +157,7 @@ dependencies = [ "regex", "rustc-hash 2.1.1", "shlex", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -201,30 +166,6 @@ version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7" -[[package]] -name = "bitcode" -version = "0.6.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0a6ed1b54d8dc333e7be604d00fa9262f4635485ffea923647b6521a5fff045d" -dependencies = [ - "arrayvec", - "bitcode_derive", - "bytemuck", - "glam", - "serde", -] - -[[package]] -name = "bitcode_derive" -version = "0.6.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "238b90427dfad9da4a9abd60f3ec1cdee6b80454bde49ed37f1781dd8e9dc7f9" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.117", -] - [[package]] name = "bitflags" version = "1.3.2" @@ -233,9 +174,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" [[package]] name = "bitflags" -version = "2.11.1" +version = "2.9.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c4512299f36f043ab09a583e57bceb5a5aab7a73db1805848e8fef3c9e8c78b3" +checksum = "1b8e56985ec62d17e9c1001dc89c88ecd7dc08e47eba5ec7c29c7b5eeecde967" [[package]] name = "blake3" @@ -278,7 +219,7 @@ checksum = "fefb4feeec9a091705938922f26081aad77c64cd2e76cd1c4a9ece8e42e1618a" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -318,7 +259,7 @@ checksum = "89385e82b5d1821d2219e0b095efa2cc1f246cbf99080f3be46a1a85c0d392d9" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -338,7 +279,7 @@ checksum = "f9abbd1bc6865053c427f7198e6af43bfdedc55ab791faed4fbd361d789575ff" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -373,10 +314,10 @@ dependencies = [ "gemm", "half", "libm", - "memmap2", + "memmap2 0.9.7", "num-traits", "num_cpus", - "rand 0.9.2", + "rand", "rand_distr", "rayon", "safetensors", @@ -435,12 +376,6 @@ version = "1.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" -[[package]] -name = "cfg_aliases" -version = "0.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724" - [[package]] name = "cglue" version = "0.3.5" @@ -479,17 +414,6 @@ dependencies = [ "syn 1.0.109", ] -[[package]] -name = "chacha20" -version = "0.10.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6f8d983286843e49675a4b7a2d174efe136dc93a18d69130dd18198a6c167601" -dependencies = [ - "cfg-if", - "cpufeatures 0.3.0", - "rand_core 0.10.0", -] - [[package]] name = "clang-sys" version = "1.8.1" @@ -516,15 +440,6 @@ dependencies = [ "cc", ] -[[package]] -name = "cobs" -version = "0.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0fa961b519f0b462e3a3b4a34b64d119eeaca1d59af726fe450bbba07a9fc0a1" -dependencies = [ - "thiserror 2.0.12", -] - [[package]] name = "compiler" version = "0.0.0" @@ -538,143 +453,6 @@ dependencies = [ "thiserror 2.0.12", ] -[[package]] -name = "compio" -version = "0.18.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9b84ee96a86948d04388f3a0b8c36b9f0a6b40b3528ac0d65737e53632fb37fe" -dependencies = [ - "compio-buf", - "compio-driver", - "compio-fs", - "compio-io", - "compio-log", - "compio-macros", - "compio-runtime", -] - -[[package]] -name = "compio-buf" -version = "0.8.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a00d719dbd8c602ab0d25d219cbc6b517008858de7a8d6c51b4dc95aefff4dce" -dependencies = [ - "arrayvec", - "bytes", - "libc", -] - -[[package]] -name = "compio-driver" -version = "0.11.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "74d42d98dc890ee4db00c1e68a723391711aab6d67085880d716b72830f7c715" -dependencies = [ - "cfg-if", - "cfg_aliases", - "compio-buf", - "compio-log", - "crossbeam-queue", - "flume", - "futures-util", - "io-uring", - "io_uring_buf_ring", - "libc", - "once_cell", - "paste", - "pin-project-lite", - "polling", - "slab", - "smallvec", - "socket2", - "synchrony", - "thin-cell", - "windows-sys 0.61.2", -] - -[[package]] -name = "compio-fs" -version = "0.11.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "65ee36e1acf2cec4835efe9a986c012b2462c5ef53580e4ee84ae6d5a3d8e3b3" -dependencies = [ - "cfg-if", - "cfg_aliases", - "compio-buf", - "compio-driver", - "compio-io", - "compio-runtime", - "libc", - "os_pipe", - "pin-project-lite", - "widestring", - "windows-sys 0.61.2", -] - -[[package]] -name = "compio-io" -version = "0.9.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "637522f28a64fd5f7dcceaa4ddef13fa8d8020025e8c993f7a069e237835580e" -dependencies = [ - "compio-buf", - "futures-util", - "paste", - "synchrony", -] - -[[package]] -name = "compio-log" -version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fc4e560213c1996b618da369b7c9109564b41af9033802ae534465c4ee4e132f" -dependencies = [ - "tracing", -] - -[[package]] -name = "compio-macros" -version = "0.1.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f05ed201484967dc70de77a8f7a02b29aaa8e6c81cbea2e75492ee0c8d97766b" -dependencies = [ - "proc-macro-crate 3.3.0", - "proc-macro2", - "quote", - "syn 2.0.117", -] - -[[package]] -name = "compio-runtime" -version = "0.11.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d6c1c71f011bdd9c8f30e97d877b606505ee6d241c7782cfaed172f66acbd9cd" -dependencies = [ - "async-task", - "compio-buf", - "compio-driver", - "compio-log", - "core_affinity", - "crossbeam-queue", - "futures-util", - "libc", - "once_cell", - "pin-project-lite", - "scoped-tls", - "slab", - "socket2", - "windows-sys 0.61.2", -] - -[[package]] -name = "concurrent-queue" -version = "2.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4ca0197aee26d1ae37445ee532fefce43251d24cc7c166799f4d46817f1d3973" -dependencies = [ - "crossbeam-utils", -] - [[package]] name = "console" version = "0.16.1" @@ -703,17 +481,6 @@ dependencies = [ "unicode-segmentation", ] -[[package]] -name = "core_affinity" -version = "0.8.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a034b3a7b624016c6e13f5df875747cc25f884156aad2abd12b6c46797971342" -dependencies = [ - "libc", - "num_cpus", - "winapi", -] - [[package]] name = "cpufeatures" version = "0.2.17" @@ -723,15 +490,6 @@ dependencies = [ "libc", ] -[[package]] -name = "cpufeatures" -version = "0.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b2a41393f66f16b0823bb79094d54ac5fbd34ab292ddafb9a0456ac9f87d201" -dependencies = [ - "libc", -] - [[package]] name = "crc32fast" version = "1.5.0" @@ -741,21 +499,6 @@ dependencies = [ "cfg-if", ] -[[package]] -name = "critical-section" -version = "1.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "790eea4361631c5e7d22598ecd5723ff611904e3344ce8720784c93e3d83d40b" - -[[package]] -name = "crossbeam-channel" -version = "0.5.15" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2" -dependencies = [ - "crossbeam-utils", -] - [[package]] name = "crossbeam-deque" version = "0.8.6" @@ -775,15 +518,6 @@ dependencies = [ "crossbeam-utils", ] -[[package]] -name = "crossbeam-queue" -version = "0.3.12" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0f58bbc28f91df819d0aa2a2c00cd19754769c2fad90579b3592b1c9ba7a3115" -dependencies = [ - "crossbeam-utils", -] - [[package]] name = "crossbeam-utils" version = "0.8.21" @@ -814,8 +548,8 @@ dependencies = [ "cuda_types", "libloading", "owo-colors", - "rand 0.10.1", - "windows 0.62.2", + "rand", + "windows", "zluda_windows", ] @@ -826,14 +560,14 @@ dependencies = [ "proc-macro2", "quote", "rustc-hash 2.1.1", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] name = "cuda_types" version = "0.0.0" dependencies = [ - "bitflags 2.11.1", + "bitflags 2.9.1", "cuda_macros", "hip_runtime-sys", "hipblaslt-sys", @@ -878,7 +612,7 @@ dependencies = [ "proc-macro2", "quote", "strsim", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -889,7 +623,7 @@ checksum = "fc34b93ccb385b40dc71c6fceac4b2ad23662c7eeb248cf10d529b7e055b6ead" dependencies = [ "darling_core", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -934,7 +668,7 @@ checksum = "30542c1ad912e0e3d22a1935c290e12e8a29d704a420177a31faad4a601a0800" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -955,7 +689,7 @@ dependencies = [ "darling", "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -965,7 +699,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ab63b0e2bf4d5928aff72e83a7dace85d7bba5fe12dcc3c5a572d78caffd3f3c" dependencies = [ "derive_builder_core", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -985,7 +719,7 @@ checksum = "cb7330aeadfbe296029522e6c40f315320aba36fc43a5b3632f3795348f3bd22" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", "unicode-xid", ] @@ -1018,7 +752,7 @@ dependencies = [ "dsl_auto_type", "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -1038,7 +772,7 @@ version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "209c735641a413bc68c4923a9d6ad4bcb3ca306b794edaa7eb0b3228a99ffb25" dependencies = [ - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -1086,7 +820,7 @@ checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -1100,7 +834,7 @@ dependencies = [ "heck", "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -1142,29 +876,28 @@ checksum = "e1d926b4d407d372f141f93bb444696142c29d32962ccbd3531117cf3aa0bfa9" [[package]] name = "dynasm" -version = "5.0.0" +version = "1.2.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "df4bf11ba8aecc00489b7ec4e8963cd3860651c3ea2a114394f8ba7e92a0e94a" +checksum = "add9a102807b524ec050363f09e06f1504214b0e1c7797f64261c891022dce8b" dependencies = [ - "bitflags 2.11.1", + "bitflags 1.3.2", "byteorder", "lazy_static", - "proc-macro-error2", + "proc-macro-error", "proc-macro2", "quote", - "syn 2.0.117", + "syn 1.0.109", ] [[package]] name = "dynasmrt" -version = "5.0.0" +version = "1.2.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b38e5331d851567729d892ed28d898d22f49a96940b29e23b5c3e681bd30ffb3" +checksum = "64fba5a42bd76a17cad4bfa00de168ee1cbfa06a5e8ce992ae880218c05641a9" dependencies = [ "byteorder", "dynasm", - "fnv", - "memmap2", + "memmap2 0.5.10", ] [[package]] @@ -1187,18 +920,6 @@ dependencies = [ "winreg", ] -[[package]] -name = "embedded-io" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ef1a6892d9eef45c8fa6b9e0086428a2cca8491aca8f787c534a3d6d0bcb3ced" - -[[package]] -name = "embedded-io" -version = "0.6.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "edd0f118536f44f5ccd48bcb8b111bdc3de888b58c74639dfb034a357d0f206d" - [[package]] name = "encode_unicode" version = "1.0.0" @@ -1223,7 +944,7 @@ dependencies = [ "heck", "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -1257,7 +978,7 @@ version = "0.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7223ae2d2f179b803433d9c830478527e92b8117eab39460edae7f1614d9fb73" dependencies = [ - "heapless 0.8.0", + "heapless", "serde", ] @@ -1310,19 +1031,10 @@ checksum = "719a903cc23e4a89e87962c2a80fdb45cdaad0983a89bd150bb57b4c8571a7d5" dependencies = [ "half", "num-traits", - "rand 0.9.2", + "rand", "rand_distr", ] -[[package]] -name = "flume" -version = "0.12.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5e139bc46ca777eb5efaf62df0ab8cc5fd400866427e56c68b22e414e53bd3be" -dependencies = [ - "spin", -] - [[package]] name = "fnv" version = "1.0.7" @@ -1358,49 +1070,6 @@ dependencies = [ "uuid", ] -[[package]] -name = "futures-core" -version = "0.3.32" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d" - -[[package]] -name = "futures-macro" -version = "0.3.32" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e835b70203e41293343137df5c0664546da5745f82ec9b84d40be8336958447b" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.117", -] - -[[package]] -name = "futures-sink" -version = "0.3.32" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c39754e157331b013978ec91992bde1ac089843443c49cbc7f46150b0fad0893" - -[[package]] -name = "futures-task" -version = "0.3.32" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393" - -[[package]] -name = "futures-util" -version = "0.3.32" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6" -dependencies = [ - "futures-core", - "futures-macro", - "futures-sink", - "futures-task", - "pin-project-lite", - "slab", -] - [[package]] name = "gemm" version = "0.19.0" @@ -1520,21 +1189,6 @@ dependencies = [ "seq-macro", ] -[[package]] -name = "generator" -version = "0.8.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "52f04ae4152da20c76fe800fa48659201d5cf627c5149ca0b707b69d7eef6cf9" -dependencies = [ - "cc", - "cfg-if", - "libc", - "log", - "rustversion", - "windows-link 0.2.1", - "windows-result 0.4.1", -] - [[package]] name = "generic-array" version = "0.14.7" @@ -1564,24 +1218,10 @@ checksum = "26145e563e54f2cadc477553f1ec5ee650b00862f0a58bcd12cbdc5f0ea2d2f4" dependencies = [ "cfg-if", "libc", - "r-efi 5.3.0", + "r-efi", "wasi 0.14.2+wasi-0.2.4", ] -[[package]] -name = "getrandom" -version = "0.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0de51e6874e94e7bf76d726fc5d13ba782deca734ff60d5bb2fb2607c7406555" -dependencies = [ - "cfg-if", - "libc", - "r-efi 6.0.0", - "rand_core 0.10.0", - "wasip2", - "wasip3", -] - [[package]] name = "gix" version = "0.71.0" @@ -1705,7 +1345,7 @@ dependencies = [ "bstr", "gix-chunk", "gix-hash 0.17.0", - "memmap2", + "memmap2 0.9.7", "thiserror 2.0.12", ] @@ -1736,7 +1376,7 @@ version = "0.14.12" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8dc2c844c4cf141884678cabef736fd91dd73068b9146e6f004ba1a0457944b6" dependencies = [ - "bitflags 2.11.1", + "bitflags 2.9.1", "bstr", "gix-path", "libc", @@ -1900,7 +1540,7 @@ version = "0.19.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "20972499c03473e773a2099e5fd0c695b9b72465837797a51a43391a1635a030" dependencies = [ - "bitflags 2.11.1", + "bitflags 2.9.1", "bstr", "gix-features 0.41.1", "gix-path", @@ -1960,7 +1600,7 @@ version = "0.39.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "855bece2d4153453aa5d0a80d51deea1ce8cd6a3b4cf213da85ac344ccb908a7" dependencies = [ - "bitflags 2.11.1", + "bitflags 2.9.1", "bstr", "filetime", "fnv", @@ -1976,7 +1616,7 @@ dependencies = [ "hashbrown 0.14.5", "itoa", "libc", - "memmap2", + "memmap2 0.9.7", "rustix 0.38.37", "smallvec", "thiserror 2.0.12", @@ -2048,7 +1688,7 @@ dependencies = [ "gix-hashtable", "gix-object", "gix-path", - "memmap2", + "memmap2 0.9.7", "smallvec", "thiserror 2.0.12", ] @@ -2097,7 +1737,7 @@ version = "0.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "fef8422c3c9066d649074b24025125963f85232bfad32d6d16aea9453b82ec14" dependencies = [ - "bitflags 2.11.1", + "bitflags 2.9.1", "bstr", "gix-attributes", "gix-config-value", @@ -2152,7 +1792,7 @@ dependencies = [ "gix-tempfile", "gix-utils 0.2.0", "gix-validate 0.9.4", - "memmap2", + "memmap2 0.9.7", "thiserror 2.0.12", "winnow 0.7.10", ] @@ -2177,7 +1817,7 @@ version = "0.33.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "342caa4e158df3020cadf62f656307c3948fe4eacfdf67171d7212811860c3e9" dependencies = [ - "bitflags 2.11.1", + "bitflags 2.9.1", "bstr", "gix-commitgraph", "gix-date", @@ -2210,7 +1850,7 @@ version = "0.10.12" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "47aeb0f13de9ef2f3033f5ff218de30f44db827ac9f1286f9ef050aacddd5888" dependencies = [ - "bitflags 2.11.1", + "bitflags 2.9.1", "gix-path", "libc", "windows-sys 0.52.0", @@ -2310,7 +1950,7 @@ version = "0.45.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "36c0b049f8bdb61b20016694102f7b507f2e1727e83e9c5e6dad4f7d84ff7384" dependencies = [ - "bitflags 2.11.1", + "bitflags 2.9.1", "gix-commitgraph", "gix-date", "gix-hash 0.17.0", @@ -2395,12 +2035,6 @@ dependencies = [ "gix-validate 0.9.4", ] -[[package]] -name = "glam" -version = "0.32.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f70749695b063ecbf6b62949ccccde2e733ec3ecbbd71d467dca4e5c6c97cca0" - [[package]] name = "glob" version = "0.3.1" @@ -2428,20 +2062,11 @@ dependencies = [ "cfg-if", "crunchy", "num-traits", - "rand 0.9.2", + "rand", "rand_distr", "zerocopy", ] -[[package]] -name = "hash32" -version = "0.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b0c35f58762feb77d74ebe43bdbc3210f09be9fe6742234d573bacc26ed92b67" -dependencies = [ - "byteorder", -] - [[package]] name = "hash32" version = "0.3.1" @@ -2483,27 +2108,13 @@ dependencies = [ "serde_core", ] -[[package]] -name = "heapless" -version = "0.7.17" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cdc6457c0eb62c71aac4bc17216026d8410337c4126773b9c5daba343f17964f" -dependencies = [ - "atomic-polyfill", - "hash32 0.2.1", - "rustc_version", - "serde", - "spin", - "stable_deref_trait", -] - [[package]] name = "heapless" version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0bfb9eb618601c89945a70e254898da93b13be0388091d42117462b265bb3fad" dependencies = [ - "hash32 0.3.1", + "hash32", "stable_deref_trait", ] @@ -2644,12 +2255,6 @@ dependencies = [ "zerovec", ] -[[package]] -name = "id-arena" -version = "2.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954" - [[package]] name = "ident_case" version = "1.0.1" @@ -2694,7 +2299,6 @@ checksum = "8c9c992b02b5b4c94ea26e32fe5bccb7aa7d9f390ab5c1221ff895bc7ea8b652" dependencies = [ "equivalent", "hashbrown 0.15.2", - "serde", ] [[package]] @@ -2719,60 +2323,19 @@ dependencies = [ "proc-macro2", "proc-macro2-diagnostics", "quote", - "syn 2.0.117", + "syn 2.0.89", "version_check", ] [[package]] -name = "io-uring" -version = "0.7.11" +name = "is-terminal" +version = "0.4.17" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fdd7bddefd0a8833b88a4b68f90dae22c7450d11b354198baee3874fd811b344" +checksum = "3640c1c38b8e4e43584d8df18be5fc6b0aa314ce6ebf51b53313d4306cca8e46" dependencies = [ - "bitflags 2.11.1", - "cfg-if", + "hermit-abi", "libc", -] - -[[package]] -name = "io_uring_buf_ring" -version = "0.2.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1838759bb8c2f24cf05a35429d83145c4aa6af43f8ad38477295e12a7320a80e" -dependencies = [ - "bytes", - "io-uring", - "rustix 1.1.4", -] - -[[package]] -name = "ipc-channel" -version = "0.21.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a441490012d80e9aea75fb27503df8e87e9557dcfc6fe4244dde86bfc12e94e3" -dependencies = [ - "crossbeam-channel", - "libc", - "mio", - "postcard", - "rand 0.9.2", - "rustc-hash 2.1.1", - "serde_core", - "tempfile", - "thiserror 2.0.12", - "uuid", - "windows 0.61.3", -] - -[[package]] -name = "is-terminal" -version = "0.4.17" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3640c1c38b8e4e43584d8df18be5fc6b0aa314ce6ebf51b53313d4306cca8e46" -dependencies = [ - "hermit-abi", - "libc", - "windows-sys 0.61.2", + "windows-sys 0.61.2", ] [[package]] @@ -2879,17 +2442,11 @@ version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe" -[[package]] -name = "leb128fmt" -version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2" - [[package]] name = "libc" -version = "0.2.184" +version = "0.2.174" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "48f5d2a454e16a5ea0f4ced81bd44e4cfc7bd3a507b61887c99fd3538b28e4af" +checksum = "1171693293099992e19cddea4e8b849964e9846f4acee11b3948bcc337be8776" [[package]] name = "libloading" @@ -2913,7 +2470,7 @@ version = "0.1.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d" dependencies = [ - "bitflags 2.11.1", + "bitflags 2.9.1", "libc", "redox_syscall", ] @@ -2946,9 +2503,9 @@ checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89" [[package]] name = "linux-raw-sys" -version = "0.12.1" +version = "0.9.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53" +checksum = "fe7db12097d22ec582439daf8618b8fdd1a7bef6270e9af3b1ebcd30893cf413" [[package]] name = "litemap" @@ -3024,7 +2581,7 @@ dependencies = [ "proc-macro2", "quote", "regex-syntax", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -3036,20 +2593,6 @@ dependencies = [ "logos-codegen", ] -[[package]] -name = "loom" -version = "0.7.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "419e0dc8046cb947daa77eb95ae174acfbddb7673b4151f56d1eed8e93fbfaca" -dependencies = [ - "cfg-if", - "generator", - "pin-utils", - "scoped-tls", - "tracing", - "tracing-subscriber", -] - [[package]] name = "lz4-sys" version = "1.11.1+lz4-1.10.0" @@ -3060,15 +2603,6 @@ dependencies = [ "libc", ] -[[package]] -name = "matchers" -version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d1525a2a28c7f4fa0fc98bb91ae755d1e2d1505079e05539e35bc876b5d65ae9" -dependencies = [ - "regex-automata", -] - [[package]] name = "maybe-async" version = "0.2.10" @@ -3077,7 +2611,7 @@ checksum = "5cf92c10c7e361d6b99666ec1c6f9805b0bea2c3bd8c78dc6fe98ac5bd78db11" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -3088,9 +2622,18 @@ checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3" [[package]] name = "memmap2" -version = "0.9.10" +version = "0.5.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "83faa42c0a078c393f6b29d5db232d8be22776a891f8f56e5284faee4a20b327" +dependencies = [ + "libc", +] + +[[package]] +name = "memmap2" +version = "0.9.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "714098028fe011992e1c3962653c96b2d578c4b4bce9036e15ff220319b1e0e3" +checksum = "483758ad303d734cec05e5c12b41d7e93e6a6390c5e9dae6bdeb7c1259012d28" dependencies = [ "libc", "stable_deref_trait", @@ -3132,17 +2675,6 @@ dependencies = [ "adler2", ] -[[package]] -name = "mio" -version = "1.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "50b7e5b27aa02a74bac8c3f23f448f8d87ff11f92d3aac1a6ed369ee08cc56c1" -dependencies = [ - "libc", - "wasi 0.11.1+wasi-snapshot-preview1", - "windows-sys 0.61.2", -] - [[package]] name = "miopen-sys" version = "0.0.0" @@ -3167,7 +2699,7 @@ checksum = "4568f25ccbd45ab5d5603dc34318c1ec56b117531781260002151b8530a9f931" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -3186,15 +2718,6 @@ dependencies = [ "minimal-lexical", ] -[[package]] -name = "nu-ansi-term" -version = "0.50.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5" -dependencies = [ - "windows-sys 0.61.2", -] - [[package]] name = "num" version = "0.4.3" @@ -3305,40 +2828,6 @@ dependencies = [ "libc", ] -[[package]] -name = "nvapi" -version = "0.0.0" -dependencies = [ - "cglue", - "cuda_macros", - "cuda_types", - "dark_api", - "format", - "libloading", - "paste", - "rustc-hash 2.1.1", - "unwrap_or", - "zluda_trace_common", -] - -[[package]] -name = "nvapi_trace" -version = "0.0.0" -dependencies = [ - "cglue", - "cuda_macros", - "cuda_types", - "dark_api", - "dynasm", - "dynasmrt", - "format", - "libloading", - "paste", - "rustc-hash 2.1.1", - "unwrap_or", - "zluda_trace_common", -] - [[package]] name = "object" version = "0.38.1" @@ -3365,16 +2854,6 @@ version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d" -[[package]] -name = "os_pipe" -version = "1.2.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7d8fae84b431384b68627d0f9b3b1245fcf9f46f6c0e3dc902e9dce64edd1967" -dependencies = [ - "libc", - "windows-sys 0.61.2", -] - [[package]] name = "owo-colors" version = "4.2.3" @@ -3436,18 +2915,6 @@ dependencies = [ "indexmap", ] -[[package]] -name = "pin-project-lite" -version = "0.2.17" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd" - -[[package]] -name = "pin-utils" -version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" - [[package]] name = "pkg-config" version = "0.3.32" @@ -3460,20 +2927,6 @@ version = "0.2.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6" -[[package]] -name = "polling" -version = "3.11.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5d0e4f59085d47d8241c88ead0f274e8a0cb551f3625263c05eb8dd897c34218" -dependencies = [ - "cfg-if", - "concurrent-queue", - "hermit-abi", - "pin-project-lite", - "rustix 1.1.4", - "windows-sys 0.61.2", -] - [[package]] name = "portable-atomic" version = "1.11.1" @@ -3489,19 +2942,6 @@ dependencies = [ "portable-atomic", ] -[[package]] -name = "postcard" -version = "1.1.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6764c3b5dd454e283a30e6dfe78e9b31096d9e32036b5d1eaac7a6119ccb9a24" -dependencies = [ - "cobs", - "embedded-io 0.4.0", - "embedded-io 0.6.1", - "heapless 0.7.17", - "serde", -] - [[package]] name = "potential_utf" version = "0.1.2" @@ -3543,7 +2983,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "64d1ec885c64d0457d564db4ec299b2dae3f9c02808b8ad9c3a089c591b18033" dependencies = [ "proc-macro2", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -3565,32 +3005,34 @@ dependencies = [ ] [[package]] -name = "proc-macro-error-attr2" -version = "2.0.0" +name = "proc-macro-error" +version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "96de42df36bb9bba5542fe9f1a054b8cc87e172759a1868aa05c1f3acc89dfc5" +checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c" dependencies = [ + "proc-macro-error-attr", "proc-macro2", "quote", + "syn 1.0.109", + "version_check", ] [[package]] -name = "proc-macro-error2" -version = "2.0.1" +name = "proc-macro-error-attr" +version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "11ec05c52be0a07b08061f7dd003e7d7092e0472bc731b4af7bb1ef876109802" +checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869" dependencies = [ - "proc-macro-error-attr2", "proc-macro2", "quote", - "syn 2.0.117", + "version_check", ] [[package]] name = "proc-macro2" -version = "1.0.106" +version = "1.0.92" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934" +checksum = "37d3544b3f2748c54e147655edb5025752e2303145b5aefb3c3ea2c78b973bb0" dependencies = [ "unicode-ident", ] @@ -3603,7 +3045,7 @@ checksum = "af066a9c399a26e020ada66a034357a868728e72cd426f3adcd35f80d88d88c8" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", "version_check", "yansi", ] @@ -3635,7 +3077,7 @@ checksum = "7347867d0a7e1208d93b46767be83e2b8f978c3dad35f775ac8d8847551d6fe1" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -3692,7 +3134,7 @@ dependencies = [ "ptx_parser_macros_impl", "quote", "rustc-hash 2.1.1", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -3702,7 +3144,7 @@ dependencies = [ "proc-macro2", "quote", "rustc-hash 2.1.1", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -3746,9 +3188,9 @@ checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0" [[package]] name = "quote" -version = "1.0.45" +version = "1.0.37" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924" +checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af" dependencies = [ "proc-macro2", ] @@ -3759,12 +3201,6 @@ version = "5.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f" -[[package]] -name = "r-efi" -version = "6.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf" - [[package]] name = "rancor" version = "0.1.1" @@ -3781,18 +3217,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1" dependencies = [ "rand_chacha", - "rand_core 0.9.5", -] - -[[package]] -name = "rand" -version = "0.10.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d2e8e8bcc7961af1fdac401278c6a831614941f6164ee3bf4ce61b7edb162207" -dependencies = [ - "chacha20", - "getrandom 0.4.2", - "rand_core 0.10.0", + "rand_core", ] [[package]] @@ -3802,7 +3227,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb" dependencies = [ "ppv-lite86", - "rand_core 0.9.5", + "rand_core", ] [[package]] @@ -3814,12 +3239,6 @@ dependencies = [ "getrandom 0.3.3", ] -[[package]] -name = "rand_core" -version = "0.10.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0c8d0fd677905edcbeedbf2edb6494d676f0e98d54d5cf9bda0b061cb8fb8aba" - [[package]] name = "rand_distr" version = "0.5.1" @@ -3827,7 +3246,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6a8615d50dcf34fa31f7ab52692afec947c4dd0ab803cc87cb3b0b4570ff7463" dependencies = [ "num-traits", - "rand 0.9.2", + "rand", ] [[package]] @@ -3836,7 +3255,7 @@ version = "11.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "498cd0dc59d73224351ee52a95fee0f1a617a2eae0e7d9d720cc622c73a54186" dependencies = [ - "bitflags 2.11.1", + "bitflags 2.9.1", ] [[package]] @@ -3871,7 +3290,7 @@ version = "0.5.11" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d2f103c6d277498fbceb16e84d317e2a400f160f46904d5f5410848c829511a3" dependencies = [ - "bitflags 2.11.1", + "bitflags 2.9.1", ] [[package]] @@ -3956,7 +3375,7 @@ checksum = "8100bb34c0a1d0f907143db3149e6b4eea3c33b9ee8b189720168e818303986f" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -4004,7 +3423,7 @@ version = "0.38.37" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8acb788b847c24f28525660c4d7758620a7210875711f79e7f663cc152726811" dependencies = [ - "bitflags 2.11.1", + "bitflags 2.9.1", "errno", "libc", "linux-raw-sys 0.4.14", @@ -4013,15 +3432,15 @@ dependencies = [ [[package]] name = "rustix" -version = "1.1.4" +version = "1.0.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190" +checksum = "d97817398dd4bb2e6da002002db259209759911da105da92bec29ccb12cf58bf" dependencies = [ - "bitflags 2.11.1", + "bitflags 2.9.1", "errno", "libc", - "linux-raw-sys 0.12.1", - "windows-sys 0.61.2", + "linux-raw-sys 0.9.3", + "windows-sys 0.59.0", ] [[package]] @@ -4065,12 +3484,6 @@ dependencies = [ "winapi-util", ] -[[package]] -name = "scoped-tls" -version = "1.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294" - [[package]] name = "scopeguard" version = "1.2.0" @@ -4094,7 +3507,7 @@ checksum = "1783eabc414609e28a5ba76aee5ddd52199f7107a0b24c2e9746a1ecc34a683d" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -4139,7 +3552,7 @@ checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -4170,7 +3583,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba" dependencies = [ "cfg-if", - "cpufeatures 0.2.17", + "cpufeatures", "digest", ] @@ -4184,15 +3597,6 @@ dependencies = [ "sha1", ] -[[package]] -name = "sharded-slab" -version = "0.1.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6" -dependencies = [ - "lazy_static", -] - [[package]] name = "shell-words" version = "1.1.0" @@ -4236,37 +3640,12 @@ version = "0.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e" -[[package]] -name = "slab" -version = "0.4.12" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5" - [[package]] name = "smallvec" version = "1.15.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03" -[[package]] -name = "socket2" -version = "0.6.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3a766e1110788c36f4fa1c2b71b387a7815aa65f88ce0229841826633d93723e" -dependencies = [ - "libc", - "windows-sys 0.61.2", -] - -[[package]] -name = "spin" -version = "0.9.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67" -dependencies = [ - "lock_api", -] - [[package]] name = "stable_deref_trait" version = "1.2.0" @@ -4310,7 +3689,7 @@ dependencies = [ "proc-macro2", "quote", "rustversion", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -4322,7 +3701,7 @@ dependencies = [ "heck", "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -4357,25 +3736,15 @@ dependencies = [ [[package]] name = "syn" -version = "2.0.117" +version = "2.0.89" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99" +checksum = "44d46482f1c1c87acd84dea20c1bf5ebff4c757009ed6bf19cfd36fb10e92c4e" dependencies = [ "proc-macro2", "quote", "unicode-ident", ] -[[package]] -name = "synchrony" -version = "0.1.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c174d82fd56da8214ec095cfe4568e59e5ccb49d060e70c2f98e3ba352b23e45" -dependencies = [ - "futures-util", - "loom", -] - [[package]] name = "synstructure" version = "0.13.2" @@ -4384,7 +3753,7 @@ checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -4393,7 +3762,7 @@ version = "0.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "01198a2debb237c62b6826ec7081082d951f46dbb64b0e8c7649a452230d1dfc" dependencies = [ - "bitflags 2.11.1", + "bitflags 2.9.1", "byteorder", "enum-as-inner", "libc", @@ -4427,16 +3796,10 @@ dependencies = [ "fastrand", "getrandom 0.3.3", "once_cell", - "rustix 1.1.4", + "rustix 1.0.5", "windows-sys 0.59.0", ] -[[package]] -name = "thin-cell" -version = "0.1.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4164c6c316ba9733b0ab021e7f9852c788a4b991b49c25820f1be48e1d41345b" - [[package]] name = "thiserror" version = "1.0.64" @@ -4463,7 +3826,7 @@ checksum = "08904e7672f5eb876eaaf87e0ce17857500934f4981c4a0ab2b4aa98baac7fc3" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -4474,16 +3837,7 @@ checksum = "7f7cf42b4507d8ea322120659672cf1b9dbb93f8f2d4ecfd6e51350ff5b17a1d" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", -] - -[[package]] -name = "thread_local" -version = "1.1.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f60246a4944f24f6e018aa17cdeffb7818b76356965d03b07d6a9886e8962185" -dependencies = [ - "cfg-if", + "syn 2.0.89", ] [[package]] @@ -4609,55 +3963,6 @@ version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "fcc842091f2def52017664b53082ecbbeb5c7731092bad69d2c63050401dfd64" -[[package]] -name = "tracing" -version = "0.1.44" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100" -dependencies = [ - "pin-project-lite", - "tracing-core", -] - -[[package]] -name = "tracing-core" -version = "0.1.36" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a" -dependencies = [ - "once_cell", - "valuable", -] - -[[package]] -name = "tracing-log" -version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3" -dependencies = [ - "log", - "once_cell", - "tracing-core", -] - -[[package]] -name = "tracing-subscriber" -version = "0.3.23" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cb7f578e5945fb242538965c2d0b04418d38ec25c79d160cd279bf0731c8d319" -dependencies = [ - "matchers", - "nu-ansi-term", - "once_cell", - "regex-automata", - "sharded-slab", - "smallvec", - "thread_local", - "tracing", - "tracing-core", - "tracing-log", -] - [[package]] name = "trie-hard" version = "0.1.0" @@ -4727,12 +4032,6 @@ version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "323402cff2dd658f39ca17c789b502021b3f18707c91cdf22e3838e1b4023817" -[[package]] -name = "unty" -version = "0.0.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6d49784317cd0d1ee7ec5c716dd598ec5b4483ea832a2dced265471cc0f690ae" - [[package]] name = "unwrap_or" version = "1.0.1" @@ -4762,17 +4061,10 @@ version = "1.18.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2f87b8aa10b915a06587d0dec516c282ff295b475d94abf425d62b57710070a2" dependencies = [ - "getrandom 0.3.3", "js-sys", "wasm-bindgen", ] -[[package]] -name = "valuable" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65" - [[package]] name = "vcpkg" version = "0.2.15" @@ -4823,12 +4115,6 @@ version = "0.9.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" -[[package]] -name = "virtue" -version = "0.0.18" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "051eb1abcf10076295e815102942cc58f9d5e3b4560e46e53c21e8ff6f3af7b1" - [[package]] name = "vswhom" version = "0.1.0" @@ -4874,24 +4160,6 @@ dependencies = [ "wit-bindgen-rt", ] -[[package]] -name = "wasip2" -version = "1.0.2+wasi-0.2.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9517f9239f02c069db75e65f174b3da828fe5f5b945c4dd26bd25d89c03ebcf5" -dependencies = [ - "wit-bindgen", -] - -[[package]] -name = "wasip3" -version = "0.4.0+wasi-0.3.0-rc-2026-01-06" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5" -dependencies = [ - "wit-bindgen", -] - [[package]] name = "wasm-bindgen" version = "0.2.104" @@ -4915,7 +4183,7 @@ dependencies = [ "log", "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", "wasm-bindgen-shared", ] @@ -4937,7 +4205,7 @@ checksum = "9f07d2f20d4da7b26400c9f4a0511e6e0345b040694e8a75bd41d578fa4421d7" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", "wasm-bindgen-backend", "wasm-bindgen-shared", ] @@ -4951,40 +4219,6 @@ dependencies = [ "unicode-ident", ] -[[package]] -name = "wasm-encoder" -version = "0.244.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319" -dependencies = [ - "leb128fmt", - "wasmparser", -] - -[[package]] -name = "wasm-metadata" -version = "0.244.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909" -dependencies = [ - "anyhow", - "indexmap", - "wasm-encoder", - "wasmparser", -] - -[[package]] -name = "wasmparser" -version = "0.244.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe" -dependencies = [ - "bitflags 2.11.1", - "hashbrown 0.15.2", - "indexmap", - "semver", -] - [[package]] name = "web-time" version = "1.1.0" @@ -5032,38 +4266,16 @@ version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" -[[package]] -name = "windows" -version = "0.61.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9babd3a767a4c1aef6900409f85f5d53ce2544ccdfaa86dad48c91782c6d6893" -dependencies = [ - "windows-collections 0.2.0", - "windows-core 0.61.2", - "windows-future 0.2.1", - "windows-link 0.1.3", - "windows-numerics 0.2.0", -] - [[package]] name = "windows" version = "0.62.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "527fadee13e0c05939a6a05d5bd6eec6cd2e3dbd648b9f8e447c6518133d8580" dependencies = [ - "windows-collections 0.3.2", - "windows-core 0.62.2", - "windows-future 0.3.2", - "windows-numerics 0.3.1", -] - -[[package]] -name = "windows-collections" -version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3beeceb5e5cfd9eb1d76b381630e82c4241ccd0d27f1a39ed41b2760b255c5e8" -dependencies = [ - "windows-core 0.61.2", + "windows-collections", + "windows-core", + "windows-future", + "windows-numerics", ] [[package]] @@ -5072,20 +4284,7 @@ version = "0.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "23b2d95af1a8a14a3c7367e1ed4fc9c20e0a26e79551b1454d72583c97cc6610" dependencies = [ - "windows-core 0.62.2", -] - -[[package]] -name = "windows-core" -version = "0.61.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3" -dependencies = [ - "windows-implement", - "windows-interface", - "windows-link 0.1.3", - "windows-result 0.3.4", - "windows-strings 0.4.2", + "windows-core", ] [[package]] @@ -5096,20 +4295,9 @@ checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb" dependencies = [ "windows-implement", "windows-interface", - "windows-link 0.2.1", - "windows-result 0.4.1", - "windows-strings 0.5.1", -] - -[[package]] -name = "windows-future" -version = "0.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fc6a41e98427b19fe4b73c550f060b59fa592d7d686537eebf9385621bfbad8e" -dependencies = [ - "windows-core 0.61.2", - "windows-link 0.1.3", - "windows-threading 0.1.0", + "windows-link", + "windows-result", + "windows-strings", ] [[package]] @@ -5118,9 +4306,9 @@ version = "0.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e1d6f90251fe18a279739e78025bd6ddc52a7e22f921070ccdc67dde84c605cb" dependencies = [ - "windows-core 0.62.2", - "windows-link 0.2.1", - "windows-threading 0.2.1", + "windows-core", + "windows-link", + "windows-threading", ] [[package]] @@ -5131,7 +4319,7 @@ checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -5142,48 +4330,23 @@ checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] -[[package]] -name = "windows-link" -version = "0.1.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a" - [[package]] name = "windows-link" version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" -[[package]] -name = "windows-numerics" -version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9150af68066c4c5c07ddc0ce30421554771e528bde427614c61038bc2c92c2b1" -dependencies = [ - "windows-core 0.61.2", - "windows-link 0.1.3", -] - [[package]] name = "windows-numerics" version = "0.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6e2e40844ac143cdb44aead537bbf727de9b044e107a0f1220392177d15b0f26" dependencies = [ - "windows-core 0.62.2", - "windows-link 0.2.1", -] - -[[package]] -name = "windows-result" -version = "0.3.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6" -dependencies = [ - "windows-link 0.1.3", + "windows-core", + "windows-link", ] [[package]] @@ -5192,16 +4355,7 @@ version = "0.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5" dependencies = [ - "windows-link 0.2.1", -] - -[[package]] -name = "windows-strings" -version = "0.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57" -dependencies = [ - "windows-link 0.1.3", + "windows-link", ] [[package]] @@ -5210,7 +4364,7 @@ version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091" dependencies = [ - "windows-link 0.2.1", + "windows-link", ] [[package]] @@ -5237,7 +4391,7 @@ version = "0.61.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" dependencies = [ - "windows-link 0.2.1", + "windows-link", ] [[package]] @@ -5256,22 +4410,13 @@ dependencies = [ "windows_x86_64_msvc", ] -[[package]] -name = "windows-threading" -version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b66463ad2e0ea3bbf808b7f1d371311c80e115c0b71d60efc142cafbcfb057a6" -dependencies = [ - "windows-link 0.1.3", -] - [[package]] name = "windows-threading" version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3949bd5b99cafdf1c7ca86b43ca564028dfe27d66958f2470940f73d86d75b37" dependencies = [ - "windows-link 0.2.1", + "windows-link", ] [[package]] @@ -5350,101 +4495,13 @@ dependencies = [ "windows-sys 0.59.0", ] -[[package]] -name = "wit-bindgen" -version = "0.51.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5" -dependencies = [ - "wit-bindgen-rust-macro", -] - -[[package]] -name = "wit-bindgen-core" -version = "0.51.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc" -dependencies = [ - "anyhow", - "heck", - "wit-parser", -] - [[package]] name = "wit-bindgen-rt" version = "0.39.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6f42320e61fe2cfd34354ecb597f86f413484a798ba44a8ca1165c58d42da6c1" dependencies = [ - "bitflags 2.11.1", -] - -[[package]] -name = "wit-bindgen-rust" -version = "0.51.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21" -dependencies = [ - "anyhow", - "heck", - "indexmap", - "prettyplease", - "syn 2.0.117", - "wasm-metadata", - "wit-bindgen-core", - "wit-component", -] - -[[package]] -name = "wit-bindgen-rust-macro" -version = "0.51.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0c0f9bfd77e6a48eccf51359e3ae77140a7f50b1e2ebfe62422d8afdaffab17a" -dependencies = [ - "anyhow", - "prettyplease", - "proc-macro2", - "quote", - "syn 2.0.117", - "wit-bindgen-core", - "wit-bindgen-rust", -] - -[[package]] -name = "wit-component" -version = "0.244.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2" -dependencies = [ - "anyhow", - "bitflags 2.11.1", - "indexmap", - "log", - "serde", - "serde_derive", - "serde_json", - "wasm-encoder", - "wasm-metadata", - "wasmparser", - "wit-parser", -] - -[[package]] -name = "wit-parser" -version = "0.244.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736" -dependencies = [ - "anyhow", - "id-arena", - "indexmap", - "log", - "semver", - "serde", - "serde_derive", - "serde_json", - "unicode-xid", - "wasmparser", + "bitflags 2.9.1", ] [[package]] @@ -5460,7 +4517,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0d65cbf2f12c15564212d48f4e3dfb87923d25d611f2aed18f4cb23f0413d89e" dependencies = [ "libc", - "rustix 1.1.4", + "rustix 1.0.5", ] [[package]] @@ -5503,7 +4560,7 @@ checksum = "38da3c9736e16c5d3c8c597a9aaa5d1fa565d0532ae05e27c24aa62fb32c0ab6" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", "synstructure", ] @@ -5524,7 +4581,7 @@ checksum = "9ecf5b4cc5364572d7f4c329661bcc82724222973f2cab6f050a4e5c22f75181" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -5544,7 +4601,7 @@ checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", "synstructure", ] @@ -5578,7 +4635,7 @@ checksum = "5b96237efa0c878c64bd89c436f661be4e46b2f3eff1ebb976f7ef2321d2f58f" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -5640,47 +4697,12 @@ dependencies = [ "serde_json", "tempfile", "vergen-gix", - "windows 0.62.2", + "windows", "zluda_cache", "zluda_common", "zluda_windows", ] -[[package]] -name = "zluda32" -version = "0.0.0" -dependencies = [ - "bincode", - "bitcode", - "cuda_macros", - "cuda_types", - "dark_api", - "ipc-channel", - "paste", - "postcard", - "rand 0.10.1", - "rkyv", - "widestring", - "windows 0.62.2", - "zluda_server_common", - "zluda_windows", -] - -[[package]] -name = "zluda64_server" -version = "0.0.0" -dependencies = [ - "bincode", - "compio", - "cuda_macros", - "cuda_types", - "dark_api", - "rkyv", - "slab", - "windows-sys 0.61.2", - "zluda_server_common", -] - [[package]] name = "zluda_bindgen" version = "0.1.0" @@ -5692,7 +4714,7 @@ dependencies = [ "proc-macro2", "quote", "rustc-hash 2.1.1", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -5789,9 +4811,9 @@ dependencies = [ "half", "libloading", "paste", - "rand 0.9.2", + "rand", "rand_chacha", - "windows 0.62.2", + "windows", "zluda_common", "zluda_dnn", "zluda_windows", @@ -5815,8 +4837,8 @@ dependencies = [ "rustc-hash 2.1.1", "tempfile", "widestring", - "windows 0.62.2", - "windows-core 0.62.2", + "windows", + "windows-core", "zluda_ml", "zluda_redirect", "zluda_trace", @@ -5860,27 +4882,12 @@ dependencies = [ "rustc-hash 2.1.1", "unwrap_or", "widestring", - "windows 0.62.2", + "windows", "windows-sys 0.61.2", "winnow 0.6.20", "zluda_windows", ] -[[package]] -name = "zluda_server_common" -version = "0.0.0" -dependencies = [ - "bincode", - "bitcode", - "cuda_macros", - "cuda_types", - "paste", - "postcard", - "rkyv", - "strum 0.28.0", - "strum_macros 0.28.0", -] - [[package]] name = "zluda_sparse" version = "0.0.0" @@ -5912,11 +4919,12 @@ dependencies = [ "libloading", "parking_lot", "paste", + "ptx", "ptx_parser", "regex", "rustc-hash 2.1.1", "unwrap_or", - "windows 0.62.2", + "windows", "zluda_common", "zluda_trace_common", "zstd-safe", @@ -6047,7 +5055,7 @@ dependencies = [ "trie-hard", "uuid", "widestring", - "windows 0.62.2", + "windows", ] [[package]] diff --git a/Cargo.toml b/Cargo.toml index 066ca9602..d199126eb 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -16,8 +16,6 @@ members = [ "ext/rocblas-sys", "format", "kernel_metadata", - "nvapi", - "nvapi_trace", "ptx_parser_macros_impl", "ptx_parser_macros", "ptx_parser", @@ -38,7 +36,6 @@ members = [ "zluda_ml", "zluda_precompile", "zluda_redirect", - "zluda_server_common", "zluda_sparse", "zluda_trace_blas", "zluda_trace_blaslt", @@ -50,8 +47,6 @@ members = [ "zluda_trace_sparse", "zluda_trace", "zluda", - "zluda32", - "zluda64_server", ] default-members = ["zluda", "zluda_ml", "zluda_inject", "zluda_redirect", "compiler"] diff --git a/cuda_check/Cargo.toml b/cuda_check/Cargo.toml index baefa150c..c0b9c3d4d 100644 --- a/cuda_check/Cargo.toml +++ b/cuda_check/Cargo.toml @@ -13,7 +13,7 @@ cuda_types = { path = "../cuda_types" } zluda_windows = { path = "../zluda_windows" } bpaf = { version = "0.9.19", features = ["derive", "bright-color"] } owo-colors = { version = "4", features = ["supports-colors"] } -rand = "0.10.1" +rand = "0.9.2" libloading = "0.8" [target.'cfg(windows)'.dependencies] diff --git a/cuda_macros/src/lib.rs b/cuda_macros/src/lib.rs index 1267860b9..769a672b9 100644 --- a/cuda_macros/src/lib.rs +++ b/cuda_macros/src/lib.rs @@ -9,7 +9,8 @@ use syn::parse::{Parse, ParseStream}; use syn::punctuated::Punctuated; use syn::visit_mut::VisitMut; use syn::{ - File, ForeignItem, ForeignItemFn, Ident, Item, PatType, Path, Signature, Token, TypeGroup, bracketed, parse_macro_input + bracketed, parse_macro_input, File, ForeignItem, ForeignItemFn, Ident, Item, Path, Signature, + Token }; const CUDA_RS: &'static str = include_str! {"cuda.rs"}; @@ -300,95 +301,6 @@ pub fn nvml_normalize_fn(tokens: TokenStream) -> TokenStream { normalize_fn_impl("nvml", None, tokens) } -#[proc_macro] -pub fn generate_input_struct(tokens: TokenStream) -> TokenStream { - let input = parse_macro_input!(tokens as FnWithFields); - let struct_name = format_ident!("{}In", input.fn_name); - let fields = input.fields.iter().filter(|pat| is_input_field(&pat.ty)).map(use_wire_object); - quote! { - #[derive(Archive, Deserialize, Serialize, Debug, PartialEq)] - #[repr(C)] - pub struct #struct_name { - #(#fields),* - } - unsafe impl Portable for #struct_name {} - }.into() -} - -#[proc_macro] -pub fn generate_output_struct(tokens: TokenStream) -> TokenStream { - let input = parse_macro_input!(tokens as FnWithFields); - let struct_name = format_ident!("{}Out", input.fn_name); - let fields = input.fields.iter().filter(|pat| !is_input_field(&pat.ty)).map(strip_mut_ptr); - quote! { - #[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] - #[repr(C)] - pub struct #struct_name { - #(#fields),* - } - unsafe impl Portable for #struct_name {} - }.into() -} - -fn is_input_field(ty: &syn::Type) -> bool { - match ty { - syn::Type::Ptr(token) if token.mutability.is_some() => false, - syn::Type::Group(TypeGroup {elem, ..}) => is_input_field(&*elem), - _ => true - } -} - -fn use_wire_object(ty: &syn::PatType) -> proc_macro2::TokenStream { - let pat = &ty.pat; - let type_ = &ty.ty; - quote! { pub #pat : <#type_ as crate::CudaEncode>::WireObject } -} - -fn strip_mut_ptr(ty: &syn::PatType) -> proc_macro2::TokenStream { - fn strip_mut_ptr_from_type(ty: &syn::Type) -> proc_macro2::TokenStream { - match ty { - syn::Type::Ptr(token) => { - let elem = &token.elem; - quote! { #elem } - }, - _ => unreachable!() - } - } - let pat = &ty.pat; - match &*ty.ty { - syn::Type::Ptr(token) => { - let type_ = strip_mut_ptr_from_type(&*token.elem); - quote! { pub #pat : <#type_ as crate::CudaEncode>::WireObject } - }, - syn::Type::Group(TypeGroup {elem, ..}) => { - let type_ = strip_mut_ptr_from_type(&*elem); - quote! { pub #pat : <#type_ as crate::CudaEncode>::WireObject } - }, - _ => unreachable!() - } -} - -struct FnWithFields { - fn_name: Ident, - fields: Punctuated, -} - -impl Parse for FnWithFields { - fn parse(input: ParseStream) -> syn::Result { - let fn_name = input.parse::()?; - let fields = if input.is_empty() { - Punctuated::new() - } else { - input.parse::()?; - input.parse_terminated(PatType::parse, Token![,])? - }; - Ok(Self { - fn_name, - fields, - }) - } -} - fn split(fn_: &str) -> Vec { let mut result = Vec::new(); let mut chars: iter::Peekable<_> = fn_.chars().peekable(); diff --git a/dark_api/src/lib.rs b/dark_api/src/lib.rs index 6b2d452e9..cfd8c928e 100644 --- a/dark_api/src/lib.rs +++ b/dark_api/src/lib.rs @@ -354,7 +354,6 @@ dark_api! { #[noformat] [0] = logged_call( fn_name: cglue::slice::CSliceRef<'static, u8>, - nvapi_interface: u32, args: crate::FnFfiRef, fn_: crate::FnFfiRef, internal_error: usize, diff --git a/nvapi/Cargo.toml b/nvapi/Cargo.toml deleted file mode 100644 index a3699b162..000000000 --- a/nvapi/Cargo.toml +++ /dev/null @@ -1,26 +0,0 @@ -[package] -name = "nvapi" -version = "0.0.0" -authors = ["Andrzej Janik "] -edition = "2021" - -[lib] -name = "nvapi64" -crate-type = ["cdylib"] - -[dependencies] -format = { path = "../format" } -dark_api = { path = "../dark_api" } -cuda_macros = { path = "../cuda_macros" } -cuda_types = { path = "../cuda_types" } -zluda_trace_common = { path = "../zluda_trace_common" } -libloading = "0.8" -paste = "1.0" -unwrap_or = "1.0.1" -cglue = "0.3.5" -rustc-hash = "2.0.0" - -[package.metadata.zluda] -windows_only = true -windows32_paths = ["nvapi.dll"] -32bit = true diff --git a/nvapi/src/lib.rs b/nvapi/src/lib.rs deleted file mode 100644 index 43b427481..000000000 --- a/nvapi/src/lib.rs +++ /dev/null @@ -1,656 +0,0 @@ -use crate::nvapi::*; -use libloading::Library; -use rustc_hash::FxHashMap; -use std::{ - collections::hash_map, - ffi::c_void, - mem, ptr, - sync::{LazyLock, Mutex}, -}; - -#[allow(warnings)] -mod nvapi; - -macro_rules! interface_to_name { - ($({ $name:ident, $id:literal }),* $(,)?) => { - fn interface_to_fn(interface: u32) -> Option<*mut c_void> { - match interface { - $( - $id => Some($name as *mut c_void), - )* - _ => None, - } - } - }; -} - -interface_to_name!( - { NvAPI_Initialize, 0x0150e828 }, - { NvAPI_Unload, 0xd22bdd7e }, - // { NvAPI_GetErrorMessage, 0x6c2d048c }, - // { NvAPI_GetInterfaceVersionString, 0x01053fa5 }, - // { NvAPI_GPU_GetEDID, 0x37d32e69 }, - // { NvAPI_SetView, 0x0957d7b6 }, - // { NvAPI_SetViewEx, 0x06b89e68 }, - { NvAPI_GetDisplayDriverVersion, 0xf951a4d1 }, - { NvAPI_SYS_GetDriverAndBranchVersion, 0x2926aaad }, - // { NvAPI_GPU_GetMemoryInfo, 0x07f9b368 }, - // { NvAPI_GPU_GetMemoryInfoEx, 0xc0599498 }, - // { NvAPI_OGL_ExpertModeSet, 0x3805ef7a }, - // { NvAPI_OGL_ExpertModeGet, 0x22ed9516 }, - // { NvAPI_OGL_ExpertModeDefaultsSet, 0xb47a657e }, - // { NvAPI_OGL_ExpertModeDefaultsGet, 0xae921f12 }, - // { NvAPI_EnumPhysicalGPUs, 0xe5ac921f }, - // { NvAPI_EnumTCCPhysicalGPUs, 0xd9930b07 }, - // { NvAPI_EnumLogicalGPUs, 0x48b3ea59 }, - // { NvAPI_GetPhysicalGPUsFromDisplay, 0x34ef9506 }, - // { NvAPI_GetPhysicalGPUFromUnAttachedDisplay, 0x5018ed61 }, - // { NvAPI_GetLogicalGPUFromDisplay, 0xee1370cf }, - // { NvAPI_GetLogicalGPUFromPhysicalGPU, 0xadd604d1 }, - // { NvAPI_GetPhysicalGPUsFromLogicalGPU, 0xaea3fa32 }, - { NvAPI_GetPhysicalGPUFromGPUID, 0x5380ad1a }, - { NvAPI_GetGPUIDfromPhysicalGPU, 0x6533ea3e }, - // { NvAPI_GPU_GetShaderSubPipeCount, 0x0be17923 }, - // { NvAPI_GPU_GetGpuCoreCount, 0xc7026a87 }, - // { NvAPI_GPU_GetAllOutputs, 0x7d554f8e }, - // { NvAPI_GPU_GetConnectedOutputs, 0x1730bfc9 }, - // { NvAPI_GPU_GetConnectedSLIOutputs, 0x0680de09 }, - // { NvAPI_GPU_GetConnectedDisplayIds, 0x0078dba2 }, - // { NvAPI_GPU_GetAllDisplayIds, 0x785210a2 }, - // { NvAPI_GPU_GetConnectedOutputsWithLidState, 0xcf8caf39 }, - // { NvAPI_GPU_GetConnectedSLIOutputsWithLidState, 0x96043cc7 }, - // { NvAPI_GPU_GetSystemType, 0xbaaabfcc }, - // { NvAPI_GPU_GetActiveOutputs, 0xe3e89b6f }, - // { NvAPI_GPU_SetEDID, 0xe83d6456 }, - // { NvAPI_GPU_GetOutputType, 0x40a505e4 }, - // { NvAPI_GPU_ValidateOutputCombination, 0x34c9c2d4 }, - // { NvAPI_GPU_GetFullName, 0xceee8e9f }, - // { NvAPI_GPU_GetPCIIdentifiers, 0x2ddfb66e }, - // { NvAPI_GPU_GetGPUType, 0xc33baeb1 }, - // { NvAPI_GPU_GetBusType, 0x1bb18724 }, - // { NvAPI_GPU_GetBusId, 0x1be0b8e5 }, - // { NvAPI_GPU_GetBusSlotId, 0x2a0a350f }, - // { NvAPI_GPU_GetIRQ, 0xe4715417 }, - // { NvAPI_GPU_GetVbiosRevision, 0xacc3da0a }, - // { NvAPI_GPU_GetVbiosOEMRevision, 0x2d43fb31 }, - // { NvAPI_GPU_GetVbiosVersionString, 0xa561fd7d }, - // { NvAPI_GPU_GetAGPAperture, 0x6e042794 }, - // { NvAPI_GPU_GetCurrentAGPRate, 0xc74925a0 }, - // { NvAPI_GPU_GetCurrentPCIEDownstreamWidth, 0xd048c3b1 }, - // { NvAPI_GPU_GetPhysicalFrameBufferSize, 0x46fbeb03 }, - // { NvAPI_GPU_GetVirtualFrameBufferSize, 0x5a04b644 }, - // { NvAPI_GPU_GetQuadroStatus, 0xe332fa47 }, - // { NvAPI_GPU_GetBoardInfo, 0x22d54523 }, - // { NvAPI_GPU_GetRamBusWidth, 0x7975c581 }, - // { NvAPI_GPU_GetArchInfo, 0xd8265d24 }, - // { NvAPI_I2CRead, 0x2fde12c5 }, - // { NvAPI_I2CWrite, 0xe812eb07 }, - // { NvAPI_GPU_WorkstationFeatureSetup, 0x6c1f3fe4 }, - // { NvAPI_GPU_WorkstationFeatureQuery, 0x004537df }, - // { NvAPI_GPU_GetHDCPSupportStatus, 0xf089eef5 }, - { NvAPI_GPU_CudaEnumComputeCapableGpus, 0x5786cc6e }, - // { NvAPI_GPU_GetTachReading, 0x5f608315 }, - // { NvAPI_GPU_GetECCStatusInfo, 0xca1ddaf3 }, - // { NvAPI_GPU_GetECCErrorInfo, 0xc71f85a6 }, - // { NvAPI_GPU_ResetECCErrorInfo, 0xc02eec20 }, - // { NvAPI_GPU_GetECCConfigurationInfo, 0x77a796f3 }, - // { NvAPI_GPU_SetECCConfiguration, 0x1cf639d9 }, - // { NvAPI_GPU_QueryWorkstationFeatureSupport, 0x80b1abb9 }, - // { NvAPI_GPU_SetScanoutIntensity, 0xa57457a4 }, - // { NvAPI_GPU_GetScanoutIntensityState, 0xe81ce836 }, - // { NvAPI_GPU_SetScanoutWarping, 0xb34bab4f }, - // { NvAPI_GPU_GetScanoutWarpingState, 0x6f5435af }, - // { NvAPI_GPU_SetScanoutCompositionParameter, 0xf898247d }, - // { NvAPI_GPU_GetScanoutCompositionParameter, 0x58fe51e6 }, - // { NvAPI_GPU_GetScanoutConfiguration, 0x6a9f5b63 }, - // { NvAPI_GPU_GetScanoutConfigurationEx, 0xe2e1e6f0 }, - // { NvAPI_GPU_GetAdapterIdFromPhysicalGpu, 0x0ff07fde }, - // { NvAPI_GPU_GetVirtualizationInfo, 0x44e022a9 }, - // { NvAPI_GPU_GetLogicalGpuInfo, 0x842b066e }, - // { NvAPI_GPU_GetLicensableFeatures, 0x3fc596aa }, - // { NvAPI_GPU_GetEncoderStatistics, 0xf0a9aeeb }, - // { NvAPI_GPU_GetEncoderSessionsInfo, 0xd8a72ce5 }, - // { NvAPI_GPU_GetGPUInfo, 0xafd1b02c }, - // { NvAPI_GPU_GetVRReadyData, 0x81d629c5 }, - // { NvAPI_GPU_GetGspFeatures, 0x581c4391 }, - // { NvAPI_GPU_GetUUID, 0xdc95673d }, - // { NvAPI_GPU_NVLINK_GetCaps, 0xbef1119d }, - // { NvAPI_GPU_NVLINK_GetStatus, 0xc72a38e3 }, - // { NvAPI_GPU_GetPerfDecreaseInfo, 0x7f7f4600 }, - // { NvAPI_GPU_GetPstatesInfoEx, 0x843c0256 }, - // { NvAPI_GPU_GetPstates20, 0x6ff81213 }, - // { NvAPI_GPU_GetCurrentPstate, 0x927da4f6 }, - // { NvAPI_GPU_GetDynamicPstatesInfoEx, 0x60ded2ed }, - // { NvAPI_GPU_GetThermalSettings, 0xe3640a56 }, - // { NvAPI_GPU_GetAllClockFrequencies, 0xdcb616c3 }, - // { NvAPI_GPU_QueryIlluminationSupport, 0xa629da31 }, - // { NvAPI_GPU_GetIllumination, 0x9a1b9365 }, - // { NvAPI_GPU_SetIllumination, 0x0254a187 }, - // { NvAPI_GPU_ClientIllumDevicesGetInfo, 0xd4100e58 }, - // { NvAPI_GPU_ClientIllumDevicesGetControl, 0x73c01d58 }, - // { NvAPI_GPU_ClientIllumDevicesSetControl, 0x57024c62 }, - // { NvAPI_GPU_ClientIllumZonesGetInfo, 0x4b81241b }, - // { NvAPI_GPU_ClientIllumZonesGetControl, 0x3dbf5764 }, - // { NvAPI_GPU_ClientIllumZonesSetControl, 0x197d065e }, - // { NvAPI_Event_RegisterCallback, 0xe6dbea69 }, - // { NvAPI_Event_UnregisterCallback, 0xde1f9b45 }, - // { NvAPI_EnumNvidiaDisplayHandle, 0x9abdd40d }, - // { NvAPI_EnumNvidiaUnAttachedDisplayHandle, 0x20de9260 }, - // { NvAPI_CreateDisplayFromUnAttachedDisplay, 0x63f9799e }, - // { NvAPI_GetAssociatedNvidiaDisplayHandle, 0x35c29134 }, - // { NvAPI_DISP_GetAssociatedUnAttachedNvidiaDisplayHandle, 0xa70503b2 }, - // { NvAPI_GetAssociatedNvidiaDisplayName, 0x22a78b05 }, - // { NvAPI_GetUnAttachedAssociatedDisplayName, 0x4888d790 }, - // { NvAPI_EnableHWCursor, 0x2863148d }, - // { NvAPI_DisableHWCursor, 0xab163097 }, - // { NvAPI_GetVBlankCounter, 0x67b5db55 }, - // { NvAPI_SetRefreshRateOverride, 0x3092ac32 }, - // { NvAPI_GetAssociatedDisplayOutputId, 0xd995937e }, - // { NvAPI_GetDisplayPortInfo, 0xc64ff367 }, - // { NvAPI_SetDisplayPort, 0xfa13e65a }, - // { NvAPI_GetHDMISupportInfo, 0x6ae16ec3 }, - // { NvAPI_Disp_InfoFrameControl, 0x6067af3f }, - // { NvAPI_Disp_ColorControl, 0x92f9d80d }, - // { NvAPI_Disp_GetHdrCapabilities, 0x84f2a8df }, - // { NvAPI_Disp_HdrColorControl, 0x351da224 }, - // { NvAPI_Disp_SetSourceColorSpace, 0x473b6caf }, - // { NvAPI_Disp_GetSourceColorSpace, 0xceedc85b }, - // { NvAPI_Disp_SetSourceHdrMetadata, 0x905eb63b }, - // { NvAPI_Disp_GetSourceHdrMetadata, 0x0d3f52da }, - // { NvAPI_Disp_SetOutputMode, 0x98e7661a }, - // { NvAPI_Disp_GetOutputMode, 0x81fed88d }, - // { NvAPI_Disp_SetHdrToneMapping, 0xdd6da362 }, - // { NvAPI_Disp_GetHdrToneMapping, 0xfbd36e71 }, - // { NvAPI_Disp_GetColorimetry, 0x00b421ad }, - // { NvAPI_DISP_GetTiming, 0x175167e9 }, - // { NvAPI_DISP_GetMonitorCapabilities, 0x3b05c7e1 }, - // { NvAPI_DISP_GetMonitorColorCapabilities, 0x6ae4cfb5 }, - // { NvAPI_DISP_EnumCustomDisplay, 0xa2072d59 }, - // { NvAPI_DISP_TryCustomDisplay, 0x1f7db630 }, - // { NvAPI_DISP_DeleteCustomDisplay, 0x552e5b9b }, - // { NvAPI_DISP_SaveCustomDisplay, 0x49882876 }, - // { NvAPI_DISP_RevertCustomDisplayTrial, 0xcbbd40f0 }, - // { NvAPI_GetView, 0xd6b99d89 }, - // { NvAPI_GetViewEx, 0xdbbc0af4 }, - // { NvAPI_GetSupportedViews, 0x66fb7fc0 }, - // { NvAPI_DISP_GetDisplayIdByDisplayName, 0xae457190 }, - // { NvAPI_DISP_GetGDIPrimaryDisplayId, 0x1e9d8a31 }, - // { NvAPI_DISP_GetDisplayConfig, 0x11abccf8 }, - // { NvAPI_DISP_SetDisplayConfig, 0x5d8cf8de }, - // { NvAPI_DISP_GetEdidData, 0x436ced76 }, - // { NvAPI_DISP_GetAdaptiveSyncData, 0xb73d1ee9 }, - // { NvAPI_DISP_SetAdaptiveSyncData, 0x3eebba1d }, - // { NvAPI_DISP_GetVirtualRefreshRateData, 0x8c00429a }, - // { NvAPI_DISP_SetVirtualRefreshRateData, 0x5abbe6a3 }, - // { NvAPI_DISP_SetPreferredStereoDisplay, 0xc9d0e25f }, - // { NvAPI_DISP_GetPreferredStereoDisplay, 0x1f6b4666 }, - // { NvAPI_DISP_GetNvManagedDedicatedDisplays, 0xdbdf0cb2 }, - // { NvAPI_DISP_AcquireDedicatedDisplay, 0x47c917ba }, - // { NvAPI_DISP_ReleaseDedicatedDisplay, 0x1247825f }, - // { NvAPI_DISP_GetNvManagedDedicatedDisplayMetadata, 0xd645d80c }, - // { NvAPI_DISP_SetNvManagedDedicatedDisplayMetadata, 0x3d8b129a }, - // { NvAPI_Disp_GetDisplayIdInfo, 0xbae8aa5e }, - // { NvAPI_Disp_GetDisplayIdsFromTarget, 0xe7e5f89e }, - // { NvAPI_Disp_GetVRRInfo, 0xdf8fda57 }, - // { NvAPI_Mosaic_GetSupportedTopoInfo, 0xfdb63c81 }, - // { NvAPI_Mosaic_GetTopoGroup, 0xcb89381d }, - // { NvAPI_Mosaic_GetOverlapLimits, 0x989685f0 }, - // { NvAPI_Mosaic_SetCurrentTopo, 0x9b542831 }, - // { NvAPI_Mosaic_GetCurrentTopo, 0xec32944e }, - // { NvAPI_Mosaic_EnableCurrentTopo, 0x5f1aa66c }, - // { NvAPI_Mosaic_GetDisplayViewportsByResolution, 0xdc6dc8d3 }, - // { NvAPI_Mosaic_SetDisplayGrids, 0x4d959a89 }, - // { NvAPI_Mosaic_ValidateDisplayGrids, 0xcf43903d }, - // { NvAPI_Mosaic_EnumDisplayModes, 0x78db97d7 }, - // { NvAPI_Mosaic_EnumDisplayGrids, 0xdf2887af }, - // { NvAPI_GetSupportedMosaicTopologies, 0x410b5c25 }, - // { NvAPI_GetCurrentMosaicTopology, 0xf60852bd }, - // { NvAPI_SetCurrentMosaicTopology, 0xd54b8989 }, - // { NvAPI_EnableCurrentMosaicTopology, 0x74073cc9 }, - // { NvAPI_GSync_EnumSyncDevices, 0xd9639601 }, - // { NvAPI_GSync_QueryCapabilities, 0x44a3f1d1 }, - // { NvAPI_GSync_GetTopology, 0x4562bc38 }, - // { NvAPI_GSync_SetSyncStateSettings, 0x60acdfdd }, - // { NvAPI_GSync_GetControlParameters, 0x16de1c6a }, - // { NvAPI_GSync_SetControlParameters, 0x8bbff88b }, - // { NvAPI_GSync_AdjustSyncDelay, 0x2d11ff51 }, - // { NvAPI_GSync_GetSyncStatus, 0xf1f5b434 }, - // { NvAPI_GSync_GetStatusParameters, 0x70d404ec }, - // { NvAPI_D3D_GetCurrentSLIState, 0x4b708b54 }, - // { NvAPI_D3D9_RegisterResource, 0xa064bdfc }, - // { NvAPI_D3D9_UnregisterResource, 0xbb2b17aa }, - // { NvAPI_D3D9_AliasSurfaceAsTexture, 0xe5ceae41 }, - // { NvAPI_D3D9_StretchRectEx, 0x22de03aa }, - // { NvAPI_D3D9_ClearRT, 0x332d3942 }, - // { NvAPI_D3D_GetObjectHandleForResource, 0xfceac864 }, - // { NvAPI_D3D_SetResourceHint, 0x6c0ed98c }, - // { NvAPI_D3D_BeginResourceRendering, 0x91123d6a }, - // { NvAPI_D3D_EndResourceRendering, 0x37e7191c }, - // { NvAPI_D3D9_GetSurfaceHandle, 0x0f2dd3f2 }, - // { NvAPI_D3D9_VideoSetStereoInfo, 0xb852f4db }, - // { NvAPI_D3D10_SetDepthBoundsTest, 0x4eadf5d2 }, - // { NvAPI_D3D11_CreateDevice, 0x6a16d3a0 }, - // { NvAPI_D3D11_CreateDeviceAndSwapChain, 0xbb939ee5 }, - // { NvAPI_D3D11_SetDepthBoundsTest, 0x7aaf7a04 }, - // { NvAPI_D3D11_IsNvShaderExtnOpCodeSupported, 0x5f68da40 }, - // { NvAPI_D3D11_SetNvShaderExtnSlot, 0x8e90bb9f }, - // { NvAPI_D3D12_SetNvShaderExtnSlotSpace, 0xac2dfeb5 }, - // { NvAPI_D3D12_SetNvShaderExtnSlotSpaceLocalThread, 0x43d867c0 }, - // { NvAPI_D3D11_SetNvShaderExtnSlotLocalThread, 0x0e6482a0 }, - // { NvAPI_D3D11_BeginUAVOverlapEx, 0xba08208a }, - // { NvAPI_D3D11_BeginUAVOverlap, 0x65b93ca8 }, - // { NvAPI_D3D11_EndUAVOverlap, 0x2216a357 }, - // { NvAPI_D3D11_GetResourceHandle, 0x09d52986 }, - // { NvAPI_D3D_SetFPSIndicatorState, 0xa776e8db }, - // { NvAPI_D3D9_Present, 0x05650beb }, - // { NvAPI_D3D9_QueryFrameCount, 0x9083e53a }, - // { NvAPI_D3D9_ResetFrameCount, 0xfa6a0675 }, - // { NvAPI_D3D9_QueryMaxSwapGroup, 0x5995410d }, - // { NvAPI_D3D9_QuerySwapGroup, 0xeba4d232 }, - // { NvAPI_D3D9_JoinSwapGroup, 0x7d44bb54 }, - // { NvAPI_D3D9_BindSwapBarrier, 0x9c39c246 }, - // { NvAPI_D3D_SetVerticalSyncMode, 0x5526cfd1 }, - // { NvAPI_D3D1x_Present, 0x03b845a1 }, - // { NvAPI_D3D1x_QueryFrameCount, 0x9152e055 }, - // { NvAPI_D3D1x_ResetFrameCount, 0xfbbb031a }, - // { NvAPI_D3D1x_QueryMaxSwapGroup, 0x9bb9d68f }, - // { NvAPI_D3D1x_QuerySwapGroup, 0x407f67aa }, - // { NvAPI_D3D1x_JoinSwapGroup, 0x14610cd7 }, - // { NvAPI_D3D1x_BindSwapBarrier, 0x9de8c729 }, - // { NvAPI_D3D12_QueryPresentBarrierSupport, 0xa15faef7 }, - // { NvAPI_D3D12_CreatePresentBarrierClient, 0x4d815de9 }, - // { NvAPI_D3D12_RegisterPresentBarrierResources, 0xd53c9ef0 }, - // { NvAPI_DestroyPresentBarrierClient, 0x3c5c351b }, - // { NvAPI_JoinPresentBarrier, 0x17f6bf82 }, - // { NvAPI_LeavePresentBarrier, 0xc3ec5a7f }, - // { NvAPI_QueryPresentBarrierFrameStatistics, 0x61b844a1 }, - // { NvAPI_D3D12_CreateDDisplayPresentBarrierClient, 0xb5a21987 }, - // { NvAPI_D3D11_CreateRasterizerState, 0xdb8d28af }, - // { NvAPI_D3D_ConfigureAnsel, 0x341c6c7f }, - // { NvAPI_D3D11_CreateTiledTexture2DArray, 0x7886981a }, - // { NvAPI_D3D11_CheckFeatureSupport, 0x106a487e }, - // { NvAPI_D3D11_CreateImplicitMSAATexture2D, 0xb8f79632 }, - // { NvAPI_D3D12_CreateCommittedImplicitMSAATexture2D, 0x24c6a07b }, - // { NvAPI_D3D11_ResolveSubresourceRegion, 0xe6bfedd6 }, - // { NvAPI_D3D12_ResolveSubresourceRegion, 0xc24a15bf }, - // { NvAPI_D3D11_TiledTexture2DArrayGetDesc, 0xf1a2b9d5 }, - // { NvAPI_D3D11_UpdateTileMappings, 0x9a06ea07 }, - // { NvAPI_D3D11_CopyTileMappings, 0xc09ee6bc }, - // { NvAPI_D3D11_TiledResourceBarrier, 0xd6839099 }, - // { NvAPI_D3D11_AliasMSAATexture2DAsNonMSAA, 0xf1c54fc9 }, - // { NvAPI_D3D11_CreateGeometryShaderEx_2, 0x99ed5c1c }, - // { NvAPI_D3D11_CreateVertexShaderEx, 0x0beaa0b2 }, - // { NvAPI_D3D11_CreateHullShaderEx, 0xb53cab00 }, - // { NvAPI_D3D11_CreateDomainShaderEx, 0xa0d7180d }, - // { NvAPI_D3D11_CreatePixelShaderEx_2, 0x4162822b }, - // { NvAPI_D3D11_CreateFastGeometryShaderExplicit, 0x71ab7c9c }, - // { NvAPI_D3D11_CreateFastGeometryShader, 0x525d43be }, - // { NvAPI_D3D11_DecompressView, 0x3a94e822 }, - // { NvAPI_D3D12_CreateGraphicsPipelineState, 0x2fc28856 }, - // { NvAPI_D3D12_CreateComputePipelineState, 0x2762deac }, - // { NvAPI_D3D12_SetDepthBoundsTestValues, 0xb9333fe9 }, - // { NvAPI_D3D12_CreateReservedResource, 0x2c85f101 }, - // { NvAPI_D3D12_CreateHeap, 0x5cb397cf }, - // { NvAPI_D3D12_CreateHeap2, 0x924be9d6 }, - // { NvAPI_D3D12_QueryCpuVisibleVidmem, 0x26322bc3 }, - // { NvAPI_D3D12_ReservedResourceGetDesc, 0x9aa2aabb }, - // { NvAPI_D3D12_UpdateTileMappings, 0xc6017a7d }, - // { NvAPI_D3D12_CopyTileMappings, 0x47f78194 }, - // { NvAPI_D3D12_ResourceAliasingBarrier, 0xb942bab7 }, - // { NvAPI_D3D12_CaptureUAVInfo, 0x6e5ea9db }, - // { NvAPI_D3D11_GetResourceGPUVirtualAddressEx, 0xaf6d14da }, - // { NvAPI_D3D11_EnumerateMetaCommands, 0xc7453ba8 }, - // { NvAPI_D3D11_CreateMetaCommand, 0xf505fba0 }, - // { NvAPI_D3D11_InitializeMetaCommand, 0xaec629e9 }, - // { NvAPI_D3D11_ExecuteMetaCommand, 0x82236c47 }, - // { NvAPI_D3D12_EnumerateMetaCommands, 0xcd9141d8 }, - // { NvAPI_D3D12_CreateMetaCommand, 0xeb29634b }, - // { NvAPI_D3D12_InitializeMetaCommand, 0xa4125399 }, - // { NvAPI_D3D12_ExecuteMetaCommand, 0xde24fc3d }, - // { NvAPI_D3D12_CreateCommittedResource, 0x027e98ae }, - // { NvAPI_D3D12_GetCopyableFootprints, 0xf6305eb5 }, - // { NvAPI_D3D12_CopyTextureRegion, 0x82b91b25 }, - // { NvAPI_D3D12_IsNvShaderExtnOpCodeSupported, 0x3dfacec8 }, - // { NvAPI_D3D12_GetOptimalThreadCountForMesh, 0xb43995cb }, - // { NvAPI_D3D_IsGSyncCapable, 0x9c1eed78 }, - // { NvAPI_D3D_IsGSyncActive, 0xe942b0ff }, - // { NvAPI_D3D12_SetFlipConfig, 0xf3148c42 }, - // { NvAPI_D3D1x_DisableShaderDiskCache, 0xd0cbca7d }, - // { NvAPI_D3D11_MultiGPU_GetCaps, 0xd2d25687 }, - // { NvAPI_D3D11_MultiGPU_Init, 0x017be49e }, - // { NvAPI_D3D11_CreateMultiGPUDevice, 0xbdb20007 }, - // { NvAPI_D3D_QuerySinglePassStereoSupport, 0x6f5f0a6d }, - // { NvAPI_D3D_SetSinglePassStereoMode, 0xa39e6e6e }, - // { NvAPI_D3D12_QuerySinglePassStereoSupport, 0x3b03791b }, - // { NvAPI_D3D12_SetSinglePassStereoMode, 0x83556d87 }, - // { NvAPI_D3D_QueryMultiViewSupport, 0xb6e0a41c }, - // { NvAPI_D3D_SetMultiViewMode, 0x8285c8da }, - // { NvAPI_D3D_QueryModifiedWSupport, 0xcbf9f4f5 }, - // { NvAPI_D3D_SetModifiedWMode, 0x06ea4bf4 }, - // { NvAPI_D3D12_QueryModifiedWSupport, 0x51235248 }, - // { NvAPI_D3D12_SetModifiedWMode, 0xe1fdaba7 }, - // { NvAPI_D3D_CreateLateLatchObject, 0x2db27d09 }, - // { NvAPI_D3D_QueryLateLatchSupport, 0x8ceca0ec }, - // { NvAPI_D3D_RegisterDevice, 0x8c02c4d0 }, - // { NvAPI_D3D11_MultiDrawInstancedIndirect, 0xd4e26bbf }, - // { NvAPI_D3D11_MultiDrawIndexedInstancedIndirect, 0x59e890f9 }, - // { NvAPI_D3D_ImplicitSLIControl, 0x2aede111 }, - // { NvAPI_D3D12_GetNeedsAppFPBlendClamping, 0x6ef4d2d1 }, - // { NvAPI_D3D12_UseDriverHeapPriorities, 0xf0d978a8 }, - // { NvAPI_D3D12_Mosaic_GetCompanionAllocations, 0xa46022c7 }, - // { NvAPI_D3D12_Mosaic_GetViewportAndGpuPartitions, 0xb092b818 }, - // { NvAPI_D3D1x_GetGraphicsCapabilities, 0x52b1499a }, - // { NvAPI_D3D12_GetGraphicsCapabilities, 0x01e87354 }, - // { NvAPI_D3D11_RSSetExclusiveScissorRects, 0xae4d73ef }, - // { NvAPI_D3D11_RSSetViewportsPixelShadingRates, 0x34f7938f }, - // { NvAPI_D3D11_CreateShadingRateResourceView, 0x99ca2dff }, - // { NvAPI_D3D11_RSSetShadingRateResourceView, 0x1b0c2f83 }, - // { NvAPI_D3D11_RSGetPixelShadingRateSampleOrder, 0x092442a1 }, - // { NvAPI_D3D11_RSSetPixelShadingRateSampleOrder, 0xa942373a }, - // { NvAPI_D3D_InitializeVRSHelper, 0x4780d70b }, - // { NvAPI_D3D_InitializeNvGazeHandler, 0x5b3b7479 }, - // { NvAPI_D3D_InitializeSMPAssist, 0x42763d0c }, - // { NvAPI_D3D_QuerySMPAssistSupport, 0xc57921de }, - // { NvAPI_D3D_GetSleepStatus, 0xaef96ca1 }, - // { NvAPI_D3D_SetSleepMode, 0xac1ca9e0 }, - // { NvAPI_D3D_Sleep, 0x852cd1d2 }, - // { NvAPI_D3D_SetReflexSync, 0xb9f6faff }, - // { NvAPI_D3D_GetLatency, 0x1a587f9c }, - // { NvAPI_D3D_SetLatencyMarker, 0xd9984c05 }, - // { NvAPI_D3D12_SetAsyncFrameMarker, 0x13c98f73 }, - // { NvAPI_D3D11_SetAsyncFrameMarker, 0x59c2c510 }, - // { NvAPI_D3D12_NotifyOutOfBandCommandQueue, 0x03d6e8cb }, - // { NvAPI_D3D12_SetCreateCommandQueueLowLatencyHint, 0x548c224f }, - // { NvAPI_D3D12_CreateCubinComputeShaderExV2, 0x299f5fdc }, - // { NvAPI_D3D12_CreateCubinComputeShader, 0x2a2c79e8 }, - // { NvAPI_D3D12_CreateCubinComputeShaderEx, 0x3151211b }, - // { NvAPI_D3D12_CreateCubinComputeShaderWithName, 0x1dc7261f }, - // { NvAPI_D3D12_LaunchCubinShader, 0x5c52bb86 }, - // { NvAPI_D3D12_DestroyCubinComputeShader, 0x7fb785ba }, - // { NvAPI_D3D12_GetCudaMergedTextureSamplerObject, 0x329fe6e0 }, - // { NvAPI_D3D12_GetCudaIndependentDescriptorObject, 0x0ddac234 }, - // { NvAPI_D3D12_GetCudaTextureObject, 0x80403fc9 }, - // { NvAPI_D3D12_GetCudaSurfaceObject, 0x48f5b2ee }, - // { NvAPI_D3D12_IsFatbinPTXSupported, 0x70c07832 }, - // { NvAPI_D3D12_CreateCuModule, 0xad1a677d }, - // { NvAPI_D3D12_EnumFunctionsInModule, 0x7ab88d88 }, - // { NvAPI_D3D12_CreateCuFunction, 0xe2436e22 }, - // { NvAPI_D3D12_LaunchCuKernelChain, 0x24973538 }, - // { NvAPI_D3D12_LaunchCuKernelChainEx, 0x846a9bf0 }, - // { NvAPI_D3D12_DestroyCuModule, 0x41c65285 }, - // { NvAPI_D3D12_DestroyCuFunction, 0xdf295ea6 }, - // { NvAPI_D3D11_CreateCubinComputeShaderExV2, 0xf2c71d48 }, - // { NvAPI_D3D11_CreateCubinComputeShader, 0x0ed98181 }, - // { NvAPI_D3D11_CreateCubinComputeShaderEx, 0x32c2a0f6 }, - // { NvAPI_D3D11_CreateCubinComputeShaderWithName, 0xb672be19 }, - // { NvAPI_D3D11_LaunchCubinShader, 0x427e236d }, - // { NvAPI_D3D11_DestroyCubinComputeShader, 0x01682c86 }, - // { NvAPI_D3D11_IsFatbinPTXSupported, 0x6086bd93 }, - // { NvAPI_D3D11_GetCudaIndependentViewObject, 0x34d2afa8 }, - // { NvAPI_D3D11_GetCudaMergedTextureSamplerObject, 0x5d637d8f }, - // { NvAPI_D3D11_CreateUnorderedAccessView, 0x74a497a1 }, - // { NvAPI_D3D11_CreateShaderResourceView, 0x65cb431e }, - // { NvAPI_D3D11_CreateSamplerState, 0x89eca416 }, - // { NvAPI_D3D11_GetCudaTextureObject, 0x9006fa68 }, - // { NvAPI_D3D11_GetResourceGPUVirtualAddress, 0x1819b423 }, - // { NvAPI_D3D12_GetRaytracingCaps, 0x85a6c2a0 }, - // { NvAPI_D3D12_EnableRaytracingValidation, 0x1de5991b }, - // { NvAPI_D3D12_RegisterRaytracingValidationMessageCallback, 0x8554eb38 }, - // { NvAPI_D3D12_UnregisterRaytracingValidationMessageCallback, 0x26975da6 }, - // { NvAPI_D3D12_FlushRaytracingValidationMessages, 0xb8fb1fcb }, - // { NvAPI_D3D12_GetRaytracingDisplacementMicromapArrayPrebuildInfo, 0xfa99b6de }, - // { NvAPI_D3D12_GetRaytracingOpacityMicromapArrayPrebuildInfo, 0x4726d180 }, - // { NvAPI_D3D12_SetCreatePipelineStateOptions, 0x5c607a27 }, - // { NvAPI_D3D12_CheckDriverMatchingIdentifierEx, 0xafb237d4 }, - // { NvAPI_D3D12_GetRaytracingAccelerationStructurePrebuildInfoEx, 0x8d025b77 }, - // { NvAPI_D3D12_BuildRaytracingOpacityMicromapArray, 0x814f8d11 }, - // { NvAPI_D3D12_RelocateRaytracingOpacityMicromapArray, 0x0425c538 }, - // { NvAPI_D3D12_BuildRaytracingDisplacementMicromapArray, 0x066f569d }, - // { NvAPI_D3D12_RelocateRaytracingDisplacementMicromapArray, 0x1c142308 }, - // { NvAPI_D3D12_EmitRaytracingDisplacementMicromapArrayPostbuildInfo, 0x68b9a790 }, - // { NvAPI_D3D12_EmitRaytracingOpacityMicromapArrayPostbuildInfo, 0x1d9a39b6 }, - // { NvAPI_D3D12_BuildRaytracingAccelerationStructureEx, 0xe24ead45 }, - // { NvAPI_D3D12_QueryWorkstationFeatureProperties, 0xa92ea23a }, - // { NvAPI_D3D12_CreateCommittedRDMABuffer, 0xe78dcb44 }, - // { NvAPI_D3D12_ConvertCooperativeVectorMatrix, 0x0f252cb3 }, - // { NvAPI_D3D12_ConvertCooperativeVectorMatrixMultiple, 0x96ba5235 }, - // { NvAPI_D3D12_GetPhysicalDeviceCooperativeVectorProperties, 0x8f182aec }, - // { NvAPI_D3D12_GetRaytracingMultiIndirectClusterOperationRequirementsInfo, 0x5c9163f4 }, - // { NvAPI_D3D12_RaytracingExecuteMultiIndirectClusterOperation, 0x67c798af }, - // { NvAPI_D3D12_GetRaytracingPartitionedTlasIndirectPrebuildInfo, 0xcdfdc5f2 }, - // { NvAPI_D3D12_BuildRaytracingPartitionedTlasIndirect, 0x7cfc6fc3 }, - // { NvAPI_NGX_GetNGXOverrideState, 0x3fd96fba }, - // { NvAPI_NGX_SetNGXOverrideState, 0xb60fcb4e }, - // { NvAPI_DirectD3D12GraphicsCommandList_Create, 0x74a4e712 }, - // { NvAPI_DirectD3D12GraphicsCommandList_Release, 0x99da3dde }, - // { NvAPI_DirectD3D12GraphicsCommandList_Reset, 0x999c26d8 }, - // { NvAPI_VIO_GetCapabilities, 0x1dc91303 }, - // { NvAPI_VIO_Open, 0x44ee4841 }, - // { NvAPI_VIO_Close, 0xd01bd237 }, - // { NvAPI_VIO_Status, 0x0e6ce4f1 }, - // { NvAPI_VIO_SyncFormatDetect, 0x118d48a3 }, - // { NvAPI_VIO_GetConfig, 0xd34a789b }, - // { NvAPI_VIO_SetConfig, 0x0e4eec07 }, - // { NvAPI_VIO_SetCSC, 0xa1ec8d74 }, - // { NvAPI_VIO_GetCSC, 0x7b0d72a3 }, - // { NvAPI_VIO_SetGamma, 0x964bf452 }, - // { NvAPI_VIO_GetGamma, 0x51d53d06 }, - // { NvAPI_VIO_SetSyncDelay, 0x2697a8d1 }, - // { NvAPI_VIO_GetSyncDelay, 0x462214a9 }, - // { NvAPI_VIO_GetPCIInfo, 0xb981d935 }, - // { NvAPI_VIO_IsRunning, 0x96bd040e }, - // { NvAPI_VIO_Start, 0xcde8e1a3 }, - // { NvAPI_VIO_Stop, 0x6ba2a5d6 }, - // { NvAPI_VIO_IsFrameLockModeCompatible, 0x7bf0a94d }, - // { NvAPI_VIO_EnumDevices, 0xfd7c5557 }, - // { NvAPI_VIO_QueryTopology, 0x869534e2 }, - // { NvAPI_VIO_EnumSignalFormats, 0xead72fe4 }, - // { NvAPI_VIO_EnumDataFormats, 0x221fa8e8 }, - // { NvAPI_Stereo_CreateConfigurationProfileRegistryKey, 0xbe7692ec }, - // { NvAPI_Stereo_DeleteConfigurationProfileRegistryKey, 0xf117b834 }, - // { NvAPI_Stereo_SetConfigurationProfileValue, 0x24409f48 }, - // { NvAPI_Stereo_DeleteConfigurationProfileValue, 0x49bceecf }, - // { NvAPI_Stereo_Enable, 0x239c4545 }, - // { NvAPI_Stereo_Disable, 0x2ec50c2b }, - // { NvAPI_Stereo_IsEnabled, 0x348ff8e1 }, - // { NvAPI_Stereo_GetStereoSupport, 0x296c434d }, - // { NvAPI_Stereo_CreateHandleFromIUnknown, 0xac7e37f4 }, - // { NvAPI_Stereo_DestroyHandle, 0x3a153134 }, - // { NvAPI_Stereo_Activate, 0xf6a1ad68 }, - // { NvAPI_Stereo_Deactivate, 0x2d68de96 }, - // { NvAPI_Stereo_IsActivated, 0x1fb0bc30 }, - // { NvAPI_Stereo_GetSeparation, 0x451f2134 }, - // { NvAPI_Stereo_SetSeparation, 0x5c069fa3 }, - // { NvAPI_Stereo_DecreaseSeparation, 0xda044458 }, - // { NvAPI_Stereo_IncreaseSeparation, 0xc9a8ecec }, - // { NvAPI_Stereo_GetConvergence, 0x4ab00934 }, - // { NvAPI_Stereo_SetConvergence, 0x3dd6b54b }, - // { NvAPI_Stereo_DecreaseConvergence, 0x4c87e317 }, - // { NvAPI_Stereo_IncreaseConvergence, 0xa17daabe }, - // { NvAPI_Stereo_GetFrustumAdjustMode, 0xe6839b43 }, - // { NvAPI_Stereo_SetFrustumAdjustMode, 0x7be27fa2 }, - // { NvAPI_Stereo_CaptureJpegImage, 0x932cb140 }, - // { NvAPI_Stereo_InitActivation, 0xc7177702 }, - // { NvAPI_Stereo_Trigger_Activation, 0x0d6c6cd2 }, - // { NvAPI_Stereo_CapturePngImage, 0x8b7e99b5 }, - // { NvAPI_Stereo_ReverseStereoBlitControl, 0x3cd58f89 }, - // { NvAPI_Stereo_SetNotificationMessage, 0x6b9b409e }, - // { NvAPI_Stereo_SetActiveEye, 0x96eea9f8 }, - // { NvAPI_Stereo_SetDriverMode, 0x5e8f0bec }, - // { NvAPI_Stereo_GetEyeSeparation, 0xce653127 }, - // { NvAPI_Stereo_IsWindowedModeSupported, 0x40c8ed5e }, - // { NvAPI_Stereo_SetSurfaceCreationMode, 0xf5dcfcba }, - // { NvAPI_Stereo_GetSurfaceCreationMode, 0x36f1c736 }, - // { NvAPI_Stereo_Debug_WasLastDrawStereoized, 0xed4416c5 }, - // { NvAPI_Stereo_SetDefaultProfile, 0x44f0ecd1 }, - // { NvAPI_Stereo_GetDefaultProfile, 0x624e21c2 }, - // { NvAPI_D3D1x_CreateSwapChain, 0x1bc21b66 }, - // { NvAPI_D3D9_CreateSwapChain, 0x1a131e09 }, - // { NvAPI_Vulkan_InitLowLatencyDevice, 0x5c1696b6 }, - // { NvAPI_Vulkan_DestroyLowLatencyDevice, 0x11a5932b }, - // { NvAPI_Vulkan_GetSleepStatus, 0xadf966af }, - // { NvAPI_Vulkan_SetSleepMode, 0x2acfd162 }, - // { NvAPI_Vulkan_Sleep, 0x36732b1e }, - // { NvAPI_Vulkan_GetLatency, 0x3233d44a }, - // { NvAPI_Vulkan_SetLatencyMarker, 0xa17d13d6 }, - // { NvAPI_Vulkan_NotifyOutOfBandVkQueue, 0x5d6d3840 }, - // { NvAPI_DRS_CreateSession, 0x0694d52e }, - // { NvAPI_DRS_DestroySession, 0xdad9cff8 }, - // { NvAPI_DRS_LoadSettings, 0x375dbd6b }, - // { NvAPI_DRS_SaveSettings, 0xfcbc7e14 }, - // { NvAPI_DRS_LoadSettingsFromFile, 0xd3ede889 }, - // { NvAPI_DRS_SaveSettingsToFile, 0x2be25df8 }, - // { NvAPI_DRS_CreateProfile, 0xcc176068 }, - // { NvAPI_DRS_DeleteProfile, 0x17093206 }, - // { NvAPI_DRS_SetCurrentGlobalProfile, 0x1c89c5df }, - // { NvAPI_DRS_GetCurrentGlobalProfile, 0x617bff9f }, - // { NvAPI_DRS_GetProfileInfo, 0x61cd6fd6 }, - // { NvAPI_DRS_SetProfileInfo, 0x16abd3a9 }, - // { NvAPI_DRS_FindProfileByName, 0x7e4a9a0b }, - // { NvAPI_DRS_EnumProfiles, 0xbc371ee0 }, - // { NvAPI_DRS_GetNumProfiles, 0x1dae4fbc }, - // { NvAPI_DRS_CreateApplication, 0x4347a9de }, - // { NvAPI_DRS_DeleteApplicationEx, 0xc5ea85a1 }, - // { NvAPI_DRS_DeleteApplication, 0x2c694bc6 }, - // { NvAPI_DRS_GetApplicationInfo, 0xed1f8c69 }, - // { NvAPI_DRS_EnumApplications, 0x7fa2173a }, - // { NvAPI_DRS_FindApplicationByName, 0xeee566b2 }, - // { NvAPI_DRS_SetSetting, 0x577dd202 }, - // { NvAPI_DRS_GetSetting, 0x73bf8338 }, - // { NvAPI_DRS_EnumSettings, 0xae3039da }, - // { NvAPI_DRS_EnumAvailableSettingIds, 0xf020614a }, - // { NvAPI_DRS_EnumAvailableSettingValues, 0x2ec39f90 }, - // { NvAPI_DRS_GetSettingIdFromName, 0xcb7309cd }, - // { NvAPI_DRS_GetSettingNameFromId, 0xd61cbe6e }, - // { NvAPI_DRS_DeleteProfileSetting, 0xe4a26362 }, - // { NvAPI_DRS_RestoreAllDefaults, 0x5927b094 }, - // { NvAPI_DRS_RestoreProfileDefault, 0xfa5f6134 }, - // { NvAPI_DRS_RestoreProfileDefaultSetting, 0x53f0381e }, - // { NvAPI_DRS_GetBaseProfile, 0xda8466a0 }, - // { NvAPI_SYS_GetChipSetInfo, 0x53dabbca }, - // { NvAPI_SYS_GetLidAndDockInfo, 0xcda14d8a }, - // { NvAPI_SYS_GetDisplayIdFromGpuAndOutputId, 0x08f2bab4 }, - // { NvAPI_SYS_GetGpuAndOutputIdFromDisplayId, 0x112ba1a5 }, - // { NvAPI_SYS_GetPhysicalGpuFromDisplayId, 0x9ea74659 }, - // { NvAPI_SYS_GetDisplayDriverInfo, 0x721faceb }, - // { NvAPI_SYS_GetPhysicalGPUs, 0xd3b24d2d }, - // { NvAPI_SYS_GetLogicalGPUs, 0xccfffc10 }, - // { NvAPI_NGX_GetDriverFeatureSupport, 0x6194b19d }, - // { NvAPI_GPU_ClientRegisterForUtilizationSampleUpdates, 0xadeeaf67 }, - // { NvAPI_RegisterRiseCallback, 0x9cfe8f94 }, - // { NvAPI_RequestRise, 0x5047de98 }, - // { NvAPI_UninstallRise, 0xab8d09f6 }, -); - -const NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_CAPABLE: u32 = 1 << 0; -const NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_ENABLE: u32 = 1 << 1; -// const NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_DEDICATED: u32 = 1 << 2; -const NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_RECOMMENDED: u32 = 1 << 3; -const NV_COMPUTE_GPU_TOPOLOGY_CUDA_AVAILABLE: u32 = 1 << 4; -const NV_COMPUTE_GPU_TOPOLOGY_CUDA_CAPABLE: u32 = 1 << 16; -// const NV_COMPUTE_GPU_TOPOLOGY_CUDA_DISABLED: u32 = 1 << 17; -const NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_AVAILABLE: u32 = 1 << 21; - -fn make_nvapi_version(ver: u32) -> u32 { - let size = std::mem::size_of::() as u32; - size | (ver << 16) -} - -#[no_mangle] -pub unsafe extern "C" fn nvapi_QueryInterface(interface: u32) -> *mut c_void { - interface_to_fn(interface).unwrap_or(std::ptr::null_mut()) -} - -#[allow(non_snake_case)] -unsafe extern "C" fn NvAPI_Initialize() -> i32 { - 0 -} - -#[allow(non_snake_case)] -unsafe extern "C" fn NvAPI_Unload() -> i32 { - 0 -} - -#[allow(non_snake_case)] -unsafe extern "C" fn NvAPI_GetDisplayDriverVersion( - _display: NvDisplayHandle, - version: *mut NV_DISPLAY_DRIVER_VERSION, -) -> i32 { - // return 0; - let version = version.as_mut(); - let version = unwrap_or::unwrap_some_or!(version, return _NvAPI_Status_NVAPI_INVALID_ARGUMENT); - if version.version != make_nvapi_version::(1) { - return _NvAPI_Status_NVAPI_INCOMPATIBLE_STRUCT_VERSION; - } - version.drvVersion = 99999; - version.bldChangeListNum = 0; - version.szBuildBranchString.fill(0); - version.szAdapterString.fill(0); - let device_name = b"ZLUDA Graphics Device"; - std::ptr::copy_nonoverlapping( - device_name.as_ptr() as _, - version.szAdapterString.as_mut_ptr() as _, - device_name.len(), - ); - 0 -} - -#[allow(non_snake_case)] -unsafe extern "C" fn NvAPI_GPU_CudaEnumComputeCapableGpus( - compute_topo: *mut NV_COMPUTE_GPU_TOPOLOGY_V1, -) -> i32 { - let compute_topo = compute_topo.as_mut(); - let compute_topo = - unwrap_or::unwrap_some_or!(compute_topo, return _NvAPI_Status_NVAPI_INVALID_ARGUMENT); - if compute_topo.version != make_nvapi_version::(1) { - return _NvAPI_Status_NVAPI_INCOMPATIBLE_STRUCT_VERSION; - } - compute_topo.gpuCount = 1; - compute_topo.computeGpus[0] = NV_COMPUTE_GPU_TOPOLOGY_V1__bindgen_ty_1 { - hPhysicalGpu: 1 as _, - flags: NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_CAPABLE - | NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_ENABLE - | NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_RECOMMENDED - | NV_COMPUTE_GPU_TOPOLOGY_CUDA_AVAILABLE - | NV_COMPUTE_GPU_TOPOLOGY_CUDA_CAPABLE - | NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_AVAILABLE, - }; - 0 -} - -#[allow(non_snake_case)] -unsafe extern "C" fn NvAPI_GetGPUIDfromPhysicalGPU( - physical_gpu: NvPhysicalGpuHandle, - gpu_id: *mut NvU32, -) -> i32 { - if physical_gpu != 1 as _ { - return _NvAPI_Status_NVAPI_INVALID_ARGUMENT; - } - let gpu_id = gpu_id.as_mut(); - let gpu_id = unwrap_or::unwrap_some_or!(gpu_id, return _NvAPI_Status_NVAPI_INVALID_ARGUMENT); - *gpu_id = 1; - 0 -} - -#[allow(non_snake_case)] -unsafe extern "C" fn NvAPI_GetPhysicalGPUFromGPUID( - gpu_id: NvU32, - physical_gpu: *mut NvPhysicalGpuHandle, -) -> i32 { - if gpu_id != 1 { - return _NvAPI_Status_NVAPI_INVALID_ARGUMENT; - } - let physical_gpu = physical_gpu.as_mut(); - let physical_gpu = - unwrap_or::unwrap_some_or!(physical_gpu, return _NvAPI_Status_NVAPI_INVALID_ARGUMENT); - *physical_gpu = 1 as _; - 0 -} - -#[allow(non_snake_case)] -unsafe extern "C" fn NvAPI_SYS_GetDriverAndBranchVersion( - _driver_version: *mut NvU32, - _build_branch_string: *mut NvAPI_ShortString, -) -> i32 { - -1 -} diff --git a/nvapi/src/nvapi.rs b/nvapi/src/nvapi.rs deleted file mode 100644 index 718bd0a38..000000000 --- a/nvapi/src/nvapi.rs +++ /dev/null @@ -1,19879 +0,0 @@ -// bindgen nvapi.h -o nvapi.rs --no-layout-tests --allowlist-type "Nv.*" --allowlist-type "NV_.*" -/* automatically generated by rust-bindgen 0.72.1 */ - -#[repr(C)] -#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] -pub struct __BindgenBitfieldUnit { - storage: Storage, -} -impl __BindgenBitfieldUnit { - #[inline] - pub const fn new(storage: Storage) -> Self { - Self { storage } - } -} -impl __BindgenBitfieldUnit -where - Storage: AsRef<[u8]> + AsMut<[u8]>, -{ - #[inline] - fn extract_bit(byte: u8, index: usize) -> bool { - let bit_index = if cfg!(target_endian = "big") { - 7 - (index % 8) - } else { - index % 8 - }; - let mask = 1 << bit_index; - byte & mask == mask - } - #[inline] - pub fn get_bit(&self, index: usize) -> bool { - debug_assert!(index / 8 < self.storage.as_ref().len()); - let byte_index = index / 8; - let byte = self.storage.as_ref()[byte_index]; - Self::extract_bit(byte, index) - } - #[inline] - pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { - debug_assert!(index / 8 < core::mem::size_of::()); - let byte_index = index / 8; - let byte = unsafe { - *(core::ptr::addr_of!((*this).storage) as *const u8).offset(byte_index as isize) - }; - Self::extract_bit(byte, index) - } - #[inline] - fn change_bit(byte: u8, index: usize, val: bool) -> u8 { - let bit_index = if cfg!(target_endian = "big") { - 7 - (index % 8) - } else { - index % 8 - }; - let mask = 1 << bit_index; - if val { - byte | mask - } else { - byte & !mask - } - } - #[inline] - pub fn set_bit(&mut self, index: usize, val: bool) { - debug_assert!(index / 8 < self.storage.as_ref().len()); - let byte_index = index / 8; - let byte = &mut self.storage.as_mut()[byte_index]; - *byte = Self::change_bit(*byte, index, val); - } - #[inline] - pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { - debug_assert!(index / 8 < core::mem::size_of::()); - let byte_index = index / 8; - let byte = unsafe { - (core::ptr::addr_of_mut!((*this).storage) as *mut u8).offset(byte_index as isize) - }; - unsafe { *byte = Self::change_bit(*byte, index, val) }; - } - #[inline] - pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { - debug_assert!(bit_width <= 64); - debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); - debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); - let mut val = 0; - for i in 0..(bit_width as usize) { - if self.get_bit(i + bit_offset) { - let index = if cfg!(target_endian = "big") { - bit_width as usize - 1 - i - } else { - i - }; - val |= 1 << index; - } - } - val - } - #[inline] - pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { - debug_assert!(bit_width <= 64); - debug_assert!(bit_offset / 8 < core::mem::size_of::()); - debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::()); - let mut val = 0; - for i in 0..(bit_width as usize) { - if unsafe { Self::raw_get_bit(this, i + bit_offset) } { - let index = if cfg!(target_endian = "big") { - bit_width as usize - 1 - i - } else { - i - }; - val |= 1 << index; - } - } - val - } - #[inline] - pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { - debug_assert!(bit_width <= 64); - debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); - debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); - for i in 0..(bit_width as usize) { - let mask = 1 << i; - let val_bit_is_set = val & mask == mask; - let index = if cfg!(target_endian = "big") { - bit_width as usize - 1 - i - } else { - i - }; - self.set_bit(index + bit_offset, val_bit_is_set); - } - } - #[inline] - pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { - debug_assert!(bit_width <= 64); - debug_assert!(bit_offset / 8 < core::mem::size_of::()); - debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::()); - for i in 0..(bit_width as usize) { - let mask = 1 << i; - let val_bit_is_set = val & mask == mask; - let index = if cfg!(target_endian = "big") { - bit_width as usize - 1 - i - } else { - i - }; - unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; - } - } -} -pub type DWORD = ::std::os::raw::c_ulong; -pub type ULONG_PTR = ::std::os::raw::c_ulonglong; -pub type SIZE_T = ULONG_PTR; -pub type LONG = ::std::os::raw::c_long; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _LUID { - pub LowPart: DWORD, - pub HighPart: LONG, -} -pub type LUID = _LUID; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MEMORY_RANGE { - pub BaseAddress: *mut ::std::os::raw::c_void, - pub Length: SIZE_T, -} -pub type NV_MEMORY_RANGE = _NV_MEMORY_RANGE; -pub type NvU64 = ::std::os::raw::c_ulonglong; -pub type NvS64 = ::std::os::raw::c_longlong; -pub type NvS32 = ::std::os::raw::c_int; -pub type NvU32 = ::std::os::raw::c_uint; -pub type NvS16 = ::std::os::raw::c_short; -pub type NvU16 = ::std::os::raw::c_ushort; -pub type NvU8 = ::std::os::raw::c_uchar; -pub type NvS8 = ::std::os::raw::c_schar; -pub type NvF32 = f32; -pub type NvF64 = f64; -pub type NvBool = NvU8; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_RECT { - pub left: NvU32, - pub top: NvU32, - pub right: NvU32, - pub bottom: NvU32, -} -pub type NV_RECT = _NV_RECT; -#[doc = "! \\addtogroup nvapihandles\n! NVAPI Handles - These handles are retrieved from various calls and passed in to others in NvAPI\n! These are meant to be opaque types. Do not assume they correspond to indices, HDCs,\n! display indexes or anything else.\n!\n! Most handles remain valid until a display re-configuration (display mode set) or GPU\n! reconfiguration (going into or out of SLI modes) occurs. If NVAPI_HANDLE_INVALIDATED\n! is received by an app, it should discard all handles, and re-enumerate them.\n! @{"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvLogicalGpuHandle__ { - pub unused: ::std::os::raw::c_int, -} -#[doc = "! \\addtogroup nvapihandles\n! NVAPI Handles - These handles are retrieved from various calls and passed in to others in NvAPI\n! These are meant to be opaque types. Do not assume they correspond to indices, HDCs,\n! display indexes or anything else.\n!\n! Most handles remain valid until a display re-configuration (display mode set) or GPU\n! reconfiguration (going into or out of SLI modes) occurs. If NVAPI_HANDLE_INVALIDATED\n! is received by an app, it should discard all handles, and re-enumerate them.\n! @{"] -pub type NvLogicalGpuHandle = *mut NvLogicalGpuHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvPhysicalGpuHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvPhysicalGpuHandle = *mut NvPhysicalGpuHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvDisplayHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvDisplayHandle = *mut NvDisplayHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvMonitorHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvMonitorHandle = *mut NvMonitorHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvUnAttachedDisplayHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvUnAttachedDisplayHandle = *mut NvUnAttachedDisplayHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvVisualComputingDeviceHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvVisualComputingDeviceHandle = *mut NvVisualComputingDeviceHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvEventHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvEventHandle = *mut NvEventHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvHICHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvHICHandle = *mut NvHICHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvGSyncDeviceHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvGSyncDeviceHandle = *mut NvGSyncDeviceHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvVioHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvVioHandle = *mut NvVioHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvTransitionHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvTransitionHandle = *mut NvTransitionHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvAudioHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvAudioHandle = *mut NvAudioHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Nv3DVPContextHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type Nv3DVPContextHandle = *mut Nv3DVPContextHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Nv3DVPTransceiverHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type Nv3DVPTransceiverHandle = *mut Nv3DVPTransceiverHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Nv3DVPGlassesHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type Nv3DVPGlassesHandle = *mut Nv3DVPGlassesHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvPcfClientHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvPcfClientHandle = *mut NvPcfClientHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvSourceHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvSourceHandle = *mut NvSourceHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvTargetHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvTargetHandle = *mut NvTargetHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvPresentBarrierClientHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvPresentBarrierClientHandle = *mut NvPresentBarrierClientHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvSBox { - pub sX: NvS32, - pub sY: NvS32, - pub sWidth: NvS32, - pub sHeight: NvS32, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvGUID { - pub data1: NvU32, - pub data2: NvU16, - pub data3: NvU16, - pub data4: [NvU8; 8usize], -} -pub type NvLUID = NvGUID; -pub type NvAPI_String = [::std::os::raw::c_char; 4096usize]; -pub type NvAPI_LongString = [::std::os::raw::c_char; 256usize]; -pub type NvAPI_ShortString = [::std::os::raw::c_char; 64usize]; -pub type NvAPI_UnicodeShortString = [NvU16; 64usize]; -#[doc = "!< Success. Request is completed."] -pub const _NvAPI_Status_NVAPI_OK: _NvAPI_Status = 0; -#[doc = "!< Generic error"] -pub const _NvAPI_Status_NVAPI_ERROR: _NvAPI_Status = -1; -#[doc = "!< NVAPI support library cannot be loaded."] -pub const _NvAPI_Status_NVAPI_LIBRARY_NOT_FOUND: _NvAPI_Status = -2; -#[doc = "!< not implemented in current driver installation"] -pub const _NvAPI_Status_NVAPI_NO_IMPLEMENTATION: _NvAPI_Status = -3; -#[doc = "!< NvAPI_Initialize has not been called (successfully)"] -pub const _NvAPI_Status_NVAPI_API_NOT_INITIALIZED: _NvAPI_Status = -4; -#[doc = "!< The argument/parameter value is not valid or NULL."] -pub const _NvAPI_Status_NVAPI_INVALID_ARGUMENT: _NvAPI_Status = -5; -#[doc = "!< No NVIDIA display driver, or NVIDIA GPU driving a display, was found."] -pub const _NvAPI_Status_NVAPI_NVIDIA_DEVICE_NOT_FOUND: _NvAPI_Status = -6; -#[doc = "!< No more items to enumerate"] -pub const _NvAPI_Status_NVAPI_END_ENUMERATION: _NvAPI_Status = -7; -#[doc = "!< Invalid handle"] -pub const _NvAPI_Status_NVAPI_INVALID_HANDLE: _NvAPI_Status = -8; -#[doc = "!< An argument's structure version is not supported"] -pub const _NvAPI_Status_NVAPI_INCOMPATIBLE_STRUCT_VERSION: _NvAPI_Status = -9; -#[doc = "!< The handle is no longer valid (likely due to GPU or display re-configuration)"] -pub const _NvAPI_Status_NVAPI_HANDLE_INVALIDATED: _NvAPI_Status = -10; -#[doc = "!< No NVIDIA OpenGL context is current (but needs to be)"] -pub const _NvAPI_Status_NVAPI_OPENGL_CONTEXT_NOT_CURRENT: _NvAPI_Status = -11; -#[doc = "!< An invalid pointer, usually NULL, was passed as a parameter"] -pub const _NvAPI_Status_NVAPI_INVALID_POINTER: _NvAPI_Status = -14; -#[doc = "!< OpenGL Expert is not supported by the current drivers"] -pub const _NvAPI_Status_NVAPI_NO_GL_EXPERT: _NvAPI_Status = -12; -#[doc = "!< OpenGL Expert is supported, but driver instrumentation is currently disabled"] -pub const _NvAPI_Status_NVAPI_INSTRUMENTATION_DISABLED: _NvAPI_Status = -13; -#[doc = "!< OpenGL does not support Nsight"] -pub const _NvAPI_Status_NVAPI_NO_GL_NSIGHT: _NvAPI_Status = -15; -#[doc = "!< Expected a logical GPU handle for one or more parameters"] -pub const _NvAPI_Status_NVAPI_EXPECTED_LOGICAL_GPU_HANDLE: _NvAPI_Status = -100; -#[doc = "!< Expected a physical GPU handle for one or more parameters"] -pub const _NvAPI_Status_NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE: _NvAPI_Status = -101; -#[doc = "!< Expected an NV display handle for one or more parameters"] -pub const _NvAPI_Status_NVAPI_EXPECTED_DISPLAY_HANDLE: _NvAPI_Status = -102; -#[doc = "!< The combination of parameters is not valid."] -pub const _NvAPI_Status_NVAPI_INVALID_COMBINATION: _NvAPI_Status = -103; -#[doc = "!< Requested feature is not supported in the selected GPU"] -pub const _NvAPI_Status_NVAPI_NOT_SUPPORTED: _NvAPI_Status = -104; -#[doc = "!< No port ID was found for the I2C transaction"] -pub const _NvAPI_Status_NVAPI_PORTID_NOT_FOUND: _NvAPI_Status = -105; -#[doc = "!< Expected an unattached display handle as one of the input parameters."] -pub const _NvAPI_Status_NVAPI_EXPECTED_UNATTACHED_DISPLAY_HANDLE: _NvAPI_Status = -106; -#[doc = "!< Invalid perf level"] -pub const _NvAPI_Status_NVAPI_INVALID_PERF_LEVEL: _NvAPI_Status = -107; -#[doc = "!< Device is busy; request not fulfilled"] -pub const _NvAPI_Status_NVAPI_DEVICE_BUSY: _NvAPI_Status = -108; -#[doc = "!< NV persist file is not found"] -pub const _NvAPI_Status_NVAPI_NV_PERSIST_FILE_NOT_FOUND: _NvAPI_Status = -109; -#[doc = "!< NV persist data is not found"] -pub const _NvAPI_Status_NVAPI_PERSIST_DATA_NOT_FOUND: _NvAPI_Status = -110; -#[doc = "!< Expected a TV output display"] -pub const _NvAPI_Status_NVAPI_EXPECTED_TV_DISPLAY: _NvAPI_Status = -111; -#[doc = "!< Expected a TV output on the D Connector - HDTV_EIAJ4120."] -pub const _NvAPI_Status_NVAPI_EXPECTED_TV_DISPLAY_ON_DCONNECTOR: _NvAPI_Status = -112; -#[doc = "!< SLI is not active on this device."] -pub const _NvAPI_Status_NVAPI_NO_ACTIVE_SLI_TOPOLOGY: _NvAPI_Status = -113; -#[doc = "!< Setup of SLI rendering mode is not possible right now."] -pub const _NvAPI_Status_NVAPI_SLI_RENDERING_MODE_NOTALLOWED: _NvAPI_Status = -114; -#[doc = "!< Expected a digital flat panel."] -pub const _NvAPI_Status_NVAPI_EXPECTED_DIGITAL_FLAT_PANEL: _NvAPI_Status = -115; -#[doc = "!< Argument exceeds the expected size."] -pub const _NvAPI_Status_NVAPI_ARGUMENT_EXCEED_MAX_SIZE: _NvAPI_Status = -116; -#[doc = "!< Inhibit is ON due to one of the flags in NV_GPU_DISPLAY_CHANGE_INHIBIT or SLI active."] -pub const _NvAPI_Status_NVAPI_DEVICE_SWITCHING_NOT_ALLOWED: _NvAPI_Status = -117; -#[doc = "!< Testing of clocks is not supported."] -pub const _NvAPI_Status_NVAPI_TESTING_CLOCKS_NOT_SUPPORTED: _NvAPI_Status = -118; -#[doc = "!< The specified underscan config is from an unknown source (e.g. INF)"] -pub const _NvAPI_Status_NVAPI_UNKNOWN_UNDERSCAN_CONFIG: _NvAPI_Status = -119; -#[doc = "!< Timeout while reconfiguring GPUs"] -pub const _NvAPI_Status_NVAPI_TIMEOUT_RECONFIGURING_GPU_TOPO: _NvAPI_Status = -120; -#[doc = "!< Requested data was not found"] -pub const _NvAPI_Status_NVAPI_DATA_NOT_FOUND: _NvAPI_Status = -121; -#[doc = "!< Expected an analog display"] -pub const _NvAPI_Status_NVAPI_EXPECTED_ANALOG_DISPLAY: _NvAPI_Status = -122; -#[doc = "!< No SLI video bridge is present"] -pub const _NvAPI_Status_NVAPI_NO_VIDLINK: _NvAPI_Status = -123; -#[doc = "!< NVAPI requires a reboot for the settings to take effect"] -pub const _NvAPI_Status_NVAPI_REQUIRES_REBOOT: _NvAPI_Status = -124; -#[doc = "!< The function is not supported with the current Hybrid mode."] -pub const _NvAPI_Status_NVAPI_INVALID_HYBRID_MODE: _NvAPI_Status = -125; -#[doc = "!< The target types are not all the same"] -pub const _NvAPI_Status_NVAPI_MIXED_TARGET_TYPES: _NvAPI_Status = -126; -#[doc = "!< The function is not supported from 32-bit on a 64-bit system."] -pub const _NvAPI_Status_NVAPI_SYSWOW64_NOT_SUPPORTED: _NvAPI_Status = -127; -#[doc = "!< There is no implicit GPU topology active. Use NVAPI_SetHybridMode to change topology."] -pub const _NvAPI_Status_NVAPI_IMPLICIT_SET_GPU_TOPOLOGY_CHANGE_NOT_ALLOWED: _NvAPI_Status = -128; -#[doc = "!< Prompt the user to close all non-migratable applications."] -pub const _NvAPI_Status_NVAPI_REQUEST_USER_TO_CLOSE_NON_MIGRATABLE_APPS: _NvAPI_Status = -129; -#[doc = "!< Could not allocate sufficient memory to complete the call."] -pub const _NvAPI_Status_NVAPI_OUT_OF_MEMORY: _NvAPI_Status = -130; -#[doc = "!< The previous operation that is transferring information to or from this surface is incomplete."] -pub const _NvAPI_Status_NVAPI_WAS_STILL_DRAWING: _NvAPI_Status = -131; -#[doc = "!< The file was not found."] -pub const _NvAPI_Status_NVAPI_FILE_NOT_FOUND: _NvAPI_Status = -132; -#[doc = "!< There are too many unique instances of a particular type of state object."] -pub const _NvAPI_Status_NVAPI_TOO_MANY_UNIQUE_STATE_OBJECTS: _NvAPI_Status = -133; -#[doc = "!< The method call is invalid. For example, a method's parameter may not be a valid pointer."] -pub const _NvAPI_Status_NVAPI_INVALID_CALL: _NvAPI_Status = -134; -#[doc = "!< d3d10_1.dll cannot be loaded."] -pub const _NvAPI_Status_NVAPI_D3D10_1_LIBRARY_NOT_FOUND: _NvAPI_Status = -135; -#[doc = "!< Couldn't find the function in the loaded DLL."] -pub const _NvAPI_Status_NVAPI_FUNCTION_NOT_FOUND: _NvAPI_Status = -136; -#[doc = "!< The application will require Administrator privileges to access this API.\n!< The application can be elevated to a higher permission level by selecting \"Run as Administrator\"."] -pub const _NvAPI_Status_NVAPI_INVALID_USER_PRIVILEGE: _NvAPI_Status = -137; -#[doc = "!< The handle corresponds to GDIPrimary."] -pub const _NvAPI_Status_NVAPI_EXPECTED_NON_PRIMARY_DISPLAY_HANDLE: _NvAPI_Status = -138; -#[doc = "!< Setting Physx GPU requires that the GPU is compute-capable."] -pub const _NvAPI_Status_NVAPI_EXPECTED_COMPUTE_GPU_HANDLE: _NvAPI_Status = -139; -#[doc = "!< The Stereo part of NVAPI failed to initialize completely. Check if the stereo driver is installed."] -pub const _NvAPI_Status_NVAPI_STEREO_NOT_INITIALIZED: _NvAPI_Status = -140; -#[doc = "!< Access to stereo-related registry keys or values has failed."] -pub const _NvAPI_Status_NVAPI_STEREO_REGISTRY_ACCESS_FAILED: _NvAPI_Status = -141; -#[doc = "!< The given registry profile type is not supported."] -pub const _NvAPI_Status_NVAPI_STEREO_REGISTRY_PROFILE_TYPE_NOT_SUPPORTED: _NvAPI_Status = -142; -#[doc = "!< The given registry value is not supported."] -pub const _NvAPI_Status_NVAPI_STEREO_REGISTRY_VALUE_NOT_SUPPORTED: _NvAPI_Status = -143; -#[doc = "!< Stereo is not enabled and the function needed it to execute completely."] -pub const _NvAPI_Status_NVAPI_STEREO_NOT_ENABLED: _NvAPI_Status = -144; -#[doc = "!< Stereo is not turned on and the function needed it to execute completely."] -pub const _NvAPI_Status_NVAPI_STEREO_NOT_TURNED_ON: _NvAPI_Status = -145; -#[doc = "!< Invalid device interface."] -pub const _NvAPI_Status_NVAPI_STEREO_INVALID_DEVICE_INTERFACE: _NvAPI_Status = -146; -#[doc = "!< Separation percentage or JPEG image capture quality is out of [0-100] range."] -pub const _NvAPI_Status_NVAPI_STEREO_PARAMETER_OUT_OF_RANGE: _NvAPI_Status = -147; -#[doc = "!< The given frustum adjust mode is not supported."] -pub const _NvAPI_Status_NVAPI_STEREO_FRUSTUM_ADJUST_MODE_NOT_SUPPORTED: _NvAPI_Status = -148; -#[doc = "!< The mosaic topology is not possible given the current state of the hardware."] -pub const _NvAPI_Status_NVAPI_TOPO_NOT_POSSIBLE: _NvAPI_Status = -149; -#[doc = "!< An attempt to do a display resolution mode change has failed."] -pub const _NvAPI_Status_NVAPI_MODE_CHANGE_FAILED: _NvAPI_Status = -150; -#[doc = "!< d3d11.dll/d3d11_beta.dll cannot be loaded."] -pub const _NvAPI_Status_NVAPI_D3D11_LIBRARY_NOT_FOUND: _NvAPI_Status = -151; -#[doc = "!< Address is outside of valid range."] -pub const _NvAPI_Status_NVAPI_INVALID_ADDRESS: _NvAPI_Status = -152; -#[doc = "!< The pre-allocated string is too small to hold the result."] -pub const _NvAPI_Status_NVAPI_STRING_TOO_SMALL: _NvAPI_Status = -153; -#[doc = "!< The input does not match any of the available devices."] -pub const _NvAPI_Status_NVAPI_MATCHING_DEVICE_NOT_FOUND: _NvAPI_Status = -154; -#[doc = "!< Driver is running."] -pub const _NvAPI_Status_NVAPI_DRIVER_RUNNING: _NvAPI_Status = -155; -#[doc = "!< Driver is not running."] -pub const _NvAPI_Status_NVAPI_DRIVER_NOTRUNNING: _NvAPI_Status = -156; -#[doc = "!< A driver reload is required to apply these settings."] -pub const _NvAPI_Status_NVAPI_ERROR_DRIVER_RELOAD_REQUIRED: _NvAPI_Status = -157; -#[doc = "!< Intended setting is not allowed."] -pub const _NvAPI_Status_NVAPI_SET_NOT_ALLOWED: _NvAPI_Status = -158; -#[doc = "!< Information can't be returned due to \"advanced display topology\"."] -pub const _NvAPI_Status_NVAPI_ADVANCED_DISPLAY_TOPOLOGY_REQUIRED: _NvAPI_Status = -159; -#[doc = "!< Setting is not found."] -pub const _NvAPI_Status_NVAPI_SETTING_NOT_FOUND: _NvAPI_Status = -160; -#[doc = "!< Setting size is too large."] -pub const _NvAPI_Status_NVAPI_SETTING_SIZE_TOO_LARGE: _NvAPI_Status = -161; -#[doc = "!< There are too many settings for a profile."] -pub const _NvAPI_Status_NVAPI_TOO_MANY_SETTINGS_IN_PROFILE: _NvAPI_Status = -162; -#[doc = "!< Profile is not found."] -pub const _NvAPI_Status_NVAPI_PROFILE_NOT_FOUND: _NvAPI_Status = -163; -#[doc = "!< Profile name is duplicated."] -pub const _NvAPI_Status_NVAPI_PROFILE_NAME_IN_USE: _NvAPI_Status = -164; -#[doc = "!< Profile name is empty."] -pub const _NvAPI_Status_NVAPI_PROFILE_NAME_EMPTY: _NvAPI_Status = -165; -#[doc = "!< Application not found in the Profile."] -pub const _NvAPI_Status_NVAPI_EXECUTABLE_NOT_FOUND: _NvAPI_Status = -166; -#[doc = "!< Application already exists in the other profile."] -pub const _NvAPI_Status_NVAPI_EXECUTABLE_ALREADY_IN_USE: _NvAPI_Status = -167; -#[doc = "!< Data Type mismatch"] -pub const _NvAPI_Status_NVAPI_DATATYPE_MISMATCH: _NvAPI_Status = -168; -#[doc = "!< The profile passed as parameter has been removed and is no longer valid."] -pub const _NvAPI_Status_NVAPI_PROFILE_REMOVED: _NvAPI_Status = -169; -#[doc = "!< An unregistered resource was passed as a parameter."] -pub const _NvAPI_Status_NVAPI_UNREGISTERED_RESOURCE: _NvAPI_Status = -170; -#[doc = "!< The DisplayId corresponds to a display which is not within the normal outputId range."] -pub const _NvAPI_Status_NVAPI_ID_OUT_OF_RANGE: _NvAPI_Status = -171; -#[doc = "!< Display topology is not valid so the driver cannot do a mode set on this configuration."] -pub const _NvAPI_Status_NVAPI_DISPLAYCONFIG_VALIDATION_FAILED: _NvAPI_Status = -172; -#[doc = "!< Display Port Multi-Stream topology has been changed."] -pub const _NvAPI_Status_NVAPI_DPMST_CHANGED: _NvAPI_Status = -173; -#[doc = "!< Input buffer is insufficient to hold the contents."] -pub const _NvAPI_Status_NVAPI_INSUFFICIENT_BUFFER: _NvAPI_Status = -174; -#[doc = "!< No access to the caller."] -pub const _NvAPI_Status_NVAPI_ACCESS_DENIED: _NvAPI_Status = -175; -#[doc = "!< The requested action cannot be performed without Mosaic being enabled."] -pub const _NvAPI_Status_NVAPI_MOSAIC_NOT_ACTIVE: _NvAPI_Status = -176; -#[doc = "!< The surface is relocated away from video memory."] -pub const _NvAPI_Status_NVAPI_SHARE_RESOURCE_RELOCATED: _NvAPI_Status = -177; -#[doc = "!< The user should disable DWM before calling NvAPI."] -pub const _NvAPI_Status_NVAPI_REQUEST_USER_TO_DISABLE_DWM: _NvAPI_Status = -178; -#[doc = "!< D3D device status is D3DERR_DEVICELOST or D3DERR_DEVICENOTRESET - the user has to reset the device."] -pub const _NvAPI_Status_NVAPI_D3D_DEVICE_LOST: _NvAPI_Status = -179; -#[doc = "!< The requested action cannot be performed in the current state."] -pub const _NvAPI_Status_NVAPI_INVALID_CONFIGURATION: _NvAPI_Status = -180; -#[doc = "!< Call failed as stereo handshake not completed."] -pub const _NvAPI_Status_NVAPI_STEREO_HANDSHAKE_NOT_DONE: _NvAPI_Status = -181; -#[doc = "!< The path provided was too short to determine the correct NVDRS_APPLICATION"] -pub const _NvAPI_Status_NVAPI_EXECUTABLE_PATH_IS_AMBIGUOUS: _NvAPI_Status = -182; -#[doc = "!< Default stereo profile is not currently defined"] -pub const _NvAPI_Status_NVAPI_DEFAULT_STEREO_PROFILE_IS_NOT_DEFINED: _NvAPI_Status = -183; -#[doc = "!< Default stereo profile does not exist"] -pub const _NvAPI_Status_NVAPI_DEFAULT_STEREO_PROFILE_DOES_NOT_EXIST: _NvAPI_Status = -184; -#[doc = "!< A cluster is already defined with the given configuration."] -pub const _NvAPI_Status_NVAPI_CLUSTER_ALREADY_EXISTS: _NvAPI_Status = -185; -#[doc = "!< The input display id is not that of a multi stream enabled connector or a display device in a multi stream topology"] -pub const _NvAPI_Status_NVAPI_DPMST_DISPLAY_ID_EXPECTED: _NvAPI_Status = -186; -#[doc = "!< The input display id is not valid or the monitor associated to it does not support the current operation"] -pub const _NvAPI_Status_NVAPI_INVALID_DISPLAY_ID: _NvAPI_Status = -187; -#[doc = "!< While playing secure audio stream, stream goes out of sync"] -pub const _NvAPI_Status_NVAPI_STREAM_IS_OUT_OF_SYNC: _NvAPI_Status = -188; -#[doc = "!< Older audio driver version than required"] -pub const _NvAPI_Status_NVAPI_INCOMPATIBLE_AUDIO_DRIVER: _NvAPI_Status = -189; -#[doc = "!< Value already set, setting again not allowed."] -pub const _NvAPI_Status_NVAPI_VALUE_ALREADY_SET: _NvAPI_Status = -190; -#[doc = "!< Requested operation timed out"] -pub const _NvAPI_Status_NVAPI_TIMEOUT: _NvAPI_Status = -191; -#[doc = "!< The requested workstation feature set has incomplete driver internal allocation resources"] -pub const _NvAPI_Status_NVAPI_GPU_WORKSTATION_FEATURE_INCOMPLETE: _NvAPI_Status = -192; -#[doc = "!< Call failed because InitActivation was not called."] -pub const _NvAPI_Status_NVAPI_STEREO_INIT_ACTIVATION_NOT_DONE: _NvAPI_Status = -193; -#[doc = "!< The requested action cannot be performed without Sync being enabled."] -pub const _NvAPI_Status_NVAPI_SYNC_NOT_ACTIVE: _NvAPI_Status = -194; -#[doc = "!< The requested action cannot be performed without Sync Master being enabled."] -pub const _NvAPI_Status_NVAPI_SYNC_MASTER_NOT_FOUND: _NvAPI_Status = -195; -#[doc = "!< Invalid displays passed in the NV_GSYNC_DISPLAY pointer."] -pub const _NvAPI_Status_NVAPI_INVALID_SYNC_TOPOLOGY: _NvAPI_Status = -196; -#[doc = "!< The specified signing algorithm is not supported. Either an incorrect value was entered or the current installed driver/hardware does not support the input value."] -pub const _NvAPI_Status_NVAPI_ECID_SIGN_ALGO_UNSUPPORTED: _NvAPI_Status = -197; -#[doc = "!< The encrypted public key verification has failed."] -pub const _NvAPI_Status_NVAPI_ECID_KEY_VERIFICATION_FAILED: _NvAPI_Status = -198; -#[doc = "!< The device's firmware is out of date."] -pub const _NvAPI_Status_NVAPI_FIRMWARE_OUT_OF_DATE: _NvAPI_Status = -199; -#[doc = "!< The device's firmware is not supported."] -pub const _NvAPI_Status_NVAPI_FIRMWARE_REVISION_NOT_SUPPORTED: _NvAPI_Status = -200; -#[doc = "!< The caller is not authorized to modify the License."] -pub const _NvAPI_Status_NVAPI_LICENSE_CALLER_AUTHENTICATION_FAILED: _NvAPI_Status = -201; -#[doc = "!< The user tried to use a deferred context without registering the device first"] -pub const _NvAPI_Status_NVAPI_D3D_DEVICE_NOT_REGISTERED: _NvAPI_Status = -202; -#[doc = "!< Head or SourceId was not reserved for the VR Display before doing the Modeset or the dedicated display."] -pub const _NvAPI_Status_NVAPI_RESOURCE_NOT_ACQUIRED: _NvAPI_Status = -203; -#[doc = "!< Provided timing is not supported."] -pub const _NvAPI_Status_NVAPI_TIMING_NOT_SUPPORTED: _NvAPI_Status = -204; -#[doc = "!< HDCP Encryption Failed for the device. Would be applicable when the device is HDCP Capable."] -pub const _NvAPI_Status_NVAPI_HDCP_ENCRYPTION_FAILED: _NvAPI_Status = -205; -#[doc = "!< Provided mode is over sink device pclk limitation."] -pub const _NvAPI_Status_NVAPI_PCLK_LIMITATION_FAILED: _NvAPI_Status = -206; -#[doc = "!< No connector on GPU found."] -pub const _NvAPI_Status_NVAPI_NO_CONNECTOR_FOUND: _NvAPI_Status = -207; -#[doc = "!< When a non-HDCP capable HMD is connected, we would inform user by this code."] -pub const _NvAPI_Status_NVAPI_HDCP_DISABLED: _NvAPI_Status = -208; -#[doc = "!< Atleast an API is still being called"] -pub const _NvAPI_Status_NVAPI_API_IN_USE: _NvAPI_Status = -209; -#[doc = "!< No display found on Nvidia GPU(s)."] -pub const _NvAPI_Status_NVAPI_NVIDIA_DISPLAY_NOT_FOUND: _NvAPI_Status = -210; -#[doc = "!< Priv security violation, improper access to a secured register."] -pub const _NvAPI_Status_NVAPI_PRIV_SEC_VIOLATION: _NvAPI_Status = -211; -#[doc = "!< NVAPI cannot be called by this vendor"] -pub const _NvAPI_Status_NVAPI_INCORRECT_VENDOR: _NvAPI_Status = -212; -#[doc = "!< DirectMode Display is already in use"] -pub const _NvAPI_Status_NVAPI_DISPLAY_IN_USE: _NvAPI_Status = -213; -#[doc = "!< The Config is having Non-NVidia GPU with Non-HDCP HMD connected"] -pub const _NvAPI_Status_NVAPI_UNSUPPORTED_CONFIG_NON_HDCP_HMD: _NvAPI_Status = -214; -#[doc = "!< GPU's Max Display Limit has Reached"] -pub const _NvAPI_Status_NVAPI_MAX_DISPLAY_LIMIT_REACHED: _NvAPI_Status = -215; -#[doc = "!< DirectMode not Enabled on the Display"] -pub const _NvAPI_Status_NVAPI_INVALID_DIRECT_MODE_DISPLAY: _NvAPI_Status = -216; -#[doc = "!< GPU is in debug mode, OC is NOT allowed."] -pub const _NvAPI_Status_NVAPI_GPU_IN_DEBUG_MODE: _NvAPI_Status = -217; -#[doc = "!< No NvAPI context was found for this D3D object"] -pub const _NvAPI_Status_NVAPI_D3D_CONTEXT_NOT_FOUND: _NvAPI_Status = -218; -#[doc = "!< there is version mismatch between stereo driver and dx driver"] -pub const _NvAPI_Status_NVAPI_STEREO_VERSION_MISMATCH: _NvAPI_Status = -219; -#[doc = "!< GPU is not powered and so the request cannot be completed."] -pub const _NvAPI_Status_NVAPI_GPU_NOT_POWERED: _NvAPI_Status = -220; -#[doc = "!< The display driver update in progress."] -pub const _NvAPI_Status_NVAPI_ERROR_DRIVER_RELOAD_IN_PROGRESS: _NvAPI_Status = -221; -#[doc = "!< Wait for HW resources allocation"] -pub const _NvAPI_Status_NVAPI_WAIT_FOR_HW_RESOURCE: _NvAPI_Status = -222; -#[doc = "!< operation requires further HDCP action"] -pub const _NvAPI_Status_NVAPI_REQUIRE_FURTHER_HDCP_ACTION: _NvAPI_Status = -223; -#[doc = "!< Dynamic Mux transition failure"] -pub const _NvAPI_Status_NVAPI_DISPLAY_MUX_TRANSITION_FAILED: _NvAPI_Status = -224; -#[doc = "!< Invalid DSC version"] -pub const _NvAPI_Status_NVAPI_INVALID_DSC_VERSION: _NvAPI_Status = -225; -#[doc = "!< Invalid DSC slice count"] -pub const _NvAPI_Status_NVAPI_INVALID_DSC_SLICECOUNT: _NvAPI_Status = -226; -#[doc = "!< Invalid DSC output BPP"] -pub const _NvAPI_Status_NVAPI_INVALID_DSC_OUTPUT_BPP: _NvAPI_Status = -227; -#[doc = "!< There was an error while loading nvapi.dll from the driver store."] -pub const _NvAPI_Status_NVAPI_FAILED_TO_LOAD_FROM_DRIVER_STORE: _NvAPI_Status = -228; -#[doc = "!< OpenGL does not export Vulkan fake extensions"] -pub const _NvAPI_Status_NVAPI_NO_VULKAN: _NvAPI_Status = -229; -#[doc = "!< A request for NvTOPPs telemetry CData has already been made and is pending a response."] -pub const _NvAPI_Status_NVAPI_REQUEST_PENDING: _NvAPI_Status = -230; -#[doc = "!< Operation cannot be performed because the resource is in use."] -pub const _NvAPI_Status_NVAPI_RESOURCE_IN_USE: _NvAPI_Status = -231; -#[doc = "!< Device kernel image is invalid"] -pub const _NvAPI_Status_NVAPI_INVALID_IMAGE: _NvAPI_Status = -232; -#[doc = "!< PTX JIT compilation failed"] -pub const _NvAPI_Status_NVAPI_INVALID_PTX: _NvAPI_Status = -233; -#[doc = "!< Uncorrectable NVLink error was detected during the execution"] -pub const _NvAPI_Status_NVAPI_NVLINK_UNCORRECTABLE: _NvAPI_Status = -234; -#[doc = "!< PTX JIT compiler library was not found."] -pub const _NvAPI_Status_NVAPI_JIT_COMPILER_NOT_FOUND: _NvAPI_Status = -235; -#[doc = "!< Device kernel source is invalid."] -pub const _NvAPI_Status_NVAPI_INVALID_SOURCE: _NvAPI_Status = -236; -#[doc = "!< While executing a kernel, the device encountered an illegal instruction."] -pub const _NvAPI_Status_NVAPI_ILLEGAL_INSTRUCTION: _NvAPI_Status = -237; -#[doc = "!< While executing a kernel, the device program counter wrapped its address space"] -pub const _NvAPI_Status_NVAPI_INVALID_PC: _NvAPI_Status = -238; -#[doc = "!< An exception occurred on the device while executing a kernel"] -pub const _NvAPI_Status_NVAPI_LAUNCH_FAILED: _NvAPI_Status = -239; -#[doc = "!< Attempted operation is not permitted."] -pub const _NvAPI_Status_NVAPI_NOT_PERMITTED: _NvAPI_Status = -240; -#[doc = "!< The callback function has already been registered."] -pub const _NvAPI_Status_NVAPI_CALLBACK_ALREADY_REGISTERED: _NvAPI_Status = -241; -#[doc = "!< The callback function is not found or not registered."] -pub const _NvAPI_Status_NVAPI_CALLBACK_NOT_FOUND: _NvAPI_Status = -242; -#[doc = "!< Invalid Wire Format for the VR HMD"] -pub const _NvAPI_Status_NVAPI_INVALID_OUTPUT_WIRE_FORMAT: _NvAPI_Status = -243; -#[doc = "! NvAPI Status Values\n! All NvAPI functions return one of these codes.\n! \\ingroup nvapistatus"] -pub type _NvAPI_Status = ::std::os::raw::c_int; -#[doc = "! NvAPI Status Values\n! All NvAPI functions return one of these codes.\n! \\ingroup nvapistatus"] -pub use self::_NvAPI_Status as NvAPI_Status; -#[doc = "! \\ingroup driverapi\n! Used in NvAPI_GPU_GetMemoryInfo()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_DISPLAY_DRIVER_MEMORY_INFO_V1 { - #[doc = "!< Version info"] - pub version: NvU32, - #[doc = "!< Size(in kb) of the physical framebuffer."] - pub dedicatedVideoMemory: NvU32, - #[doc = "!< Size(in kb) of the available physical framebuffer for allocating video memory surfaces."] - pub availableDedicatedVideoMemory: NvU32, - #[doc = "!< Size(in kb) of system memory the driver allocates at load time."] - pub systemVideoMemory: NvU32, - #[doc = "!< Size(in kb) of shared system memory that driver is allowed to commit for surfaces across all allocations."] - pub sharedSystemMemory: NvU32, -} -#[doc = "! \\ingroup driverapi\n! Used in NvAPI_GPU_GetMemoryInfo()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_DISPLAY_DRIVER_MEMORY_INFO_V2 { - #[doc = "!< Version info"] - pub version: NvU32, - #[doc = "!< Size(in kb) of the physical framebuffer."] - pub dedicatedVideoMemory: NvU32, - #[doc = "!< Size(in kb) of the available physical framebuffer for allocating video memory surfaces."] - pub availableDedicatedVideoMemory: NvU32, - #[doc = "!< Size(in kb) of system memory the driver allocates at load time."] - pub systemVideoMemory: NvU32, - #[doc = "!< Size(in kb) of shared system memory that driver is allowed to commit for surfaces across all allocations."] - pub sharedSystemMemory: NvU32, - #[doc = "!< Size(in kb) of the current available physical framebuffer for allocating video memory surfaces."] - pub curAvailableDedicatedVideoMemory: NvU32, -} -#[doc = "! \\ingroup driverapi\n! Used in NvAPI_GPU_GetMemoryInfo()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_DISPLAY_DRIVER_MEMORY_INFO_V3 { - #[doc = "!< Version info"] - pub version: NvU32, - #[doc = "!< Size(in kb) of the physical framebuffer."] - pub dedicatedVideoMemory: NvU32, - #[doc = "!< Size(in kb) of the available physical framebuffer for allocating video memory surfaces."] - pub availableDedicatedVideoMemory: NvU32, - #[doc = "!< Size(in kb) of system memory the driver allocates at load time."] - pub systemVideoMemory: NvU32, - #[doc = "!< Size(in kb) of shared system memory that driver is allowed to commit for surfaces across all allocations."] - pub sharedSystemMemory: NvU32, - #[doc = "!< Size(in kb) of the current available physical framebuffer for allocating video memory surfaces."] - pub curAvailableDedicatedVideoMemory: NvU32, - #[doc = "!< Size(in kb) of the total size of memory released as a result of the evictions."] - pub dedicatedVideoMemoryEvictionsSize: NvU32, - #[doc = "!< Indicates the number of eviction events that caused an allocation to be removed from dedicated video memory to free GPU\n!< video memory to make room for other allocations."] - pub dedicatedVideoMemoryEvictionCount: NvU32, -} -#[doc = "! \\ingroup driverapi"] -pub type NV_DISPLAY_DRIVER_MEMORY_INFO = NV_DISPLAY_DRIVER_MEMORY_INFO_V3; -#[doc = "! \\ingroup driverapi\n! Used in NvAPI_GPU_GetMemoryInfoEx()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_MEMORY_INFO_EX_V1 { - #[doc = "!< Structure version"] - pub version: NvU32, - #[doc = "!< Size(in bytes) of the physical framebuffer. Refers to the dedicated video memory on discrete GPUs."] - pub dedicatedVideoMemory: NvU64, - #[doc = "!< Size(in bytes) of the available physical framebuffer for allocating video memory surfaces."] - pub availableDedicatedVideoMemory: NvU64, - #[doc = "!< Size(in bytes) of system memory the driver allocates at load time. It is a substitute for dedicated video memory.\n!< Typically used with integrated GPUs that do not have dedicated video memory."] - pub systemVideoMemory: NvU64, - #[doc = "!< Size(in bytes) of shared system memory that driver is allowed to commit for surfaces across all allocations.\n!< On discrete GPUs, it is used to utilize system memory for various operations. It does not need to be reserved during boot.\n!< It may be used by both GPU and CPU, and has an \"on-demand\" type of usage."] - pub sharedSystemMemory: NvU64, - #[doc = "!< Size(in bytes) of the current available physical framebuffer for allocating video memory surfaces."] - pub curAvailableDedicatedVideoMemory: NvU64, - #[doc = "!< Size(in bytes) of the total size of memory released as a result of the evictions."] - pub dedicatedVideoMemoryEvictionsSize: NvU64, - #[doc = "!< Indicates the number of eviction events that caused an allocation to be removed from dedicated video memory to free GPU\n!< video memory to make room for other allocations."] - pub dedicatedVideoMemoryEvictionCount: NvU64, - #[doc = "!< Size(in bytes) of the total size of memory allocated as a result of the promotions."] - pub dedicatedVideoMemoryPromotionsSize: NvU64, - #[doc = "!< Indicates the number of promotion events that caused an allocation to be promoted to dedicated video memory"] - pub dedicatedVideoMemoryPromotionCount: NvU64, -} -#[doc = "! \\ingroup driverapi"] -pub type NV_GPU_MEMORY_INFO_EX = NV_GPU_MEMORY_INFO_EX_V1; -#[doc = "! \\ingroup dx\n! Used in NvAPI_D3D10_GetCurrentSLIState(), and NvAPI_D3D_GetCurrentSLIState()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GET_CURRENT_SLI_STATE_V1 { - #[doc = "!< Structure version"] - pub version: NvU32, - #[doc = "!< [OUT] The maximum possible value of numAFRGroups"] - pub maxNumAFRGroups: NvU32, - #[doc = "!< [OUT] The number of AFR groups enabled in the system"] - pub numAFRGroups: NvU32, - #[doc = "!< [OUT] The AFR group index for the frame currently being rendered"] - pub currentAFRIndex: NvU32, - #[doc = "!< [OUT] What the AFR group index will be for the next frame (i.e. after calling Present)"] - pub nextFrameAFRIndex: NvU32, - #[doc = "!< [OUT] The AFR group index that was used for the previous frame (~0 if more than one frame has not been rendered yet)"] - pub previousFrameAFRIndex: NvU32, - #[doc = "!< [OUT] Boolean: Is this frame the first time running on the current AFR group"] - pub bIsCurAFRGroupNew: NvU32, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GET_CURRENT_SLI_STATE_V2 { - #[doc = "!< Structure version"] - pub version: NvU32, - #[doc = "!< [OUT] The maximum possible value of numAFRGroups"] - pub maxNumAFRGroups: NvU32, - #[doc = "!< [OUT] The number of AFR groups enabled in the system"] - pub numAFRGroups: NvU32, - #[doc = "!< [OUT] The AFR group index for the frame currently being rendered"] - pub currentAFRIndex: NvU32, - #[doc = "!< [OUT] What the AFR group index will be for the next frame (i.e. after calling Present)"] - pub nextFrameAFRIndex: NvU32, - #[doc = "!< [OUT] The AFR group index that was used for the previous frame (~0 if more than one frame has not been rendered yet)"] - pub previousFrameAFRIndex: NvU32, - #[doc = "!< [OUT] Boolean: Is this frame the first time running on the current AFR group"] - pub bIsCurAFRGroupNew: NvU32, - #[doc = "!< [OUT] The number of GPUs used in VR-SLI. If it is 0 VR-SLI is not active"] - pub numVRSLIGpus: NvU32, -} -pub const _NV_StereoActiveEye_NVAPI_STEREO_EYE_RIGHT: _NV_StereoActiveEye = 1; -pub const _NV_StereoActiveEye_NVAPI_STEREO_EYE_LEFT: _NV_StereoActiveEye = 2; -pub const _NV_StereoActiveEye_NVAPI_STEREO_EYE_MONO: _NV_StereoActiveEye = 3; -#[doc = "! \\ingroup stereoapi"] -pub type _NV_StereoActiveEye = ::std::os::raw::c_int; -#[doc = "! \\ingroup stereoapi"] -pub use self::_NV_StereoActiveEye as NV_STEREO_ACTIVE_EYE; -pub const _NV_StereoDriverMode_NVAPI_STEREO_DRIVER_MODE_AUTOMATIC: _NV_StereoDriverMode = 0; -pub const _NV_StereoDriverMode_NVAPI_STEREO_DRIVER_MODE_DIRECT: _NV_StereoDriverMode = 2; -#[doc = "! \\ingroup stereoapi"] -pub type _NV_StereoDriverMode = ::std::os::raw::c_int; -#[doc = "! \\ingroup stereoapi"] -pub use self::_NV_StereoDriverMode as NV_STEREO_DRIVER_MODE; -pub const _NV_DP_LINK_RATE_NV_DP_1_62GBPS: _NV_DP_LINK_RATE = 6; -pub const _NV_DP_LINK_RATE_NV_DP_2_70GBPS: _NV_DP_LINK_RATE = 10; -pub const _NV_DP_LINK_RATE_NV_DP_5_40GBPS: _NV_DP_LINK_RATE = 20; -pub const _NV_DP_LINK_RATE_NV_DP_8_10GBPS: _NV_DP_LINK_RATE = 30; -pub const _NV_DP_LINK_RATE_NV_EDP_2_16GBPS: _NV_DP_LINK_RATE = 8; -pub const _NV_DP_LINK_RATE_NV_EDP_2_43GBPS: _NV_DP_LINK_RATE = 9; -pub const _NV_DP_LINK_RATE_NV_EDP_3_24GBPS: _NV_DP_LINK_RATE = 12; -pub const _NV_DP_LINK_RATE_NV_EDP_4_32GBPS: _NV_DP_LINK_RATE = 16; -#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] -pub type _NV_DP_LINK_RATE = ::std::os::raw::c_int; -#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] -pub use self::_NV_DP_LINK_RATE as NV_DP_LINK_RATE; -pub const _NV_DP2X_LINK_RATE_NV_DP2X_1_62Gbps: _NV_DP2X_LINK_RATE = 162; -pub const _NV_DP2X_LINK_RATE_NV_DP2X_2_16Gbps: _NV_DP2X_LINK_RATE = 216; -pub const _NV_DP2X_LINK_RATE_NV_DP2X_2_43Gbps: _NV_DP2X_LINK_RATE = 243; -pub const _NV_DP2X_LINK_RATE_NV_DP2X_2_50Gbps: _NV_DP2X_LINK_RATE = 250; -pub const _NV_DP2X_LINK_RATE_NV_DP2X_2_70Gbps: _NV_DP2X_LINK_RATE = 270; -pub const _NV_DP2X_LINK_RATE_NV_DP2X_3_24Gbps: _NV_DP2X_LINK_RATE = 324; -pub const _NV_DP2X_LINK_RATE_NV_DP2X_4_32Gbps: _NV_DP2X_LINK_RATE = 432; -pub const _NV_DP2X_LINK_RATE_NV_DP2X_5_40Gbps: _NV_DP2X_LINK_RATE = 540; -pub const _NV_DP2X_LINK_RATE_NV_DP2X_6_75Gbps: _NV_DP2X_LINK_RATE = 675; -pub const _NV_DP2X_LINK_RATE_NV_DP2X_8_10Gbps: _NV_DP2X_LINK_RATE = 810; -pub const _NV_DP2X_LINK_RATE_NV_DP2X_10_0Gbps: _NV_DP2X_LINK_RATE = 1000; -pub const _NV_DP2X_LINK_RATE_NV_DP2X_13_5Gbps: _NV_DP2X_LINK_RATE = 1350; -pub const _NV_DP2X_LINK_RATE_NV_DP2X_20_0Gbps: _NV_DP2X_LINK_RATE = 2000; -pub type _NV_DP2X_LINK_RATE = ::std::os::raw::c_int; -pub use self::_NV_DP2X_LINK_RATE as NV_DP2X_LINK_RATE; -pub const _NV_DP_LANE_COUNT_NV_DP_1_LANE: _NV_DP_LANE_COUNT = 1; -pub const _NV_DP_LANE_COUNT_NV_DP_2_LANE: _NV_DP_LANE_COUNT = 2; -pub const _NV_DP_LANE_COUNT_NV_DP_4_LANE: _NV_DP_LANE_COUNT = 4; -#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] -pub type _NV_DP_LANE_COUNT = ::std::os::raw::c_int; -#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] -pub use self::_NV_DP_LANE_COUNT as NV_DP_LANE_COUNT; -pub const _NV_DP_COLOR_FORMAT_NV_DP_COLOR_FORMAT_RGB: _NV_DP_COLOR_FORMAT = 0; -pub const _NV_DP_COLOR_FORMAT_NV_DP_COLOR_FORMAT_YCbCr422: _NV_DP_COLOR_FORMAT = 1; -pub const _NV_DP_COLOR_FORMAT_NV_DP_COLOR_FORMAT_YCbCr444: _NV_DP_COLOR_FORMAT = 2; -#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] -pub type _NV_DP_COLOR_FORMAT = ::std::os::raw::c_int; -#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] -pub use self::_NV_DP_COLOR_FORMAT as NV_DP_COLOR_FORMAT; -pub const _NV_DP_COLORIMETRY_NV_DP_COLORIMETRY_RGB: _NV_DP_COLORIMETRY = 0; -pub const _NV_DP_COLORIMETRY_NV_DP_COLORIMETRY_YCbCr_ITU601: _NV_DP_COLORIMETRY = 1; -pub const _NV_DP_COLORIMETRY_NV_DP_COLORIMETRY_YCbCr_ITU709: _NV_DP_COLORIMETRY = 2; -#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] -pub type _NV_DP_COLORIMETRY = ::std::os::raw::c_int; -#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] -pub use self::_NV_DP_COLORIMETRY as NV_DP_COLORIMETRY; -pub const _NV_DP_DYNAMIC_RANGE_NV_DP_DYNAMIC_RANGE_VESA: _NV_DP_DYNAMIC_RANGE = 0; -pub const _NV_DP_DYNAMIC_RANGE_NV_DP_DYNAMIC_RANGE_CEA: _NV_DP_DYNAMIC_RANGE = 1; -#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] -pub type _NV_DP_DYNAMIC_RANGE = ::std::os::raw::c_int; -#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] -pub use self::_NV_DP_DYNAMIC_RANGE as NV_DP_DYNAMIC_RANGE; -pub const _NV_DP_BPC_NV_DP_BPC_DEFAULT: _NV_DP_BPC = 0; -pub const _NV_DP_BPC_NV_DP_BPC_6: _NV_DP_BPC = 1; -pub const _NV_DP_BPC_NV_DP_BPC_8: _NV_DP_BPC = 2; -pub const _NV_DP_BPC_NV_DP_BPC_10: _NV_DP_BPC = 3; -pub const _NV_DP_BPC_NV_DP_BPC_12: _NV_DP_BPC = 4; -pub const _NV_DP_BPC_NV_DP_BPC_16: _NV_DP_BPC = 5; -#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] -pub type _NV_DP_BPC = ::std::os::raw::c_int; -#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] -pub use self::_NV_DP_BPC as NV_DP_BPC; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_EDID_V1 { - pub version: NvU32, - pub EDID_Data: [NvU8; 256usize], -} -#[doc = "! Used in NvAPI_GPU_GetEDID()"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_EDID_V2 { - #[doc = "!< Structure version"] - pub version: NvU32, - pub EDID_Data: [NvU8; 256usize], - pub sizeofEDID: NvU32, -} -#[doc = "! Used in NvAPI_GPU_GetEDID()"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_EDID_V3 { - #[doc = "!< Structure version"] - pub version: NvU32, - pub EDID_Data: [NvU8; 256usize], - pub sizeofEDID: NvU32, - #[doc = "!< ID which always returned in a monotonically increasing counter.\n!< Across a split-EDID read we need to verify that all calls returned the same edidId.\n!< This counter is incremented if we get the updated EDID."] - pub edidId: NvU32, - #[doc = "!< Which 256-byte page of the EDID we want to read. Start at 0.\n!< If the read succeeds with edidSize > NV_EDID_DATA_SIZE,\n!< call back again with offset+256 until we have read the entire buffer"] - pub offset: NvU32, -} -#[doc = "! Used in NvAPI_GPU_GetEDID()"] -pub type NV_EDID = NV_EDID_V3; -#[doc = "!< the EDID which is actively used by the driver, it could be _RAW/_COOKED/_FORCED/_INF."] -pub const NV_EDID_FLAG_NV_EDID_FLAG_DEFAULT: NV_EDID_FLAG = 0; -#[doc = "!< the EDID which is not modified by the driver. If there's no _FORCED edid engaged, it\n!< will be the unmodified monitor EDID from the I2C bus. Otherwise it is original _FORCED edid."] -pub const NV_EDID_FLAG_NV_EDID_FLAG_RAW: NV_EDID_FLAG = 1; -#[doc = "!< the EDID has been modified by the driver for compatibility"] -pub const NV_EDID_FLAG_NV_EDID_FLAG_COOKED: NV_EDID_FLAG = 2; -#[doc = "!< the EDID is forced by the end-user over s/w interface,"] -pub const NV_EDID_FLAG_NV_EDID_FLAG_FORCED: NV_EDID_FLAG = 3; -#[doc = "!< the EDID is from monitor INF"] -pub const NV_EDID_FLAG_NV_EDID_FLAG_INF: NV_EDID_FLAG = 4; -#[doc = "!< the EDID is from the monitor over I2C bus without any modification."] -pub const NV_EDID_FLAG_NV_EDID_FLAG_HW: NV_EDID_FLAG = 5; -pub type NV_EDID_FLAG = ::std::os::raw::c_int; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_VGA_15_PIN: _NV_GPU_CONNECTOR_TYPE = 0; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_TV_COMPOSITE: _NV_GPU_CONNECTOR_TYPE = 16; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_TV_SVIDEO: _NV_GPU_CONNECTOR_TYPE = 17; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_TV_HDTV_COMPONENT: _NV_GPU_CONNECTOR_TYPE = 19; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_TV_SCART: _NV_GPU_CONNECTOR_TYPE = 20; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_TV_COMPOSITE_SCART_ON_EIAJ4120: - _NV_GPU_CONNECTOR_TYPE = 22; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_TV_HDTV_EIAJ4120: _NV_GPU_CONNECTOR_TYPE = 23; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_PC_POD_HDTV_YPRPB: _NV_GPU_CONNECTOR_TYPE = 24; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_PC_POD_SVIDEO: _NV_GPU_CONNECTOR_TYPE = 25; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_PC_POD_COMPOSITE: _NV_GPU_CONNECTOR_TYPE = 26; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DVI_I_TV_SVIDEO: _NV_GPU_CONNECTOR_TYPE = 32; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DVI_I_TV_COMPOSITE: _NV_GPU_CONNECTOR_TYPE = - 33; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DVI_I: _NV_GPU_CONNECTOR_TYPE = 48; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DVI_D: _NV_GPU_CONNECTOR_TYPE = 49; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_ADC: _NV_GPU_CONNECTOR_TYPE = 50; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_LFH_DVI_I_1: _NV_GPU_CONNECTOR_TYPE = 56; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_LFH_DVI_I_2: _NV_GPU_CONNECTOR_TYPE = 57; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_SPWG: _NV_GPU_CONNECTOR_TYPE = 64; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_OEM: _NV_GPU_CONNECTOR_TYPE = 65; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DISPLAYPORT_EXTERNAL: _NV_GPU_CONNECTOR_TYPE = - 70; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DISPLAYPORT_INTERNAL: _NV_GPU_CONNECTOR_TYPE = - 71; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DISPLAYPORT_MINI_EXT: _NV_GPU_CONNECTOR_TYPE = - 72; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_HDMI_A: _NV_GPU_CONNECTOR_TYPE = 97; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_HDMI_C_MINI: _NV_GPU_CONNECTOR_TYPE = 99; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_LFH_DISPLAYPORT_1: _NV_GPU_CONNECTOR_TYPE = - 100; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_LFH_DISPLAYPORT_2: _NV_GPU_CONNECTOR_TYPE = - 101; -#[doc = "!< Deprecated."] -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_VIRTUAL_WFD: _NV_GPU_CONNECTOR_TYPE = 112; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_USB_C: _NV_GPU_CONNECTOR_TYPE = 113; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_UNKNOWN: _NV_GPU_CONNECTOR_TYPE = -1; -#[doc = "! \\ingroup gpu\n! Used in NV_GPU_CONNECTOR_DATA"] -pub type _NV_GPU_CONNECTOR_TYPE = ::std::os::raw::c_int; -#[doc = "! \\ingroup gpu\n! Used in NV_GPU_CONNECTOR_DATA"] -pub use self::_NV_GPU_CONNECTOR_TYPE as NV_GPU_CONNECTOR_TYPE; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_NONE: _NV_DISPLAY_TV_FORMAT = 0; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_NTSCM: _NV_DISPLAY_TV_FORMAT = 1; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_NTSCJ: _NV_DISPLAY_TV_FORMAT = 2; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_PALM: _NV_DISPLAY_TV_FORMAT = 4; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_PALBDGH: _NV_DISPLAY_TV_FORMAT = 8; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_PALN: _NV_DISPLAY_TV_FORMAT = 16; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_PALNC: _NV_DISPLAY_TV_FORMAT = 32; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_576i: _NV_DISPLAY_TV_FORMAT = 256; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_480i: _NV_DISPLAY_TV_FORMAT = 512; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_ED_480p: _NV_DISPLAY_TV_FORMAT = 1024; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_ED_576p: _NV_DISPLAY_TV_FORMAT = 2048; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_720p: _NV_DISPLAY_TV_FORMAT = 4096; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_1080i: _NV_DISPLAY_TV_FORMAT = 8192; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_1080p: _NV_DISPLAY_TV_FORMAT = 16384; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_720p50: _NV_DISPLAY_TV_FORMAT = 32768; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_1080p24: _NV_DISPLAY_TV_FORMAT = 65536; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_1080i50: _NV_DISPLAY_TV_FORMAT = 131072; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_1080p50: _NV_DISPLAY_TV_FORMAT = 262144; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp30: _NV_DISPLAY_TV_FORMAT = 524288; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp30_3840: _NV_DISPLAY_TV_FORMAT = 524288; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp25: _NV_DISPLAY_TV_FORMAT = 1048576; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp25_3840: _NV_DISPLAY_TV_FORMAT = - 1048576; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp24: _NV_DISPLAY_TV_FORMAT = 2097152; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp24_3840: _NV_DISPLAY_TV_FORMAT = - 2097152; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp24_SMPTE: _NV_DISPLAY_TV_FORMAT = - 4194304; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp50_3840: _NV_DISPLAY_TV_FORMAT = - 8388608; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp60_3840: _NV_DISPLAY_TV_FORMAT = - 9437184; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp30_4096: _NV_DISPLAY_TV_FORMAT = - 10485760; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp25_4096: _NV_DISPLAY_TV_FORMAT = - 11534336; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp24_4096: _NV_DISPLAY_TV_FORMAT = - 12582912; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp50_4096: _NV_DISPLAY_TV_FORMAT = - 13631488; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp60_4096: _NV_DISPLAY_TV_FORMAT = - 14680064; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp24_7680: _NV_DISPLAY_TV_FORMAT = - 16777216; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp25_7680: _NV_DISPLAY_TV_FORMAT = - 33554432; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp30_7680: _NV_DISPLAY_TV_FORMAT = - 67108864; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp48_7680: _NV_DISPLAY_TV_FORMAT = - 134217728; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp50_7680: _NV_DISPLAY_TV_FORMAT = - 150994944; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp60_7680: _NV_DISPLAY_TV_FORMAT = - 167772160; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp100_7680: _NV_DISPLAY_TV_FORMAT = - 184549376; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp120_7680: _NV_DISPLAY_TV_FORMAT = - 201326592; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp48_3840: _NV_DISPLAY_TV_FORMAT = - 218103808; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp48_4096: _NV_DISPLAY_TV_FORMAT = - 234881024; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp100_4096: _NV_DISPLAY_TV_FORMAT = - 251658240; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp100_3840: _NV_DISPLAY_TV_FORMAT = - 268435456; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp120_4096: _NV_DISPLAY_TV_FORMAT = - 285212672; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp120_3840: _NV_DISPLAY_TV_FORMAT = - 301989888; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp100_5120: _NV_DISPLAY_TV_FORMAT = - 318767104; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp120_5120: _NV_DISPLAY_TV_FORMAT = - 335544320; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp24_5120: _NV_DISPLAY_TV_FORMAT = - 352321536; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp25_5120: _NV_DISPLAY_TV_FORMAT = - 369098752; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp30_5120: _NV_DISPLAY_TV_FORMAT = - 385875968; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp48_5120: _NV_DISPLAY_TV_FORMAT = - 402653184; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp50_5120: _NV_DISPLAY_TV_FORMAT = - 419430400; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp60_5120: _NV_DISPLAY_TV_FORMAT = - 536870912; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp24_10240: _NV_DISPLAY_TV_FORMAT = - 553648128; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp25_10240: _NV_DISPLAY_TV_FORMAT = - 570425344; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp30_10240: _NV_DISPLAY_TV_FORMAT = - 587202560; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp48_10240: _NV_DISPLAY_TV_FORMAT = - 603979776; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp50_10240: _NV_DISPLAY_TV_FORMAT = - 620756992; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp60_10240: _NV_DISPLAY_TV_FORMAT = - 637534208; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp100_10240: _NV_DISPLAY_TV_FORMAT = - 654311424; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp120_10240: _NV_DISPLAY_TV_FORMAT = - 671088640; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_OTHER: _NV_DISPLAY_TV_FORMAT = 805306368; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_ED_OTHER: _NV_DISPLAY_TV_FORMAT = 1073741824; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_OTHER: _NV_DISPLAY_TV_FORMAT = 1342177280; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_ANY: _NV_DISPLAY_TV_FORMAT = -2147483648; -#[doc = "! \\ingroup tvapi\n! Used in NV_DISPLAY_TV_OUTPUT_INFO"] -pub type _NV_DISPLAY_TV_FORMAT = ::std::os::raw::c_int; -#[doc = "! \\ingroup tvapi\n! Used in NV_DISPLAY_TV_OUTPUT_INFO"] -pub use self::_NV_DISPLAY_TV_FORMAT as NV_DISPLAY_TV_FORMAT; -pub const _NV_TARGET_VIEW_MODE_NV_VIEW_MODE_STANDARD: _NV_TARGET_VIEW_MODE = 0; -pub const _NV_TARGET_VIEW_MODE_NV_VIEW_MODE_CLONE: _NV_TARGET_VIEW_MODE = 1; -pub const _NV_TARGET_VIEW_MODE_NV_VIEW_MODE_HSPAN: _NV_TARGET_VIEW_MODE = 2; -pub const _NV_TARGET_VIEW_MODE_NV_VIEW_MODE_VSPAN: _NV_TARGET_VIEW_MODE = 3; -pub const _NV_TARGET_VIEW_MODE_NV_VIEW_MODE_DUALVIEW: _NV_TARGET_VIEW_MODE = 4; -pub const _NV_TARGET_VIEW_MODE_NV_VIEW_MODE_MULTIVIEW: _NV_TARGET_VIEW_MODE = 5; -#[doc = "! Used in NvAPI_SetView()."] -pub type _NV_TARGET_VIEW_MODE = ::std::os::raw::c_int; -#[doc = "! Used in NvAPI_SetView()."] -pub use self::_NV_TARGET_VIEW_MODE as NV_TARGET_VIEW_MODE; -#[doc = "!< No change"] -pub const _NV_SCALING_NV_SCALING_DEFAULT: _NV_SCALING = 0; -#[doc = "!< Balanced - Full Screen"] -pub const _NV_SCALING_NV_SCALING_GPU_SCALING_TO_CLOSEST: _NV_SCALING = 1; -#[doc = "!< Force GPU - Full Screen"] -pub const _NV_SCALING_NV_SCALING_GPU_SCALING_TO_NATIVE: _NV_SCALING = 2; -#[doc = "!< Force GPU - Centered\\No Scaling"] -pub const _NV_SCALING_NV_SCALING_GPU_SCANOUT_TO_NATIVE: _NV_SCALING = 3; -#[doc = "!< Force GPU - Aspect Ratio"] -pub const _NV_SCALING_NV_SCALING_GPU_SCALING_TO_ASPECT_SCANOUT_TO_NATIVE: _NV_SCALING = 5; -#[doc = "!< Balanced - Aspect Ratio"] -pub const _NV_SCALING_NV_SCALING_GPU_SCALING_TO_ASPECT_SCANOUT_TO_CLOSEST: _NV_SCALING = 6; -#[doc = "!< Balanced - Centered\\No Scaling"] -pub const _NV_SCALING_NV_SCALING_GPU_SCANOUT_TO_CLOSEST: _NV_SCALING = 7; -#[doc = "!< Force GPU - Integer Scaling"] -pub const _NV_SCALING_NV_SCALING_GPU_INTEGER_ASPECT_SCALING: _NV_SCALING = 8; -pub const _NV_SCALING_NV_SCALING_MONITOR_SCALING: _NV_SCALING = 1; -pub const _NV_SCALING_NV_SCALING_ADAPTER_SCALING: _NV_SCALING = 2; -pub const _NV_SCALING_NV_SCALING_CENTERED: _NV_SCALING = 3; -pub const _NV_SCALING_NV_SCALING_ASPECT_SCALING: _NV_SCALING = 5; -#[doc = "!< For future use"] -pub const _NV_SCALING_NV_SCALING_CUSTOMIZED: _NV_SCALING = 255; -#[doc = "! Scaling modes - used in NvAPI_SetViewEx().\n! \\ingroup dispcontrol"] -pub type _NV_SCALING = ::std::os::raw::c_int; -#[doc = "! Scaling modes - used in NvAPI_SetViewEx().\n! \\ingroup dispcontrol"] -pub use self::_NV_SCALING as NV_SCALING; -pub const _NV_ROTATE_NV_ROTATE_0: _NV_ROTATE = 0; -pub const _NV_ROTATE_NV_ROTATE_90: _NV_ROTATE = 1; -pub const _NV_ROTATE_NV_ROTATE_180: _NV_ROTATE = 2; -pub const _NV_ROTATE_NV_ROTATE_270: _NV_ROTATE = 3; -pub const _NV_ROTATE_NV_ROTATE_IGNORED: _NV_ROTATE = 4; -#[doc = "! \\ingroup dispcontrol"] -pub type _NV_ROTATE = ::std::os::raw::c_int; -#[doc = "! \\ingroup dispcontrol"] -pub use self::_NV_ROTATE as NV_ROTATE; -#[doc = "!< unknown. Driver will choose one as following value."] -pub const _NV_FORMAT_NV_FORMAT_UNKNOWN: _NV_FORMAT = 0; -#[doc = "!< for 8bpp mode"] -pub const _NV_FORMAT_NV_FORMAT_P8: _NV_FORMAT = 41; -#[doc = "!< for 16bpp mode"] -pub const _NV_FORMAT_NV_FORMAT_R5G6B5: _NV_FORMAT = 23; -#[doc = "!< for 32bpp mode"] -pub const _NV_FORMAT_NV_FORMAT_A8R8G8B8: _NV_FORMAT = 21; -#[doc = "!< for 64bpp(floating point) mode."] -pub const _NV_FORMAT_NV_FORMAT_A16B16G16R16F: _NV_FORMAT = 113; -#[doc = "! Color formats- used in NvAPI_SetViewEx().\n! \\ingroup dispcontrol"] -pub type _NV_FORMAT = ::std::os::raw::c_int; -#[doc = "! Color formats- used in NvAPI_SetViewEx().\n! \\ingroup dispcontrol"] -pub use self::_NV_FORMAT as NV_FORMAT; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_VIEWPORTF { - #[doc = "!< x-coordinate of the viewport top-left point"] - pub x: f32, - #[doc = "!< y-coordinate of the viewport top-left point"] - pub y: f32, - #[doc = "!< Width of the viewport"] - pub w: f32, - #[doc = "!< Height of the viewport"] - pub h: f32, -} -#[doc = "!< get the current timing"] -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_CURRENT: _NV_TIMING_OVERRIDE = 0; -#[doc = "!< the timing the driver will use based the current policy"] -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_AUTO: _NV_TIMING_OVERRIDE = 1; -#[doc = "!< EDID timing"] -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_EDID: _NV_TIMING_OVERRIDE = 2; -#[doc = "!< VESA DMT timing"] -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_DMT: _NV_TIMING_OVERRIDE = 3; -#[doc = "!< VESA DMT timing with reduced blanking"] -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_DMT_RB: _NV_TIMING_OVERRIDE = 4; -#[doc = "!< VESA CVT timing"] -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_CVT: _NV_TIMING_OVERRIDE = 5; -#[doc = "!< VESA CVT timing with reduced blanking"] -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_CVT_RB: _NV_TIMING_OVERRIDE = 6; -#[doc = "!< VESA GTF timing"] -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_GTF: _NV_TIMING_OVERRIDE = 7; -#[doc = "!< EIA 861x pre-defined timing"] -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_EIA861: _NV_TIMING_OVERRIDE = 8; -#[doc = "!< analog SD/HDTV timing"] -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_ANALOG_TV: _NV_TIMING_OVERRIDE = 9; -#[doc = "!< NV custom timings"] -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_CUST: _NV_TIMING_OVERRIDE = 10; -#[doc = "!< NV pre-defined timing (basically the PsF timings)"] -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_NV_PREDEFINED: _NV_TIMING_OVERRIDE = 11; -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_NV_PSF: _NV_TIMING_OVERRIDE = 11; -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_NV_ASPR: _NV_TIMING_OVERRIDE = 12; -#[doc = "!< Override for SDI timing"] -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_SDI: _NV_TIMING_OVERRIDE = 13; -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVRRIDE_MAX: _NV_TIMING_OVERRIDE = 14; -#[doc = "! \\ingroup dispcontrol\n! The timing override is not supported yet; must be set to _AUTO. \\n"] -pub type _NV_TIMING_OVERRIDE = ::std::os::raw::c_int; -#[doc = "! \\ingroup dispcontrol\n! The timing override is not supported yet; must be set to _AUTO. \\n"] -pub use self::_NV_TIMING_OVERRIDE as NV_TIMING_OVERRIDE; -#[doc = "! \\ingroup dispcontrol\n! NVIDIA-specific timing extras \\n\n! Used in NV_TIMING."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct tagNV_TIMINGEXT { - #[doc = "!< Reserved for NVIDIA hardware-based enhancement, such as double-scan."] - pub flag: NvU32, - #[doc = "!< Logical refresh rate to present"] - pub rr: NvU16, - #[doc = "!< Physical vertical refresh rate in 0.001Hz"] - pub rrx1k: NvU32, - #[doc = "!< Display aspect ratio Hi(aspect):horizontal-aspect, Low(aspect):vertical-aspect"] - pub aspect: NvU32, - #[doc = "!< Bit-wise pixel repetition factor: 0x1:no pixel repetition; 0x2:each pixel repeats twice horizontally,.."] - pub rep: NvU16, - #[doc = "!< Timing standard"] - pub status: NvU32, - #[doc = "!< Timing name"] - pub name: [NvU8; 40usize], -} -#[doc = "! \\ingroup dispcontrol\n! NVIDIA-specific timing extras \\n\n! Used in NV_TIMING."] -pub type NV_TIMINGEXT = tagNV_TIMINGEXT; -#[doc = "! \\ingroup dispcontrol\n!The very basic timing structure based on the VESA standard:\n! \\code\n! |<----------------------------htotal--------------------------->|\n! ---------\"active\" video-------->|<-------blanking------>|<-----\n! |<-------hvisible-------->|<-hb->|<-hfp->|<-hsw->|<-hbp->|<-hb->|\n! --------- -+-------------------------+ | | | | |\n! A A | | | | | | |\n! : : | | | | | | |\n! : : | | | | | | |\n! :vertical| addressable video | | | | | |\n! : visible| | | | | | |\n! : : | | | | | | |\n! : : | | | | | | |\n! vertical V | | | | | | |\n! total --+-------------------------+ | | | | |\n! : vb border | | | | |\n! : -----------------------------------+ | | | |\n! : vfp front porch | | | |\n! : -------------------------------------------+ | | |\n! : vsw sync width | | |\n! : ---------------------------------------------------+ | |\n! : vbp back porch | |\n! : -----------------------------------------------------------+ |\n! V vb border |\n! ---------------------------------------------------------------------------+\n! \\endcode"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_TIMING { - #[doc = "!< horizontal visible"] - pub HVisible: NvU16, - #[doc = "!< horizontal border"] - pub HBorder: NvU16, - #[doc = "!< horizontal front porch"] - pub HFrontPorch: NvU16, - #[doc = "!< horizontal sync width"] - pub HSyncWidth: NvU16, - #[doc = "!< horizontal total"] - pub HTotal: NvU16, - #[doc = "!< horizontal sync polarity: 1-negative, 0-positive"] - pub HSyncPol: NvU8, - #[doc = "!< vertical visible"] - pub VVisible: NvU16, - #[doc = "!< vertical border"] - pub VBorder: NvU16, - #[doc = "!< vertical front porch"] - pub VFrontPorch: NvU16, - #[doc = "!< vertical sync width"] - pub VSyncWidth: NvU16, - #[doc = "!< vertical total"] - pub VTotal: NvU16, - #[doc = "!< vertical sync polarity: 1-negative, 0-positive"] - pub VSyncPol: NvU8, - #[doc = "!< 1-interlaced, 0-progressive"] - pub interlaced: NvU16, - #[doc = "!< pixel clock in 10 kHz"] - pub pclk: NvU32, - pub etc: NV_TIMINGEXT, -} -#[doc = "! \\ingroup dispcontrol\n!The very basic timing structure based on the VESA standard:\n! \\code\n! |<----------------------------htotal--------------------------->|\n! ---------\"active\" video-------->|<-------blanking------>|<-----\n! |<-------hvisible-------->|<-hb->|<-hfp->|<-hsw->|<-hbp->|<-hb->|\n! --------- -+-------------------------+ | | | | |\n! A A | | | | | | |\n! : : | | | | | | |\n! : : | | | | | | |\n! :vertical| addressable video | | | | | |\n! : visible| | | | | | |\n! : : | | | | | | |\n! : : | | | | | | |\n! vertical V | | | | | | |\n! total --+-------------------------+ | | | | |\n! : vb border | | | | |\n! : -----------------------------------+ | | | |\n! : vfp front porch | | | |\n! : -------------------------------------------+ | | |\n! : vsw sync width | | |\n! : ---------------------------------------------------+ | |\n! : vbp back porch | |\n! : -----------------------------------------------------------+ |\n! V vb border |\n! ---------------------------------------------------------------------------+\n! \\endcode"] -pub type NV_TIMING = _NV_TIMING; -#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_SetView() and NvAPI_GetView()"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_VIEW_TARGET_INFO { - #[doc = "!< (IN) structure version"] - pub version: NvU32, - #[doc = "!< (IN) target count"] - pub count: NvU32, - pub target: [NV_VIEW_TARGET_INFO__bindgen_ty_1; 2usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_VIEW_TARGET_INFO__bindgen_ty_1 { - #[doc = "!< (IN/OUT) Device mask"] - pub deviceMask: NvU32, - #[doc = "!< (IN/OUT) Source ID - values will be based on the number of heads exposed per GPU."] - pub sourceId: NvU32, - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, - pub __bindgen_padding_0: [u8; 3usize], -} -impl NV_VIEW_TARGET_INFO__bindgen_ty_1 { - #[inline] - pub fn bPrimary(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bPrimary(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bPrimary_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bPrimary_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bInterlaced(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_bInterlaced(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bInterlaced_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bInterlaced_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bGDIPrimary(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_bGDIPrimary(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bGDIPrimary_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bGDIPrimary_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bForceModeSet(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_bForceModeSet(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bForceModeSet_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bForceModeSet_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bPrimary: NvU32, - bInterlaced: NvU32, - bGDIPrimary: NvU32, - bForceModeSet: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bPrimary: u32 = unsafe { ::std::mem::transmute(bPrimary) }; - bPrimary as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let bInterlaced: u32 = unsafe { ::std::mem::transmute(bInterlaced) }; - bInterlaced as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let bGDIPrimary: u32 = unsafe { ::std::mem::transmute(bGDIPrimary) }; - bGDIPrimary as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let bForceModeSet: u32 = unsafe { ::std::mem::transmute(bForceModeSet) }; - bForceModeSet as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PATH_INFO."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_DISPLAY_PATH { - #[doc = "!< (IN) Device mask"] - pub deviceMask: NvU32, - #[doc = "!< (IN) Values will be based on the number of heads exposed per GPU(0, 1?)"] - pub sourceId: NvU32, - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, - #[doc = "!< (IN) Specify connector type. For TV only."] - pub connector: NV_GPU_CONNECTOR_TYPE, - #[doc = "!< (IN) Width of the mode"] - pub width: NvU32, - #[doc = "!< (IN) Height of the mode"] - pub height: NvU32, - #[doc = "!< (IN) Depth of the mode"] - pub depth: NvU32, - #[doc = "!< Color format if it needs to be specified. Not used now."] - pub colorFormat: NV_FORMAT, - #[doc = "!< (IN) Rotation setting."] - pub rotation: NV_ROTATE, - #[doc = "!< (IN) Scaling setting"] - pub scaling: NV_SCALING, - #[doc = "!< (IN) Refresh rate of the mode"] - pub refreshRate: NvU32, - pub _bitfield_align_2: [u8; 0], - pub _bitfield_2: __BindgenBitfieldUnit<[u8; 1usize]>, - #[doc = "!< (IN) To choose the last TV format set this value to NV_DISPLAY_TV_FORMAT_NONE"] - pub tvFormat: NV_DISPLAY_TV_FORMAT, - #[doc = "!< (IN/OUT) X-offset of this display on the Windows desktop"] - pub posx: NvU32, - #[doc = "!< (IN/OUT) Y-offset of this display on the Windows desktop"] - pub posy: NvU32, - pub _bitfield_align_3: [u32; 0], - pub _bitfield_3: __BindgenBitfieldUnit<[u8; 4usize]>, -} -impl NV_DISPLAY_PATH { - #[inline] - pub fn bPrimary(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bPrimary(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bPrimary_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bPrimary_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1(bPrimary: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bPrimary: u32 = unsafe { ::std::mem::transmute(bPrimary) }; - bPrimary as u64 - }); - __bindgen_bitfield_unit - } - #[inline] - pub fn interlaced(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_interlaced(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_2.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn interlaced_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_2), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_interlaced_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_2), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_2(interlaced: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let interlaced: u32 = unsafe { ::std::mem::transmute(interlaced) }; - interlaced as u64 - }); - __bindgen_bitfield_unit - } - #[inline] - pub fn bGDIPrimary(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_3.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bGDIPrimary(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_3.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bGDIPrimary_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_3), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bGDIPrimary_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_3), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bForceModeSet(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_3.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_bForceModeSet(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_3.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bForceModeSet_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_3), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bForceModeSet_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_3), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bFocusDisplay(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_3.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_bFocusDisplay(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_3.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bFocusDisplay_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_3), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bFocusDisplay_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_3), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn gpuId(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_3.get(3usize, 24u8) as u32) } - } - #[inline] - pub fn set_gpuId(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_3.set(3usize, 24u8, val as u64) - } - } - #[inline] - pub unsafe fn gpuId_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_3), - 3usize, - 24u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_gpuId_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_3), - 3usize, - 24u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_3( - bGDIPrimary: NvU32, - bForceModeSet: NvU32, - bFocusDisplay: NvU32, - gpuId: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bGDIPrimary: u32 = unsafe { ::std::mem::transmute(bGDIPrimary) }; - bGDIPrimary as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let bForceModeSet: u32 = unsafe { ::std::mem::transmute(bForceModeSet) }; - bForceModeSet as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let bFocusDisplay: u32 = unsafe { ::std::mem::transmute(bFocusDisplay) }; - bFocusDisplay as u64 - }); - __bindgen_bitfield_unit.set(3usize, 24u8, { - let gpuId: u32 = unsafe { ::std::mem::transmute(gpuId) }; - gpuId as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_SetViewEx() and NvAPI_GetViewEx()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_DISPLAY_PATH_INFO_V3 { - #[doc = "!< (IN) Structure version"] - pub version: NvU32, - #[doc = "!< (IN) Path count"] - pub count: NvU32, - pub path: [NV_DISPLAY_PATH; 2usize], -} -#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_SetViewEx() and NvAPI_GetViewEx()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_DISPLAY_PATH_INFO { - #[doc = "!< (IN) Structure version"] - pub version: NvU32, - #[doc = "!< (IN) Path count"] - pub count: NvU32, - pub path: [NV_DISPLAY_PATH; 4usize], -} -#[doc = "\n! \\ingroup dispcontrol"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_POSITION { - pub x: NvS32, - pub y: NvS32, -} -#[doc = "\n! \\ingroup dispcontrol"] -pub type NV_POSITION = _NV_POSITION; -#[doc = "! \\ingroup dispcontrol"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_RESOLUTION { - pub width: NvU32, - pub height: NvU32, - pub colorDepth: NvU32, -} -#[doc = "! \\ingroup dispcontrol"] -pub type NV_RESOLUTION = _NV_RESOLUTION; -#[doc = "! \\ingroup dispcontrol"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO_V1 { - pub version: NvU32, - #[doc = "!< (IN) rotation setting."] - pub rotation: NV_ROTATE, - #[doc = "!< (IN) scaling setting."] - pub scaling: NV_SCALING, - #[doc = "!< (IN) Non-interlaced Refresh Rate of the mode, multiplied by 1000, 0 = ignored\n!< This is the value which driver reports to the OS."] - pub refreshRate1K: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Specify connector type. For TV only, ignored if tvFormat == NV_DISPLAY_TV_FORMAT_NONE"] - pub connector: NV_GPU_CONNECTOR_TYPE, - #[doc = "!< (IN) to choose the last TV format set this value to NV_DISPLAY_TV_FORMAT_NONE\n!< In case of NvAPI_DISP_GetDisplayConfig(), this field will indicate the currently applied TV format;\n!< if no TV format is applied, this field will have NV_DISPLAY_TV_FORMAT_NONE value.\n!< In case of NvAPI_DISP_SetDisplayConfig(), this field should only be set in case of TVs;\n!< for other displays this field will be ignored and resolution & refresh rate specified in input will be used to apply the TV format."] - pub tvFormat: NV_DISPLAY_TV_FORMAT, - #[doc = "!< Ignored if timingOverride == NV_TIMING_OVERRIDE_CURRENT"] - pub timingOverride: NV_TIMING_OVERRIDE, - #[doc = "!< Scan out timing, valid only if timingOverride == NV_TIMING_OVERRIDE_CUST\n!< The value NV_TIMING::NV_TIMINGEXT::rrx1k is obtained from the EDID. The driver may\n!< tweak this value for HDTV, stereo, etc., before reporting it to the OS."] - pub timing: NV_TIMING, -} -impl _NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO_V1 { - #[inline] - pub fn interlaced(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_interlaced(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn interlaced_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_interlaced_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn primary(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_primary(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn primary_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_primary_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reservedBit1(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_reservedBit1(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn reservedBit1_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reservedBit1_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn disableVirtualModeSupport(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_disableVirtualModeSupport(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn disableVirtualModeSupport_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_disableVirtualModeSupport_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isPreferredUnscaledTarget(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } - } - #[inline] - pub fn set_isPreferredUnscaledTarget(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isPreferredUnscaledTarget_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isPreferredUnscaledTarget_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 27u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 27u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 27u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - interlaced: NvU32, - primary: NvU32, - reservedBit1: NvU32, - disableVirtualModeSupport: NvU32, - isPreferredUnscaledTarget: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let interlaced: u32 = unsafe { ::std::mem::transmute(interlaced) }; - interlaced as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let primary: u32 = unsafe { ::std::mem::transmute(primary) }; - primary as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let reservedBit1: u32 = unsafe { ::std::mem::transmute(reservedBit1) }; - reservedBit1 as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let disableVirtualModeSupport: u32 = - unsafe { ::std::mem::transmute(disableVirtualModeSupport) }; - disableVirtualModeSupport as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let isPreferredUnscaledTarget: u32 = - unsafe { ::std::mem::transmute(isPreferredUnscaledTarget) }; - isPreferredUnscaledTarget as u64 - }); - __bindgen_bitfield_unit.set(5usize, 27u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! \\ingroup dispcontrol"] -pub type NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO_V1 = - _NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO_V1; -#[doc = "! \\ingroup dispcontrol"] -pub type NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO = NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO_V1; -#[doc = "! \\ingroup dispcontrol"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_DISPLAYCONFIG_PATH_TARGET_INFO_V1 { - #[doc = "!< Display ID"] - pub displayId: NvU32, - #[doc = "!< May be NULL if no advanced settings are required. NULL for Non-NVIDIA Display."] - pub details: *mut NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO, -} -#[doc = "! \\ingroup dispcontrol"] -pub type NV_DISPLAYCONFIG_PATH_TARGET_INFO_V1 = _NV_DISPLAYCONFIG_PATH_TARGET_INFO_V1; -#[doc = "! \\ingroup dispcontrol"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_DISPLAYCONFIG_PATH_TARGET_INFO_V2 { - #[doc = "!< Display ID"] - pub displayId: NvU32, - #[doc = "!< May be NULL if no advanced settings are required"] - pub details: *mut NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO, - #[doc = "!< Windows CCD target ID. Must be present only for non-NVIDIA adapter, for NVIDIA adapter this parameter is ignored."] - pub targetId: NvU32, -} -#[doc = "! \\ingroup dispcontrol"] -pub type NV_DISPLAYCONFIG_PATH_TARGET_INFO_V2 = _NV_DISPLAYCONFIG_PATH_TARGET_INFO_V2; -#[doc = "! \\ingroup dispcontrol\n! As version is not defined for this structure, we will be using version of NV_DISPLAYCONFIG_PATH_INFO"] -pub type NV_DISPLAYCONFIG_PATH_TARGET_INFO = NV_DISPLAYCONFIG_PATH_TARGET_INFO_V2; -pub const _NV_DISPLAYCONFIG_SPANNING_ORIENTATION_NV_DISPLAYCONFIG_SPAN_NONE: - _NV_DISPLAYCONFIG_SPANNING_ORIENTATION = 0; -pub const _NV_DISPLAYCONFIG_SPANNING_ORIENTATION_NV_DISPLAYCONFIG_SPAN_HORIZONTAL: - _NV_DISPLAYCONFIG_SPANNING_ORIENTATION = 1; -pub const _NV_DISPLAYCONFIG_SPANNING_ORIENTATION_NV_DISPLAYCONFIG_SPAN_VERTICAL: - _NV_DISPLAYCONFIG_SPANNING_ORIENTATION = 2; -#[doc = "! \\ingroup dispcontrol"] -pub type _NV_DISPLAYCONFIG_SPANNING_ORIENTATION = ::std::os::raw::c_int; -#[doc = "! \\ingroup dispcontrol"] -pub use self::_NV_DISPLAYCONFIG_SPANNING_ORIENTATION as NV_DISPLAYCONFIG_SPANNING_ORIENTATION; -#[doc = "! \\ingroup dispcontrol"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1 { - pub resolution: NV_RESOLUTION, - #[doc = "!< Ignored at present, must be NV_FORMAT_UNKNOWN (0)"] - pub colorFormat: NV_FORMAT, - #[doc = "!< Is all positions are 0 or invalid, displays will be automatically\n!< positioned from left to right with GDI Primary at 0,0, and all\n!< other displays in the order of the path array."] - pub position: NV_POSITION, - #[doc = "!< Spanning is only supported on XP"] - pub spanningOrientation: NV_DISPLAYCONFIG_SPANNING_ORIENTATION, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, -} -impl _NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1 { - #[inline] - pub fn bGDIPrimary(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bGDIPrimary(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bGDIPrimary_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bGDIPrimary_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bSLIFocus(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_bSLIFocus(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bSLIFocus_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bSLIFocus_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 30u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 30u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 30u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bGDIPrimary: NvU32, - bSLIFocus: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bGDIPrimary: u32 = unsafe { ::std::mem::transmute(bGDIPrimary) }; - bGDIPrimary as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let bSLIFocus: u32 = unsafe { ::std::mem::transmute(bSLIFocus) }; - bSLIFocus as u64 - }); - __bindgen_bitfield_unit.set(2usize, 30u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! \\ingroup dispcontrol"] -pub type NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1 = _NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1; -#[doc = "! \\ingroup dispcontrol"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_DISPLAYCONFIG_PATH_INFO_V1 { - pub version: NvU32, - #[doc = "!< This field is reserved. There is ongoing debate if we need this field.\n!< Identifies sourceIds used by Windows. If all sourceIds are 0,\n!< these will be computed automatically."] - pub reserved_sourceId: NvU32, - #[doc = "!< Number of elements in targetInfo array"] - pub targetInfoCount: NvU32, - pub targetInfo: *mut NV_DISPLAYCONFIG_PATH_TARGET_INFO_V1, - #[doc = "!< May be NULL if mode info is not important"] - pub sourceModeInfo: *mut NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1, -} -#[doc = "! \\ingroup dispcontrol"] -pub type NV_DISPLAYCONFIG_PATH_INFO_V1 = _NV_DISPLAYCONFIG_PATH_INFO_V1; -#[doc = "! \\ingroup dispcontrol"] -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_DISPLAYCONFIG_PATH_INFO { - pub version: NvU32, - pub __bindgen_anon_1: _NV_DISPLAYCONFIG_PATH_INFO__bindgen_ty_1, - #[doc = "!< Number of elements in targetInfo array"] - pub targetInfoCount: NvU32, - pub targetInfo: *mut NV_DISPLAYCONFIG_PATH_TARGET_INFO_V2, - #[doc = "!< May be NULL if mode info is not important"] - pub sourceModeInfo: *mut NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Used by Non-NVIDIA adapter for pointer to OS Adapter of LUID\n!< type, type casted to void *."] - pub pOSAdapterID: *mut ::std::os::raw::c_void, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union _NV_DISPLAYCONFIG_PATH_INFO__bindgen_ty_1 { - #[doc = "!< Identifies sourceId used by Windows CCD. This can be optionally set."] - pub sourceId: NvU32, - #[doc = "!< Only for compatibility"] - pub reserved_sourceId: NvU32, -} -impl _NV_DISPLAYCONFIG_PATH_INFO { - #[inline] - pub fn IsNonNVIDIAAdapter(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_IsNonNVIDIAAdapter(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn IsNonNVIDIAAdapter_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_IsNonNVIDIAAdapter_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - IsNonNVIDIAAdapter: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let IsNonNVIDIAAdapter: u32 = unsafe { ::std::mem::transmute(IsNonNVIDIAAdapter) }; - IsNonNVIDIAAdapter as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! \\ingroup dispcontrol"] -pub type NV_DISPLAYCONFIG_PATH_INFO_V2 = _NV_DISPLAYCONFIG_PATH_INFO; -#[doc = "! \\ingroup dispcontrol"] -pub type NV_DISPLAYCONFIG_PATH_INFO = NV_DISPLAYCONFIG_PATH_INFO_V2; -#[doc = "! \\ingroup dispcontrol"] -pub type NV_DISPLAYCONFIG_SOURCE_MODE_INFO = NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1; -pub const _NV_DISPLAYCONFIG_FLAGS_NV_DISPLAYCONFIG_VALIDATE_ONLY: _NV_DISPLAYCONFIG_FLAGS = 1; -pub const _NV_DISPLAYCONFIG_FLAGS_NV_DISPLAYCONFIG_SAVE_TO_PERSISTENCE: _NV_DISPLAYCONFIG_FLAGS = 2; -#[doc = "!< Driver reload is permitted if necessary"] -pub const _NV_DISPLAYCONFIG_FLAGS_NV_DISPLAYCONFIG_DRIVER_RELOAD_ALLOWED: _NV_DISPLAYCONFIG_FLAGS = - 4; -#[doc = "!< Refresh OS mode list."] -pub const _NV_DISPLAYCONFIG_FLAGS_NV_DISPLAYCONFIG_FORCE_MODE_ENUMERATION: _NV_DISPLAYCONFIG_FLAGS = - 8; -#[doc = "!< Tell OS to avoid optimizing CommitVidPn call during a modeset"] -pub const _NV_DISPLAYCONFIG_FLAGS_NV_FORCE_COMMIT_VIDPN: _NV_DISPLAYCONFIG_FLAGS = 16; -#[doc = "! \\ingroup dispcontrol"] -pub type _NV_DISPLAYCONFIG_FLAGS = ::std::os::raw::c_int; -#[doc = "! \\ingroup dispcontrol"] -pub use self::_NV_DISPLAYCONFIG_FLAGS as NV_DISPLAYCONFIG_FLAGS; -pub type NvAPI_UnicodeString = [NvU16; 2048usize]; -pub type NvAPI_LPCWSTR = *const NvU16; -pub const _NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID_NVAPI_GPU_PERF_VOLTAGE_INFO_DOMAIN_CORE: - _NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID = 0; -pub const _NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID_NVAPI_GPU_PERF_VOLTAGE_INFO_DOMAIN_UNDEFINED: - _NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID = 16; -#[doc = "! \\ingroup gpuclock"] -pub type _NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID = ::std::os::raw::c_int; -#[doc = "! \\ingroup gpuclock"] -pub use self::_NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID as NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID; -pub const _NV_GPU_PUBLIC_CLOCK_ID_NVAPI_GPU_PUBLIC_CLOCK_GRAPHICS: _NV_GPU_PUBLIC_CLOCK_ID = 0; -pub const _NV_GPU_PUBLIC_CLOCK_ID_NVAPI_GPU_PUBLIC_CLOCK_MEMORY: _NV_GPU_PUBLIC_CLOCK_ID = 4; -pub const _NV_GPU_PUBLIC_CLOCK_ID_NVAPI_GPU_PUBLIC_CLOCK_PROCESSOR: _NV_GPU_PUBLIC_CLOCK_ID = 7; -pub const _NV_GPU_PUBLIC_CLOCK_ID_NVAPI_GPU_PUBLIC_CLOCK_VIDEO: _NV_GPU_PUBLIC_CLOCK_ID = 8; -pub const _NV_GPU_PUBLIC_CLOCK_ID_NVAPI_GPU_PUBLIC_CLOCK_UNDEFINED: _NV_GPU_PUBLIC_CLOCK_ID = 32; -#[doc = "! \\ingroup gpuclock"] -pub type _NV_GPU_PUBLIC_CLOCK_ID = ::std::os::raw::c_int; -#[doc = "! \\ingroup gpuclock"] -pub use self::_NV_GPU_PUBLIC_CLOCK_ID as NV_GPU_PUBLIC_CLOCK_ID; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P0: _NV_GPU_PERF_PSTATE_ID = 0; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P1: _NV_GPU_PERF_PSTATE_ID = 1; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P2: _NV_GPU_PERF_PSTATE_ID = 2; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P3: _NV_GPU_PERF_PSTATE_ID = 3; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P4: _NV_GPU_PERF_PSTATE_ID = 4; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P5: _NV_GPU_PERF_PSTATE_ID = 5; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P6: _NV_GPU_PERF_PSTATE_ID = 6; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P7: _NV_GPU_PERF_PSTATE_ID = 7; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P8: _NV_GPU_PERF_PSTATE_ID = 8; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P9: _NV_GPU_PERF_PSTATE_ID = 9; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P10: _NV_GPU_PERF_PSTATE_ID = 10; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P11: _NV_GPU_PERF_PSTATE_ID = 11; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P12: _NV_GPU_PERF_PSTATE_ID = 12; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P13: _NV_GPU_PERF_PSTATE_ID = 13; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P14: _NV_GPU_PERF_PSTATE_ID = 14; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P15: _NV_GPU_PERF_PSTATE_ID = 15; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_UNDEFINED: _NV_GPU_PERF_PSTATE_ID = 16; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_ALL: _NV_GPU_PERF_PSTATE_ID = 17; -#[doc = "! \\addtogroup gpupstate\n! @{"] -pub type _NV_GPU_PERF_PSTATE_ID = ::std::os::raw::c_int; -#[doc = "! \\addtogroup gpupstate\n! @{"] -pub use self::_NV_GPU_PERF_PSTATE_ID as NV_GPU_PERF_PSTATE_ID; -#[doc = "! Clock domains that use single frequency value within given pstate"] -pub const NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID_NVAPI_GPU_PERF_PSTATE20_CLOCK_TYPE_SINGLE: - NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID = 0; -#[doc = "! Clock domains that allow range of frequency values within given pstate"] -pub const NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID_NVAPI_GPU_PERF_PSTATE20_CLOCK_TYPE_RANGE: - NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID = 1; -#[doc = "! Used to identify clock type"] -pub type NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID = ::std::os::raw::c_int; -#[doc = "! Used to describe both voltage and frequency deltas"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_PERF_PSTATES20_PARAM_DELTA { - #[doc = "! Value of parameter delta (in respective units [kHz, uV])"] - pub value: NvS32, - pub valueRange: NV_GPU_PERF_PSTATES20_PARAM_DELTA__bindgen_ty_1, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_PERF_PSTATES20_PARAM_DELTA__bindgen_ty_1 { - #[doc = "! Min value allowed for parameter delta (in respective units [kHz, uV])"] - pub min: NvS32, - #[doc = "! Max value allowed for parameter delta (in respective units [kHz, uV])"] - pub max: NvS32, -} -#[doc = "! Used to describe single clock entry"] -#[repr(C)] -#[derive(Copy, Clone)] -pub struct NV_GPU_PSTATE20_CLOCK_ENTRY_V1 { - #[doc = "! ID of the clock domain"] - pub domainId: NV_GPU_PUBLIC_CLOCK_ID, - #[doc = "! Clock type ID"] - pub typeId: NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "! Current frequency delta from nominal settings in (kHz)"] - pub freqDelta_kHz: NV_GPU_PERF_PSTATES20_PARAM_DELTA, - pub data: NV_GPU_PSTATE20_CLOCK_ENTRY_V1__bindgen_ty_1, -} -#[doc = "! Clock domain type dependant information"] -#[repr(C)] -#[derive(Copy, Clone)] -pub union NV_GPU_PSTATE20_CLOCK_ENTRY_V1__bindgen_ty_1 { - pub single: NV_GPU_PSTATE20_CLOCK_ENTRY_V1__bindgen_ty_1__bindgen_ty_1, - pub range: NV_GPU_PSTATE20_CLOCK_ENTRY_V1__bindgen_ty_1__bindgen_ty_2, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_PSTATE20_CLOCK_ENTRY_V1__bindgen_ty_1__bindgen_ty_1 { - #[doc = "! Clock frequency within given pstate in (kHz)"] - pub freq_kHz: NvU32, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_PSTATE20_CLOCK_ENTRY_V1__bindgen_ty_1__bindgen_ty_2 { - #[doc = "! Min clock frequency within given pstate in (kHz)"] - pub minFreq_kHz: NvU32, - #[doc = "! Max clock frequency within given pstate in (kHz)"] - pub maxFreq_kHz: NvU32, - #[doc = "! Voltage domain ID and value range in (uV) required for this clock"] - pub domainId: NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID, - pub minVoltage_uV: NvU32, - pub maxVoltage_uV: NvU32, -} -impl NV_GPU_PSTATE20_CLOCK_ENTRY_V1 { - #[inline] - pub fn bIsEditable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsEditable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsEditable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsEditable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bIsEditable: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsEditable: u32 = unsafe { ::std::mem::transmute(bIsEditable) }; - bIsEditable as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! Used to describe single base voltage entry"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY_V1 { - #[doc = "! ID of the voltage domain"] - pub domainId: NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "! Current base voltage settings in [uV]"] - pub volt_uV: NvU32, - pub voltDelta_uV: NV_GPU_PERF_PSTATES20_PARAM_DELTA, -} -impl NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY_V1 { - #[inline] - pub fn bIsEditable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsEditable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsEditable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsEditable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bIsEditable: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsEditable: u32 = unsafe { ::std::mem::transmute(bIsEditable) }; - bIsEditable as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! Used in NvAPI_GPU_GetPstates20() interface call."] -#[repr(C)] -#[derive(Copy, Clone)] -pub struct NV_GPU_PERF_PSTATES20_INFO_V1 { - #[doc = "! Version info of the structure (NV_GPU_PERF_PSTATES20_INFO_VER)"] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "! Number of populated pstates"] - pub numPstates: NvU32, - #[doc = "! Number of populated clocks (per pstate)"] - pub numClocks: NvU32, - #[doc = "! Number of populated base voltages (per pstate)"] - pub numBaseVoltages: NvU32, - pub pstates: [NV_GPU_PERF_PSTATES20_INFO_V1__bindgen_ty_1; 16usize], -} -#[doc = "! Performance state (P-State) settings\n! Valid index range is 0 to numPstates-1"] -#[repr(C)] -#[derive(Copy, Clone)] -pub struct NV_GPU_PERF_PSTATES20_INFO_V1__bindgen_ty_1 { - #[doc = "! ID of the P-State"] - pub pstateId: NV_GPU_PERF_PSTATE_ID, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "! Array of clock entries\n! Valid index range is 0 to numClocks-1"] - pub clocks: [NV_GPU_PSTATE20_CLOCK_ENTRY_V1; 8usize], - #[doc = "! Array of baseVoltage entries\n! Valid index range is 0 to numBaseVoltages-1"] - pub baseVoltages: [NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY_V1; 4usize], -} -impl NV_GPU_PERF_PSTATES20_INFO_V1__bindgen_ty_1 { - #[inline] - pub fn bIsEditable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsEditable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsEditable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsEditable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bIsEditable: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsEditable: u32 = unsafe { ::std::mem::transmute(bIsEditable) }; - bIsEditable as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -impl NV_GPU_PERF_PSTATES20_INFO_V1 { - #[inline] - pub fn bIsEditable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsEditable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsEditable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsEditable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bIsEditable: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsEditable: u32 = unsafe { ::std::mem::transmute(bIsEditable) }; - bIsEditable as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! Used in NvAPI_GPU_GetPstates20() interface call."] -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_GPU_PERF_PSTATES20_INFO_V2 { - #[doc = "! Version info of the structure (NV_GPU_PERF_PSTATES20_INFO_VER)"] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "! Number of populated pstates"] - pub numPstates: NvU32, - #[doc = "! Number of populated clocks (per pstate)"] - pub numClocks: NvU32, - #[doc = "! Number of populated base voltages (per pstate)"] - pub numBaseVoltages: NvU32, - pub pstates: [_NV_GPU_PERF_PSTATES20_INFO_V2__bindgen_ty_1; 16usize], - pub ov: _NV_GPU_PERF_PSTATES20_INFO_V2__bindgen_ty_2, -} -#[doc = "! Performance state (P-State) settings\n! Valid index range is 0 to numPstates-1"] -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_GPU_PERF_PSTATES20_INFO_V2__bindgen_ty_1 { - #[doc = "! ID of the P-State"] - pub pstateId: NV_GPU_PERF_PSTATE_ID, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "! Array of clock entries\n! Valid index range is 0 to numClocks-1"] - pub clocks: [NV_GPU_PSTATE20_CLOCK_ENTRY_V1; 8usize], - #[doc = "! Array of baseVoltage entries\n! Valid index range is 0 to numBaseVoltages-1"] - pub baseVoltages: [NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY_V1; 4usize], -} -impl _NV_GPU_PERF_PSTATES20_INFO_V2__bindgen_ty_1 { - #[inline] - pub fn bIsEditable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsEditable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsEditable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsEditable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bIsEditable: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsEditable: u32 = unsafe { ::std::mem::transmute(bIsEditable) }; - bIsEditable as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! OV settings - Please refer to NVIDIA over-volting recommendation to understand impact of this functionality\n! Valid index range is 0 to numVoltages-1"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_PERF_PSTATES20_INFO_V2__bindgen_ty_2 { - #[doc = "! Number of populated voltages"] - pub numVoltages: NvU32, - #[doc = "! Array of voltage entries\n! Valid index range is 0 to numVoltages-1"] - pub voltages: [NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY_V1; 4usize], -} -impl _NV_GPU_PERF_PSTATES20_INFO_V2 { - #[inline] - pub fn bIsEditable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsEditable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsEditable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsEditable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bIsEditable: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsEditable: u32 = unsafe { ::std::mem::transmute(bIsEditable) }; - bIsEditable as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! Used in NvAPI_GPU_GetPstates20() interface call."] -pub type NV_GPU_PERF_PSTATES20_INFO_V2 = _NV_GPU_PERF_PSTATES20_INFO_V2; -#[doc = "! Used in NvAPI_GPU_GetPstates20() interface call."] -pub type NV_GPU_PERF_PSTATES20_INFO = NV_GPU_PERF_PSTATES20_INFO_V2; -#[doc = "! \\ingroup driverapi\n! Used in NvAPI_GetDisplayDriverVersion()"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_DISPLAY_DRIVER_VERSION { - pub version: NvU32, - pub drvVersion: NvU32, - pub bldChangeListNum: NvU32, - pub szBuildBranchString: NvAPI_ShortString, - pub szAdapterString: NvAPI_ShortString, -} -pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_UNINITIALIZED: NV_MONITOR_CONN_TYPE = 0; -pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_VGA: NV_MONITOR_CONN_TYPE = 1; -pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_COMPONENT: NV_MONITOR_CONN_TYPE = 2; -pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_SVIDEO: NV_MONITOR_CONN_TYPE = 3; -pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_HDMI: NV_MONITOR_CONN_TYPE = 4; -pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_DVI: NV_MONITOR_CONN_TYPE = 5; -pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_LVDS: NV_MONITOR_CONN_TYPE = 6; -pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_DP: NV_MONITOR_CONN_TYPE = 7; -pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_COMPOSITE: NV_MONITOR_CONN_TYPE = 8; -pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_UNKNOWN: NV_MONITOR_CONN_TYPE = -1; -#[doc = "! \\ingroup gpu"] -pub type NV_MONITOR_CONN_TYPE = ::std::os::raw::c_int; -#[doc = "! \\ingroup gpu"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_DISPLAYIDS { - pub version: NvU32, - #[doc = "!< out: vga, tv, dvi, hdmi and dp. This is reserved for future use and clients should not rely on this information. Instead get the\n!< GPU connector type from NvAPI_GPU_GetConnectorInfo/NvAPI_GPU_GetConnectorInfoEx"] - pub connectorType: NV_MONITOR_CONN_TYPE, - #[doc = "!< this is a unique identifier for each device"] - pub displayId: NvU32, - pub _bitfield_align_1: [u16; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, -} -impl _NV_GPU_DISPLAYIDS { - #[inline] - pub fn isDynamic(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isDynamic(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isDynamic_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isDynamic_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMultiStreamRootNode(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMultiStreamRootNode(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMultiStreamRootNode_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMultiStreamRootNode_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isActive(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_isActive(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isActive_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isActive_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isCluster(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_isCluster(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isCluster_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isCluster_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isOSVisible(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } - } - #[inline] - pub fn set_isOSVisible(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isOSVisible_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isOSVisible_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isWFD(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } - } - #[inline] - pub fn set_isWFD(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isWFD_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isWFD_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isConnected(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } - } - #[inline] - pub fn set_isConnected(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(6usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isConnected_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 6usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isConnected_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 6usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reservedInternal(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 10u8) as u32) } - } - #[inline] - pub fn set_reservedInternal(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(7usize, 10u8, val as u64) - } - } - #[inline] - pub unsafe fn reservedInternal_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 7usize, - 10u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reservedInternal_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 7usize, - 10u8, - val as u64, - ) - } - } - #[inline] - pub fn isPhysicallyConnected(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) } - } - #[inline] - pub fn set_isPhysicallyConnected(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(17usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isPhysicallyConnected_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 17usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isPhysicallyConnected_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 17usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 14u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(18usize, 14u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 18usize, - 14u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 18usize, - 14u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isDynamic: NvU32, - isMultiStreamRootNode: NvU32, - isActive: NvU32, - isCluster: NvU32, - isOSVisible: NvU32, - isWFD: NvU32, - isConnected: NvU32, - reservedInternal: NvU32, - isPhysicallyConnected: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isDynamic: u32 = unsafe { ::std::mem::transmute(isDynamic) }; - isDynamic as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let isMultiStreamRootNode: u32 = - unsafe { ::std::mem::transmute(isMultiStreamRootNode) }; - isMultiStreamRootNode as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let isActive: u32 = unsafe { ::std::mem::transmute(isActive) }; - isActive as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let isCluster: u32 = unsafe { ::std::mem::transmute(isCluster) }; - isCluster as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let isOSVisible: u32 = unsafe { ::std::mem::transmute(isOSVisible) }; - isOSVisible as u64 - }); - __bindgen_bitfield_unit.set(5usize, 1u8, { - let isWFD: u32 = unsafe { ::std::mem::transmute(isWFD) }; - isWFD as u64 - }); - __bindgen_bitfield_unit.set(6usize, 1u8, { - let isConnected: u32 = unsafe { ::std::mem::transmute(isConnected) }; - isConnected as u64 - }); - __bindgen_bitfield_unit.set(7usize, 10u8, { - let reservedInternal: u32 = unsafe { ::std::mem::transmute(reservedInternal) }; - reservedInternal as u64 - }); - __bindgen_bitfield_unit.set(17usize, 1u8, { - let isPhysicallyConnected: u32 = - unsafe { ::std::mem::transmute(isPhysicallyConnected) }; - isPhysicallyConnected as u64 - }); - __bindgen_bitfield_unit.set(18usize, 14u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! \\ingroup gpu"] -pub type NV_GPU_DISPLAYIDS = _NV_GPU_DISPLAYIDS; -pub const NV_SYSTEM_TYPE_NV_SYSTEM_TYPE_UNKNOWN: NV_SYSTEM_TYPE = 0; -pub const NV_SYSTEM_TYPE_NV_SYSTEM_TYPE_LAPTOP: NV_SYSTEM_TYPE = 1; -pub const NV_SYSTEM_TYPE_NV_SYSTEM_TYPE_DESKTOP: NV_SYSTEM_TYPE = 2; -#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetSystemType()"] -pub type NV_SYSTEM_TYPE = ::std::os::raw::c_int; -pub const _NV_GPU_OUTPUT_TYPE_NVAPI_GPU_OUTPUT_UNKNOWN: _NV_GPU_OUTPUT_TYPE = 0; -#[doc = "!< CRT display device"] -pub const _NV_GPU_OUTPUT_TYPE_NVAPI_GPU_OUTPUT_CRT: _NV_GPU_OUTPUT_TYPE = 1; -#[doc = "!< Digital Flat Panel display device"] -pub const _NV_GPU_OUTPUT_TYPE_NVAPI_GPU_OUTPUT_DFP: _NV_GPU_OUTPUT_TYPE = 2; -#[doc = "!< TV display device"] -pub const _NV_GPU_OUTPUT_TYPE_NVAPI_GPU_OUTPUT_TV: _NV_GPU_OUTPUT_TYPE = 3; -#[doc = "! \\ingroup gpu\n! used in NvAPI_GPU_GetOutputType()"] -pub type _NV_GPU_OUTPUT_TYPE = ::std::os::raw::c_int; -#[doc = "! \\ingroup gpu\n! used in NvAPI_GPU_GetOutputType()"] -pub use self::_NV_GPU_OUTPUT_TYPE as NV_GPU_OUTPUT_TYPE; -pub const _NV_GPU_TYPE_NV_SYSTEM_TYPE_GPU_UNKNOWN: _NV_GPU_TYPE = 0; -#[doc = "!< Integrated GPU"] -pub const _NV_GPU_TYPE_NV_SYSTEM_TYPE_IGPU: _NV_GPU_TYPE = 1; -#[doc = "!< Discrete GPU"] -pub const _NV_GPU_TYPE_NV_SYSTEM_TYPE_DGPU: _NV_GPU_TYPE = 2; -#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetGPUType()."] -pub type _NV_GPU_TYPE = ::std::os::raw::c_int; -#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetGPUType()."] -pub use self::_NV_GPU_TYPE as NV_GPU_TYPE; -pub const _NV_GPU_BUS_TYPE_NVAPI_GPU_BUS_TYPE_UNDEFINED: _NV_GPU_BUS_TYPE = 0; -pub const _NV_GPU_BUS_TYPE_NVAPI_GPU_BUS_TYPE_PCI: _NV_GPU_BUS_TYPE = 1; -pub const _NV_GPU_BUS_TYPE_NVAPI_GPU_BUS_TYPE_AGP: _NV_GPU_BUS_TYPE = 2; -pub const _NV_GPU_BUS_TYPE_NVAPI_GPU_BUS_TYPE_PCI_EXPRESS: _NV_GPU_BUS_TYPE = 3; -pub const _NV_GPU_BUS_TYPE_NVAPI_GPU_BUS_TYPE_FPCI: _NV_GPU_BUS_TYPE = 4; -pub const _NV_GPU_BUS_TYPE_NVAPI_GPU_BUS_TYPE_AXI: _NV_GPU_BUS_TYPE = 5; -#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetBusType()"] -pub type _NV_GPU_BUS_TYPE = ::std::os::raw::c_int; -#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetBusType()"] -pub use self::_NV_GPU_BUS_TYPE as NV_GPU_BUS_TYPE; -#[doc = "! \\ingroup gpu"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_BOARD_INFO { - #[doc = "!< structure version"] - pub version: NvU32, - #[doc = "!< Board Serial Number"] - pub BoardNum: [NvU8; 16usize], -} -#[doc = "! \\ingroup gpu"] -pub type NV_BOARD_INFO_V1 = _NV_BOARD_INFO; -#[doc = "! \\ingroup gpu"] -pub type NV_BOARD_INFO = NV_BOARD_INFO_V1; -#[doc = "! Used in NvAPI_GPU_GetArchInfo()"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_ARCH_INFO_V1 { - pub version: NvU32, - pub architecture: NvU32, - pub implementation: NvU32, - pub revision: NvU32, -} -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_T2X: _NV_GPU_ARCHITECTURE_ID = -536870880; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_T3X: _NV_GPU_ARCHITECTURE_ID = -536870864; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_T4X: _NV_GPU_ARCHITECTURE_ID = -536870848; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_T12X: _NV_GPU_ARCHITECTURE_ID = -536870848; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_NV40: _NV_GPU_ARCHITECTURE_ID = 64; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_NV50: _NV_GPU_ARCHITECTURE_ID = 80; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_G78: _NV_GPU_ARCHITECTURE_ID = 96; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_G80: _NV_GPU_ARCHITECTURE_ID = 128; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_G90: _NV_GPU_ARCHITECTURE_ID = 144; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GT200: _NV_GPU_ARCHITECTURE_ID = 160; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GF100: _NV_GPU_ARCHITECTURE_ID = 192; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GF110: _NV_GPU_ARCHITECTURE_ID = 208; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GK100: _NV_GPU_ARCHITECTURE_ID = 224; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GK110: _NV_GPU_ARCHITECTURE_ID = 240; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GK200: _NV_GPU_ARCHITECTURE_ID = 256; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GM000: _NV_GPU_ARCHITECTURE_ID = 272; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GM200: _NV_GPU_ARCHITECTURE_ID = 288; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GP100: _NV_GPU_ARCHITECTURE_ID = 304; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GV100: _NV_GPU_ARCHITECTURE_ID = 320; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GV110: _NV_GPU_ARCHITECTURE_ID = 336; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_TU100: _NV_GPU_ARCHITECTURE_ID = 352; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GA100: _NV_GPU_ARCHITECTURE_ID = 368; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_AD100: _NV_GPU_ARCHITECTURE_ID = 400; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GB200: _NV_GPU_ARCHITECTURE_ID = 432; -#[doc = "! NV_GPU_ARCH_INFO() values to identify Architecture level for the GPU."] -pub type _NV_GPU_ARCHITECTURE_ID = ::std::os::raw::c_int; -#[doc = "! NV_GPU_ARCH_INFO() values to identify Architecture level for the GPU."] -pub use self::_NV_GPU_ARCHITECTURE_ID as NV_GPU_ARCHITECTURE_ID; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_T20: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_T30: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_T35: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 5; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_T40: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_T124: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV40: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV41: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 1; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV42: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV43: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 3; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV44: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV44A: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 10; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV46: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV47: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 7; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV49: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 9; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV4B: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 11; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV4C: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 12; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV4E: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 14; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV50: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV63: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 3; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV67: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 7; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_G84: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_G86: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_G92: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_G94: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_G96: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_G98: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 8; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT200: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT212: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT214: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT215: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 3; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT216: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 5; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT218: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 8; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_MCP77: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 10; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT21C: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 11; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_MCP79: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 12; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT21A: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 13; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_MCP89: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 15; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF100: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF104: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF106: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 3; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF108: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 1; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF110: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF116: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF117: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 7; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF118: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 8; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF119: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 9; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GK104: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GK106: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GK107: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 7; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GK20A: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 10; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GK110: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GK208: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 8; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GM204: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GM206: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP100: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP000: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 1; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP102: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP104: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP106: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP107: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 7; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP108: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 8; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GV100: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GV10B: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 11; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU100: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU102: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU104: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU106: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU116: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 8; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU117: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 7; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU000: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 1; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GA100: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GA102: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GA104: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_AD102: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_AD103: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 3; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_AD104: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GB202: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; -#[doc = "! NV_GPU_ARCH_INFO() values to identify GPU Architecture Implementation."] -pub type _NV_GPU_ARCH_IMPLEMENTATION_ID = ::std::os::raw::c_int; -#[doc = "! NV_GPU_ARCH_INFO() values to identify GPU Architecture Implementation."] -pub use self::_NV_GPU_ARCH_IMPLEMENTATION_ID as NV_GPU_ARCH_IMPLEMENTATION_ID; -#[doc = "!< QT chip"] -pub const _NV_GPU_CHIP_REVISION_NV_GPU_CHIP_REV_EMULATION_QT: _NV_GPU_CHIP_REVISION = 0; -#[doc = "!< FPGA implementation of the chipset"] -pub const _NV_GPU_CHIP_REVISION_NV_GPU_CHIP_REV_EMULATION_FPGA: _NV_GPU_CHIP_REVISION = 1; -#[doc = "!< First silicon chipset revision"] -pub const _NV_GPU_CHIP_REVISION_NV_GPU_CHIP_REV_A01: _NV_GPU_CHIP_REVISION = 17; -#[doc = "!< Second Silicon chipset revision"] -pub const _NV_GPU_CHIP_REVISION_NV_GPU_CHIP_REV_A02: _NV_GPU_CHIP_REVISION = 18; -#[doc = "!< Third Silicon chipset revision"] -pub const _NV_GPU_CHIP_REVISION_NV_GPU_CHIP_REV_A03: _NV_GPU_CHIP_REVISION = 19; -#[doc = "!< Unknown chip revision"] -pub const _NV_GPU_CHIP_REVISION_NV_GPU_CHIP_REV_UNKNOWN: _NV_GPU_CHIP_REVISION = -1; -pub type _NV_GPU_CHIP_REVISION = ::std::os::raw::c_int; -pub use self::_NV_GPU_CHIP_REVISION as NV_GPU_CHIP_REVISION; -#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetArchInfo()"] -#[repr(C)] -#[derive(Copy, Clone)] -pub struct NV_GPU_ARCH_INFO_V2 { - pub version: NvU32, - pub __bindgen_anon_1: NV_GPU_ARCH_INFO_V2__bindgen_ty_1, - pub __bindgen_anon_2: NV_GPU_ARCH_INFO_V2__bindgen_ty_2, - pub __bindgen_anon_3: NV_GPU_ARCH_INFO_V2__bindgen_ty_3, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union NV_GPU_ARCH_INFO_V2__bindgen_ty_1 { - #[doc = "!< architecture and architecture_id are the same. The former is NvU32 while the latter is an enum made for readability."] - pub architecture: NvU32, - #[doc = "!< specifies the architecture level for the GPU."] - pub architecture_id: NV_GPU_ARCHITECTURE_ID, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union NV_GPU_ARCH_INFO_V2__bindgen_ty_2 { - #[doc = "!< implementation and implementation_id are the same. The former is NvU32 while the latter is an enum made for readability."] - pub implementation: NvU32, - #[doc = "!< specifies the implementation of the architecture for the GPU."] - pub implementation_id: NV_GPU_ARCH_IMPLEMENTATION_ID, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union NV_GPU_ARCH_INFO_V2__bindgen_ty_3 { - #[doc = "!< revision and revision_id are the same. The former is NvU32 while the latter is an enum made for readability."] - pub revision: NvU32, - #[doc = "!< specifies the architecture revision of the GPU."] - pub revision_id: NV_GPU_CHIP_REVISION, -} -#[doc = "! \\ingroup gpu"] -pub type NV_GPU_ARCH_INFO = NV_GPU_ARCH_INFO_V2; -#[doc = "!< Set i2cSpeedKhz to I2C_SPEED_DEFAULT if default I2C speed is to be chosen, ie.use the current frequency setting."] -pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_DEFAULT: NV_I2C_SPEED = 0; -pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_3KHZ: NV_I2C_SPEED = 1; -pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_10KHZ: NV_I2C_SPEED = 2; -pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_33KHZ: NV_I2C_SPEED = 3; -pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_100KHZ: NV_I2C_SPEED = 4; -pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_200KHZ: NV_I2C_SPEED = 5; -pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_400KHZ: NV_I2C_SPEED = 6; -pub type NV_I2C_SPEED = ::std::os::raw::c_int; -#[doc = "! Used in NvAPI_I2CRead() and NvAPI_I2CWrite()"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_I2C_INFO_V1 { - #[doc = "!< The structure version."] - pub version: NvU32, - #[doc = "!< The Display Mask of the concerned display."] - pub displayMask: NvU32, - #[doc = "!< This flag indicates either the DDC port (TRUE) or the communication port\n!< (FALSE) of the concerned display."] - pub bIsDDCPort: NvU8, - #[doc = "!< The address of the I2C slave. The address should be shifted left by one. For\n!< example, the I2C address 0x50, often used for reading EDIDs, would be stored\n!< here as 0xA0. This matches the position within the byte sent by the master, as\n!< the last bit is reserved to specify the read or write direction."] - pub i2cDevAddress: NvU8, - #[doc = "!< The I2C target register address. May be NULL, which indicates no register\n!< address should be sent."] - pub pbI2cRegAddress: *mut NvU8, - #[doc = "!< The size in bytes of target register address. If pbI2cRegAddress is NULL, this\n!< field must be 0."] - pub regAddrSize: NvU32, - #[doc = "!< The buffer of data which is to be read or written (depending on the command)."] - pub pbData: *mut NvU8, - #[doc = "!< The size of the data buffer, pbData, to be read or written."] - pub cbSize: NvU32, - #[doc = "!< The target speed of the transaction (between 28Kbps to 40Kbps; not guaranteed)."] - pub i2cSpeed: NvU32, -} -#[doc = "! Used in NvAPI_I2CRead() and NvAPI_I2CWrite()"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_I2C_INFO_V2 { - #[doc = "!< The structure version."] - pub version: NvU32, - #[doc = "!< The Display Mask of the concerned display."] - pub displayMask: NvU32, - #[doc = "!< This flag indicates either the DDC port (TRUE) or the communication port\n!< (FALSE) of the concerned display."] - pub bIsDDCPort: NvU8, - #[doc = "!< The address of the I2C slave. The address should be shifted left by one. For\n!< example, the I2C address 0x50, often used for reading EDIDs, would be stored\n!< here as 0xA0. This matches the position within the byte sent by the master, as\n!< the last bit is reserved to specify the read or write direction."] - pub i2cDevAddress: NvU8, - #[doc = "!< The I2C target register address. May be NULL, which indicates no register\n!< address should be sent."] - pub pbI2cRegAddress: *mut NvU8, - #[doc = "!< The size in bytes of target register address. If pbI2cRegAddress is NULL, this\n!< field must be 0."] - pub regAddrSize: NvU32, - #[doc = "!< The buffer of data which is to be read or written (depending on the command)."] - pub pbData: *mut NvU8, - #[doc = "!< The size of the data buffer, pbData, to be read or written."] - pub cbSize: NvU32, - #[doc = "!< Deprecated, Must be set to NVAPI_I2C_SPEED_DEPRECATED."] - pub i2cSpeed: NvU32, - #[doc = "!< The target speed of the transaction in (kHz) (Chosen from the enum NV_I2C_SPEED)."] - pub i2cSpeedKhz: NV_I2C_SPEED, -} -#[doc = "! Used in NvAPI_I2CRead() and NvAPI_I2CWrite()"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_I2C_INFO_V3 { - #[doc = "!< The structure version."] - pub version: NvU32, - #[doc = "!< The Display Mask of the concerned display."] - pub displayMask: NvU32, - #[doc = "!< This flag indicates either the DDC port (TRUE) or the communication port\n!< (FALSE) of the concerned display."] - pub bIsDDCPort: NvU8, - #[doc = "!< The address of the I2C slave. The address should be shifted left by one. For\n!< example, the I2C address 0x50, often used for reading EDIDs, would be stored\n!< here as 0xA0. This matches the position within the byte sent by the master, as\n!< the last bit is reserved to specify the read or write direction."] - pub i2cDevAddress: NvU8, - #[doc = "!< The I2C target register address. May be NULL, which indicates no register\n!< address should be sent."] - pub pbI2cRegAddress: *mut NvU8, - #[doc = "!< The size in bytes of target register address. If pbI2cRegAddress is NULL, this\n!< field must be 0."] - pub regAddrSize: NvU32, - #[doc = "!< The buffer of data which is to be read or written (depending on the command)."] - pub pbData: *mut NvU8, - #[doc = "!< The size of the data buffer, pbData, to be read or written."] - pub cbSize: NvU32, - #[doc = "!< Deprecated, Must be set to NVAPI_I2C_SPEED_DEPRECATED."] - pub i2cSpeed: NvU32, - #[doc = "!< The target speed of the transaction in (kHz) (Chosen from the enum NV_I2C_SPEED)."] - pub i2cSpeedKhz: NV_I2C_SPEED, - #[doc = "!< The portid on which device is connected (remember to set bIsPortIdSet if this value is set)\n!< Optional for pre-Kepler"] - pub portId: NvU8, - #[doc = "!< set this flag on if and only if portid value is set"] - pub bIsPortIdSet: NvU32, -} -#[doc = "! Used in NvAPI_I2CRead() and NvAPI_I2CWrite()"] -pub type NV_I2C_INFO = NV_I2C_INFO_V3; -pub const _NV_GPU_HDCP_FUSE_STATE_NV_GPU_HDCP_FUSE_STATE_UNKNOWN: _NV_GPU_HDCP_FUSE_STATE = 0; -pub const _NV_GPU_HDCP_FUSE_STATE_NV_GPU_HDCP_FUSE_STATE_DISABLED: _NV_GPU_HDCP_FUSE_STATE = 1; -pub const _NV_GPU_HDCP_FUSE_STATE_NV_GPU_HDCP_FUSE_STATE_ENABLED: _NV_GPU_HDCP_FUSE_STATE = 2; -#[doc = "! HDCP fuse states - used in NV_GPU_GET_HDCP_SUPPORT_STATUS"] -pub type _NV_GPU_HDCP_FUSE_STATE = ::std::os::raw::c_int; -#[doc = "! HDCP fuse states - used in NV_GPU_GET_HDCP_SUPPORT_STATUS"] -pub use self::_NV_GPU_HDCP_FUSE_STATE as NV_GPU_HDCP_FUSE_STATE; -pub const _NV_GPU_HDCP_KEY_SOURCE_NV_GPU_HDCP_KEY_SOURCE_UNKNOWN: _NV_GPU_HDCP_KEY_SOURCE = 0; -pub const _NV_GPU_HDCP_KEY_SOURCE_NV_GPU_HDCP_KEY_SOURCE_NONE: _NV_GPU_HDCP_KEY_SOURCE = 1; -pub const _NV_GPU_HDCP_KEY_SOURCE_NV_GPU_HDCP_KEY_SOURCE_CRYPTO_ROM: _NV_GPU_HDCP_KEY_SOURCE = 2; -pub const _NV_GPU_HDCP_KEY_SOURCE_NV_GPU_HDCP_KEY_SOURCE_SBIOS: _NV_GPU_HDCP_KEY_SOURCE = 3; -pub const _NV_GPU_HDCP_KEY_SOURCE_NV_GPU_HDCP_KEY_SOURCE_I2C_ROM: _NV_GPU_HDCP_KEY_SOURCE = 4; -pub const _NV_GPU_HDCP_KEY_SOURCE_NV_GPU_HDCP_KEY_SOURCE_FUSES: _NV_GPU_HDCP_KEY_SOURCE = 5; -#[doc = "! HDCP key sources - used in NV_GPU_GET_HDCP_SUPPORT_STATUS"] -pub type _NV_GPU_HDCP_KEY_SOURCE = ::std::os::raw::c_int; -#[doc = "! HDCP key sources - used in NV_GPU_GET_HDCP_SUPPORT_STATUS"] -pub use self::_NV_GPU_HDCP_KEY_SOURCE as NV_GPU_HDCP_KEY_SOURCE; -pub const _NV_GPU_HDCP_KEY_SOURCE_STATE_NV_GPU_HDCP_KEY_SOURCE_STATE_UNKNOWN: - _NV_GPU_HDCP_KEY_SOURCE_STATE = 0; -pub const _NV_GPU_HDCP_KEY_SOURCE_STATE_NV_GPU_HDCP_KEY_SOURCE_STATE_ABSENT: - _NV_GPU_HDCP_KEY_SOURCE_STATE = 1; -pub const _NV_GPU_HDCP_KEY_SOURCE_STATE_NV_GPU_HDCP_KEY_SOURCE_STATE_PRESENT: - _NV_GPU_HDCP_KEY_SOURCE_STATE = 2; -#[doc = "! HDCP key source states - used in NV_GPU_GET_HDCP_SUPPORT_STATUS"] -pub type _NV_GPU_HDCP_KEY_SOURCE_STATE = ::std::os::raw::c_int; -#[doc = "! HDCP key source states - used in NV_GPU_GET_HDCP_SUPPORT_STATUS"] -pub use self::_NV_GPU_HDCP_KEY_SOURCE_STATE as NV_GPU_HDCP_KEY_SOURCE_STATE; -#[doc = "! HDPC support status - used in NvAPI_GPU_GetHDCPSupportStatus()"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_GET_HDCP_SUPPORT_STATUS { - pub version: NvU32, - #[doc = "! Structure version constucted by macro #NV_GPU_GET_HDCP_SUPPORT_STATUS"] - pub hdcpFuseState: NV_GPU_HDCP_FUSE_STATE, - #[doc = "! GPU's HDCP fuse state"] - pub hdcpKeySource: NV_GPU_HDCP_KEY_SOURCE, - #[doc = "! GPU's HDCP key source"] - pub hdcpKeySourceState: NV_GPU_HDCP_KEY_SOURCE_STATE, -} -#[doc = "! @}"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_COMPUTE_GPU_TOPOLOGY_V1 { - #[doc = "!< Structure version"] - pub version: NvU32, - #[doc = "!< Total number of compute-capable GPUs"] - pub gpuCount: NvU32, - #[doc = "!< Array of compute-capable physical GPUs."] - pub computeGpus: [NV_COMPUTE_GPU_TOPOLOGY_V1__bindgen_ty_1; 8usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_COMPUTE_GPU_TOPOLOGY_V1__bindgen_ty_1 { - #[doc = "!< Compute-capable physical GPU handle"] - pub hPhysicalGpu: NvPhysicalGpuHandle, - #[doc = "!< One or more flags from \\ref nvcomp_gpu_top"] - pub flags: NvU32, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_COMPUTE_GPU { - #[doc = "!< Compute-capable physical GPU handle"] - pub hPhysicalGpu: NvPhysicalGpuHandle, - #[doc = "!< One or more flags from \\ref nvcomp_gpu_top"] - pub flags: NvU32, -} -pub type NV_COMPUTE_GPU = _NV_COMPUTE_GPU; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_COMPUTE_GPU_TOPOLOGY_V2 { - #[doc = "!< Structure version"] - pub version: NvU32, - #[doc = "!< Size of array"] - pub gpuCount: NvU32, - #[doc = "!< Array of compute-capable physical GPUs (allocate memory of size of Physical gpuCount of system)."] - pub computeGpus: *mut NV_COMPUTE_GPU, -} -pub type NV_COMPUTE_GPU_TOPOLOGY_V2 = _NV_COMPUTE_GPU_TOPOLOGY_V2; -pub type NV_COMPUTE_GPU_TOPOLOGY = NV_COMPUTE_GPU_TOPOLOGY_V2; -pub const _NV_ECC_CONFIGURATION_NV_ECC_CONFIGURATION_NOT_SUPPORTED: _NV_ECC_CONFIGURATION = 0; -#[doc = "!< Changes require a POST to take effect"] -pub const _NV_ECC_CONFIGURATION_NV_ECC_CONFIGURATION_DEFERRED: _NV_ECC_CONFIGURATION = 1; -#[doc = "!< Changes can optionally be made to take effect immediately"] -pub const _NV_ECC_CONFIGURATION_NV_ECC_CONFIGURATION_IMMEDIATE: _NV_ECC_CONFIGURATION = 2; -#[doc = "! \\addtogroup gpuecc\n! Used in NV_GPU_ECC_STATUS_INFO."] -pub type _NV_ECC_CONFIGURATION = ::std::os::raw::c_int; -#[doc = "! \\addtogroup gpuecc\n! Used in NV_GPU_ECC_STATUS_INFO."] -pub use self::_NV_ECC_CONFIGURATION as NV_ECC_CONFIGURATION; -#[doc = "! \\ingroup gpuecc\n! Used in NvAPI_GPU_GetECCStatusInfo()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_ECC_STATUS_INFO { - #[doc = "!< Structure version"] - pub version: NvU32, - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, - #[doc = "!< Supported ECC memory feature configuration options"] - pub configurationOptions: NV_ECC_CONFIGURATION, - pub _bitfield_align_2: [u8; 0], - pub _bitfield_2: __BindgenBitfieldUnit<[u8; 1usize]>, - pub __bindgen_padding_0: [u8; 3usize], -} -impl NV_GPU_ECC_STATUS_INFO { - #[inline] - pub fn isSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1(isSupported: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isSupported: u32 = unsafe { ::std::mem::transmute(isSupported) }; - isSupported as u64 - }); - __bindgen_bitfield_unit - } - #[inline] - pub fn isEnabled(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isEnabled(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_2.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isEnabled_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_2), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isEnabled_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_2), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_2(isEnabled: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isEnabled: u32 = unsafe { ::std::mem::transmute(isEnabled) }; - isEnabled as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! \\ingroup gpuecc\n! Used in NvAPI_GPU_GetECCErrorInfo()/"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_ECC_ERROR_INFO { - #[doc = "!< Structure version"] - pub version: NvU32, - pub current: NV_GPU_ECC_ERROR_INFO__bindgen_ty_1, - pub aggregate: NV_GPU_ECC_ERROR_INFO__bindgen_ty_2, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_ECC_ERROR_INFO__bindgen_ty_1 { - #[doc = "!< Number of single-bit ECC errors detected since last boot"] - pub singleBitErrors: NvU64, - #[doc = "!< Number of double-bit ECC errors detected since last boot"] - pub doubleBitErrors: NvU64, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_ECC_ERROR_INFO__bindgen_ty_2 { - #[doc = "!< Number of single-bit ECC errors detected since last counter reset"] - pub singleBitErrors: NvU64, - #[doc = "!< Number of double-bit ECC errors detected since last counter reset"] - pub doubleBitErrors: NvU64, -} -#[doc = "! \\ingroup gpuecc\n! Used in NvAPI_GPU_GetECCConfigurationInfo()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_ECC_CONFIGURATION_INFO { - pub version: NvU32, - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, - pub __bindgen_padding_0: [u8; 3usize], -} -impl NV_GPU_ECC_CONFIGURATION_INFO { - #[inline] - pub fn isEnabled(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isEnabled(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isEnabled_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isEnabled_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isEnabledByDefault(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_isEnabledByDefault(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isEnabledByDefault_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isEnabledByDefault_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isEnabled: NvU32, - isEnabledByDefault: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isEnabled: u32 = unsafe { ::std::mem::transmute(isEnabled) }; - isEnabled as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let isEnabledByDefault: u32 = unsafe { ::std::mem::transmute(isEnabledByDefault) }; - isEnabledByDefault as u64 - }); - __bindgen_bitfield_unit - } -} -pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_NONE: NV_QSYNC_EVENT = 0; -pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_SYNC_LOSS: NV_QSYNC_EVENT = 1; -pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_SYNC_GAIN: NV_QSYNC_EVENT = 2; -pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_HOUSESYNC_GAIN: NV_QSYNC_EVENT = 3; -pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_HOUSESYNC_LOSS: NV_QSYNC_EVENT = 4; -pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_RJ45_GAIN: NV_QSYNC_EVENT = 5; -pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_RJ45_LOSS: NV_QSYNC_EVENT = 6; -pub type NV_QSYNC_EVENT = ::std::os::raw::c_int; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_QSYNC_EVENT_DATA { - pub qsyncEvent: NV_QSYNC_EVENT, - pub reserved: [NvU32; 7usize], -} -#[doc = "! Callback for QSYNC event"] -pub type NVAPI_CALLBACK_QSYNCEVENT = ::std::option::Option< - unsafe extern "C" fn( - qyncEventData: NV_QSYNC_EVENT_DATA, - callbackParam: *mut ::std::os::raw::c_void, - ), ->; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_DISPLAY_OUTPUT_MODE_CHANGE_EVENT_DATA { - #[doc = "!< displayId of the display"] - pub displayId: NvU32, - #[doc = "!< display output mode"] - pub outputMode: NvU32, -} -pub type NV_DISPLAY_OUTPUT_MODE_CHANGE_EVENT_DATA = _NV_DISPLAY_OUTPUT_MODE_CHANGE_EVENT_DATA; -#[doc = "! Callback for Display Output Mode change events"] -pub type NVAPI_CALLBACK_DISPLAY_OUTPUT_MODE_CHANGE_EVENT = ::std::option::Option< - unsafe extern "C" fn( - pEventData: *mut NV_DISPLAY_OUTPUT_MODE_CHANGE_EVENT_DATA, - callbackParam: *mut ::std::os::raw::c_void, - ), ->; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_DISPLAY_COLORIMETRY_CHANGE_EVENT_DATA { - #[doc = "!< displayId of the monitor"] - pub displayId: NvU32, - #[doc = "!< min luminance, cd/m^2"] - pub min_luminance: f32, - #[doc = "!< max 100% frame luminance, cd/m^2"] - pub max_full_frame_luminance: f32, - #[doc = "!< max 10% frame luminance, cd/m^2"] - pub max_luminance: f32, - #[doc = "!< HDR brightness luminance scaling factor applied by GPU on output pixels"] - pub hdrBrightnessLuminanceScalingFactor: f32, - #[doc = "!< red primary chromaticity coordinate x"] - pub red_primary_x: f32, - #[doc = "!< red primary chromaticity coordinate y"] - pub red_primary_y: f32, - #[doc = "!< green primary chromaticity coordinate x"] - pub green_primary_x: f32, - #[doc = "!< green primary chromaticity coordinate y"] - pub green_primary_y: f32, - #[doc = "!< blue primary chromaticity coordinate x"] - pub blue_primary_x: f32, - #[doc = "!< blue primary chromaticity coordinate y"] - pub blue_primary_y: f32, - #[doc = "!< white point chromaticity coordinate x"] - pub white_point_x: f32, - #[doc = "!< white point chromaticity coordinate y"] - pub white_point_y: f32, -} -pub type NV_DISPLAY_COLORIMETRY_CHANGE_EVENT_DATA = _NV_DISPLAY_COLORIMETRY_CHANGE_EVENT_DATA; -#[doc = "! Callback for Display Colorimetry change events"] -pub type NVAPI_CALLBACK_DISPLAY_COLORIMETRY_CHANGE_EVENT = ::std::option::Option< - unsafe extern "C" fn( - pEventData: *mut NV_DISPLAY_COLORIMETRY_CHANGE_EVENT_DATA, - callbackParam: *mut ::std::os::raw::c_void, - ), ->; -pub const NV_EVENT_TYPE_NV_EVENT_TYPE_NONE: NV_EVENT_TYPE = 0; -pub const NV_EVENT_TYPE_NV_EVENT_TYPE_QSYNC: NV_EVENT_TYPE = 6; -pub const NV_EVENT_TYPE_NV_EVENT_TYPE_DISPLAY_OUTPUT_MODE_CHANGE: NV_EVENT_TYPE = 103; -pub const NV_EVENT_TYPE_NV_EVENT_TYPE_DISPLAY_COLORIMETRY_CHANGE: NV_EVENT_TYPE = 104; -#[doc = "! Enum for Event IDs"] -pub type NV_EVENT_TYPE = ::std::os::raw::c_int; -#[doc = "! Core NV_EVENT_REGISTER_CALLBACK structure declaration"] -#[repr(C)] -#[derive(Copy, Clone)] -pub struct NV_EVENT_REGISTER_CALLBACK { - #[doc = "!< version field to ensure minimum version compatibility"] - pub version: NvU32, - #[doc = "!< ID of the event being sent"] - pub eventId: NV_EVENT_TYPE, - #[doc = "!< This value will be passed back to the callback function when an event occurs"] - pub callbackParam: *mut ::std::os::raw::c_void, - pub nvCallBackFunc: NV_EVENT_REGISTER_CALLBACK__bindgen_ty_1, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union NV_EVENT_REGISTER_CALLBACK__bindgen_ty_1 { - #[doc = "!< Callback function pointer for QSYNC events"] - pub nvQSYNCEventCallback: NVAPI_CALLBACK_QSYNCEVENT, - #[doc = "!< Callback function pointer for Display Output Mode change events"] - pub nvDisplayOutputModeChangeEventCallback: NVAPI_CALLBACK_DISPLAY_OUTPUT_MODE_CHANGE_EVENT, - #[doc = "!< Callback function pointer for Display Colorimetry change events"] - pub nvDisplayColorimetryChangeEventCallback: NVAPI_CALLBACK_DISPLAY_COLORIMETRY_CHANGE_EVENT, -} -#[doc = "!< NVIDIA RTX VR Ready"] -pub const _NV_GPU_WORKSTATION_FEATURE_TYPE_NV_GPU_WORKSTATION_FEATURE_TYPE_NVIDIA_RTX_VR_READY: - _NV_GPU_WORKSTATION_FEATURE_TYPE = 1; -#[doc = "!< DEPRECATED name - do not use"] -pub const _NV_GPU_WORKSTATION_FEATURE_TYPE_NV_GPU_WORKSTATION_FEATURE_TYPE_QUADRO_VR_READY: - _NV_GPU_WORKSTATION_FEATURE_TYPE = 1; -pub const _NV_GPU_WORKSTATION_FEATURE_TYPE_NV_GPU_WORKSTATION_FEATURE_TYPE_PROVIZ: - _NV_GPU_WORKSTATION_FEATURE_TYPE = 2; -#[doc = "! \\ingroup gpu"] -pub type _NV_GPU_WORKSTATION_FEATURE_TYPE = ::std::os::raw::c_int; -#[doc = "! \\ingroup gpu"] -pub use self::_NV_GPU_WORKSTATION_FEATURE_TYPE as NV_GPU_WORKSTATION_FEATURE_TYPE; -#[doc = "! \\ingroup gpu"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_SCANOUT_INTENSITY_DATA_V1 { - #[doc = "!< version of this structure"] - pub version: NvU32, - #[doc = "!< width of the input texture"] - pub width: NvU32, - #[doc = "!< height of the input texture"] - pub height: NvU32, - #[doc = "!< array of floating values building an intensity RGB texture"] - pub blendingTexture: *mut f32, -} -#[doc = "! \\ingroup gpu"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_SCANOUT_INTENSITY_DATA_V2 { - #[doc = "!< version of this structure"] - pub version: NvU32, - #[doc = "!< width of the input texture"] - pub width: NvU32, - #[doc = "!< height of the input texture"] - pub height: NvU32, - #[doc = "!< array of floating values building an intensity RGB texture"] - pub blendingTexture: *mut f32, - #[doc = "!< array of floating values building an offset texture"] - pub offsetTexture: *mut f32, - #[doc = "!< number of channels per pixel in the offset texture"] - pub offsetTexChannels: NvU32, -} -#[doc = "! \\ingroup gpu"] -pub type NV_SCANOUT_INTENSITY_DATA = NV_SCANOUT_INTENSITY_DATA_V2; -#[doc = "! \\ingroup gpu"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_SCANOUT_INTENSITY_STATE_DATA { - #[doc = "!< version of this structure"] - pub version: NvU32, - #[doc = "!< intensity is enabled or not"] - pub bEnabled: NvU32, -} -#[doc = "! \\ingroup gpu"] -pub type NV_SCANOUT_INTENSITY_STATE_DATA = _NV_SCANOUT_INTENSITY_STATE_DATA; -pub const NV_GPU_WARPING_VERTICE_FORMAT_NV_GPU_WARPING_VERTICE_FORMAT_TRIANGLESTRIP_XYUVRQ: - NV_GPU_WARPING_VERTICE_FORMAT = 0; -pub const NV_GPU_WARPING_VERTICE_FORMAT_NV_GPU_WARPING_VERTICE_FORMAT_TRIANGLES_XYUVRQ: - NV_GPU_WARPING_VERTICE_FORMAT = 1; -#[doc = "! \\ingroup gpu"] -pub type NV_GPU_WARPING_VERTICE_FORMAT = ::std::os::raw::c_int; -#[doc = "! \\ingroup gpu"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_SCANOUT_WARPING_DATA { - #[doc = "!< version of this structure"] - pub version: NvU32, - #[doc = "!< width of the input texture"] - pub vertices: *mut f32, - #[doc = "!< format of the input vertices"] - pub vertexFormat: NV_GPU_WARPING_VERTICE_FORMAT, - #[doc = "!< number of the input vertices"] - pub numVertices: ::std::os::raw::c_int, - #[doc = "!< rectangle in desktop coordinates describing the source area for the warping"] - pub textureRect: *mut NvSBox, -} -#[doc = "! \\ingroup gpu"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_SCANOUT_WARPING_STATE_DATA { - #[doc = "!< version of this structure"] - pub version: NvU32, - #[doc = "!< warping is enabled or not"] - pub bEnabled: NvU32, -} -#[doc = "! \\ingroup gpu"] -pub type NV_SCANOUT_WARPING_STATE_DATA = _NV_SCANOUT_WARPING_STATE_DATA; -pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_WARPING_RESAMPLING_METHOD : NV_GPU_SCANOUT_COMPOSITION_PARAMETER = 0 ; -pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_SCANOUT_INTENSITY_METHOD : NV_GPU_SCANOUT_COMPOSITION_PARAMETER = 1 ; -pub type NV_GPU_SCANOUT_COMPOSITION_PARAMETER = ::std::os::raw::c_int; -pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_SET_TO_DEFAULT : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 0 ; -pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BILINEAR : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 256 ; -pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_TRIANGULAR : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 257 ; -pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_BELL_SHAPED : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 258 ; -pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_BSPLINE : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 259 ; -pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_ADAPTIVE_TRIANGULAR : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 260 ; -pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_ADAPTIVE_BELL_SHAPED : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 261 ; -pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_ADAPTIVE_BSPLINE : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 262 ; -pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_SCANOUT_INTENSITY_NO_GAMMA : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 512 ; -pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_SCANOUT_INTENSITY_COLOR_GAMMA : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 513 ; -pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_SCANOUT_INTENSITY_COLOR_AND_OFFSET_GAMMA : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 514 ; -#[doc = "! This enum defines a collection of scanout composition values that can be used to configure\n! the supported scanout composition settings"] -pub type NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = ::std::os::raw::c_int; -#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetScanoutConfigurationEx()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_SCANOUT_INFORMATION { - #[doc = "!< Structure version, needs to be initialized with NV_SCANOUT_INFORMATION_VER."] - pub version: NvU32, - #[doc = "!< Operating system display device rect in desktop coordinates displayId is scanning out from."] - pub sourceDesktopRect: NvSBox, - #[doc = "!< Area inside the sourceDesktopRect which is scanned out to the display."] - pub sourceViewportRect: NvSBox, - #[doc = "!< Area inside the rect described by targetDisplayWidth/Height sourceViewportRect is scanned out to."] - pub targetViewportRect: NvSBox, - #[doc = "!< Horizontal size of the active resolution scanned out to the display."] - pub targetDisplayWidth: NvU32, - #[doc = "!< Vertical size of the active resolution scanned out to the display."] - pub targetDisplayHeight: NvU32, - #[doc = "!< If targets are cloned views of the sourceDesktopRect the cloned targets have an importance assigned (0:primary,1 secondary,...)."] - pub cloneImportance: NvU32, - #[doc = "!< Rotation performed between the sourceViewportRect and the targetViewportRect."] - pub sourceToTargetRotation: NV_ROTATE, -} -#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetScanoutConfigurationEx()."] -pub type NV_SCANOUT_INFORMATION = _NV_SCANOUT_INFORMATION; -#[doc = "!< Represents Bare Metal GPU"] -pub const _NV_VIRTUALIZATION_MODE_NV_VIRTUALIZATION_MODE_NONE: _NV_VIRTUALIZATION_MODE = 0; -#[doc = "!< Represents GPU-Passthrough"] -pub const _NV_VIRTUALIZATION_MODE_NV_VIRTUALIZATION_MODE_NMOS: _NV_VIRTUALIZATION_MODE = 1; -#[doc = "!< Represents vGPU inside virtual machine"] -pub const _NV_VIRTUALIZATION_MODE_NV_VIRTUALIZATION_MODE_VGX: _NV_VIRTUALIZATION_MODE = 2; -#[doc = "!< Represents VGX hypervisor in vGPU mode"] -pub const _NV_VIRTUALIZATION_MODE_NV_VIRTUALIZATION_MODE_HOST_VGPU: _NV_VIRTUALIZATION_MODE = 3; -#[doc = "! \\ingroup gpu"] -pub type _NV_VIRTUALIZATION_MODE = ::std::os::raw::c_int; -#[doc = "! \\ingroup gpu"] -pub use self::_NV_VIRTUALIZATION_MODE as NV_VIRTUALIZATION_MODE; -#[doc = "! \\ingroup gpu"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_VIRTUALIZATION_INFO { - #[doc = "!< Structure version"] - pub version: NvU32, - #[doc = "!< one of NV_VIRTUALIZATION_MODE."] - pub virtualizationMode: NV_VIRTUALIZATION_MODE, - #[doc = "!< reserved for future use. Should be set to ZERO."] - pub reserved: NvU32, -} -#[doc = "! \\ingroup gpu"] -pub type NV_GPU_VIRTUALIZATION_INFO_V1 = _NV_GPU_VIRTUALIZATION_INFO; -#[doc = "! \\ingroup gpu"] -pub type NV_GPU_VIRTUALIZATION_INFO = NV_GPU_VIRTUALIZATION_INFO_V1; -#[doc = "! \\ingroup gpu"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LOGICAL_GPU_DATA_V1 { - #[doc = "!< [in] Structure version."] - pub version: NvU32, - #[doc = "!< [out] Returns OS-AdapterId. User must send memory buffer of size atleast equal to the size of LUID structure before calling the NVAPI."] - pub pOSAdapterId: *mut ::std::os::raw::c_void, - #[doc = "!< [out] Number of physical GPU handles associated with the specified logical GPU handle."] - pub physicalGpuCount: NvU32, - #[doc = "!< [out] This array will be filled with physical GPU handles associated with the given logical GPU handle.\n!< The array index refers to the Physical Gpu Index (Idx).\n!< Idx value is the same as D3D11 MultiGPUDevice GPU index, D3D12 node index, OpenGL GL_NV_gpu_multicast GPU index.\n!< When converted to a bit mask (1 << Idx), it matches:\n!< 1. Vulkan deviceNodeMask in VkPhysicalDeviceIDProperties\n!< 2. CUDA deviceNodeMask returned by cuDeviceGetLuid"] - pub physicalGpuHandles: [NvPhysicalGpuHandle; 64usize], - #[doc = "!< Reserved for future use. Should be set to ZERO."] - pub reserved: [NvU32; 8usize], -} -#[doc = "! \\ingroup gpu"] -pub type NV_LOGICAL_GPU_DATA_V1 = _NV_LOGICAL_GPU_DATA_V1; -#[doc = "! \\ingroup gpu"] -pub type NV_LOGICAL_GPU_DATA = NV_LOGICAL_GPU_DATA_V1; -#[doc = "! License string"] -pub type NvAPI_LicenseString = [::std::os::raw::c_char; 128usize]; -pub const _NV_LICENSE_FEATURE_TYPE_NV_LICENSE_FEATURE_UNKNOWN: _NV_LICENSE_FEATURE_TYPE = 0; -pub const _NV_LICENSE_FEATURE_TYPE_NV_LICENSE_FEATURE_VGPU: _NV_LICENSE_FEATURE_TYPE = 1; -pub const _NV_LICENSE_FEATURE_TYPE_NV_LICENSE_FEATURE_NVIDIA_RTX: _NV_LICENSE_FEATURE_TYPE = 2; -#[doc = "!< DEPRECATED name - do not use"] -pub const _NV_LICENSE_FEATURE_TYPE_NV_LICENSE_FEATURE_QUADRO: _NV_LICENSE_FEATURE_TYPE = 2; -pub const _NV_LICENSE_FEATURE_TYPE_NV_LICENSE_FEATURE_GAMING: _NV_LICENSE_FEATURE_TYPE = 3; -pub const _NV_LICENSE_FEATURE_TYPE_NV_LICENSE_FEATURE_COMPUTE: _NV_LICENSE_FEATURE_TYPE = 4; -#[doc = "! Used in NV_LICENSE_FEATURE_DETAILS"] -pub type _NV_LICENSE_FEATURE_TYPE = ::std::os::raw::c_int; -#[doc = "! Used in NV_LICENSE_FEATURE_DETAILS"] -pub use self::_NV_LICENSE_FEATURE_TYPE as NV_LICENSE_FEATURE_TYPE; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LICENSE_EXPIRY_DETAILS { - #[doc = "!< Year value of license expiry"] - pub year: NvU32, - #[doc = "!< Month value of license expiry"] - pub month: NvU16, - #[doc = "!< Day value of license expiry"] - pub day: NvU16, - #[doc = "!< Hour value of license expiry"] - pub hour: NvU16, - #[doc = "!< Minutes value of license expiry"] - pub min: NvU16, - #[doc = "!< Seconds value of license expiry"] - pub sec: NvU16, - #[doc = "!< License expiry status"] - pub status: NvU8, -} -pub type NV_LICENSE_EXPIRY_DETAILS = _NV_LICENSE_EXPIRY_DETAILS; -#[doc = "! Used in NV_LICENSABLE_FEATURES"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LICENSE_FEATURE_DETAILS_V1 { - #[doc = "!< IN - Structure version."] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Feature code that corresponds to the licensable feature."] - pub featureCode: NV_LICENSE_FEATURE_TYPE, - #[doc = "!< Deprecated"] - pub licenseInfo: NvAPI_LicenseString, -} -impl _NV_LICENSE_FEATURE_DETAILS_V1 { - #[inline] - pub fn isEnabled(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isEnabled(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isEnabled_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isEnabled_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isEnabled: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isEnabled: u32 = unsafe { ::std::mem::transmute(isEnabled) }; - isEnabled as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! Used in NV_LICENSABLE_FEATURES"] -pub type NV_LICENSE_FEATURE_DETAILS_V1 = _NV_LICENSE_FEATURE_DETAILS_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LICENSE_FEATURE_DETAILS_V2 { - #[doc = "!< Unused."] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Feature code that corresponds to the licensable feature."] - pub featureCode: NV_LICENSE_FEATURE_TYPE, - #[doc = "!< Deprecated"] - pub licenseInfo: NvAPI_LicenseString, - #[doc = "!< Nvidia Grid licensable product name."] - pub productName: NvAPI_LicenseString, -} -impl _NV_LICENSE_FEATURE_DETAILS_V2 { - #[inline] - pub fn isEnabled(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isEnabled(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isEnabled_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isEnabled_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isEnabled: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isEnabled: u32 = unsafe { ::std::mem::transmute(isEnabled) }; - isEnabled as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_LICENSE_FEATURE_DETAILS_V2 = _NV_LICENSE_FEATURE_DETAILS_V2; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LICENSE_FEATURE_DETAILS_V3 { - #[doc = "!< Unused."] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Feature code that corresponds to the licensable feature."] - pub featureCode: NV_LICENSE_FEATURE_TYPE, - #[doc = "!< Deprecated"] - pub licenseInfo: NvAPI_LicenseString, - #[doc = "!< Nvidia Grid licensable product name."] - pub productName: NvAPI_LicenseString, -} -impl _NV_LICENSE_FEATURE_DETAILS_V3 { - #[inline] - pub fn isEnabled(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isEnabled(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isEnabled_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isEnabled_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isFeatureEnabled(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_isFeatureEnabled(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isFeatureEnabled_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isFeatureEnabled_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 30u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 30u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 30u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isEnabled: NvU32, - isFeatureEnabled: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isEnabled: u32 = unsafe { ::std::mem::transmute(isEnabled) }; - isEnabled as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let isFeatureEnabled: u32 = unsafe { ::std::mem::transmute(isFeatureEnabled) }; - isFeatureEnabled as u64 - }); - __bindgen_bitfield_unit.set(2usize, 30u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_LICENSE_FEATURE_DETAILS_V3 = _NV_LICENSE_FEATURE_DETAILS_V3; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LICENSE_FEATURE_DETAILS_V4 { - #[doc = "!< Unused."] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Feature code that corresponds to the licensable feature."] - pub featureCode: NV_LICENSE_FEATURE_TYPE, - #[doc = "!< Deprecated"] - pub licenseInfo: NvAPI_LicenseString, - #[doc = "!< Nvidia Grid licensable product name."] - pub productName: NvAPI_LicenseString, - #[doc = "!< License expiry information."] - pub licenseExpiry: NV_LICENSE_EXPIRY_DETAILS, -} -impl _NV_LICENSE_FEATURE_DETAILS_V4 { - #[inline] - pub fn isEnabled(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isEnabled(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isEnabled_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isEnabled_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isFeatureEnabled(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_isFeatureEnabled(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isFeatureEnabled_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isFeatureEnabled_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 30u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 30u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 30u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isEnabled: NvU32, - isFeatureEnabled: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isEnabled: u32 = unsafe { ::std::mem::transmute(isEnabled) }; - isEnabled as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let isFeatureEnabled: u32 = unsafe { ::std::mem::transmute(isFeatureEnabled) }; - isFeatureEnabled as u64 - }); - __bindgen_bitfield_unit.set(2usize, 30u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_LICENSE_FEATURE_DETAILS_V4 = _NV_LICENSE_FEATURE_DETAILS_V4; -#[doc = "! Used in NV_LICENSABLE_FEATURES"] -pub type NV_LICENSE_FEATURE_DETAILS = NV_LICENSE_FEATURE_DETAILS_V1; -#[doc = "! Licensable features"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LICENSABLE_FEATURES_V1 { - #[doc = "!< IN - Structure version."] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< The number of licensable features."] - pub licensableFeatureCount: NvU32, - #[doc = "!< Dynamic signature required for Authentication of the components,\n!< signature length limited to NV_LICENSE_SIGNATURE_SIZE"] - pub signature: [NvU8; 128usize], - #[doc = "!< Array of licensable features"] - pub licenseDetails: [NV_LICENSE_FEATURE_DETAILS_V1; 3usize], -} -impl _NV_LICENSABLE_FEATURES_V1 { - #[inline] - pub fn isLicenseSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isLicenseSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isLicenseSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isLicenseSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isLicenseSupported: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isLicenseSupported: u32 = unsafe { ::std::mem::transmute(isLicenseSupported) }; - isLicenseSupported as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! Licensable features"] -pub type NV_LICENSABLE_FEATURES_V1 = _NV_LICENSABLE_FEATURES_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LICENSABLE_FEATURES_V2 { - #[doc = "!< IN - Structure version."] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< The number of licensable features."] - pub licensableFeatureCount: NvU32, - #[doc = "!< Dynamic signature required for Authentication of the components,\n!< signature length limited to NV_LICENSE_SIGNATURE_SIZE"] - pub signature: [NvU8; 128usize], - #[doc = "!< Array of licensable features"] - pub licenseDetails: [NV_LICENSE_FEATURE_DETAILS_V2; 3usize], -} -impl _NV_LICENSABLE_FEATURES_V2 { - #[inline] - pub fn isLicenseSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isLicenseSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isLicenseSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isLicenseSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isLicenseSupported: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isLicenseSupported: u32 = unsafe { ::std::mem::transmute(isLicenseSupported) }; - isLicenseSupported as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_LICENSABLE_FEATURES_V2 = _NV_LICENSABLE_FEATURES_V2; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LICENSABLE_FEATURES_V3 { - #[doc = "!< IN - Structure version."] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< The number of licensable features."] - pub licensableFeatureCount: NvU32, - #[doc = "!< Dynamic signature required for Authentication of the components,\n!< signature length limited to NV_LICENSE_SIGNATURE_SIZE"] - pub signature: [NvU8; 128usize], - #[doc = "!< Array of licensable features"] - pub licenseDetails: [NV_LICENSE_FEATURE_DETAILS_V3; 3usize], -} -impl _NV_LICENSABLE_FEATURES_V3 { - #[inline] - pub fn isLicenseSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isLicenseSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isLicenseSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isLicenseSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isLicenseSupported: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isLicenseSupported: u32 = unsafe { ::std::mem::transmute(isLicenseSupported) }; - isLicenseSupported as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_LICENSABLE_FEATURES_V3 = _NV_LICENSABLE_FEATURES_V3; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LICENSABLE_FEATURES_V4 { - #[doc = "!< IN - Structure version."] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< The number of licensable features."] - pub licensableFeatureCount: NvU32, - #[doc = "!< Dynamic signature required for Authentication of the components,\n!< signature length limited to NV_LICENSE_SIGNATURE_SIZE"] - pub signature: [NvU8; 128usize], - #[doc = "!< Array of licensable features"] - pub licenseDetails: [NV_LICENSE_FEATURE_DETAILS_V4; 3usize], -} -impl _NV_LICENSABLE_FEATURES_V4 { - #[inline] - pub fn isLicenseSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isLicenseSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isLicenseSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isLicenseSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isLicenseSupported: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isLicenseSupported: u32 = unsafe { ::std::mem::transmute(isLicenseSupported) }; - isLicenseSupported as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_LICENSABLE_FEATURES_V4 = _NV_LICENSABLE_FEATURES_V4; -pub type NV_LICENSABLE_FEATURES = NV_LICENSABLE_FEATURES_V4; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_ENCODER_STATISTICS_V1 { - #[doc = "!< [in] Structure version value."] - pub version: NvU32, - #[doc = "!< [out] Count of active encoder sessions."] - pub sessionsCount: NvU32, - #[doc = "!< [out] Trailing average FPS of all active sessions."] - pub averageFps: NvU32, - #[doc = "!< [out] Encode latency in microseconds."] - pub averageLatency: NvU32, -} -pub type NV_ENCODER_STATISTICS_V1 = _NV_ENCODER_STATISTICS_V1; -pub type NV_ENCODER_STATISTICS = NV_ENCODER_STATISTICS_V1; -pub const _NV_ENCODER_TYPE_NV_ENCODER_H264: _NV_ENCODER_TYPE = 0; -pub const _NV_ENCODER_TYPE_NV_ENCODER_HEVC: _NV_ENCODER_TYPE = 1; -pub const _NV_ENCODER_TYPE_NV_ENCODER_UNKNOWN: _NV_ENCODER_TYPE = -1; -pub type _NV_ENCODER_TYPE = ::std::os::raw::c_int; -pub use self::_NV_ENCODER_TYPE as NV_ENCODER_TYPE; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_ENCODER_PER_SESSION_INFO_V1 { - #[doc = "!< Unique session ID."] - pub sessionId: NvU32, - #[doc = "!< Owning process ID."] - pub processId: NvU32, - #[doc = "!< Owning vGPU instance ID (only valid on vGPU hosts, otherwise zero)."] - pub vgpuInstance: NvU32, - #[doc = "!< Video encoder type."] - pub codecType: NV_ENCODER_TYPE, - #[doc = "!< Current encode horizontal resolution."] - pub hResolution: NvU32, - #[doc = "!< Current encode vertical resolution."] - pub vResolution: NvU32, - #[doc = "!< Moving average encode frames per second."] - pub averageEncodeFps: NvU32, - #[doc = "!< Moving average encode latency in microseconds."] - pub averageEncodeLatency: NvU32, -} -pub type NV_ENCODER_PER_SESSION_INFO_V1 = _NV_ENCODER_PER_SESSION_INFO_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_ENCODER_SESSIONS_INFO_V1 { - #[doc = "!< [in] Structure version value."] - pub version: NvU32, - #[doc = "!< [out] Count of active encoder sessions."] - pub sessionsCount: NvU32, - #[doc = "!< [out] Array of session info. Caller should allocate memory for this field before making\n!< the NvAPI_GPU_GetEncoderSessionsInfo() call, memory allocated should be of\n!< size = sizeof(NV_ENCODER_PER_SESSION_INFO_V1) * NV_ENCODER_SESSION_INFO_MAX_ENTRIES_V1."] - pub pSessionInfo: *mut NV_ENCODER_PER_SESSION_INFO_V1, -} -pub type NV_ENCODER_SESSIONS_INFO_V1 = _NV_ENCODER_SESSIONS_INFO_V1; -pub type NV_ENCODER_SESSIONS_INFO = NV_ENCODER_SESSIONS_INFO_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_INFO_V1 { - #[doc = "!< Structure Version."] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, -} -impl _NV_GPU_INFO_V1 { - #[inline] - pub fn bIsExternalGpu(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsExternalGpu(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsExternalGpu_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsExternalGpu_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bIsExternalGpu: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsExternalGpu: u32 = unsafe { ::std::mem::transmute(bIsExternalGpu) }; - bIsExternalGpu as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_GPU_INFO_V1 = _NV_GPU_INFO_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_INFO_V2 { - #[doc = "!< Structure Version."] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Reserved for future use"] - pub reserved1: NvU64, - #[doc = "!< Number of \"Ray Tracing Cores\" supported by the GPU."] - pub rayTracingCores: NvU32, - #[doc = "!< Number of \"Tensor Cores\" supported by the GPU."] - pub tensorCores: NvU32, - #[doc = "!< Reserved for future use."] - pub reserved2: [NvU32; 14usize], -} -impl _NV_GPU_INFO_V2 { - #[inline] - pub fn bIsExternalGpu(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsExternalGpu(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsExternalGpu_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsExternalGpu_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved0(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved0(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved0_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved0_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bIsExternalGpu: NvU32, - reserved0: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsExternalGpu: u32 = unsafe { ::std::mem::transmute(bIsExternalGpu) }; - bIsExternalGpu as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved0: u32 = unsafe { ::std::mem::transmute(reserved0) }; - reserved0 as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_GPU_INFO_V2 = _NV_GPU_INFO_V2; -pub type NV_GPU_INFO = NV_GPU_INFO_V2; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_VR_READY_V1 { - #[doc = "!< Structure Version."] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, -} -impl _NV_GPU_VR_READY_V1 { - #[inline] - pub fn isVRReady(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isVRReady(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isVRReady_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isVRReady_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isVRReady: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isVRReady: u32 = unsafe { ::std::mem::transmute(isVRReady) }; - isVRReady as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_GPU_VR_READY_V1 = _NV_GPU_VR_READY_V1; -pub type NV_GPU_VR_READY = NV_GPU_VR_READY_V1; -pub const _NV_ADAPTER_TYPE_NV_ADAPTER_TYPE_UNKNOWN: _NV_ADAPTER_TYPE = 0; -pub const _NV_ADAPTER_TYPE_NV_ADAPTER_TYPE_WDDM: _NV_ADAPTER_TYPE = 1; -pub const _NV_ADAPTER_TYPE_NV_ADAPTER_TYPE_MCDM: _NV_ADAPTER_TYPE = 2; -pub const _NV_ADAPTER_TYPE_NV_ADAPTER_TYPE_TCC: _NV_ADAPTER_TYPE = 4; -pub const _NV_ADAPTER_TYPE_NV_ADAPTER_TYPE_LAST: _NV_ADAPTER_TYPE = -1; -pub type _NV_ADAPTER_TYPE = ::std::os::raw::c_int; -pub use self::_NV_ADAPTER_TYPE as NV_ADAPTER_TYPE; -#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetGspFeatures()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_GSP_INFO_V1 { - #[doc = "!< [in] Structure version"] - pub version: NvU32, - #[doc = "!< [out] Contains GSP firmware version"] - pub firmwareVersion: [NvU8; 64usize], - #[doc = "!< Reserved for future use"] - pub reserved: NvU32, -} -#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetGspFeatures()."] -pub type NV_GPU_GSP_INFO_V1 = _NV_GPU_GSP_INFO_V1; -#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetGspFeatures()."] -pub type NV_GPU_GSP_INFO = NV_GPU_GSP_INFO_V1; -#[doc = "! \\fn NvAPI_GPU_GetUUID(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_UUID *pGpuUuid)\n! DESCRIPTION: This function returns the GPU UUID for the specified physical GPU handle.\n! The UUID is returned in GUID format (16 bytes).\n!\n! SUPPORTED OS: Windows 10 and higher\n!\n!\n! TCC_SUPPORTED\n!\n! MCDM_SUPPORTED\n!\n! \\since Release: 595\n!\n! \\param [in] hPhysicalGpu Physical GPU handle to get UUID for\n! \\param [in,out] pGpuUuid Pointer to structure that will receive the GPU UUID\n!\n! \\retval NVAPI_OK Request completed successfully\n! \\return This API can return any of the error codes enumerated in #NvAPI_Status.\n!\n! \\ingroup gpu\n\n! Used in NvAPI_GPU_GetUUID()"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_UUID_V1 { - pub version: NvU32, - pub uuid: [NvU8; 16usize], -} -#[doc = "! \\fn NvAPI_GPU_GetUUID(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_UUID *pGpuUuid)\n! DESCRIPTION: This function returns the GPU UUID for the specified physical GPU handle.\n! The UUID is returned in GUID format (16 bytes).\n!\n! SUPPORTED OS: Windows 10 and higher\n!\n!\n! TCC_SUPPORTED\n!\n! MCDM_SUPPORTED\n!\n! \\since Release: 595\n!\n! \\param [in] hPhysicalGpu Physical GPU handle to get UUID for\n! \\param [in,out] pGpuUuid Pointer to structure that will receive the GPU UUID\n!\n! \\retval NVAPI_OK Request completed successfully\n! \\return This API can return any of the error codes enumerated in #NvAPI_Status.\n!\n! \\ingroup gpu\n\n! Used in NvAPI_GPU_GetUUID()"] -pub type NV_GPU_UUID_V1 = _NV_GPU_UUID_V1; -#[doc = "! \\fn NvAPI_GPU_GetUUID(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_UUID *pGpuUuid)\n! DESCRIPTION: This function returns the GPU UUID for the specified physical GPU handle.\n! The UUID is returned in GUID format (16 bytes).\n!\n! SUPPORTED OS: Windows 10 and higher\n!\n!\n! TCC_SUPPORTED\n!\n! MCDM_SUPPORTED\n!\n! \\since Release: 595\n!\n! \\param [in] hPhysicalGpu Physical GPU handle to get UUID for\n! \\param [in,out] pGpuUuid Pointer to structure that will receive the GPU UUID\n!\n! \\retval NVAPI_OK Request completed successfully\n! \\return This API can return any of the error codes enumerated in #NvAPI_Status.\n!\n! \\ingroup gpu\n\n! Used in NvAPI_GPU_GetUUID()"] -pub type NV_GPU_UUID = NV_GPU_UUID_V1; -#[doc = "! \\ingroup gpupstate\n! Used in NvAPI_GPU_GetPstatesInfoEx()"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_PERF_PSTATES_INFO_V1 { - pub version: NvU32, - #[doc = "!< - bit 0 indicates if perfmon is enabled or not\n!< - bit 1 indicates if dynamic Pstate is capable or not\n!< - bit 2 indicates if dynamic Pstate is enable or not\n!< - all other bits must be set to 0"] - pub flags: NvU32, - #[doc = "!< The number of available p-states"] - pub numPstates: NvU32, - #[doc = "!< The number of clock domains supported by each P-State"] - pub numClocks: NvU32, - pub pstates: [NV_GPU_PERF_PSTATES_INFO_V1__bindgen_ty_1; 16usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_PERF_PSTATES_INFO_V1__bindgen_ty_1 { - #[doc = "!< ID of the p-state."] - pub pstateId: NV_GPU_PERF_PSTATE_ID, - #[doc = "!< - bit 0 indicates if the PCIE limit is GEN1 or GEN2\n!< - bit 1 indicates if the Pstate is overclocked or not\n!< - bit 2 indicates if the Pstate is overclockable or not\n!< - all other bits must be set to 0"] - pub flags: NvU32, - pub clocks: [NV_GPU_PERF_PSTATES_INFO_V1__bindgen_ty_1__bindgen_ty_1; 32usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_PERF_PSTATES_INFO_V1__bindgen_ty_1__bindgen_ty_1 { - #[doc = "!< ID of the clock domain"] - pub domainId: NV_GPU_PUBLIC_CLOCK_ID, - #[doc = "!< Reserved. Must be set to 0"] - pub flags: NvU32, - #[doc = "!< Clock frequency in kHz"] - pub freq: NvU32, -} -#[doc = "! \\ingroup gpupstate"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_PERF_PSTATES_INFO_V2 { - pub version: NvU32, - #[doc = "!< - bit 0 indicates if perfmon is enabled or not\n!< - bit 1 indicates if dynamic Pstate is capable or not\n!< - bit 2 indicates if dynamic Pstate is enable or not\n!< - all other bits must be set to 0"] - pub flags: NvU32, - #[doc = "!< The number of available p-states"] - pub numPstates: NvU32, - #[doc = "!< The number of clock domains supported by each P-State"] - pub numClocks: NvU32, - pub numVoltages: NvU32, - #[doc = "!< Valid index range is 0 to numVoltages-1"] - pub pstates: [NV_GPU_PERF_PSTATES_INFO_V2__bindgen_ty_1; 16usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_PERF_PSTATES_INFO_V2__bindgen_ty_1 { - #[doc = "!< ID of the p-state."] - pub pstateId: NV_GPU_PERF_PSTATE_ID, - #[doc = "!< - bit 0 indicates if the PCIE limit is GEN1 or GEN2\n!< - bit 1 indicates if the Pstate is overclocked or not\n!< - bit 2 indicates if the Pstate is overclockable or not\n!< - all other bits must be set to 0"] - pub flags: NvU32, - pub clocks: [NV_GPU_PERF_PSTATES_INFO_V2__bindgen_ty_1__bindgen_ty_1; 32usize], - pub voltages: [NV_GPU_PERF_PSTATES_INFO_V2__bindgen_ty_1__bindgen_ty_2; 16usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_PERF_PSTATES_INFO_V2__bindgen_ty_1__bindgen_ty_1 { - pub domainId: NV_GPU_PUBLIC_CLOCK_ID, - #[doc = "!< bit 0 indicates if this clock is overclockable\n!< all other bits must be set to 0"] - pub flags: NvU32, - pub freq: NvU32, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_PERF_PSTATES_INFO_V2__bindgen_ty_1__bindgen_ty_2 { - #[doc = "!< ID of the voltage domain, containing flags and mvolt info"] - pub domainId: NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID, - #[doc = "!< Reserved for future use. Must be set to 0"] - pub flags: NvU32, - #[doc = "!< Voltage in mV"] - pub mvolt: NvU32, -} -#[doc = "! \\ingroup gpupstate"] -pub type NV_GPU_PERF_PSTATES_INFO = NV_GPU_PERF_PSTATES_INFO_V2; -#[doc = "! \\ingroup gpupstate\n! Used in NvAPI_GPU_GetDynamicPstatesInfoEx()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_DYNAMIC_PSTATES_INFO_EX { - #[doc = "!< Structure version"] - pub version: NvU32, - #[doc = "!< bit 0 indicates if the dynamic Pstate is enabled or not"] - pub flags: NvU32, - pub utilization: [NV_GPU_DYNAMIC_PSTATES_INFO_EX__bindgen_ty_1; 8usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_DYNAMIC_PSTATES_INFO_EX__bindgen_ty_1 { - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, - #[doc = "!< Percentage of time where the domain is considered busy in the last 1 second interval"] - pub percentage: NvU32, -} -impl NV_GPU_DYNAMIC_PSTATES_INFO_EX__bindgen_ty_1 { - #[inline] - pub fn bIsPresent(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsPresent(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsPresent_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsPresent_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1(bIsPresent: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsPresent: u32 = unsafe { ::std::mem::transmute(bIsPresent) }; - bIsPresent as u64 - }); - __bindgen_bitfield_unit - } -} -pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_NONE: NV_THERMAL_TARGET = 0; -#[doc = "!< GPU core temperature requires NvPhysicalGpuHandle"] -pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_GPU: NV_THERMAL_TARGET = 1; -#[doc = "!< GPU memory temperature requires NvPhysicalGpuHandle"] -pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_MEMORY: NV_THERMAL_TARGET = 2; -#[doc = "!< GPU power supply temperature requires NvPhysicalGpuHandle"] -pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_POWER_SUPPLY: NV_THERMAL_TARGET = 4; -#[doc = "!< GPU board ambient temperature requires NvPhysicalGpuHandle"] -pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_BOARD: NV_THERMAL_TARGET = 8; -#[doc = "!< Visual Computing Device Board temperature requires NvVisualComputingDeviceHandle"] -pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_VCD_BOARD: NV_THERMAL_TARGET = 9; -#[doc = "!< Visual Computing Device Inlet temperature requires NvVisualComputingDeviceHandle"] -pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_VCD_INLET: NV_THERMAL_TARGET = 10; -#[doc = "!< Visual Computing Device Outlet temperature requires NvVisualComputingDeviceHandle"] -pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_VCD_OUTLET: NV_THERMAL_TARGET = 11; -pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_ALL: NV_THERMAL_TARGET = 15; -pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_UNKNOWN: NV_THERMAL_TARGET = -1; -#[doc = "! \\ingroup gputhermal\n! Used in NV_GPU_THERMAL_SETTINGS"] -pub type NV_THERMAL_TARGET = ::std::os::raw::c_int; -pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_NONE: NV_THERMAL_CONTROLLER = 0; -pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_GPU_INTERNAL: NV_THERMAL_CONTROLLER = 1; -pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_ADM1032: NV_THERMAL_CONTROLLER = 2; -pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_MAX6649: NV_THERMAL_CONTROLLER = 3; -pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_MAX1617: NV_THERMAL_CONTROLLER = 4; -pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_LM99: NV_THERMAL_CONTROLLER = 5; -pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_LM89: NV_THERMAL_CONTROLLER = 6; -pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_LM64: NV_THERMAL_CONTROLLER = 7; -pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_ADT7473: NV_THERMAL_CONTROLLER = 8; -pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_SBMAX6649: NV_THERMAL_CONTROLLER = 9; -pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_VBIOSEVT: NV_THERMAL_CONTROLLER = 10; -pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_OS: NV_THERMAL_CONTROLLER = 11; -pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_UNKNOWN: NV_THERMAL_CONTROLLER = -1; -#[doc = "! \\ingroup gputhermal\n! Used in NV_GPU_THERMAL_SETTINGS"] -pub type NV_THERMAL_CONTROLLER = ::std::os::raw::c_int; -#[doc = "! \\ingroup gputhermal\n! Used in NvAPI_GPU_GetThermalSettings()"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_THERMAL_SETTINGS_V1 { - #[doc = "!< structure version"] - pub version: NvU32, - #[doc = "!< number of associated thermal sensors"] - pub count: NvU32, - pub sensor: [NV_GPU_THERMAL_SETTINGS_V1__bindgen_ty_1; 3usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_THERMAL_SETTINGS_V1__bindgen_ty_1 { - #[doc = "!< internal, ADM1032, MAX6649..."] - pub controller: NV_THERMAL_CONTROLLER, - #[doc = "!< The min default temperature value of the thermal sensor in degree Celsius"] - pub defaultMinTemp: NvU32, - #[doc = "!< The max default temperature value of the thermal sensor in degree Celsius"] - pub defaultMaxTemp: NvU32, - #[doc = "!< The current temperature value of the thermal sensor in degree Celsius"] - pub currentTemp: NvU32, - #[doc = "!< Thermal sensor targeted @ GPU, memory, chipset, powersupply, Visual Computing Device, etc."] - pub target: NV_THERMAL_TARGET, -} -#[doc = "! \\ingroup gputhermal"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_THERMAL_SETTINGS_V2 { - #[doc = "!< structure version"] - pub version: NvU32, - #[doc = "!< number of associated thermal sensors"] - pub count: NvU32, - pub sensor: [NV_GPU_THERMAL_SETTINGS_V2__bindgen_ty_1; 3usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_THERMAL_SETTINGS_V2__bindgen_ty_1 { - #[doc = "!< internal, ADM1032, MAX6649..."] - pub controller: NV_THERMAL_CONTROLLER, - #[doc = "!< Minimum default temperature value of the thermal sensor in degree Celsius"] - pub defaultMinTemp: NvS32, - #[doc = "!< Maximum default temperature value of the thermal sensor in degree Celsius"] - pub defaultMaxTemp: NvS32, - #[doc = "!< Current temperature value of the thermal sensor in degree Celsius"] - pub currentTemp: NvS32, - #[doc = "!< Thermal sensor targeted - GPU, memory, chipset, powersupply, Visual Computing Device, etc"] - pub target: NV_THERMAL_TARGET, -} -#[doc = "! \\ingroup gputhermal"] -pub type NV_GPU_THERMAL_SETTINGS = NV_GPU_THERMAL_SETTINGS_V2; -#[doc = "! \\ingroup gpuclock\n! Used in NvAPI_GPU_GetAllClockFrequencies()"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_CLOCK_FREQUENCIES_V1 { - #[doc = "!< Structure version"] - pub version: NvU32, - #[doc = "!< These bits are reserved for future use."] - pub reserved: NvU32, - pub domain: [NV_GPU_CLOCK_FREQUENCIES_V1__bindgen_ty_1; 32usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_CLOCK_FREQUENCIES_V1__bindgen_ty_1 { - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Clock frequency (kHz)"] - pub frequency: NvU32, -} -impl NV_GPU_CLOCK_FREQUENCIES_V1__bindgen_ty_1 { - #[inline] - pub fn bIsPresent(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsPresent(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsPresent_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsPresent_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bIsPresent: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsPresent: u32 = unsafe { ::std::mem::transmute(bIsPresent) }; - bIsPresent as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub const NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE_NV_GPU_CLOCK_FREQUENCIES_CURRENT_FREQ: - NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE = 0; -pub const NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE_NV_GPU_CLOCK_FREQUENCIES_BASE_CLOCK: - NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE = 1; -pub const NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE_NV_GPU_CLOCK_FREQUENCIES_BOOST_CLOCK: - NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE = 2; -pub const NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE_NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE_NUM: - NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE = 3; -#[doc = "! \\ingroup gpuclock\n! Used in NvAPI_GPU_GetAllClockFrequencies()"] -pub type NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE = ::std::os::raw::c_int; -#[doc = "! \\ingroup gpuclock\n! Used in NvAPI_GPU_GetAllClockFrequencies()"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_CLOCK_FREQUENCIES_V2 { - #[doc = "!< Structure version"] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - pub domain: [NV_GPU_CLOCK_FREQUENCIES_V2__bindgen_ty_1; 32usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_CLOCK_FREQUENCIES_V2__bindgen_ty_1 { - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Clock frequency (kHz)"] - pub frequency: NvU32, -} -impl NV_GPU_CLOCK_FREQUENCIES_V2__bindgen_ty_1 { - #[inline] - pub fn bIsPresent(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsPresent(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsPresent_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsPresent_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bIsPresent: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsPresent: u32 = unsafe { ::std::mem::transmute(bIsPresent) }; - bIsPresent as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -impl NV_GPU_CLOCK_FREQUENCIES_V2 { - #[inline] - pub fn ClockType(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32) } - } - #[inline] - pub fn set_ClockType(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 4u8, val as u64) - } - } - #[inline] - pub unsafe fn ClockType_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 4u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_ClockType_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 4u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 20u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 20u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 20u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 20u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved1(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u32) } - } - #[inline] - pub fn set_reserved1(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(24usize, 8u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved1_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 24usize, - 8u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved1_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 24usize, - 8u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - ClockType: NvU32, - reserved: NvU32, - reserved1: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 4u8, { - let ClockType: u32 = unsafe { ::std::mem::transmute(ClockType) }; - ClockType as u64 - }); - __bindgen_bitfield_unit.set(4usize, 20u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit.set(24usize, 8u8, { - let reserved1: u32 = unsafe { ::std::mem::transmute(reserved1) }; - reserved1 as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! \\ingroup gpuclock\n! Used in NvAPI_GPU_GetAllClockFrequencies()"] -pub type NV_GPU_CLOCK_FREQUENCIES = NV_GPU_CLOCK_FREQUENCIES_V2; -pub const _NV_GPU_ILLUMINATION_ATTRIB_NV_GPU_IA_LOGO_BRIGHTNESS: _NV_GPU_ILLUMINATION_ATTRIB = 0; -pub const _NV_GPU_ILLUMINATION_ATTRIB_NV_GPU_IA_SLI_BRIGHTNESS: _NV_GPU_ILLUMINATION_ATTRIB = 1; -#[doc = "! \\ingroup gpu"] -pub type _NV_GPU_ILLUMINATION_ATTRIB = ::std::os::raw::c_int; -#[doc = "! \\ingroup gpu"] -pub use self::_NV_GPU_ILLUMINATION_ATTRIB as NV_GPU_ILLUMINATION_ATTRIB; -#[doc = "! \\ingroup gpu"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_QUERY_ILLUMINATION_SUPPORT_PARM_V1 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< The handle of the GPU that you are checking for the specified attribute.\n!< note that this is the GPU that is managing the attribute.\n!< Only a single GPU can manage an given attribute on a given HW element,\n!< regardless of how many are attatched.\n!< I.E. only one GPU will be used to control the brightness of the LED on an SLI bridge,\n!< regardless of how many are physicaly attached.\n!< You enumerate thru the GPUs with this call to determine which GPU is managing the attribute."] - pub hPhysicalGpu: NvPhysicalGpuHandle, - #[doc = "!< An enumeration value specifying the Illumination attribute to be querried.\n!< refer to enum \\ref NV_GPU_ILLUMINATION_ATTRIB."] - pub Attribute: NV_GPU_ILLUMINATION_ATTRIB, - #[doc = "!< A boolean indicating if the attribute is supported."] - pub bSupported: NvU32, -} -#[doc = "! \\ingroup gpu"] -pub type NV_GPU_QUERY_ILLUMINATION_SUPPORT_PARM_V1 = _NV_GPU_QUERY_ILLUMINATION_SUPPORT_PARM_V1; -#[doc = "! \\ingroup gpu"] -pub type NV_GPU_QUERY_ILLUMINATION_SUPPORT_PARM = NV_GPU_QUERY_ILLUMINATION_SUPPORT_PARM_V1; -#[doc = "! \\ingroup gpu"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_GET_ILLUMINATION_PARM_V1 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< The handle of the GPU that you are checking for the specified attribute.\n!< Note that this is the GPU that is managing the attribute.\n!< Only a single GPU can manage an given attribute on a given HW element,\n!< regardless of how many are attatched.\n!< I.E. only one GPU will be used to control the brightness of the LED on an SLI bridge,\n!< regardless of how many are physicaly attached.\n!< You enumerate thru the GPUs with this call to determine which GPU is managing the attribute."] - pub hPhysicalGpu: NvPhysicalGpuHandle, - #[doc = "!< An enumeration value specifying the Illumination attribute to be querried.\n!< refer to enum \\ref NV_GPU_ILLUMINATION_ATTRIB."] - pub Attribute: NV_GPU_ILLUMINATION_ATTRIB, - #[doc = "!< A DWORD that will contain the current value of the specified attribute."] - pub Value: NvU32, -} -#[doc = "! \\ingroup gpu"] -pub type NV_GPU_GET_ILLUMINATION_PARM_V1 = _NV_GPU_GET_ILLUMINATION_PARM_V1; -#[doc = "! \\ingroup gpu"] -pub type NV_GPU_GET_ILLUMINATION_PARM = NV_GPU_GET_ILLUMINATION_PARM_V1; -#[doc = "! \\ingroup gpu"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_SET_ILLUMINATION_PARM_V1 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< The handle of the GPU that you are checking for the specified attribute.\n!< Note that this is the GPU that is managing the attribute.\n!< Only a single GPU can manage an given attribute on a given HW element,\n!< regardless of how many are attatched.\n!< I.E. only one GPU will be used to control the brightness of the LED on an SLI bridge,\n!< regardless of how many are physicaly attached.\n!< You enumerate thru the GPUs with this call to determine which GPU is managing the attribute."] - pub hPhysicalGpu: NvPhysicalGpuHandle, - #[doc = "!< An enumeration value specifying the Illumination attribute to be querried.\n!< refer to enum \\ref NV_GPU_ILLUMINATION_ATTRIB."] - pub Attribute: NV_GPU_ILLUMINATION_ATTRIB, - #[doc = "!< A DWORD containing the new value for the specified attribute.\n!< This should be specified as a percentage of the full range of the attribute\n!< (0-100; 0 = off, 100 = full brightness)\n!< If a value is specified outside this range, NVAPI_INVALID_ARGUMENT will be returned."] - pub Value: NvU32, -} -#[doc = "! \\ingroup gpu"] -pub type NV_GPU_SET_ILLUMINATION_PARM_V1 = _NV_GPU_SET_ILLUMINATION_PARM_V1; -#[doc = "! \\ingroup gpu"] -pub type NV_GPU_SET_ILLUMINATION_PARM = NV_GPU_SET_ILLUMINATION_PARM_V1; -pub const NV_GPU_CLIENT_ILLUM_CTRL_MODE_NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB: - NV_GPU_CLIENT_ILLUM_CTRL_MODE = 0; -pub const NV_GPU_CLIENT_ILLUM_CTRL_MODE_NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB: - NV_GPU_CLIENT_ILLUM_CTRL_MODE = 1; -pub const NV_GPU_CLIENT_ILLUM_CTRL_MODE_NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL: - NV_GPU_CLIENT_ILLUM_CTRL_MODE = 0; -pub const NV_GPU_CLIENT_ILLUM_CTRL_MODE_NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR: - NV_GPU_CLIENT_ILLUM_CTRL_MODE = 1; -pub const NV_GPU_CLIENT_ILLUM_CTRL_MODE_NV_GPU_CLIENT_ILLUM_CTRL_MODE_INVALID: - NV_GPU_CLIENT_ILLUM_CTRL_MODE = 255; -#[doc = " Enumeration of control modes that can be applied to Illumination Zones."] -pub type NV_GPU_CLIENT_ILLUM_CTRL_MODE = ::std::os::raw::c_int; -pub const NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_GPU_TOP_0: - NV_GPU_CLIENT_ILLUM_ZONE_LOCATION = 0; -pub const NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_GPU_FRONT_0: - NV_GPU_CLIENT_ILLUM_ZONE_LOCATION = 8; -pub const NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_GPU_BACK_0: - NV_GPU_CLIENT_ILLUM_ZONE_LOCATION = 12; -pub const NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_SLI_TOP_0: - NV_GPU_CLIENT_ILLUM_ZONE_LOCATION = 32; -pub const NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_INVALID: - NV_GPU_CLIENT_ILLUM_ZONE_LOCATION = -1; -#[doc = " Enumeration of locations where an Illumination Zone might be present.\n Encoding used -\n 1:0 - Number specifier (0)\n 4:2 - Location (TOP)\n 7:5 - Type (GPU/SLI)"] -pub type NV_GPU_CLIENT_ILLUM_ZONE_LOCATION = ::std::os::raw::c_int; -pub const NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_INVALID: - NV_GPU_CLIENT_ILLUM_DEVICE_TYPE = 0; -pub const NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_MCUV10: - NV_GPU_CLIENT_ILLUM_DEVICE_TYPE = 1; -pub const NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_GPIO_PWM_RGBW_V10: - NV_GPU_CLIENT_ILLUM_DEVICE_TYPE = 2; -pub const NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_GPIO_PWM_SINGLE_COLOR_V10 : NV_GPU_CLIENT_ILLUM_DEVICE_TYPE = 3 ; -#[doc = " Enumeration of ILLUM_DEVICEs."] -pub type NV_GPU_CLIENT_ILLUM_DEVICE_TYPE = ::std::os::raw::c_int; -pub const NV_GPU_CLIENT_ILLUM_ZONE_TYPE_NV_GPU_CLIENT_ILLUM_ZONE_TYPE_INVALID: - NV_GPU_CLIENT_ILLUM_ZONE_TYPE = 0; -pub const NV_GPU_CLIENT_ILLUM_ZONE_TYPE_NV_GPU_CLIENT_ILLUM_ZONE_TYPE_RGB: - NV_GPU_CLIENT_ILLUM_ZONE_TYPE = 1; -pub const NV_GPU_CLIENT_ILLUM_ZONE_TYPE_NV_GPU_CLIENT_ILLUM_ZONE_TYPE_COLOR_FIXED: - NV_GPU_CLIENT_ILLUM_ZONE_TYPE = 2; -pub const NV_GPU_CLIENT_ILLUM_ZONE_TYPE_NV_GPU_CLIENT_ILLUM_ZONE_TYPE_RGBW: - NV_GPU_CLIENT_ILLUM_ZONE_TYPE = 3; -pub const NV_GPU_CLIENT_ILLUM_ZONE_TYPE_NV_GPU_CLIENT_ILLUM_ZONE_TYPE_SINGLE_COLOR: - NV_GPU_CLIENT_ILLUM_ZONE_TYPE = 4; -#[doc = " Enumeration of ILLUM_ZONEs."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_TYPE = ::std::os::raw::c_int; -pub const NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE_NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_HALF_HALT : NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE = 0 ; -pub const NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE_NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_FULL_HALT : NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE = 1 ; -pub const NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE_NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_FULL_REPEAT : NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE = 2 ; -pub const NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE_NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_INVALID : NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE = 255 ; -#[doc = " Enumeration of Cycle types for piecewise linear control mode."] -pub type NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE = ::std::os::raw::c_int; -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1\n Describes the static information of illumination device type MCUV10."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_MCUV10 { - #[doc = " I2C Device Index: Pointing to the illumination device in I2C Devices Table."] - pub i2cDevIdx: NvU8, -} -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1\n Describes the static information of illumination device type MCUV10."] -pub type NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_MCUV10 = _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_MCUV10; -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1\n Describes the static information of illum device type GPIO_PWM_RGBW."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_RGBW { - #[doc = " Red drive GPIO pin."] - pub gpioPinRed: NvU8, - #[doc = " Green drive GPIO pin."] - pub gpioPinGreen: NvU8, - #[doc = " Blue drive GPIO pin."] - pub gpioPinBlue: NvU8, - #[doc = " White drive GPIO pin."] - pub gpioPinWhite: NvU8, -} -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1\n Describes the static information of illum device type GPIO_PWM_RGBW."] -pub type NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_RGBW = - _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_RGBW; -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1\n Describes the static information of illum device type GPIO_PWM_SINGLE_COLOR."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_SINGLE_COLOR { - #[doc = " Single Color GPIO pin."] - pub gpioPinSingleColor: NvU8, -} -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1\n Describes the static information of illum device type GPIO_PWM_SINGLE_COLOR."] -pub type NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_SINGLE_COLOR = - _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_SINGLE_COLOR; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1 { - #[doc = " Type of the illumination device."] - pub type_: NV_GPU_CLIENT_ILLUM_DEVICE_TYPE, - #[doc = " Supported control modes for this illumination device."] - pub ctrlModeMask: NvU32, - pub data: _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1__bindgen_ty_1, - #[doc = " Reserved for future."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Union of illumination device info data. Interpreted as per\n @ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1::type"] -#[repr(C)] -#[derive(Copy, Clone)] -pub union _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1__bindgen_ty_1 { - pub mcuv10: NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_MCUV10, - pub gpioPwmRgbwv10: NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_RGBW, - pub gpioPwmSingleColorv10: NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_SINGLE_COLOR, - #[doc = " Reserved bytes for possible future extension of this struct."] - pub rsvd: [NvU8; 64usize], -} -pub type NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1 = _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_PARAMS_V1 { - #[doc = " Version of structure. Must always be first member."] - pub version: NvU32, - #[doc = " Number of illumination devices present."] - pub numIllumDevices: NvU32, - #[doc = " Reserved bytes for possible future extension of this struct."] - pub rsvd: [NvU8; 64usize], - pub devices: [NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1; 32usize], -} -pub type NV_GPU_CLIENT_ILLUM_DEVICE_INFO_PARAMS_V1 = _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_PARAMS_V1; -pub type NV_GPU_CLIENT_ILLUM_DEVICE_INFO_PARAMS = NV_GPU_CLIENT_ILLUM_DEVICE_INFO_PARAMS_V1; -#[doc = " Structure representing the data required for synchronization."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_CLIENT_ILLUM_DEVICE_SYNC_V1 { - #[doc = " Boolean representing the need for synchronization."] - pub bSync: NvBool, - #[doc = " Time stamp value required for synchronization."] - pub timeStampms: NvU64, - #[doc = " Reserved for future."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Structure representing the device control parameters of each ILLUM_DEVICE."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_V1 { - #[doc = " Type of the illum device."] - pub type_: NV_GPU_CLIENT_ILLUM_DEVICE_TYPE, - #[doc = " Structure containing the synchronization data for the illumination device."] - pub syncData: NV_GPU_CLIENT_ILLUM_DEVICE_SYNC_V1, - #[doc = " Reserved for future."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Structure representing the device control parameters of each ILLUM_DEVICE."] -pub type NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL = NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_V1; -#[doc = " Structure representing the control parameters of ILLUM_DEVICE-s."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_PARAMS_V1 { - #[doc = " Version of structure. Must always be first member."] - pub version: NvU32, - #[doc = " Number of illumination devices present."] - pub numIllumDevices: NvU32, - #[doc = " Reserved bytes for possible future extension of this struct."] - pub rsvd: [NvU8; 64usize], - pub devices: [NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_V1; 32usize], -} -#[doc = " Structure representing the control parameters of ILLUM_DEVICE-s."] -pub type NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_PARAMS = NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_PARAMS_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGB { - pub rsvd: NvU8, -} -pub type NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGB = _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGB; -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1\n Describes the static information of illum zone type RGBW."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGBW { - pub rsvd: NvU8, -} -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1\n Describes the static information of illum zone type RGBW."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGBW = _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGBW; -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1\n Describes the static information of illum zone type SINGLE_COLOR."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_SINGLE_COLOR { - pub rsvd: NvU8, -} -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1\n Describes the static information of illum zone type SINGLE_COLOR."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_SINGLE_COLOR = - _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_SINGLE_COLOR; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1 { - pub type_: NV_GPU_CLIENT_ILLUM_ZONE_TYPE, - #[doc = " Index pointing to an Illumination Device that controls this zone."] - pub illumDeviceIdx: NvU8, - #[doc = " Provider index for representing logical to physical zone mapping."] - pub provIdx: NvU8, - #[doc = " Location of the zone on the board."] - pub zoneLocation: NV_GPU_CLIENT_ILLUM_ZONE_LOCATION, - pub data: _NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1__bindgen_ty_1, - pub rsvd: [NvU8; 64usize], -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union _NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1__bindgen_ty_1 { - pub rgb: NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGB, - pub rgbw: NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGBW, - pub singleColor: NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_SINGLE_COLOR, - #[doc = " Reserved bytes for possible future extension of this struct."] - pub rsvd: [NvU8; 64usize], -} -pub type NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1 = _NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_INFO_PARAMS_V1 { - #[doc = " Version of structure. Must always be first member."] - pub version: NvU32, - #[doc = " Number of illumination zones present."] - pub numIllumZones: NvU32, - #[doc = " Reserved bytes for possible future extension of this struct."] - pub rsvd: [NvU8; 64usize], - pub zones: [NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1; 32usize], -} -pub type NV_GPU_CLIENT_ILLUM_ZONE_INFO_PARAMS_V1 = _NV_GPU_CLIENT_ILLUM_ZONE_INFO_PARAMS_V1; -pub type NV_GPU_CLIENT_ILLUM_ZONE_INFO_PARAMS = NV_GPU_CLIENT_ILLUM_ZONE_INFO_PARAMS_V1; -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB\n Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB_PARAMS { - #[doc = " Red compenent of color applied to the zone."] - pub colorR: NvU8, - #[doc = " Green compenent of color applied to the zone."] - pub colorG: NvU8, - #[doc = " Blue compenent of color applied to the zone."] - pub colorB: NvU8, - #[doc = " Brightness perecentage value of the zone."] - pub brightnessPct: NvU8, -} -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB\n Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB_PARAMS = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB_PARAMS; -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB { - #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] - pub rgbParams: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB_PARAMS, -} -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB; -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR { - #[doc = " Type of cycle effect to apply."] - pub cycleType: NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE, - #[doc = " Number of times to repeat function within group period."] - pub grpCount: NvU8, - #[doc = " Time in ms to transition from color A to color B."] - pub riseTimems: NvU16, - #[doc = " Time in ms to transition from color B to color A."] - pub fallTimems: NvU16, - #[doc = " Time in ms to remain at color A before color A to color B transition."] - pub ATimems: NvU16, - #[doc = " Time in ms to remain at color B before color B to color A transition."] - pub BTimems: NvU16, - #[doc = " Time in ms to remain idle before next group of repeated function cycles."] - pub grpIdleTimems: NvU16, - #[doc = " Time in ms to offset the cycle relative to other zones."] - pub phaseOffsetms: NvU16, -} -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR; -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB { - #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] - pub rgbParams: [NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB_PARAMS; 2usize], - pub piecewiseLinearData: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR, -} -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB; -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illumination zone of type\n \\ref NV_GPU_CLIENT_ILLUM_ZONE_TYPE_RGB."] -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB { - pub data: _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB__bindgen_ty_1, - #[doc = " Reserved for future."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Union of illumination zone control data for zone of type NV_GPU_CLIENT_ILLUM_ZONE_TYPE_RGB.\n Interpreted as per ctrlMode."] -#[repr(C)] -#[derive(Copy, Clone)] -pub union _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB__bindgen_ty_1 { - pub manualRGB: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB, - pub piecewiseLinearRGB: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB, - #[doc = " Reserved bytes for possible future extension of this struct."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illumination zone of type\n \\ref NV_GPU_CLIENT_ILLUM_ZONE_TYPE_RGB."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB = _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB; -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED\n Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_RGB."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED_PARAMS { - #[doc = " Brightness percentage value of the zone."] - pub brightnessPct: NvU8, -} -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED\n Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_RGB."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED_PARAMS = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED_PARAMS; -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED { - #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] - pub colorFixedParams: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED_PARAMS, -} -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED; -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_COLOR_FIXED { - #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] - pub colorFixedParams: [NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED_PARAMS; 2usize], - pub piecewiseLinearData: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR, -} -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_COLOR_FIXED = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_COLOR_FIXED; -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illum zone of type\n \\ref NV_GPU_CLIENT_ILLUM_ZONE_TYPE_COLOR_FIXED."] -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED { - pub data: _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED__bindgen_ty_1, - #[doc = " Reserved for future."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Union of illum zone control data for zone of type NV_GPU_CLIENT_ILLUM_ZONE_TYPE_COLOR_FIXED.\n Interpreted as per ctrlMode."] -#[repr(C)] -#[derive(Copy, Clone)] -pub union _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED__bindgen_ty_1 { - pub manualColorFixed: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED, - pub piecewiseLinearColorFixed: - NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_COLOR_FIXED, - #[doc = " Reserved bytes for possible future extension of this struct."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illum zone of type\n \\ref NV_GPU_CLIENT_ILLUM_ZONE_TYPE_COLOR_FIXED."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED; -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW\n Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGBW."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW_PARAMS { - #[doc = " Red component of color applied to the zone."] - pub colorR: NvU8, - #[doc = " Green component of color applied to the zone."] - pub colorG: NvU8, - #[doc = " Blue component of color applied to the zone."] - pub colorB: NvU8, - #[doc = " White component of color applied to the zone."] - pub colorW: NvU8, - #[doc = " Brightness percentage value of the zone."] - pub brightnessPct: NvU8, -} -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW\n Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGBW."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW_PARAMS = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW_PARAMS; -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_RGBW\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_RGBW."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW { - #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_RGBW."] - pub rgbwParams: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW_PARAMS, -} -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_RGBW\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_RGBW."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW; -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_RGBW\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGBW."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGBW { - #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGBW."] - pub rgbwParams: [NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW_PARAMS; 2usize], - pub piecewiseLinearData: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR, -} -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_RGBW\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGBW."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGBW = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGBW; -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illum zone of type\n \\ref NV_GPU_ILLUM_ZONE_TYPE_RGBW."] -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW { - pub data: _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW__bindgen_ty_1, - #[doc = " Reserved for future."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Union of illum zone control data for zone of type NV_GPU_ILLUM_ZONE_TYPE_RGBW.\n Interpreted as per ctrlMode."] -#[repr(C)] -#[derive(Copy, Clone)] -pub union _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW__bindgen_ty_1 { - pub manualRGBW: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW, - pub piecewiseLinearRGBW: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGBW, - #[doc = " Reserved bytes for possible future extension of this struct."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illum zone of type\n \\ref NV_GPU_ILLUM_ZONE_TYPE_RGBW."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW = _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW; -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR\n Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_SINGLE_COLOR."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR_PARAMS { - #[doc = " Brightness percentage value of the zone."] - pub brightnessPct: NvU8, -} -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR\n Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_SINGLE_COLOR."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR_PARAMS = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR_PARAMS; -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_SINGLE_COLOR."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR { - #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_SINGLE_COLOR."] - pub singleColorParams: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR_PARAMS, -} -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_SINGLE_COLOR."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR; -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_SINGLE_COLOR."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_SINGLE_COLOR { - #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_SINGLE_COLOR."] - pub singleColorParams: - [NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR_PARAMS; 2usize], - pub piecewiseLinearData: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR, -} -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_SINGLE_COLOR."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_SINGLE_COLOR = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_SINGLE_COLOR; -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illum zone of type\n \\ref NV_GPU_ILLUM_ZONE_TYPE_SINGLE_COLOR."] -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR { - pub data: _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR__bindgen_ty_1, - #[doc = " Reserved for future."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Union of illum zone control data for zone of type NV_GPU_ILLUM_ZONE_TYPE_SINGLE_COLOR.\n Interpreted as per ctrlMode."] -#[repr(C)] -#[derive(Copy, Clone)] -pub union _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR__bindgen_ty_1 { - pub manualSingleColor: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR, - pub piecewiseLinearSingleColor: - NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_SINGLE_COLOR, - #[doc = " Reserved bytes for possible future extension of this struct."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illum zone of type\n \\ref NV_GPU_ILLUM_ZONE_TYPE_SINGLE_COLOR."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1 { - pub type_: NV_GPU_CLIENT_ILLUM_ZONE_TYPE, - pub ctrlMode: NV_GPU_CLIENT_ILLUM_CTRL_MODE, - pub data: _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1__bindgen_ty_1, - pub rsvd: [NvU8; 64usize], -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1__bindgen_ty_1 { - pub rgb: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB, - pub colorFixed: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED, - pub rgbw: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW, - pub singleColor: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR, - pub rsvd: [NvU8; 64usize], -} -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1 = _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS_V1 { - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = " Number of illumination zones present."] - pub numIllumZonesControl: NvU32, - #[doc = " Reserved bytes for possible future extension of this struct."] - pub rsvd: [NvU8; 64usize], - pub zones: [NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1; 32usize], -} -impl _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS_V1 { - #[inline] - pub fn bDefault(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bDefault(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bDefault_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bDefault_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn rsvdField(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_rsvdField(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn rsvdField_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_rsvdField_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bDefault: NvU32, - rsvdField: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bDefault: u32 = unsafe { ::std::mem::transmute(bDefault) }; - bDefault as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let rsvdField: u32 = unsafe { ::std::mem::transmute(rsvdField) }; - rsvdField as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS_V1 = _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS_V1; -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS = NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS_V1; -#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_GetDisplayPortInfo()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_DISPLAY_PORT_INFO_V1 { - #[doc = "!< Structure version"] - pub version: NvU32, - #[doc = "!< DPCD version of the monitor"] - pub dpcd_ver: NvU32, - #[doc = "!< Maximum supported link rate"] - pub maxLinkRate: NV_DP_LINK_RATE, - #[doc = "!< Maximum supported lane count"] - pub maxLaneCount: NV_DP_LANE_COUNT, - #[doc = "!< Current link rate"] - pub curLinkRate: NV_DP_LINK_RATE, - #[doc = "!< Current lane count"] - pub curLaneCount: NV_DP_LANE_COUNT, - #[doc = "!< Current color format"] - pub colorFormat: NV_DP_COLOR_FORMAT, - #[doc = "!< Dynamic range"] - pub dynamicRange: NV_DP_DYNAMIC_RANGE, - #[doc = "!< Ignored in RGB space"] - pub colorimetry: NV_DP_COLORIMETRY, - #[doc = "!< Current bit-per-component"] - pub bpc: NV_DP_BPC, - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, -} -impl _NV_DISPLAY_PORT_INFO_V1 { - #[inline] - pub fn isDp(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isDp(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isDp_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isDp_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isInternalDp(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_isInternalDp(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isInternalDp_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isInternalDp_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isColorCtrlSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_isColorCtrlSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isColorCtrlSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isColorCtrlSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn is6BPCSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_is6BPCSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn is6BPCSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_is6BPCSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn is8BPCSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } - } - #[inline] - pub fn set_is8BPCSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn is8BPCSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_is8BPCSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn is10BPCSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } - } - #[inline] - pub fn set_is10BPCSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn is10BPCSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_is10BPCSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn is12BPCSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } - } - #[inline] - pub fn set_is12BPCSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(6usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn is12BPCSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 6usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_is12BPCSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 6usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn is16BPCSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } - } - #[inline] - pub fn set_is16BPCSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(7usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn is16BPCSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 7usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_is16BPCSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 7usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isYCrCb420Supported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) } - } - #[inline] - pub fn set_isYCrCb420Supported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(8usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isYCrCb420Supported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 8usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isYCrCb420Supported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 8usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isYCrCb422Supported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) } - } - #[inline] - pub fn set_isYCrCb422Supported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(9usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isYCrCb422Supported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 9usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isYCrCb422Supported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 9usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isYCrCb444Supported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) } - } - #[inline] - pub fn set_isYCrCb444Supported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(10usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isYCrCb444Supported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 10usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isYCrCb444Supported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 10usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isRgb444SupportedOnCurrentMode(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) } - } - #[inline] - pub fn set_isRgb444SupportedOnCurrentMode(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(11usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isRgb444SupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 11usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isRgb444SupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 11usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isYCbCr444SupportedOnCurrentMode(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) } - } - #[inline] - pub fn set_isYCbCr444SupportedOnCurrentMode(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(12usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isYCbCr444SupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 12usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isYCbCr444SupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 12usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isYCbCr422SupportedOnCurrentMode(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) } - } - #[inline] - pub fn set_isYCbCr422SupportedOnCurrentMode(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(13usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isYCbCr422SupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 13usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isYCbCr422SupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 13usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isYCbCr420SupportedOnCurrentMode(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) } - } - #[inline] - pub fn set_isYCbCr420SupportedOnCurrentMode(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(14usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isYCbCr420SupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 14usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isYCbCr420SupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 14usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn is6BPCSupportedOnCurrentMode(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) } - } - #[inline] - pub fn set_is6BPCSupportedOnCurrentMode(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(15usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn is6BPCSupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 15usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_is6BPCSupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 15usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn is8BPCSupportedOnCurrentMode(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) } - } - #[inline] - pub fn set_is8BPCSupportedOnCurrentMode(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(16usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn is8BPCSupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 16usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_is8BPCSupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 16usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn is10BPCSupportedOnCurrentMode(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) } - } - #[inline] - pub fn set_is10BPCSupportedOnCurrentMode(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(17usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn is10BPCSupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 17usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_is10BPCSupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 17usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn is12BPCSupportedOnCurrentMode(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) } - } - #[inline] - pub fn set_is12BPCSupportedOnCurrentMode(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(18usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn is12BPCSupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 18usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_is12BPCSupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 18usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn is16BPCSupportedOnCurrentMode(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u32) } - } - #[inline] - pub fn set_is16BPCSupportedOnCurrentMode(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(19usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn is16BPCSupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 19usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_is16BPCSupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 19usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonxvYCC601Capable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonxvYCC601Capable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(20usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonxvYCC601Capable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 20usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonxvYCC601Capable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 20usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonxvYCC709Capable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonxvYCC709Capable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(21usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonxvYCC709Capable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 21usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonxvYCC709Capable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 21usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonsYCC601Capable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonsYCC601Capable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(22usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonsYCC601Capable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 22usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonsYCC601Capable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 22usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonAdobeYCC601Capable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonAdobeYCC601Capable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(23usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonAdobeYCC601Capable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 23usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonAdobeYCC601Capable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 23usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonAdobeRGBCapable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonAdobeRGBCapable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(24usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonAdobeRGBCapable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 24usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonAdobeRGBCapable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 24usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonBT2020RGBCapable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonBT2020RGBCapable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(25usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonBT2020RGBCapable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 25usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonBT2020RGBCapable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 25usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonBT2020YCCCapable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonBT2020YCCCapable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(26usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonBT2020YCCCapable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 26usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonBT2020YCCCapable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 26usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonBT2020cYCCCapable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonBT2020cYCCCapable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(27usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonBT2020cYCCCapable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 27usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonBT2020cYCCCapable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 27usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 4u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(28usize, 4u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 28usize, - 4u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 28usize, - 4u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isDp: NvU32, - isInternalDp: NvU32, - isColorCtrlSupported: NvU32, - is6BPCSupported: NvU32, - is8BPCSupported: NvU32, - is10BPCSupported: NvU32, - is12BPCSupported: NvU32, - is16BPCSupported: NvU32, - isYCrCb420Supported: NvU32, - isYCrCb422Supported: NvU32, - isYCrCb444Supported: NvU32, - isRgb444SupportedOnCurrentMode: NvU32, - isYCbCr444SupportedOnCurrentMode: NvU32, - isYCbCr422SupportedOnCurrentMode: NvU32, - isYCbCr420SupportedOnCurrentMode: NvU32, - is6BPCSupportedOnCurrentMode: NvU32, - is8BPCSupportedOnCurrentMode: NvU32, - is10BPCSupportedOnCurrentMode: NvU32, - is12BPCSupportedOnCurrentMode: NvU32, - is16BPCSupportedOnCurrentMode: NvU32, - isMonxvYCC601Capable: NvU32, - isMonxvYCC709Capable: NvU32, - isMonsYCC601Capable: NvU32, - isMonAdobeYCC601Capable: NvU32, - isMonAdobeRGBCapable: NvU32, - isMonBT2020RGBCapable: NvU32, - isMonBT2020YCCCapable: NvU32, - isMonBT2020cYCCCapable: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isDp: u32 = unsafe { ::std::mem::transmute(isDp) }; - isDp as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let isInternalDp: u32 = unsafe { ::std::mem::transmute(isInternalDp) }; - isInternalDp as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let isColorCtrlSupported: u32 = unsafe { ::std::mem::transmute(isColorCtrlSupported) }; - isColorCtrlSupported as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let is6BPCSupported: u32 = unsafe { ::std::mem::transmute(is6BPCSupported) }; - is6BPCSupported as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let is8BPCSupported: u32 = unsafe { ::std::mem::transmute(is8BPCSupported) }; - is8BPCSupported as u64 - }); - __bindgen_bitfield_unit.set(5usize, 1u8, { - let is10BPCSupported: u32 = unsafe { ::std::mem::transmute(is10BPCSupported) }; - is10BPCSupported as u64 - }); - __bindgen_bitfield_unit.set(6usize, 1u8, { - let is12BPCSupported: u32 = unsafe { ::std::mem::transmute(is12BPCSupported) }; - is12BPCSupported as u64 - }); - __bindgen_bitfield_unit.set(7usize, 1u8, { - let is16BPCSupported: u32 = unsafe { ::std::mem::transmute(is16BPCSupported) }; - is16BPCSupported as u64 - }); - __bindgen_bitfield_unit.set(8usize, 1u8, { - let isYCrCb420Supported: u32 = unsafe { ::std::mem::transmute(isYCrCb420Supported) }; - isYCrCb420Supported as u64 - }); - __bindgen_bitfield_unit.set(9usize, 1u8, { - let isYCrCb422Supported: u32 = unsafe { ::std::mem::transmute(isYCrCb422Supported) }; - isYCrCb422Supported as u64 - }); - __bindgen_bitfield_unit.set(10usize, 1u8, { - let isYCrCb444Supported: u32 = unsafe { ::std::mem::transmute(isYCrCb444Supported) }; - isYCrCb444Supported as u64 - }); - __bindgen_bitfield_unit.set(11usize, 1u8, { - let isRgb444SupportedOnCurrentMode: u32 = - unsafe { ::std::mem::transmute(isRgb444SupportedOnCurrentMode) }; - isRgb444SupportedOnCurrentMode as u64 - }); - __bindgen_bitfield_unit.set(12usize, 1u8, { - let isYCbCr444SupportedOnCurrentMode: u32 = - unsafe { ::std::mem::transmute(isYCbCr444SupportedOnCurrentMode) }; - isYCbCr444SupportedOnCurrentMode as u64 - }); - __bindgen_bitfield_unit.set(13usize, 1u8, { - let isYCbCr422SupportedOnCurrentMode: u32 = - unsafe { ::std::mem::transmute(isYCbCr422SupportedOnCurrentMode) }; - isYCbCr422SupportedOnCurrentMode as u64 - }); - __bindgen_bitfield_unit.set(14usize, 1u8, { - let isYCbCr420SupportedOnCurrentMode: u32 = - unsafe { ::std::mem::transmute(isYCbCr420SupportedOnCurrentMode) }; - isYCbCr420SupportedOnCurrentMode as u64 - }); - __bindgen_bitfield_unit.set(15usize, 1u8, { - let is6BPCSupportedOnCurrentMode: u32 = - unsafe { ::std::mem::transmute(is6BPCSupportedOnCurrentMode) }; - is6BPCSupportedOnCurrentMode as u64 - }); - __bindgen_bitfield_unit.set(16usize, 1u8, { - let is8BPCSupportedOnCurrentMode: u32 = - unsafe { ::std::mem::transmute(is8BPCSupportedOnCurrentMode) }; - is8BPCSupportedOnCurrentMode as u64 - }); - __bindgen_bitfield_unit.set(17usize, 1u8, { - let is10BPCSupportedOnCurrentMode: u32 = - unsafe { ::std::mem::transmute(is10BPCSupportedOnCurrentMode) }; - is10BPCSupportedOnCurrentMode as u64 - }); - __bindgen_bitfield_unit.set(18usize, 1u8, { - let is12BPCSupportedOnCurrentMode: u32 = - unsafe { ::std::mem::transmute(is12BPCSupportedOnCurrentMode) }; - is12BPCSupportedOnCurrentMode as u64 - }); - __bindgen_bitfield_unit.set(19usize, 1u8, { - let is16BPCSupportedOnCurrentMode: u32 = - unsafe { ::std::mem::transmute(is16BPCSupportedOnCurrentMode) }; - is16BPCSupportedOnCurrentMode as u64 - }); - __bindgen_bitfield_unit.set(20usize, 1u8, { - let isMonxvYCC601Capable: u32 = unsafe { ::std::mem::transmute(isMonxvYCC601Capable) }; - isMonxvYCC601Capable as u64 - }); - __bindgen_bitfield_unit.set(21usize, 1u8, { - let isMonxvYCC709Capable: u32 = unsafe { ::std::mem::transmute(isMonxvYCC709Capable) }; - isMonxvYCC709Capable as u64 - }); - __bindgen_bitfield_unit.set(22usize, 1u8, { - let isMonsYCC601Capable: u32 = unsafe { ::std::mem::transmute(isMonsYCC601Capable) }; - isMonsYCC601Capable as u64 - }); - __bindgen_bitfield_unit.set(23usize, 1u8, { - let isMonAdobeYCC601Capable: u32 = - unsafe { ::std::mem::transmute(isMonAdobeYCC601Capable) }; - isMonAdobeYCC601Capable as u64 - }); - __bindgen_bitfield_unit.set(24usize, 1u8, { - let isMonAdobeRGBCapable: u32 = unsafe { ::std::mem::transmute(isMonAdobeRGBCapable) }; - isMonAdobeRGBCapable as u64 - }); - __bindgen_bitfield_unit.set(25usize, 1u8, { - let isMonBT2020RGBCapable: u32 = - unsafe { ::std::mem::transmute(isMonBT2020RGBCapable) }; - isMonBT2020RGBCapable as u64 - }); - __bindgen_bitfield_unit.set(26usize, 1u8, { - let isMonBT2020YCCCapable: u32 = - unsafe { ::std::mem::transmute(isMonBT2020YCCCapable) }; - isMonBT2020YCCCapable as u64 - }); - __bindgen_bitfield_unit.set(27usize, 1u8, { - let isMonBT2020cYCCCapable: u32 = - unsafe { ::std::mem::transmute(isMonBT2020cYCCCapable) }; - isMonBT2020cYCCCapable as u64 - }); - __bindgen_bitfield_unit.set(28usize, 4u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_GetDisplayPortInfo()."] -pub type NV_DISPLAY_PORT_INFO_V1 = _NV_DISPLAY_PORT_INFO_V1; -#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_GetDisplayPortInfo()."] -pub type NV_DISPLAY_PORT_INFO = NV_DISPLAY_PORT_INFO_V1; -#[doc = "! \\ingroup dispcontrol\n! DisplayPort configuration settings - used in NvAPI_SetDisplayPort()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_DISPLAY_PORT_CONFIG { - #[doc = "!< Structure version - 2 is the latest"] - pub version: NvU32, - #[doc = "!< Link rate"] - pub linkRate: NV_DP_LINK_RATE, - #[doc = "!< Lane count"] - pub laneCount: NV_DP_LANE_COUNT, - #[doc = "!< Color format to set"] - pub colorFormat: NV_DP_COLOR_FORMAT, - #[doc = "!< Dynamic range"] - pub dynamicRange: NV_DP_DYNAMIC_RANGE, - #[doc = "!< Ignored in RGB space"] - pub colorimetry: NV_DP_COLORIMETRY, - #[doc = "!< Bit-per-component"] - pub bpc: NV_DP_BPC, - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, - pub __bindgen_padding_0: [u8; 3usize], -} -impl NV_DISPLAY_PORT_CONFIG { - #[inline] - pub fn isHPD(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isHPD(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isHPD_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isHPD_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isSetDeferred(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_isSetDeferred(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isSetDeferred_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isSetDeferred_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isChromaLpfOff(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_isChromaLpfOff(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isChromaLpfOff_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isChromaLpfOff_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isDitherOff(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_isDitherOff(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isDitherOff_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isDitherOff_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn testLinkTrain(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } - } - #[inline] - pub fn set_testLinkTrain(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn testLinkTrain_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_testLinkTrain_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn testColorChange(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } - } - #[inline] - pub fn set_testColorChange(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn testColorChange_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_testColorChange_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isHPD: NvU32, - isSetDeferred: NvU32, - isChromaLpfOff: NvU32, - isDitherOff: NvU32, - testLinkTrain: NvU32, - testColorChange: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isHPD: u32 = unsafe { ::std::mem::transmute(isHPD) }; - isHPD as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let isSetDeferred: u32 = unsafe { ::std::mem::transmute(isSetDeferred) }; - isSetDeferred as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let isChromaLpfOff: u32 = unsafe { ::std::mem::transmute(isChromaLpfOff) }; - isChromaLpfOff as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let isDitherOff: u32 = unsafe { ::std::mem::transmute(isDitherOff) }; - isDitherOff as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let testLinkTrain: u32 = unsafe { ::std::mem::transmute(testLinkTrain) }; - testLinkTrain as u64 - }); - __bindgen_bitfield_unit.set(5usize, 1u8, { - let testColorChange: u32 = unsafe { ::std::mem::transmute(testColorChange) }; - testColorChange as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_GetHDMISupportInfo()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDMI_SUPPORT_INFO_V1 { - #[doc = "!< Structure version"] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Revision number of the EDID 861 extension"] - pub EDID861ExtRev: NvU32, -} -impl _NV_HDMI_SUPPORT_INFO_V1 { - #[inline] - pub fn isGpuHDMICapable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isGpuHDMICapable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isGpuHDMICapable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isGpuHDMICapable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonUnderscanCapable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonUnderscanCapable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonUnderscanCapable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonUnderscanCapable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonBasicAudioCapable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonBasicAudioCapable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonBasicAudioCapable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonBasicAudioCapable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonYCbCr444Capable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonYCbCr444Capable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonYCbCr444Capable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonYCbCr444Capable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonYCbCr422Capable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonYCbCr422Capable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonYCbCr422Capable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonYCbCr422Capable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonxvYCC601Capable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonxvYCC601Capable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonxvYCC601Capable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonxvYCC601Capable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonxvYCC709Capable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonxvYCC709Capable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(6usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonxvYCC709Capable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 6usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonxvYCC709Capable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 6usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonHDMI(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonHDMI(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(7usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonHDMI_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 7usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonHDMI_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 7usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 24u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(8usize, 24u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 8usize, - 24u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 8usize, - 24u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isGpuHDMICapable: NvU32, - isMonUnderscanCapable: NvU32, - isMonBasicAudioCapable: NvU32, - isMonYCbCr444Capable: NvU32, - isMonYCbCr422Capable: NvU32, - isMonxvYCC601Capable: NvU32, - isMonxvYCC709Capable: NvU32, - isMonHDMI: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isGpuHDMICapable: u32 = unsafe { ::std::mem::transmute(isGpuHDMICapable) }; - isGpuHDMICapable as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let isMonUnderscanCapable: u32 = - unsafe { ::std::mem::transmute(isMonUnderscanCapable) }; - isMonUnderscanCapable as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let isMonBasicAudioCapable: u32 = - unsafe { ::std::mem::transmute(isMonBasicAudioCapable) }; - isMonBasicAudioCapable as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let isMonYCbCr444Capable: u32 = unsafe { ::std::mem::transmute(isMonYCbCr444Capable) }; - isMonYCbCr444Capable as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let isMonYCbCr422Capable: u32 = unsafe { ::std::mem::transmute(isMonYCbCr422Capable) }; - isMonYCbCr422Capable as u64 - }); - __bindgen_bitfield_unit.set(5usize, 1u8, { - let isMonxvYCC601Capable: u32 = unsafe { ::std::mem::transmute(isMonxvYCC601Capable) }; - isMonxvYCC601Capable as u64 - }); - __bindgen_bitfield_unit.set(6usize, 1u8, { - let isMonxvYCC709Capable: u32 = unsafe { ::std::mem::transmute(isMonxvYCC709Capable) }; - isMonxvYCC709Capable as u64 - }); - __bindgen_bitfield_unit.set(7usize, 1u8, { - let isMonHDMI: u32 = unsafe { ::std::mem::transmute(isMonHDMI) }; - isMonHDMI as u64 - }); - __bindgen_bitfield_unit.set(8usize, 24u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_GetHDMISupportInfo()."] -pub type NV_HDMI_SUPPORT_INFO_V1 = _NV_HDMI_SUPPORT_INFO_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDMI_SUPPORT_INFO_V2 { - #[doc = "!< Structure version"] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Revision number of the EDID 861 extension"] - pub EDID861ExtRev: NvU32, -} -impl _NV_HDMI_SUPPORT_INFO_V2 { - #[inline] - pub fn isGpuHDMICapable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isGpuHDMICapable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isGpuHDMICapable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isGpuHDMICapable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonUnderscanCapable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonUnderscanCapable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonUnderscanCapable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonUnderscanCapable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonBasicAudioCapable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonBasicAudioCapable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonBasicAudioCapable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonBasicAudioCapable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonYCbCr444Capable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonYCbCr444Capable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonYCbCr444Capable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonYCbCr444Capable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonYCbCr422Capable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonYCbCr422Capable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonYCbCr422Capable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonYCbCr422Capable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonxvYCC601Capable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonxvYCC601Capable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonxvYCC601Capable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonxvYCC601Capable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonxvYCC709Capable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonxvYCC709Capable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(6usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonxvYCC709Capable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 6usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonxvYCC709Capable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 6usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonHDMI(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonHDMI(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(7usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonHDMI_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 7usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonHDMI_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 7usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonsYCC601Capable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonsYCC601Capable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(8usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonsYCC601Capable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 8usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonsYCC601Capable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 8usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonAdobeYCC601Capable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonAdobeYCC601Capable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(9usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonAdobeYCC601Capable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 9usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonAdobeYCC601Capable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 9usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonAdobeRGBCapable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonAdobeRGBCapable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(10usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonAdobeRGBCapable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 10usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonAdobeRGBCapable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 10usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 21u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(11usize, 21u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 11usize, - 21u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 11usize, - 21u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isGpuHDMICapable: NvU32, - isMonUnderscanCapable: NvU32, - isMonBasicAudioCapable: NvU32, - isMonYCbCr444Capable: NvU32, - isMonYCbCr422Capable: NvU32, - isMonxvYCC601Capable: NvU32, - isMonxvYCC709Capable: NvU32, - isMonHDMI: NvU32, - isMonsYCC601Capable: NvU32, - isMonAdobeYCC601Capable: NvU32, - isMonAdobeRGBCapable: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isGpuHDMICapable: u32 = unsafe { ::std::mem::transmute(isGpuHDMICapable) }; - isGpuHDMICapable as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let isMonUnderscanCapable: u32 = - unsafe { ::std::mem::transmute(isMonUnderscanCapable) }; - isMonUnderscanCapable as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let isMonBasicAudioCapable: u32 = - unsafe { ::std::mem::transmute(isMonBasicAudioCapable) }; - isMonBasicAudioCapable as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let isMonYCbCr444Capable: u32 = unsafe { ::std::mem::transmute(isMonYCbCr444Capable) }; - isMonYCbCr444Capable as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let isMonYCbCr422Capable: u32 = unsafe { ::std::mem::transmute(isMonYCbCr422Capable) }; - isMonYCbCr422Capable as u64 - }); - __bindgen_bitfield_unit.set(5usize, 1u8, { - let isMonxvYCC601Capable: u32 = unsafe { ::std::mem::transmute(isMonxvYCC601Capable) }; - isMonxvYCC601Capable as u64 - }); - __bindgen_bitfield_unit.set(6usize, 1u8, { - let isMonxvYCC709Capable: u32 = unsafe { ::std::mem::transmute(isMonxvYCC709Capable) }; - isMonxvYCC709Capable as u64 - }); - __bindgen_bitfield_unit.set(7usize, 1u8, { - let isMonHDMI: u32 = unsafe { ::std::mem::transmute(isMonHDMI) }; - isMonHDMI as u64 - }); - __bindgen_bitfield_unit.set(8usize, 1u8, { - let isMonsYCC601Capable: u32 = unsafe { ::std::mem::transmute(isMonsYCC601Capable) }; - isMonsYCC601Capable as u64 - }); - __bindgen_bitfield_unit.set(9usize, 1u8, { - let isMonAdobeYCC601Capable: u32 = - unsafe { ::std::mem::transmute(isMonAdobeYCC601Capable) }; - isMonAdobeYCC601Capable as u64 - }); - __bindgen_bitfield_unit.set(10usize, 1u8, { - let isMonAdobeRGBCapable: u32 = unsafe { ::std::mem::transmute(isMonAdobeRGBCapable) }; - isMonAdobeRGBCapable as u64 - }); - __bindgen_bitfield_unit.set(11usize, 21u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_HDMI_SUPPORT_INFO_V2 = _NV_HDMI_SUPPORT_INFO_V2; -pub type NV_HDMI_SUPPORT_INFO = NV_HDMI_SUPPORT_INFO_V2; -#[doc = "!< Returns the fields in the infoframe with values set by the manufacturer - NVIDIA/OEM."] -pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_GET_DEFAULT: NV_INFOFRAME_CMD = 0; -#[doc = "!< Sets the fields in the infoframe to auto, and infoframe to the default infoframe for use in a set."] -pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_RESET: NV_INFOFRAME_CMD = 1; -#[doc = "!< Get the current infoframe state."] -pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_GET: NV_INFOFRAME_CMD = 2; -#[doc = "!< Set the current infoframe state (flushed to the monitor), the values are one time and do not persist."] -pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_SET: NV_INFOFRAME_CMD = 3; -#[doc = "!< Get the override infoframe state, non-override fields will be set to value = AUTO, overridden fields will have the current override values."] -pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_GET_OVERRIDE: NV_INFOFRAME_CMD = 4; -#[doc = "!< Set the override infoframe state, non-override fields will be set to value = AUTO, other values indicate override; persist across modeset/reboot"] -pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_SET_OVERRIDE: NV_INFOFRAME_CMD = 5; -#[doc = "!< get properties associated with infoframe (each of the infoframe type will have properties)"] -pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_GET_PROPERTY: NV_INFOFRAME_CMD = 6; -#[doc = "!< set properties associated with infoframe"] -pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_SET_PROPERTY: NV_INFOFRAME_CMD = 7; -#[doc = "! \\ingroup dispcontrol"] -pub type NV_INFOFRAME_CMD = ::std::os::raw::c_int; -#[doc = "!< Driver determines whether to send infoframes."] -pub const NV_INFOFRAME_PROPERTY_MODE_NV_INFOFRAME_PROPERTY_MODE_AUTO: NV_INFOFRAME_PROPERTY_MODE = - 0; -#[doc = "!< Driver always sends infoframe."] -pub const NV_INFOFRAME_PROPERTY_MODE_NV_INFOFRAME_PROPERTY_MODE_ENABLE: NV_INFOFRAME_PROPERTY_MODE = - 1; -#[doc = "!< Driver never sends infoframe."] -pub const NV_INFOFRAME_PROPERTY_MODE_NV_INFOFRAME_PROPERTY_MODE_DISABLE: - NV_INFOFRAME_PROPERTY_MODE = 2; -#[doc = "!< Driver only sends infoframe when client requests it via infoframe escape call."] -pub const NV_INFOFRAME_PROPERTY_MODE_NV_INFOFRAME_PROPERTY_MODE_ALLOW_OVERRIDE: - NV_INFOFRAME_PROPERTY_MODE = 3; -pub type NV_INFOFRAME_PROPERTY_MODE = ::std::os::raw::c_int; -pub const NV_INFOFRAME_PROPERTY_BLACKLIST_NV_INFOFRAME_PROPERTY_BLACKLIST_FALSE: - NV_INFOFRAME_PROPERTY_BLACKLIST = 0; -pub const NV_INFOFRAME_PROPERTY_BLACKLIST_NV_INFOFRAME_PROPERTY_BLACKLIST_TRUE: - NV_INFOFRAME_PROPERTY_BLACKLIST = 1; -#[doc = "! Returns whether the current monitor is in blacklist or force this monitor to be in blacklist."] -pub type NV_INFOFRAME_PROPERTY_BLACKLIST = ::std::os::raw::c_int; -#[repr(C)] -#[repr(align(4))] -#[derive(Debug, Copy, Clone)] -pub struct NV_INFOFRAME_PROPERTY { - pub _bitfield_align_1: [u16; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, -} -impl NV_INFOFRAME_PROPERTY { - #[inline] - pub fn mode(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32) } - } - #[inline] - pub fn set_mode(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 4u8, val as u64) - } - } - #[inline] - pub unsafe fn mode_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 4u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_mode_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 4u8, - val as u64, - ) - } - } - #[inline] - pub fn blackList(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 2u8) as u32) } - } - #[inline] - pub fn set_blackList(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn blackList_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_blackList_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 10u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(6usize, 10u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 6usize, - 10u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 6usize, - 10u8, - val as u64, - ) - } - } - #[inline] - pub fn version(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 8u8) as u32) } - } - #[inline] - pub fn set_version(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(16usize, 8u8, val as u64) - } - } - #[inline] - pub unsafe fn version_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 16usize, - 8u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_version_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 16usize, - 8u8, - val as u64, - ) - } - } - #[inline] - pub fn length(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u32) } - } - #[inline] - pub fn set_length(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(24usize, 8u8, val as u64) - } - } - #[inline] - pub unsafe fn length_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 24usize, - 8u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_length_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 24usize, - 8u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - mode: NvU32, - blackList: NvU32, - reserved: NvU32, - version: NvU32, - length: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 4u8, { - let mode: u32 = unsafe { ::std::mem::transmute(mode) }; - mode as u64 - }); - __bindgen_bitfield_unit.set(4usize, 2u8, { - let blackList: u32 = unsafe { ::std::mem::transmute(blackList) }; - blackList as u64 - }); - __bindgen_bitfield_unit.set(6usize, 10u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit.set(16usize, 8u8, { - let version: u32 = unsafe { ::std::mem::transmute(version) }; - version as u64 - }); - __bindgen_bitfield_unit.set(24usize, 8u8, { - let length: u32 = unsafe { ::std::mem::transmute(length) }; - length as u64 - }); - __bindgen_bitfield_unit - } -} -pub const NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_NODATA: - NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO = 0; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_OVERSCAN: - NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO = 1; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_UNDERSCAN: - NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO = 2; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_FUTURE: - NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO = 3; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_AUTO: - NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO = 7; -#[doc = "! Byte1 related"] -pub type NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_NOT_PRESENT: - NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA = 0; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_VERTICAL_PRESENT : NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_HORIZONTAL_PRESENT : NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_BOTH_PRESENT: - NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA = 3; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_AUTO: - NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA = 7; -pub type NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO_NV_INFOFRAME_FIELD_VALUE_AVI_AFI_ABSENT: - NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO = 0; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO_NV_INFOFRAME_FIELD_VALUE_AVI_AFI_PRESENT: - NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO = 1; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO_NV_INFOFRAME_FIELD_VALUE_AVI_AFI_AUTO: - NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO = 3; -pub type NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_RGB: - NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT = 0; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_YCbCr422 : NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_YCbCr444 : NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_FUTURE : NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_AUTO: - NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT = 7; -pub type NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_F17_NV_INFOFRAME_FIELD_VALUE_AVI_F17_FALSE: - NV_INFOFRAME_FIELD_VALUE_AVI_F17 = 0; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_F17_NV_INFOFRAME_FIELD_VALUE_AVI_F17_TRUE: - NV_INFOFRAME_FIELD_VALUE_AVI_F17 = 1; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_F17_NV_INFOFRAME_FIELD_VALUE_AVI_F17_AUTO: - NV_INFOFRAME_FIELD_VALUE_AVI_F17 = 3; -pub type NV_INFOFRAME_FIELD_VALUE_AVI_F17 = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NO_AFD : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE01 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE02 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE03 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_LETTERBOX_GT16x9 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 4 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE05 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 5 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE06 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 6 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE07 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 7 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_EQUAL_CODEDFRAME : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 8 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_CENTER_4x3 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 9 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_CENTER_16x9 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 10 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_CENTER_14x9 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 11 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE12 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 12 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_4x3_ON_14x9 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 13 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_16x9_ON_14x9 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 14 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_16x9_ON_4x3 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 15 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 31 ; -#[doc = "! Byte2 related"] -pub type NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_NO_DATA : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_4x3 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_16x9 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_FUTURE : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME = 7 ; -pub type NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_NO_DATA : NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_SMPTE_170M : NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_ITUR_BT709 : NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_USE_EXTENDED_COLORIMETRY : NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_AUTO: - NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY = 7; -pub type NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_NO_DATA : NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_HORIZONTAL : NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_VERTICAL : NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_BOTH : NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING = 7 ; -#[doc = "! Byte 3 related"] -pub type NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_DEFAULT : NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_LIMITED_RANGE : NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_FULL_RANGE : NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_RESERVED : NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION = 7 ; -pub type NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_XVYCC601 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_XVYCC709 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_SYCC601 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_ADOBEYCC601 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_ADOBERGB : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 4 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_RESERVED05 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 5 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_RESERVED06 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 6 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_RESERVED07 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 7 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 15 ; -pub type NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ITC_NV_INFOFRAME_FIELD_VALUE_AVI_ITC_VIDEO_CONTENT: - NV_INFOFRAME_FIELD_VALUE_AVI_ITC = 0; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ITC_NV_INFOFRAME_FIELD_VALUE_AVI_ITC_ITCONTENT: - NV_INFOFRAME_FIELD_VALUE_AVI_ITC = 1; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ITC_NV_INFOFRAME_FIELD_VALUE_AVI_ITC_AUTO: - NV_INFOFRAME_FIELD_VALUE_AVI_ITC = 3; -pub type NV_INFOFRAME_FIELD_VALUE_AVI_ITC = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NONE : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X02 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X03 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X04 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X05 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 4 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X06 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 5 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X07 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 6 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X08 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 7 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X09 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 8 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X10 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 9 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED10 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 10 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED11 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 11 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED12 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 12 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED13 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 13 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED14 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 14 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED15 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 15 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 31 ; -#[doc = "! Byte 4 related"] -pub type NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_GRAPHICS : NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_PHOTO : NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_CINEMA : NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_GAME: - NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE = 3; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_AUTO: - NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE = 7; -pub type NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_LIMITED_RANGE : NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_FULL_RANGE : NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_RESERVED02 : NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_RESERVED03 : NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION = 7 ; -pub type NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION = ::std::os::raw::c_int; -#[doc = "! Adding an Auto bit to each field"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_INFOFRAME_VIDEO { - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 23usize]>, -} -impl NV_INFOFRAME_VIDEO { - #[inline] - pub fn vic(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) } - } - #[inline] - pub fn set_vic(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 8u8, val as u64) - } - } - #[inline] - pub unsafe fn vic_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 8u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_vic_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 8u8, - val as u64, - ) - } - } - #[inline] - pub fn pixelRepeat(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 5u8) as u32) } - } - #[inline] - pub fn set_pixelRepeat(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(8usize, 5u8, val as u64) - } - } - #[inline] - pub unsafe fn pixelRepeat_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 8usize, - 5u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_pixelRepeat_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 8usize, - 5u8, - val as u64, - ) - } - } - #[inline] - pub fn colorSpace(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 3u8) as u32) } - } - #[inline] - pub fn set_colorSpace(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(13usize, 3u8, val as u64) - } - } - #[inline] - pub unsafe fn colorSpace_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 13usize, - 3u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_colorSpace_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 13usize, - 3u8, - val as u64, - ) - } - } - #[inline] - pub fn colorimetry(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 3u8) as u32) } - } - #[inline] - pub fn set_colorimetry(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(16usize, 3u8, val as u64) - } - } - #[inline] - pub unsafe fn colorimetry_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 16usize, - 3u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_colorimetry_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 16usize, - 3u8, - val as u64, - ) - } - } - #[inline] - pub fn extendedColorimetry(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 4u8) as u32) } - } - #[inline] - pub fn set_extendedColorimetry(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(19usize, 4u8, val as u64) - } - } - #[inline] - pub unsafe fn extendedColorimetry_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 19usize, - 4u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_extendedColorimetry_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 19usize, - 4u8, - val as u64, - ) - } - } - #[inline] - pub fn rgbQuantizationRange(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 3u8) as u32) } - } - #[inline] - pub fn set_rgbQuantizationRange(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(23usize, 3u8, val as u64) - } - } - #[inline] - pub unsafe fn rgbQuantizationRange_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 23usize, - 3u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_rgbQuantizationRange_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 23usize, - 3u8, - val as u64, - ) - } - } - #[inline] - pub fn yccQuantizationRange(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 3u8) as u32) } - } - #[inline] - pub fn set_yccQuantizationRange(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(26usize, 3u8, val as u64) - } - } - #[inline] - pub unsafe fn yccQuantizationRange_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 26usize, - 3u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_yccQuantizationRange_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 26usize, - 3u8, - val as u64, - ) - } - } - #[inline] - pub fn itContent(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 2u8) as u32) } - } - #[inline] - pub fn set_itContent(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(29usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn itContent_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 29usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_itContent_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 29usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn contentTypes(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 3u8) as u32) } - } - #[inline] - pub fn set_contentTypes(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(32usize, 3u8, val as u64) - } - } - #[inline] - pub unsafe fn contentTypes_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 32usize, - 3u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_contentTypes_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 32usize, - 3u8, - val as u64, - ) - } - } - #[inline] - pub fn scanInfo(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(35usize, 3u8) as u32) } - } - #[inline] - pub fn set_scanInfo(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(35usize, 3u8, val as u64) - } - } - #[inline] - pub unsafe fn scanInfo_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 35usize, - 3u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_scanInfo_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 35usize, - 3u8, - val as u64, - ) - } - } - #[inline] - pub fn activeFormatInfoPresent(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(38usize, 2u8) as u32) } - } - #[inline] - pub fn set_activeFormatInfoPresent(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(38usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn activeFormatInfoPresent_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 38usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_activeFormatInfoPresent_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 38usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn activeFormatAspectRatio(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(40usize, 5u8) as u32) } - } - #[inline] - pub fn set_activeFormatAspectRatio(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(40usize, 5u8, val as u64) - } - } - #[inline] - pub unsafe fn activeFormatAspectRatio_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 40usize, - 5u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_activeFormatAspectRatio_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 40usize, - 5u8, - val as u64, - ) - } - } - #[inline] - pub fn picAspectRatio(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(45usize, 3u8) as u32) } - } - #[inline] - pub fn set_picAspectRatio(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(45usize, 3u8, val as u64) - } - } - #[inline] - pub unsafe fn picAspectRatio_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 45usize, - 3u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_picAspectRatio_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 45usize, - 3u8, - val as u64, - ) - } - } - #[inline] - pub fn nonuniformScaling(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 3u8) as u32) } - } - #[inline] - pub fn set_nonuniformScaling(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(48usize, 3u8, val as u64) - } - } - #[inline] - pub unsafe fn nonuniformScaling_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 48usize, - 3u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_nonuniformScaling_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 48usize, - 3u8, - val as u64, - ) - } - } - #[inline] - pub fn barInfo(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(51usize, 3u8) as u32) } - } - #[inline] - pub fn set_barInfo(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(51usize, 3u8, val as u64) - } - } - #[inline] - pub unsafe fn barInfo_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 51usize, - 3u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_barInfo_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 51usize, - 3u8, - val as u64, - ) - } - } - #[inline] - pub fn top_bar(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(64usize, 17u8) as u32) } - } - #[inline] - pub fn set_top_bar(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(64usize, 17u8, val as u64) - } - } - #[inline] - pub unsafe fn top_bar_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 64usize, - 17u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_top_bar_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 64usize, - 17u8, - val as u64, - ) - } - } - #[inline] - pub fn bottom_bar(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(96usize, 17u8) as u32) } - } - #[inline] - pub fn set_bottom_bar(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(96usize, 17u8, val as u64) - } - } - #[inline] - pub unsafe fn bottom_bar_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 96usize, - 17u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bottom_bar_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 96usize, - 17u8, - val as u64, - ) - } - } - #[inline] - pub fn left_bar(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(128usize, 17u8) as u32) } - } - #[inline] - pub fn set_left_bar(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(128usize, 17u8, val as u64) - } - } - #[inline] - pub unsafe fn left_bar_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 128usize, - 17u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_left_bar_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 128usize, - 17u8, - val as u64, - ) - } - } - #[inline] - pub fn right_bar(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(160usize, 17u8) as u32) } - } - #[inline] - pub fn set_right_bar(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(160usize, 17u8, val as u64) - } - } - #[inline] - pub unsafe fn right_bar_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 160usize, - 17u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_right_bar_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 160usize, - 17u8, - val as u64, - ) - } - } - #[inline] - pub fn Future17(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(177usize, 2u8) as u32) } - } - #[inline] - pub fn set_Future17(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(177usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn Future17_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 177usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_Future17_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 177usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn Future47(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(179usize, 2u8) as u32) } - } - #[inline] - pub fn set_Future47(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(179usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn Future47_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 179usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_Future47_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 179usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - vic: NvU32, - pixelRepeat: NvU32, - colorSpace: NvU32, - colorimetry: NvU32, - extendedColorimetry: NvU32, - rgbQuantizationRange: NvU32, - yccQuantizationRange: NvU32, - itContent: NvU32, - contentTypes: NvU32, - scanInfo: NvU32, - activeFormatInfoPresent: NvU32, - activeFormatAspectRatio: NvU32, - picAspectRatio: NvU32, - nonuniformScaling: NvU32, - barInfo: NvU32, - top_bar: NvU32, - bottom_bar: NvU32, - left_bar: NvU32, - right_bar: NvU32, - Future17: NvU32, - Future47: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 23usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 23usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 8u8, { - let vic: u32 = unsafe { ::std::mem::transmute(vic) }; - vic as u64 - }); - __bindgen_bitfield_unit.set(8usize, 5u8, { - let pixelRepeat: u32 = unsafe { ::std::mem::transmute(pixelRepeat) }; - pixelRepeat as u64 - }); - __bindgen_bitfield_unit.set(13usize, 3u8, { - let colorSpace: u32 = unsafe { ::std::mem::transmute(colorSpace) }; - colorSpace as u64 - }); - __bindgen_bitfield_unit.set(16usize, 3u8, { - let colorimetry: u32 = unsafe { ::std::mem::transmute(colorimetry) }; - colorimetry as u64 - }); - __bindgen_bitfield_unit.set(19usize, 4u8, { - let extendedColorimetry: u32 = unsafe { ::std::mem::transmute(extendedColorimetry) }; - extendedColorimetry as u64 - }); - __bindgen_bitfield_unit.set(23usize, 3u8, { - let rgbQuantizationRange: u32 = unsafe { ::std::mem::transmute(rgbQuantizationRange) }; - rgbQuantizationRange as u64 - }); - __bindgen_bitfield_unit.set(26usize, 3u8, { - let yccQuantizationRange: u32 = unsafe { ::std::mem::transmute(yccQuantizationRange) }; - yccQuantizationRange as u64 - }); - __bindgen_bitfield_unit.set(29usize, 2u8, { - let itContent: u32 = unsafe { ::std::mem::transmute(itContent) }; - itContent as u64 - }); - __bindgen_bitfield_unit.set(32usize, 3u8, { - let contentTypes: u32 = unsafe { ::std::mem::transmute(contentTypes) }; - contentTypes as u64 - }); - __bindgen_bitfield_unit.set(35usize, 3u8, { - let scanInfo: u32 = unsafe { ::std::mem::transmute(scanInfo) }; - scanInfo as u64 - }); - __bindgen_bitfield_unit.set(38usize, 2u8, { - let activeFormatInfoPresent: u32 = - unsafe { ::std::mem::transmute(activeFormatInfoPresent) }; - activeFormatInfoPresent as u64 - }); - __bindgen_bitfield_unit.set(40usize, 5u8, { - let activeFormatAspectRatio: u32 = - unsafe { ::std::mem::transmute(activeFormatAspectRatio) }; - activeFormatAspectRatio as u64 - }); - __bindgen_bitfield_unit.set(45usize, 3u8, { - let picAspectRatio: u32 = unsafe { ::std::mem::transmute(picAspectRatio) }; - picAspectRatio as u64 - }); - __bindgen_bitfield_unit.set(48usize, 3u8, { - let nonuniformScaling: u32 = unsafe { ::std::mem::transmute(nonuniformScaling) }; - nonuniformScaling as u64 - }); - __bindgen_bitfield_unit.set(51usize, 3u8, { - let barInfo: u32 = unsafe { ::std::mem::transmute(barInfo) }; - barInfo as u64 - }); - __bindgen_bitfield_unit.set(64usize, 17u8, { - let top_bar: u32 = unsafe { ::std::mem::transmute(top_bar) }; - top_bar as u64 - }); - __bindgen_bitfield_unit.set(96usize, 17u8, { - let bottom_bar: u32 = unsafe { ::std::mem::transmute(bottom_bar) }; - bottom_bar as u64 - }); - __bindgen_bitfield_unit.set(128usize, 17u8, { - let left_bar: u32 = unsafe { ::std::mem::transmute(left_bar) }; - left_bar as u64 - }); - __bindgen_bitfield_unit.set(160usize, 17u8, { - let right_bar: u32 = unsafe { ::std::mem::transmute(right_bar) }; - right_bar as u64 - }); - __bindgen_bitfield_unit.set(177usize, 2u8, { - let Future17: u32 = unsafe { ::std::mem::transmute(Future17) }; - Future17 as u64 - }); - __bindgen_bitfield_unit.set(179usize, 2u8, { - let Future47: u32 = unsafe { ::std::mem::transmute(Future47) }; - Future47 as u64 - }); - __bindgen_bitfield_unit - } -} -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_IN_HEADER : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_2 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_3 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_4 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_5 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 4 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_6 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 5 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_7 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 6 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_8 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 7 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 15 ; -#[doc = "! Byte 1 related"] -pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_IN_HEADER : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_PCM : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_AC3 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_MPEG1 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_MP3 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 4 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_MPEG2 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 5 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_AACLC : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 6 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_DTS : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 7 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_ATRAC : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 8 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_DSD : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 9 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_EAC3 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 10 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_DTSHD : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 11 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_MLP : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 12 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_DST : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 13 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_WMAPRO : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 14 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_USE_CODING_EXTENSION_TYPE : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 15 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 31 ; -pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_IN_HEADER : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_16BITS : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_20BITS : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_24BITS : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE = 7 ; -#[doc = "! Byte 2 related"] -pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_IN_HEADER : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_32000HZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_44100HZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_48000HZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_88200KHZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 4 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_96000KHZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 5 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_176400KHZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 6 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_192000KHZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 7 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 15 ; -pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_USE_CODING_TYPE : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_HEAAC : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_HEAACV2 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_MPEGSURROUND : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE04 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 4 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE05 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 5 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE06 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 6 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE07 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 7 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE08 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 8 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE09 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 9 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE10 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 10 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE11 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 11 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE12 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 12 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE13 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 13 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE14 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 14 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE15 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 15 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE16 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 16 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE17 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 17 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE18 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 18 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE19 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 19 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE20 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 20 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE21 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 21 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE22 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 22 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE23 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 23 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE24 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 24 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE25 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 25 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE26 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 26 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE27 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 27 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE28 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 28 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE29 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 29 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE30 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 30 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE31 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 31 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 63 ; -#[doc = "! Byte 3 related"] -pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_X_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_X_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_X_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_X_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_RC_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 4 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_RC_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 5 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_RC_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 6 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_RC_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 7 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_RR_RL_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 8 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_RR_RL_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 9 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 10 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 11 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_RC_RR_RL_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 12 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_RC_RR_RL_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 13 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_RC_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 14 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_RC_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 15 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_RRC_RLC_RR_RL_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 16 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_RRC_RLC_RR_RL_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 17 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_RRC_RLC_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 18 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_RRC_RLC_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 19 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_X_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 20 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_X_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 21 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_X_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 22 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_X_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 23 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_RC_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 24 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_RC_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 25 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_RC_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 26 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_RC_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 27 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_RR_RL_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 28 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_RR_RL_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 29 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 30 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 31 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_FCH_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 32 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_FCH_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 33 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_X_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 34 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_X_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 35 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRH_FLH_RR_RL_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 36 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRH_FLH_RR_RL_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 37 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRW_FLW_RR_RL_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 38 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRW_FLW_RR_RL_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 39 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_RC_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 40 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_RC_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 41 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FCH_RC_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 42 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FCH_RC_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 43 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_FCH_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 44 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_FCH_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 45 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRH_FLH_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 46 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRH_FLH_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 47 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRW_FLW_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 48 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRW_FLW_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 49 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 511 ; -#[doc = "! Byte 4 related"] -pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_NO_DATA : NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_0DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_PLUS10DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_RESERVED03 : NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL = 7 ; -#[doc = "! Byte 5 related"] -pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_0DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_1DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_2DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_3DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_4DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 4 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_5DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 5 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_6DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 6 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_7DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 7 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_8DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 8 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_9DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 9 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_10DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 10 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_11DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 11 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_12DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 12 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_13DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 13 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_14DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 14 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_15DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 15 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 31 ; -pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_PERMITTED : NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_PROHIBITED : NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_AUTO: - NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX = 3; -pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX = ::std::os::raw::c_int; -#[repr(C)] -#[repr(align(4))] -#[derive(Debug, Copy, Clone)] -pub struct NV_INFOFRAME_AUDIO { - pub _bitfield_align_1: [u16; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 14usize]>, - pub __bindgen_padding_0: u16, -} -impl NV_INFOFRAME_AUDIO { - #[inline] - pub fn codingType(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 5u8) as u32) } - } - #[inline] - pub fn set_codingType(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 5u8, val as u64) - } - } - #[inline] - pub unsafe fn codingType_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 5u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_codingType_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 5u8, - val as u64, - ) - } - } - #[inline] - pub fn codingExtensionType(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 6u8) as u32) } - } - #[inline] - pub fn set_codingExtensionType(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 6u8, val as u64) - } - } - #[inline] - pub unsafe fn codingExtensionType_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 6u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_codingExtensionType_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 6u8, - val as u64, - ) - } - } - #[inline] - pub fn sampleSize(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 3u8) as u32) } - } - #[inline] - pub fn set_sampleSize(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(11usize, 3u8, val as u64) - } - } - #[inline] - pub unsafe fn sampleSize_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 11usize, - 3u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_sampleSize_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 11usize, - 3u8, - val as u64, - ) - } - } - #[inline] - pub fn sampleRate(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 4u8) as u32) } - } - #[inline] - pub fn set_sampleRate(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(14usize, 4u8, val as u64) - } - } - #[inline] - pub unsafe fn sampleRate_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 14usize, - 4u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_sampleRate_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 14usize, - 4u8, - val as u64, - ) - } - } - #[inline] - pub fn channelCount(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 4u8) as u32) } - } - #[inline] - pub fn set_channelCount(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(18usize, 4u8, val as u64) - } - } - #[inline] - pub unsafe fn channelCount_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 18usize, - 4u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_channelCount_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 18usize, - 4u8, - val as u64, - ) - } - } - #[inline] - pub fn speakerPlacement(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 9u8) as u32) } - } - #[inline] - pub fn set_speakerPlacement(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(22usize, 9u8, val as u64) - } - } - #[inline] - pub unsafe fn speakerPlacement_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 22usize, - 9u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_speakerPlacement_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 22usize, - 9u8, - val as u64, - ) - } - } - #[inline] - pub fn downmixInhibit(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 2u8) as u32) } - } - #[inline] - pub fn set_downmixInhibit(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(32usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn downmixInhibit_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 32usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_downmixInhibit_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 32usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn lfePlaybackLevel(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(34usize, 3u8) as u32) } - } - #[inline] - pub fn set_lfePlaybackLevel(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(34usize, 3u8, val as u64) - } - } - #[inline] - pub unsafe fn lfePlaybackLevel_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 34usize, - 3u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_lfePlaybackLevel_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 34usize, - 3u8, - val as u64, - ) - } - } - #[inline] - pub fn levelShift(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(37usize, 5u8) as u32) } - } - #[inline] - pub fn set_levelShift(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(37usize, 5u8, val as u64) - } - } - #[inline] - pub unsafe fn levelShift_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 37usize, - 5u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_levelShift_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 37usize, - 5u8, - val as u64, - ) - } - } - #[inline] - pub fn Future12(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(42usize, 2u8) as u32) } - } - #[inline] - pub fn set_Future12(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(42usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn Future12_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 42usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_Future12_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 42usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn Future2x(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(44usize, 4u8) as u32) } - } - #[inline] - pub fn set_Future2x(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(44usize, 4u8, val as u64) - } - } - #[inline] - pub unsafe fn Future2x_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 44usize, - 4u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_Future2x_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 44usize, - 4u8, - val as u64, - ) - } - } - #[inline] - pub fn Future3x(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 4u8) as u32) } - } - #[inline] - pub fn set_Future3x(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(48usize, 4u8, val as u64) - } - } - #[inline] - pub unsafe fn Future3x_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 48usize, - 4u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_Future3x_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 48usize, - 4u8, - val as u64, - ) - } - } - #[inline] - pub fn Future52(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(52usize, 2u8) as u32) } - } - #[inline] - pub fn set_Future52(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(52usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn Future52_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 52usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_Future52_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 52usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn Future6(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(54usize, 9u8) as u32) } - } - #[inline] - pub fn set_Future6(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(54usize, 9u8, val as u64) - } - } - #[inline] - pub unsafe fn Future6_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 54usize, - 9u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_Future6_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 54usize, - 9u8, - val as u64, - ) - } - } - #[inline] - pub fn Future7(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(64usize, 9u8) as u32) } - } - #[inline] - pub fn set_Future7(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(64usize, 9u8, val as u64) - } - } - #[inline] - pub unsafe fn Future7_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 64usize, - 9u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_Future7_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 64usize, - 9u8, - val as u64, - ) - } - } - #[inline] - pub fn Future8(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(73usize, 9u8) as u32) } - } - #[inline] - pub fn set_Future8(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(73usize, 9u8, val as u64) - } - } - #[inline] - pub unsafe fn Future8_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 73usize, - 9u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_Future8_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 73usize, - 9u8, - val as u64, - ) - } - } - #[inline] - pub fn Future9(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(82usize, 9u8) as u32) } - } - #[inline] - pub fn set_Future9(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(82usize, 9u8, val as u64) - } - } - #[inline] - pub unsafe fn Future9_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 82usize, - 9u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_Future9_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 82usize, - 9u8, - val as u64, - ) - } - } - #[inline] - pub fn Future10(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(96usize, 9u8) as u32) } - } - #[inline] - pub fn set_Future10(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(96usize, 9u8, val as u64) - } - } - #[inline] - pub unsafe fn Future10_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 96usize, - 9u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_Future10_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 96usize, - 9u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - codingType: NvU32, - codingExtensionType: NvU32, - sampleSize: NvU32, - sampleRate: NvU32, - channelCount: NvU32, - speakerPlacement: NvU32, - downmixInhibit: NvU32, - lfePlaybackLevel: NvU32, - levelShift: NvU32, - Future12: NvU32, - Future2x: NvU32, - Future3x: NvU32, - Future52: NvU32, - Future6: NvU32, - Future7: NvU32, - Future8: NvU32, - Future9: NvU32, - Future10: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 14usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 14usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 5u8, { - let codingType: u32 = unsafe { ::std::mem::transmute(codingType) }; - codingType as u64 - }); - __bindgen_bitfield_unit.set(5usize, 6u8, { - let codingExtensionType: u32 = unsafe { ::std::mem::transmute(codingExtensionType) }; - codingExtensionType as u64 - }); - __bindgen_bitfield_unit.set(11usize, 3u8, { - let sampleSize: u32 = unsafe { ::std::mem::transmute(sampleSize) }; - sampleSize as u64 - }); - __bindgen_bitfield_unit.set(14usize, 4u8, { - let sampleRate: u32 = unsafe { ::std::mem::transmute(sampleRate) }; - sampleRate as u64 - }); - __bindgen_bitfield_unit.set(18usize, 4u8, { - let channelCount: u32 = unsafe { ::std::mem::transmute(channelCount) }; - channelCount as u64 - }); - __bindgen_bitfield_unit.set(22usize, 9u8, { - let speakerPlacement: u32 = unsafe { ::std::mem::transmute(speakerPlacement) }; - speakerPlacement as u64 - }); - __bindgen_bitfield_unit.set(32usize, 2u8, { - let downmixInhibit: u32 = unsafe { ::std::mem::transmute(downmixInhibit) }; - downmixInhibit as u64 - }); - __bindgen_bitfield_unit.set(34usize, 3u8, { - let lfePlaybackLevel: u32 = unsafe { ::std::mem::transmute(lfePlaybackLevel) }; - lfePlaybackLevel as u64 - }); - __bindgen_bitfield_unit.set(37usize, 5u8, { - let levelShift: u32 = unsafe { ::std::mem::transmute(levelShift) }; - levelShift as u64 - }); - __bindgen_bitfield_unit.set(42usize, 2u8, { - let Future12: u32 = unsafe { ::std::mem::transmute(Future12) }; - Future12 as u64 - }); - __bindgen_bitfield_unit.set(44usize, 4u8, { - let Future2x: u32 = unsafe { ::std::mem::transmute(Future2x) }; - Future2x as u64 - }); - __bindgen_bitfield_unit.set(48usize, 4u8, { - let Future3x: u32 = unsafe { ::std::mem::transmute(Future3x) }; - Future3x as u64 - }); - __bindgen_bitfield_unit.set(52usize, 2u8, { - let Future52: u32 = unsafe { ::std::mem::transmute(Future52) }; - Future52 as u64 - }); - __bindgen_bitfield_unit.set(54usize, 9u8, { - let Future6: u32 = unsafe { ::std::mem::transmute(Future6) }; - Future6 as u64 - }); - __bindgen_bitfield_unit.set(64usize, 9u8, { - let Future7: u32 = unsafe { ::std::mem::transmute(Future7) }; - Future7 as u64 - }); - __bindgen_bitfield_unit.set(73usize, 9u8, { - let Future8: u32 = unsafe { ::std::mem::transmute(Future8) }; - Future8 as u64 - }); - __bindgen_bitfield_unit.set(82usize, 9u8, { - let Future9: u32 = unsafe { ::std::mem::transmute(Future9) }; - Future9 as u64 - }); - __bindgen_bitfield_unit.set(96usize, 9u8, { - let Future10: u32 = unsafe { ::std::mem::transmute(Future10) }; - Future10 as u64 - }); - __bindgen_bitfield_unit - } -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct NV_INFOFRAME_DATA { - #[doc = "!< version of this structure"] - pub version: NvU32, - #[doc = "!< size of this structure"] - pub size: NvU16, - #[doc = "!< The actions to perform from NV_INFOFRAME_CMD"] - pub cmd: NvU8, - #[doc = "!< type of infoframe"] - pub type_: NvU8, - pub infoframe: NV_INFOFRAME_DATA__bindgen_ty_1, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union NV_INFOFRAME_DATA__bindgen_ty_1 { - #[doc = "!< This is NVIDIA-specific and corresponds to the property cmds and associated infoframe."] - pub property: NV_INFOFRAME_PROPERTY, - pub audio: NV_INFOFRAME_AUDIO, - pub video: NV_INFOFRAME_VIDEO, -} -pub const NV_COLOR_CMD_NV_COLOR_CMD_GET: NV_COLOR_CMD = 1; -pub const NV_COLOR_CMD_NV_COLOR_CMD_SET: NV_COLOR_CMD = 2; -pub const NV_COLOR_CMD_NV_COLOR_CMD_IS_SUPPORTED_COLOR: NV_COLOR_CMD = 3; -pub const NV_COLOR_CMD_NV_COLOR_CMD_GET_DEFAULT: NV_COLOR_CMD = 4; -pub type NV_COLOR_CMD = ::std::os::raw::c_int; -pub const NV_COLOR_FORMAT_NV_COLOR_FORMAT_RGB: NV_COLOR_FORMAT = 0; -pub const NV_COLOR_FORMAT_NV_COLOR_FORMAT_YUV422: NV_COLOR_FORMAT = 1; -pub const NV_COLOR_FORMAT_NV_COLOR_FORMAT_YUV444: NV_COLOR_FORMAT = 2; -pub const NV_COLOR_FORMAT_NV_COLOR_FORMAT_YUV420: NV_COLOR_FORMAT = 3; -pub const NV_COLOR_FORMAT_NV_COLOR_FORMAT_DEFAULT: NV_COLOR_FORMAT = 254; -pub const NV_COLOR_FORMAT_NV_COLOR_FORMAT_AUTO: NV_COLOR_FORMAT = 255; -#[doc = "! See Table 14 of CEA-861E. Not all of this is supported by the GPU."] -pub type NV_COLOR_FORMAT = ::std::os::raw::c_int; -pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_RGB: NV_COLOR_COLORIMETRY = 0; -pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_YCC601: NV_COLOR_COLORIMETRY = 1; -pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_YCC709: NV_COLOR_COLORIMETRY = 2; -pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_XVYCC601: NV_COLOR_COLORIMETRY = 3; -pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_XVYCC709: NV_COLOR_COLORIMETRY = 4; -pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_SYCC601: NV_COLOR_COLORIMETRY = 5; -pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_ADOBEYCC601: NV_COLOR_COLORIMETRY = 6; -pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_ADOBERGB: NV_COLOR_COLORIMETRY = 7; -pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_BT2020RGB: NV_COLOR_COLORIMETRY = 8; -pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_BT2020YCC: NV_COLOR_COLORIMETRY = 9; -pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_BT2020cYCC: NV_COLOR_COLORIMETRY = 10; -pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_DEFAULT: NV_COLOR_COLORIMETRY = 254; -pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_AUTO: NV_COLOR_COLORIMETRY = 255; -pub type NV_COLOR_COLORIMETRY = ::std::os::raw::c_int; -pub const _NV_DYNAMIC_RANGE_NV_DYNAMIC_RANGE_VESA: _NV_DYNAMIC_RANGE = 0; -pub const _NV_DYNAMIC_RANGE_NV_DYNAMIC_RANGE_CEA: _NV_DYNAMIC_RANGE = 1; -pub const _NV_DYNAMIC_RANGE_NV_DYNAMIC_RANGE_AUTO: _NV_DYNAMIC_RANGE = 255; -pub type _NV_DYNAMIC_RANGE = ::std::os::raw::c_int; -pub use self::_NV_DYNAMIC_RANGE as NV_DYNAMIC_RANGE; -pub const _NV_BPC_NV_BPC_DEFAULT: _NV_BPC = 0; -pub const _NV_BPC_NV_BPC_6: _NV_BPC = 1; -pub const _NV_BPC_NV_BPC_8: _NV_BPC = 2; -pub const _NV_BPC_NV_BPC_10: _NV_BPC = 3; -pub const _NV_BPC_NV_BPC_12: _NV_BPC = 4; -pub const _NV_BPC_NV_BPC_16: _NV_BPC = 5; -pub type _NV_BPC = ::std::os::raw::c_int; -pub use self::_NV_BPC as NV_BPC; -#[doc = "!< app/nvcpl make decision to select the desire color format"] -pub const _NV_COLOR_SELECTION_POLICY_NV_COLOR_SELECTION_POLICY_USER: _NV_COLOR_SELECTION_POLICY = 0; -#[doc = "!< driver/ OS make decision to select the best color format"] -pub const _NV_COLOR_SELECTION_POLICY_NV_COLOR_SELECTION_POLICY_BEST_QUALITY: - _NV_COLOR_SELECTION_POLICY = 1; -pub const _NV_COLOR_SELECTION_POLICY_NV_COLOR_SELECTION_POLICY_DEFAULT: _NV_COLOR_SELECTION_POLICY = - 1; -pub const _NV_COLOR_SELECTION_POLICY_NV_COLOR_SELECTION_POLICY_UNKNOWN: _NV_COLOR_SELECTION_POLICY = - 255; -pub type _NV_COLOR_SELECTION_POLICY = ::std::os::raw::c_int; -pub use self::_NV_COLOR_SELECTION_POLICY as NV_COLOR_SELECTION_POLICY; -pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_DEFAULT: _NV_DESKTOP_COLOR_DEPTH = 0; -pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_8BPC: _NV_DESKTOP_COLOR_DEPTH = 1; -pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_10BPC: _NV_DESKTOP_COLOR_DEPTH = 2; -pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_16BPC_FLOAT: _NV_DESKTOP_COLOR_DEPTH = 3; -pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_16BPC_FLOAT_WCG: _NV_DESKTOP_COLOR_DEPTH = - 4; -pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_16BPC_FLOAT_HDR: _NV_DESKTOP_COLOR_DEPTH = - 5; -pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_MAX_VALUE: _NV_DESKTOP_COLOR_DEPTH = 5; -pub type _NV_DESKTOP_COLOR_DEPTH = ::std::os::raw::c_int; -pub use self::_NV_DESKTOP_COLOR_DEPTH as NV_DESKTOP_COLOR_DEPTH; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_COLOR_DATA_V1 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< Size of this structure"] - pub size: NvU16, - pub cmd: NvU8, - pub data: _NV_COLOR_DATA_V1__bindgen_ty_1, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_COLOR_DATA_V1__bindgen_ty_1 { - #[doc = "!< One of NV_COLOR_FORMAT enum values."] - pub colorFormat: NvU8, - #[doc = "!< One of NV_COLOR_COLORIMETRY enum values."] - pub colorimetry: NvU8, -} -pub type NV_COLOR_DATA_V1 = _NV_COLOR_DATA_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_COLOR_DATA_V2 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< Size of this structure"] - pub size: NvU16, - pub cmd: NvU8, - pub data: _NV_COLOR_DATA_V2__bindgen_ty_1, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_COLOR_DATA_V2__bindgen_ty_1 { - #[doc = "!< One of NV_COLOR_FORMAT enum values."] - pub colorFormat: NvU8, - #[doc = "!< One of NV_COLOR_COLORIMETRY enum values."] - pub colorimetry: NvU8, - #[doc = "!< One of NV_DYNAMIC_RANGE enum values."] - pub dynamicRange: NvU8, -} -pub type NV_COLOR_DATA_V2 = _NV_COLOR_DATA_V2; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_COLOR_DATA_V3 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< Size of this structure"] - pub size: NvU16, - pub cmd: NvU8, - pub data: _NV_COLOR_DATA_V3__bindgen_ty_1, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_COLOR_DATA_V3__bindgen_ty_1 { - #[doc = "!< One of NV_COLOR_FORMAT enum values."] - pub colorFormat: NvU8, - #[doc = "!< One of NV_COLOR_COLORIMETRY enum values."] - pub colorimetry: NvU8, - #[doc = "!< One of NV_DYNAMIC_RANGE enum values."] - pub dynamicRange: NvU8, - #[doc = "!< One of NV_BPC enum values."] - pub bpc: NV_BPC, -} -pub type NV_COLOR_DATA_V3 = _NV_COLOR_DATA_V3; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_COLOR_DATA_V4 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< Size of this structure"] - pub size: NvU16, - pub cmd: NvU8, - pub data: _NV_COLOR_DATA_V4__bindgen_ty_1, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_COLOR_DATA_V4__bindgen_ty_1 { - #[doc = "!< One of NV_COLOR_FORMAT enum values."] - pub colorFormat: NvU8, - #[doc = "!< One of NV_COLOR_COLORIMETRY enum values."] - pub colorimetry: NvU8, - #[doc = "!< One of NV_DYNAMIC_RANGE enum values."] - pub dynamicRange: NvU8, - #[doc = "!< One of NV_BPC enum values."] - pub bpc: NV_BPC, - #[doc = "!< One of the color selection policy"] - pub colorSelectionPolicy: NV_COLOR_SELECTION_POLICY, -} -pub type NV_COLOR_DATA_V4 = _NV_COLOR_DATA_V4; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_COLOR_DATA_V5 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< Size of this structure"] - pub size: NvU16, - pub cmd: NvU8, - pub data: _NV_COLOR_DATA_V5__bindgen_ty_1, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_COLOR_DATA_V5__bindgen_ty_1 { - #[doc = "!< One of NV_COLOR_FORMAT enum values."] - pub colorFormat: NvU8, - #[doc = "!< One of NV_COLOR_COLORIMETRY enum values."] - pub colorimetry: NvU8, - #[doc = "!< One of NV_DYNAMIC_RANGE enum values."] - pub dynamicRange: NvU8, - #[doc = "!< One of NV_BPC enum values."] - pub bpc: NV_BPC, - #[doc = "!< One of the color selection policy"] - pub colorSelectionPolicy: NV_COLOR_SELECTION_POLICY, - #[doc = "!< One of NV_DESKTOP_COLOR_DEPTH enum values."] - pub depth: NV_DESKTOP_COLOR_DEPTH, -} -pub type NV_COLOR_DATA_V5 = _NV_COLOR_DATA_V5; -pub type NV_COLOR_DATA = NV_COLOR_DATA_V5; -#[doc = "!< Tells the type of structure used to define the Static Metadata Descriptor block."] -pub const NV_STATIC_METADATA_DESCRIPTOR_ID_NV_STATIC_METADATA_TYPE_1: - NV_STATIC_METADATA_DESCRIPTOR_ID = 0; -#[doc = "! @}"] -pub type NV_STATIC_METADATA_DESCRIPTOR_ID = ::std::os::raw::c_int; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDR_CAPABILITIES_V1 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Static Metadata Descriptor Id (0 for static metadata type 1)"] - pub static_metadata_descriptor_id: NV_STATIC_METADATA_DESCRIPTOR_ID, - pub display_data: _NV_HDR_CAPABILITIES_V1__bindgen_ty_1, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDR_CAPABILITIES_V1__bindgen_ty_1 { - #[doc = "!< x coordinate of color primary 0 (e.g. Red) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x0: NvU16, - #[doc = "!< y coordinate of color primary 0 (e.g. Red) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y0: NvU16, - #[doc = "!< x coordinate of color primary 1 (e.g. Green) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x1: NvU16, - #[doc = "!< y coordinate of color primary 1 (e.g. Green) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y1: NvU16, - #[doc = "!< x coordinate of color primary 2 (e.g. Blue) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x2: NvU16, - #[doc = "!< y coordinate of color primary 2 (e.g. Blue) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y2: NvU16, - #[doc = "!< x coordinate of white point of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayWhitePoint_x: NvU16, - #[doc = "!< y coordinate of white point of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayWhitePoint_y: NvU16, - #[doc = "!< Maximum display luminance = desired max luminance of HDR content ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] - pub desired_content_max_luminance: NvU16, - #[doc = "!< Minimum display luminance = desired min luminance of HDR content ([0x0001-0xFFFF] = [1.0 - 6.55350] cd/m^2)"] - pub desired_content_min_luminance: NvU16, - #[doc = "!< Desired maximum Frame-Average Light Level (MaxFALL) of HDR content ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] - pub desired_content_max_frame_average_luminance: NvU16, -} -impl _NV_HDR_CAPABILITIES_V1 { - #[inline] - pub fn isST2084EotfSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isST2084EotfSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isST2084EotfSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isST2084EotfSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isTraditionalHdrGammaSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_isTraditionalHdrGammaSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isTraditionalHdrGammaSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isTraditionalHdrGammaSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isEdrSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_isEdrSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isEdrSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isEdrSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn driverExpandDefaultHdrParameters(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_driverExpandDefaultHdrParameters(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn driverExpandDefaultHdrParameters_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_driverExpandDefaultHdrParameters_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isTraditionalSdrGammaSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } - } - #[inline] - pub fn set_isTraditionalSdrGammaSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isTraditionalSdrGammaSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isTraditionalSdrGammaSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 27u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 27u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 27u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isST2084EotfSupported: NvU32, - isTraditionalHdrGammaSupported: NvU32, - isEdrSupported: NvU32, - driverExpandDefaultHdrParameters: NvU32, - isTraditionalSdrGammaSupported: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isST2084EotfSupported: u32 = - unsafe { ::std::mem::transmute(isST2084EotfSupported) }; - isST2084EotfSupported as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let isTraditionalHdrGammaSupported: u32 = - unsafe { ::std::mem::transmute(isTraditionalHdrGammaSupported) }; - isTraditionalHdrGammaSupported as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let isEdrSupported: u32 = unsafe { ::std::mem::transmute(isEdrSupported) }; - isEdrSupported as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let driverExpandDefaultHdrParameters: u32 = - unsafe { ::std::mem::transmute(driverExpandDefaultHdrParameters) }; - driverExpandDefaultHdrParameters as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let isTraditionalSdrGammaSupported: u32 = - unsafe { ::std::mem::transmute(isTraditionalSdrGammaSupported) }; - isTraditionalSdrGammaSupported as u64 - }); - __bindgen_bitfield_unit.set(5usize, 27u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_HDR_CAPABILITIES_V1 = _NV_HDR_CAPABILITIES_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDR_CAPABILITIES_V2 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Static Metadata Descriptor Id (0 for static metadata type 1)"] - pub static_metadata_descriptor_id: NV_STATIC_METADATA_DESCRIPTOR_ID, - pub display_data: _NV_HDR_CAPABILITIES_V2__bindgen_ty_1, - pub dv_static_metadata: _NV_HDR_CAPABILITIES_V2__bindgen_ty_2, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDR_CAPABILITIES_V2__bindgen_ty_1 { - #[doc = "!< x coordinate of color primary 0 (e.g. Red) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x0: NvU16, - #[doc = "!< y coordinate of color primary 0 (e.g. Red) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y0: NvU16, - #[doc = "!< x coordinate of color primary 1 (e.g. Green) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x1: NvU16, - #[doc = "!< y coordinate of color primary 1 (e.g. Green) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y1: NvU16, - #[doc = "!< x coordinate of color primary 2 (e.g. Blue) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x2: NvU16, - #[doc = "!< y coordinate of color primary 2 (e.g. Blue) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y2: NvU16, - #[doc = "!< x coordinate of white point of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayWhitePoint_x: NvU16, - #[doc = "!< y coordinate of white point of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayWhitePoint_y: NvU16, - #[doc = "!< Maximum display luminance = desired max luminance of HDR content ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] - pub desired_content_max_luminance: NvU16, - #[doc = "!< Minimum display luminance = desired min luminance of HDR content ([0x0001-0xFFFF] = [1.0 - 6.55350] cd/m^2)"] - pub desired_content_min_luminance: NvU16, - #[doc = "!< Desired maximum Frame-Average Light Level (MaxFALL) of HDR content ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] - pub desired_content_max_frame_average_luminance: NvU16, -} -#[repr(C)] -#[repr(align(4))] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDR_CAPABILITIES_V2__bindgen_ty_2 { - pub _bitfield_align_1: [u16; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Represents min luminance level of Sink"] - pub target_min_luminance: NvU16, - #[doc = "!< Represents max luminance level of sink"] - pub target_max_luminance: NvU16, - #[doc = "!< Red primary chromaticity coordinate x"] - pub cc_red_x: NvU16, - #[doc = "!< Red primary chromaticity coordinate y"] - pub cc_red_y: NvU16, - #[doc = "!< Green primary chromaticity coordinate x"] - pub cc_green_x: NvU16, - #[doc = "!< Green primary chromaticity coordinate Y"] - pub cc_green_y: NvU16, - #[doc = "!< Blue primary chromaticity coordinate x"] - pub cc_blue_x: NvU16, - #[doc = "!< Blue primary chromaticity coordinate y"] - pub cc_blue_y: NvU16, - #[doc = "!< White primary chromaticity coordinate x"] - pub cc_white_x: NvU16, - #[doc = "!< White primary chromaticity coordinate y"] - pub cc_white_y: NvU16, -} -impl _NV_HDR_CAPABILITIES_V2__bindgen_ty_2 { - #[inline] - pub fn VSVDB_version(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 3u8) as u32) } - } - #[inline] - pub fn set_VSVDB_version(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 3u8, val as u64) - } - } - #[inline] - pub unsafe fn VSVDB_version_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 3u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_VSVDB_version_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 3u8, - val as u64, - ) - } - } - #[inline] - pub fn dm_version(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 8u8) as u32) } - } - #[inline] - pub fn set_dm_version(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 8u8, val as u64) - } - } - #[inline] - pub unsafe fn dm_version_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 8u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_dm_version_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 8u8, - val as u64, - ) - } - } - #[inline] - pub fn supports_2160p60hz(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) } - } - #[inline] - pub fn set_supports_2160p60hz(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(11usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supports_2160p60hz_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 11usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_supports_2160p60hz_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 11usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn supports_YUV422_12bit(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) } - } - #[inline] - pub fn set_supports_YUV422_12bit(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(12usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supports_YUV422_12bit_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 12usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_supports_YUV422_12bit_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 12usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn supports_global_dimming(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) } - } - #[inline] - pub fn set_supports_global_dimming(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(13usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supports_global_dimming_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 13usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_supports_global_dimming_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 13usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn colorimetry(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) } - } - #[inline] - pub fn set_colorimetry(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(14usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn colorimetry_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 14usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_colorimetry_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 14usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn supports_backlight_control(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 2u8) as u32) } - } - #[inline] - pub fn set_supports_backlight_control(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(15usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn supports_backlight_control_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 15usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_supports_backlight_control_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 15usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn backlt_min_luma(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 2u8) as u32) } - } - #[inline] - pub fn set_backlt_min_luma(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(17usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn backlt_min_luma_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 17usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_backlt_min_luma_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 17usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn interface_supported_by_sink(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 2u8) as u32) } - } - #[inline] - pub fn set_interface_supported_by_sink(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(19usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn interface_supported_by_sink_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 19usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_interface_supported_by_sink_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 19usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn supports_10b_12b_444(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 2u8) as u32) } - } - #[inline] - pub fn set_supports_10b_12b_444(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(21usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn supports_10b_12b_444_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 21usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_supports_10b_12b_444_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 21usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 9u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(23usize, 9u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 23usize, - 9u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 23usize, - 9u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - VSVDB_version: NvU32, - dm_version: NvU32, - supports_2160p60hz: NvU32, - supports_YUV422_12bit: NvU32, - supports_global_dimming: NvU32, - colorimetry: NvU32, - supports_backlight_control: NvU32, - backlt_min_luma: NvU32, - interface_supported_by_sink: NvU32, - supports_10b_12b_444: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 3u8, { - let VSVDB_version: u32 = unsafe { ::std::mem::transmute(VSVDB_version) }; - VSVDB_version as u64 - }); - __bindgen_bitfield_unit.set(3usize, 8u8, { - let dm_version: u32 = unsafe { ::std::mem::transmute(dm_version) }; - dm_version as u64 - }); - __bindgen_bitfield_unit.set(11usize, 1u8, { - let supports_2160p60hz: u32 = unsafe { ::std::mem::transmute(supports_2160p60hz) }; - supports_2160p60hz as u64 - }); - __bindgen_bitfield_unit.set(12usize, 1u8, { - let supports_YUV422_12bit: u32 = - unsafe { ::std::mem::transmute(supports_YUV422_12bit) }; - supports_YUV422_12bit as u64 - }); - __bindgen_bitfield_unit.set(13usize, 1u8, { - let supports_global_dimming: u32 = - unsafe { ::std::mem::transmute(supports_global_dimming) }; - supports_global_dimming as u64 - }); - __bindgen_bitfield_unit.set(14usize, 1u8, { - let colorimetry: u32 = unsafe { ::std::mem::transmute(colorimetry) }; - colorimetry as u64 - }); - __bindgen_bitfield_unit.set(15usize, 2u8, { - let supports_backlight_control: u32 = - unsafe { ::std::mem::transmute(supports_backlight_control) }; - supports_backlight_control as u64 - }); - __bindgen_bitfield_unit.set(17usize, 2u8, { - let backlt_min_luma: u32 = unsafe { ::std::mem::transmute(backlt_min_luma) }; - backlt_min_luma as u64 - }); - __bindgen_bitfield_unit.set(19usize, 2u8, { - let interface_supported_by_sink: u32 = - unsafe { ::std::mem::transmute(interface_supported_by_sink) }; - interface_supported_by_sink as u64 - }); - __bindgen_bitfield_unit.set(21usize, 2u8, { - let supports_10b_12b_444: u32 = unsafe { ::std::mem::transmute(supports_10b_12b_444) }; - supports_10b_12b_444 as u64 - }); - __bindgen_bitfield_unit.set(23usize, 9u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -impl _NV_HDR_CAPABILITIES_V2 { - #[inline] - pub fn isST2084EotfSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isST2084EotfSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isST2084EotfSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isST2084EotfSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isTraditionalHdrGammaSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_isTraditionalHdrGammaSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isTraditionalHdrGammaSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isTraditionalHdrGammaSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isEdrSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_isEdrSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isEdrSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isEdrSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn driverExpandDefaultHdrParameters(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_driverExpandDefaultHdrParameters(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn driverExpandDefaultHdrParameters_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_driverExpandDefaultHdrParameters_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isTraditionalSdrGammaSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } - } - #[inline] - pub fn set_isTraditionalSdrGammaSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isTraditionalSdrGammaSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isTraditionalSdrGammaSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isDolbyVisionSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } - } - #[inline] - pub fn set_isDolbyVisionSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isDolbyVisionSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isDolbyVisionSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 26u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(6usize, 26u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 6usize, - 26u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 6usize, - 26u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isST2084EotfSupported: NvU32, - isTraditionalHdrGammaSupported: NvU32, - isEdrSupported: NvU32, - driverExpandDefaultHdrParameters: NvU32, - isTraditionalSdrGammaSupported: NvU32, - isDolbyVisionSupported: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isST2084EotfSupported: u32 = - unsafe { ::std::mem::transmute(isST2084EotfSupported) }; - isST2084EotfSupported as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let isTraditionalHdrGammaSupported: u32 = - unsafe { ::std::mem::transmute(isTraditionalHdrGammaSupported) }; - isTraditionalHdrGammaSupported as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let isEdrSupported: u32 = unsafe { ::std::mem::transmute(isEdrSupported) }; - isEdrSupported as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let driverExpandDefaultHdrParameters: u32 = - unsafe { ::std::mem::transmute(driverExpandDefaultHdrParameters) }; - driverExpandDefaultHdrParameters as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let isTraditionalSdrGammaSupported: u32 = - unsafe { ::std::mem::transmute(isTraditionalSdrGammaSupported) }; - isTraditionalSdrGammaSupported as u64 - }); - __bindgen_bitfield_unit.set(5usize, 1u8, { - let isDolbyVisionSupported: u32 = - unsafe { ::std::mem::transmute(isDolbyVisionSupported) }; - isDolbyVisionSupported as u64 - }); - __bindgen_bitfield_unit.set(6usize, 26u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_HDR_CAPABILITIES_V2 = _NV_HDR_CAPABILITIES_V2; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDR_CAPABILITIES_V3 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Static Metadata Descriptor Id (0 for static metadata type 1)"] - pub static_metadata_descriptor_id: NV_STATIC_METADATA_DESCRIPTOR_ID, - pub display_data: _NV_HDR_CAPABILITIES_V3__bindgen_ty_1, - pub dv_static_metadata: _NV_HDR_CAPABILITIES_V3__bindgen_ty_2, - pub hdr10plus_vsvdb: _NV_HDR_CAPABILITIES_V3__bindgen_ty_3, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDR_CAPABILITIES_V3__bindgen_ty_1 { - #[doc = "!< x coordinate of color primary 0 (e.g. Red) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x0: NvU16, - #[doc = "!< y coordinate of color primary 0 (e.g. Red) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y0: NvU16, - #[doc = "!< x coordinate of color primary 1 (e.g. Green) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x1: NvU16, - #[doc = "!< y coordinate of color primary 1 (e.g. Green) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y1: NvU16, - #[doc = "!< x coordinate of color primary 2 (e.g. Blue) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x2: NvU16, - #[doc = "!< y coordinate of color primary 2 (e.g. Blue) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y2: NvU16, - #[doc = "!< x coordinate of white point of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayWhitePoint_x: NvU16, - #[doc = "!< y coordinate of white point of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayWhitePoint_y: NvU16, - #[doc = "!< Maximum display luminance = desired max luminance of HDR content ([0x0000-0xFFFF] = [0.0 - 65535.0] cd/m^2, in units of 1 cd/m^2)"] - pub desired_content_max_luminance: NvU16, - #[doc = "!< Minimum display luminance = desired min luminance of HDR content ([0x0000-0xFFFF] = [0.0 - 6.55350] cd/m^2, in units of 0.0001 cd/m^2)"] - pub desired_content_min_luminance: NvU16, - #[doc = "!< Desired maximum Frame-Average Light Level (MaxFALL) of HDR content ([0x0000-0xFFFF] = [0.0 - 65535.0] cd/m^2, in units of 1 cd/m^2)"] - pub desired_content_max_frame_average_luminance: NvU16, -} -#[repr(C)] -#[repr(align(4))] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDR_CAPABILITIES_V3__bindgen_ty_2 { - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Represents min luminance level of Sink"] - pub target_min_luminance: NvU16, - #[doc = "!< Represents max luminance level of sink"] - pub target_max_luminance: NvU16, - #[doc = "!< Red primary chromaticity coordinate x"] - pub cc_red_x: NvU16, - #[doc = "!< Red primary chromaticity coordinate y"] - pub cc_red_y: NvU16, - #[doc = "!< Green primary chromaticity coordinate x"] - pub cc_green_x: NvU16, - #[doc = "!< Green primary chromaticity coordinate Y"] - pub cc_green_y: NvU16, - #[doc = "!< Blue primary chromaticity coordinate x"] - pub cc_blue_x: NvU16, - #[doc = "!< Blue primary chromaticity coordinate y"] - pub cc_blue_y: NvU16, - #[doc = "!< White primary chromaticity coordinate x"] - pub cc_white_x: NvU16, - #[doc = "!< White primary chromaticity coordinate y"] - pub cc_white_y: NvU16, -} -impl _NV_HDR_CAPABILITIES_V3__bindgen_ty_2 { - #[inline] - pub fn VSVDB_version(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 3u8) as u32) } - } - #[inline] - pub fn set_VSVDB_version(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 3u8, val as u64) - } - } - #[inline] - pub unsafe fn VSVDB_version_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 3u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_VSVDB_version_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 3u8, - val as u64, - ) - } - } - #[inline] - pub fn dm_version(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 8u8) as u32) } - } - #[inline] - pub fn set_dm_version(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 8u8, val as u64) - } - } - #[inline] - pub unsafe fn dm_version_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 8u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_dm_version_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 8u8, - val as u64, - ) - } - } - #[inline] - pub fn supports_2160p60hz(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) } - } - #[inline] - pub fn set_supports_2160p60hz(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(11usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supports_2160p60hz_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 11usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_supports_2160p60hz_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 11usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn supports_YUV422_12bit(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) } - } - #[inline] - pub fn set_supports_YUV422_12bit(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(12usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supports_YUV422_12bit_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 12usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_supports_YUV422_12bit_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 12usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn supports_global_dimming(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) } - } - #[inline] - pub fn set_supports_global_dimming(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(13usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supports_global_dimming_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 13usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_supports_global_dimming_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 13usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn colorimetry(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) } - } - #[inline] - pub fn set_colorimetry(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(14usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn colorimetry_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 14usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_colorimetry_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 14usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn supports_backlight_control(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 2u8) as u32) } - } - #[inline] - pub fn set_supports_backlight_control(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(15usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn supports_backlight_control_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 15usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_supports_backlight_control_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 15usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn backlt_min_luma(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 2u8) as u32) } - } - #[inline] - pub fn set_backlt_min_luma(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(17usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn backlt_min_luma_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 17usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_backlt_min_luma_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 17usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn interface_supported_by_sink(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 2u8) as u32) } - } - #[inline] - pub fn set_interface_supported_by_sink(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(19usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn interface_supported_by_sink_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 19usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_interface_supported_by_sink_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 19usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn supports_10b_12b_444(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 2u8) as u32) } - } - #[inline] - pub fn set_supports_10b_12b_444(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(21usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn supports_10b_12b_444_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 21usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_supports_10b_12b_444_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 21usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn parity(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u32) } - } - #[inline] - pub fn set_parity(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(23usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn parity_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 23usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_parity_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 23usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(24usize, 8u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 24usize, - 8u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 24usize, - 8u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - VSVDB_version: NvU32, - dm_version: NvU32, - supports_2160p60hz: NvU32, - supports_YUV422_12bit: NvU32, - supports_global_dimming: NvU32, - colorimetry: NvU32, - supports_backlight_control: NvU32, - backlt_min_luma: NvU32, - interface_supported_by_sink: NvU32, - supports_10b_12b_444: NvU32, - parity: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 3u8, { - let VSVDB_version: u32 = unsafe { ::std::mem::transmute(VSVDB_version) }; - VSVDB_version as u64 - }); - __bindgen_bitfield_unit.set(3usize, 8u8, { - let dm_version: u32 = unsafe { ::std::mem::transmute(dm_version) }; - dm_version as u64 - }); - __bindgen_bitfield_unit.set(11usize, 1u8, { - let supports_2160p60hz: u32 = unsafe { ::std::mem::transmute(supports_2160p60hz) }; - supports_2160p60hz as u64 - }); - __bindgen_bitfield_unit.set(12usize, 1u8, { - let supports_YUV422_12bit: u32 = - unsafe { ::std::mem::transmute(supports_YUV422_12bit) }; - supports_YUV422_12bit as u64 - }); - __bindgen_bitfield_unit.set(13usize, 1u8, { - let supports_global_dimming: u32 = - unsafe { ::std::mem::transmute(supports_global_dimming) }; - supports_global_dimming as u64 - }); - __bindgen_bitfield_unit.set(14usize, 1u8, { - let colorimetry: u32 = unsafe { ::std::mem::transmute(colorimetry) }; - colorimetry as u64 - }); - __bindgen_bitfield_unit.set(15usize, 2u8, { - let supports_backlight_control: u32 = - unsafe { ::std::mem::transmute(supports_backlight_control) }; - supports_backlight_control as u64 - }); - __bindgen_bitfield_unit.set(17usize, 2u8, { - let backlt_min_luma: u32 = unsafe { ::std::mem::transmute(backlt_min_luma) }; - backlt_min_luma as u64 - }); - __bindgen_bitfield_unit.set(19usize, 2u8, { - let interface_supported_by_sink: u32 = - unsafe { ::std::mem::transmute(interface_supported_by_sink) }; - interface_supported_by_sink as u64 - }); - __bindgen_bitfield_unit.set(21usize, 2u8, { - let supports_10b_12b_444: u32 = unsafe { ::std::mem::transmute(supports_10b_12b_444) }; - supports_10b_12b_444 as u64 - }); - __bindgen_bitfield_unit.set(23usize, 1u8, { - let parity: u32 = unsafe { ::std::mem::transmute(parity) }; - parity as u64 - }); - __bindgen_bitfield_unit.set(24usize, 8u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[repr(C)] -#[repr(align(2))] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDR_CAPABILITIES_V3__bindgen_ty_3 { - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>, -} -impl _NV_HDR_CAPABILITIES_V3__bindgen_ty_3 { - #[inline] - pub fn application_version(&self) -> NvU16 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u16) } - } - #[inline] - pub fn set_application_version(&mut self, val: NvU16) { - unsafe { - let val: u16 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn application_version_raw(this: *const Self) -> NvU16 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 2u8, - ) as u16) - } - } - #[inline] - pub unsafe fn set_application_version_raw(this: *mut Self, val: NvU16) { - unsafe { - let val: u16 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn full_frame_peak_luminance_index(&self) -> NvU16 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 2u8) as u16) } - } - #[inline] - pub fn set_full_frame_peak_luminance_index(&mut self, val: NvU16) { - unsafe { - let val: u16 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn full_frame_peak_luminance_index_raw(this: *const Self) -> NvU16 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 2u8, - ) as u16) - } - } - #[inline] - pub unsafe fn set_full_frame_peak_luminance_index_raw(this: *mut Self, val: NvU16) { - unsafe { - let val: u16 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn peak_luminance_index(&self) -> NvU16 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u16) } - } - #[inline] - pub fn set_peak_luminance_index(&mut self, val: NvU16) { - unsafe { - let val: u16 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 4u8, val as u64) - } - } - #[inline] - pub unsafe fn peak_luminance_index_raw(this: *const Self) -> NvU16 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 4u8, - ) as u16) - } - } - #[inline] - pub unsafe fn set_peak_luminance_index_raw(this: *mut Self, val: NvU16) { - unsafe { - let val: u16 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 4u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU16 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 8u8) as u16) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU16) { - unsafe { - let val: u16 = ::std::mem::transmute(val); - self._bitfield_1.set(8usize, 8u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU16 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 8usize, - 8u8, - ) as u16) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU16) { - unsafe { - let val: u16 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 8usize, - 8u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - application_version: NvU16, - full_frame_peak_luminance_index: NvU16, - peak_luminance_index: NvU16, - reserved: NvU16, - ) -> __BindgenBitfieldUnit<[u8; 2usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 2u8, { - let application_version: u16 = unsafe { ::std::mem::transmute(application_version) }; - application_version as u64 - }); - __bindgen_bitfield_unit.set(2usize, 2u8, { - let full_frame_peak_luminance_index: u16 = - unsafe { ::std::mem::transmute(full_frame_peak_luminance_index) }; - full_frame_peak_luminance_index as u64 - }); - __bindgen_bitfield_unit.set(4usize, 4u8, { - let peak_luminance_index: u16 = unsafe { ::std::mem::transmute(peak_luminance_index) }; - peak_luminance_index as u64 - }); - __bindgen_bitfield_unit.set(8usize, 8u8, { - let reserved: u16 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -impl _NV_HDR_CAPABILITIES_V3 { - #[inline] - pub fn isST2084EotfSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isST2084EotfSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isST2084EotfSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isST2084EotfSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isTraditionalHdrGammaSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_isTraditionalHdrGammaSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isTraditionalHdrGammaSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isTraditionalHdrGammaSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isEdrSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_isEdrSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isEdrSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isEdrSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn driverExpandDefaultHdrParameters(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_driverExpandDefaultHdrParameters(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn driverExpandDefaultHdrParameters_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_driverExpandDefaultHdrParameters_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isTraditionalSdrGammaSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } - } - #[inline] - pub fn set_isTraditionalSdrGammaSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isTraditionalSdrGammaSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isTraditionalSdrGammaSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isDolbyVisionSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } - } - #[inline] - pub fn set_isDolbyVisionSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isDolbyVisionSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isDolbyVisionSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isHdr10PlusSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } - } - #[inline] - pub fn set_isHdr10PlusSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(6usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isHdr10PlusSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 6usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isHdr10PlusSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 6usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isHdr10PlusGamingSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } - } - #[inline] - pub fn set_isHdr10PlusGamingSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(7usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isHdr10PlusGamingSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 7usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isHdr10PlusGamingSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 7usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isNvidiaCertifiedDisplay(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) } - } - #[inline] - pub fn set_isNvidiaCertifiedDisplay(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(8usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isNvidiaCertifiedDisplay_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 8usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isNvidiaCertifiedDisplay_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 8usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 23u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(9usize, 23u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 9usize, - 23u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 9usize, - 23u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isST2084EotfSupported: NvU32, - isTraditionalHdrGammaSupported: NvU32, - isEdrSupported: NvU32, - driverExpandDefaultHdrParameters: NvU32, - isTraditionalSdrGammaSupported: NvU32, - isDolbyVisionSupported: NvU32, - isHdr10PlusSupported: NvU32, - isHdr10PlusGamingSupported: NvU32, - isNvidiaCertifiedDisplay: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isST2084EotfSupported: u32 = - unsafe { ::std::mem::transmute(isST2084EotfSupported) }; - isST2084EotfSupported as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let isTraditionalHdrGammaSupported: u32 = - unsafe { ::std::mem::transmute(isTraditionalHdrGammaSupported) }; - isTraditionalHdrGammaSupported as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let isEdrSupported: u32 = unsafe { ::std::mem::transmute(isEdrSupported) }; - isEdrSupported as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let driverExpandDefaultHdrParameters: u32 = - unsafe { ::std::mem::transmute(driverExpandDefaultHdrParameters) }; - driverExpandDefaultHdrParameters as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let isTraditionalSdrGammaSupported: u32 = - unsafe { ::std::mem::transmute(isTraditionalSdrGammaSupported) }; - isTraditionalSdrGammaSupported as u64 - }); - __bindgen_bitfield_unit.set(5usize, 1u8, { - let isDolbyVisionSupported: u32 = - unsafe { ::std::mem::transmute(isDolbyVisionSupported) }; - isDolbyVisionSupported as u64 - }); - __bindgen_bitfield_unit.set(6usize, 1u8, { - let isHdr10PlusSupported: u32 = unsafe { ::std::mem::transmute(isHdr10PlusSupported) }; - isHdr10PlusSupported as u64 - }); - __bindgen_bitfield_unit.set(7usize, 1u8, { - let isHdr10PlusGamingSupported: u32 = - unsafe { ::std::mem::transmute(isHdr10PlusGamingSupported) }; - isHdr10PlusGamingSupported as u64 - }); - __bindgen_bitfield_unit.set(8usize, 1u8, { - let isNvidiaCertifiedDisplay: u32 = - unsafe { ::std::mem::transmute(isNvidiaCertifiedDisplay) }; - isNvidiaCertifiedDisplay as u64 - }); - __bindgen_bitfield_unit.set(9usize, 23u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_HDR_CAPABILITIES_V3 = _NV_HDR_CAPABILITIES_V3; -pub type NV_HDR_CAPABILITIES = NV_HDR_CAPABILITIES_V3; -#[doc = "!< Get current HDR output configuration"] -pub const NV_HDR_CMD_NV_HDR_CMD_GET: NV_HDR_CMD = 0; -#[doc = "!< Set HDR output configuration"] -pub const NV_HDR_CMD_NV_HDR_CMD_SET: NV_HDR_CMD = 1; -#[doc = "! @}"] -pub type NV_HDR_CMD = ::std::os::raw::c_int; -#[doc = "!< Turn off HDR"] -pub const NV_HDR_MODE_NV_HDR_MODE_OFF: NV_HDR_MODE = 0; -#[doc = "!< Source: CCCS [a.k.a FP16 scRGB, linear, sRGB primaries, [-65504,0, 65504] range, RGB(1,1,1) = 80nits] Output : UHDA HDR [a.k.a HDR10, RGB/YCC 10/12bpc ST2084(PQ) EOTF RGB(1,1,1) = 10000 nits, Rec2020 color primaries, ST2086 static HDR metadata]. This is the only supported production HDR mode."] -pub const NV_HDR_MODE_NV_HDR_MODE_UHDA: NV_HDR_MODE = 2; -#[doc = "!< Experimental mode only, not for production! Source: HDR10 RGB 10bpc Output: HDR10 RGB 10 bpc - signal UHDA HDR mode (PQ + Rec2020) to the sink but send source pixel values unmodified (no PQ or Rec2020 conversions) - assumes source is already in HDR10 format."] -pub const NV_HDR_MODE_NV_HDR_MODE_UHDA_PASSTHROUGH: NV_HDR_MODE = 5; -#[doc = "!< Experimental mode only, not for production! Source: RGB8 Dolby Vision encoded (12 bpc YCbCr422 packed into RGB8) Output: Dolby Vision encoded : Application is to encoded frames in DV format and embed DV dynamic metadata as described in Dolby Vision specification."] -pub const NV_HDR_MODE_NV_HDR_MODE_DOLBY_VISION: NV_HDR_MODE = 7; -#[doc = "!< Do not use! Internal test mode only, to be removed. Source: CCCS (a.k.a FP16 scRGB) Output : EDR (Extended Dynamic Range) - HDR content is tonemapped and gamut mapped to output on regular SDR display set to max luminance ( ~300 nits )."] -pub const NV_HDR_MODE_NV_HDR_MODE_EDR: NV_HDR_MODE = 3; -#[doc = "!< Do not use! Internal test mode only, to be removed. Source: any Output: SDR (Standard Dynamic Range), we continuously send SDR EOTF InfoFrame signaling, HDMI compliance testing."] -pub const NV_HDR_MODE_NV_HDR_MODE_SDR: NV_HDR_MODE = 4; -#[doc = "!< Do not use! Internal test mode only, to be removed. Source: CCCS (a.k.a FP16 scRGB) Output : notebook HDR"] -pub const NV_HDR_MODE_NV_HDR_MODE_UHDA_NB: NV_HDR_MODE = 6; -#[doc = "!< Do not use! Obsolete, to be removed. NV_HDR_MODE_UHDBD == NV_HDR_MODE_UHDA, reflects obsolete pre-UHDA naming convention."] -pub const NV_HDR_MODE_NV_HDR_MODE_UHDBD: NV_HDR_MODE = 2; -pub type NV_HDR_MODE = ::std::os::raw::c_int; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDR_COLOR_DATA_V1 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< Command get/set"] - pub cmd: NV_HDR_CMD, - #[doc = "!< HDR mode"] - pub hdrMode: NV_HDR_MODE, - #[doc = "!< Static Metadata Descriptor Id (0 for static metadata type 1)"] - pub static_metadata_descriptor_id: NV_STATIC_METADATA_DESCRIPTOR_ID, - pub mastering_display_data: _NV_HDR_COLOR_DATA_V1__bindgen_ty_1, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDR_COLOR_DATA_V1__bindgen_ty_1 { - #[doc = "!< x coordinate of color primary 0 (e.g. Red) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x0: NvU16, - #[doc = "!< y coordinate of color primary 0 (e.g. Red) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y0: NvU16, - #[doc = "!< x coordinate of color primary 1 (e.g. Green) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x1: NvU16, - #[doc = "!< y coordinate of color primary 1 (e.g. Green) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y1: NvU16, - #[doc = "!< x coordinate of color primary 2 (e.g. Blue) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x2: NvU16, - #[doc = "!< y coordinate of color primary 2 (e.g. Blue) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y2: NvU16, - #[doc = "!< x coordinate of white point of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayWhitePoint_x: NvU16, - #[doc = "!< y coordinate of white point of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayWhitePoint_y: NvU16, - #[doc = "!< Maximum display mastering luminance ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] - pub max_display_mastering_luminance: NvU16, - #[doc = "!< Minimum display mastering luminance ([0x0001-0xFFFF] = [1.0 - 6.55350] cd/m^2)"] - pub min_display_mastering_luminance: NvU16, - #[doc = "!< Maximum Content Light level (MaxCLL) ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] - pub max_content_light_level: NvU16, - #[doc = "!< Maximum Frame-Average Light Level (MaxFALL) ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] - pub max_frame_average_light_level: NvU16, -} -pub type NV_HDR_COLOR_DATA_V1 = _NV_HDR_COLOR_DATA_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDR_COLOR_DATA_V2 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< Command get/set"] - pub cmd: NV_HDR_CMD, - #[doc = "!< HDR mode"] - pub hdrMode: NV_HDR_MODE, - #[doc = "!< Static Metadata Descriptor Id (0 for static metadata type 1)"] - pub static_metadata_descriptor_id: NV_STATIC_METADATA_DESCRIPTOR_ID, - pub mastering_display_data: _NV_HDR_COLOR_DATA_V2__bindgen_ty_1, - #[doc = "!< Optional, One of NV_COLOR_FORMAT enum values, if set it will apply requested color format for HDR session"] - pub hdrColorFormat: NV_COLOR_FORMAT, - #[doc = "!< Optional, One of NV_DYNAMIC_RANGE enum values, if set it will apply requested dynamic range for HDR session"] - pub hdrDynamicRange: NV_DYNAMIC_RANGE, - #[doc = "!< Optional, One of NV_BPC enum values, if set it will apply requested color depth\n!< Dolby Vision mode: DV supports specific combinations of colorformat, dynamic range and bpc. Please refer Dolby Vision specification.\n!< If invalid or no combination is passed driver will force default combination of RGB format + full range + 8bpc.\n!< HDR mode: These fields are ignored in hdr mode"] - pub hdrBpc: NV_BPC, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDR_COLOR_DATA_V2__bindgen_ty_1 { - #[doc = "!< x coordinate of color primary 0 (e.g. Red) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x0: NvU16, - #[doc = "!< y coordinate of color primary 0 (e.g. Red) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y0: NvU16, - #[doc = "!< x coordinate of color primary 1 (e.g. Green) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x1: NvU16, - #[doc = "!< y coordinate of color primary 1 (e.g. Green) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y1: NvU16, - #[doc = "!< x coordinate of color primary 2 (e.g. Blue) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x2: NvU16, - #[doc = "!< y coordinate of color primary 2 (e.g. Blue) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y2: NvU16, - #[doc = "!< x coordinate of white point of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayWhitePoint_x: NvU16, - #[doc = "!< y coordinate of white point of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayWhitePoint_y: NvU16, - #[doc = "!< Maximum display mastering luminance ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] - pub max_display_mastering_luminance: NvU16, - #[doc = "!< Minimum display mastering luminance ([0x0001-0xFFFF] = [1.0 - 6.55350] cd/m^2)"] - pub min_display_mastering_luminance: NvU16, - #[doc = "!< Maximum Content Light level (MaxCLL) ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] - pub max_content_light_level: NvU16, - #[doc = "!< Maximum Frame-Average Light Level (MaxFALL) ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] - pub max_frame_average_light_level: NvU16, -} -pub type NV_HDR_COLOR_DATA_V2 = _NV_HDR_COLOR_DATA_V2; -pub type NV_HDR_COLOR_DATA = NV_HDR_COLOR_DATA_V2; -#[doc = "!< sRGB IEC 61966-2-1:1999 == DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709"] -pub const _NV_COLORSPACE_TYPE_NV_COLORSPACE_sRGB: _NV_COLORSPACE_TYPE = 0; -#[doc = "!< FP16 linear with sRGB color primaries == DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709"] -pub const _NV_COLORSPACE_TYPE_NV_COLORSPACE_xRGB: _NV_COLORSPACE_TYPE = 1; -#[doc = "!< ITU-R Rec BT.2100 (HDR10) == DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020"] -pub const _NV_COLORSPACE_TYPE_NV_COLORSPACE_REC2100: _NV_COLORSPACE_TYPE = 12; -pub type _NV_COLORSPACE_TYPE = ::std::os::raw::c_int; -pub use self::_NV_COLORSPACE_TYPE as NV_COLORSPACE_TYPE; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDR_METADATA_V1 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< x coordinate of color primary 0 (e.g. Red) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x0: NvU16, - #[doc = "!< y coordinate of color primary 0 (e.g. Red) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y0: NvU16, - #[doc = "!< x coordinate of color primary 1 (e.g. Green) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x1: NvU16, - #[doc = "!< y coordinate of color primary 1 (e.g. Green) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y1: NvU16, - #[doc = "!< x coordinate of color primary 2 (e.g. Blue) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x2: NvU16, - #[doc = "!< y coordinate of color primary 2 (e.g. Blue) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y2: NvU16, - #[doc = "!< x coordinate of white point of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayWhitePoint_x: NvU16, - #[doc = "!< y coordinate of white point of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayWhitePoint_y: NvU16, - #[doc = "!< Maximum display mastering luminance ([0x0000-0xFFFF] = [0.0 - 65535.0] cd/m^2, in units of 1 cd/m^2)"] - pub max_display_mastering_luminance: NvU16, - #[doc = "!< Minimum display mastering luminance ([0x0000-0xFFFF] = [0.0 - 6.55350] cd/m^2, in units of 0.0001 cd/m^2)"] - pub min_display_mastering_luminance: NvU16, - #[doc = "!< Maximum Content Light level (MaxCLL) ([0x0000-0xFFFF] = [0.0 - 65535.0] cd/m^2, in units of 1 cd/m^2)"] - pub max_content_light_level: NvU16, - #[doc = "!< Maximum Frame-Average Light Level (MaxFALL) ([0x0000-0xFFFF] = [0.0 - 65535.0] cd/m^2, in units of 1 cd/m^2)"] - pub max_frame_average_light_level: NvU16, -} -pub type NV_HDR_METADATA_V1 = _NV_HDR_METADATA_V1; -pub type NV_HDR_METADATA = NV_HDR_METADATA_V1; -pub const _NV_DISPLAY_OUTPUT_MODE_NV_DISPLAY_OUTPUT_MODE_SDR: _NV_DISPLAY_OUTPUT_MODE = 0; -pub const _NV_DISPLAY_OUTPUT_MODE_NV_DISPLAY_OUTPUT_MODE_HDR10: _NV_DISPLAY_OUTPUT_MODE = 1; -pub const _NV_DISPLAY_OUTPUT_MODE_NV_DISPLAY_OUTPUT_MODE_HDR10PLUS_GAMING: _NV_DISPLAY_OUTPUT_MODE = - 2; -pub type _NV_DISPLAY_OUTPUT_MODE = ::std::os::raw::c_int; -pub use self::_NV_DISPLAY_OUTPUT_MODE as NV_DISPLAY_OUTPUT_MODE; -pub const _NV_HDR_TONEMAPPING_METHOD_NV_HDR_TONEMAPPING_APP: _NV_HDR_TONEMAPPING_METHOD = 0; -pub const _NV_HDR_TONEMAPPING_METHOD_NV_HDR_TONEMAPPING_GPU: _NV_HDR_TONEMAPPING_METHOD = 1; -pub type _NV_HDR_TONEMAPPING_METHOD = ::std::os::raw::c_int; -pub use self::_NV_HDR_TONEMAPPING_METHOD as NV_HDR_TONEMAPPING_METHOD; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_DISPLAY_COLORIMETRY_V1 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< min luminance, cd/m^2"] - pub min_luminance: f32, - #[doc = "!< max 100% frame luminance, cd/m^2"] - pub max_full_frame_luminance: f32, - #[doc = "!< max 10% frame luminance, cd/m^2"] - pub max_luminance: f32, - #[doc = "!< HDR brightness luminance scaling factor applied by GPU on output pixels"] - pub hdrBrightnessLuminanceScalingFactor: f32, - #[doc = "!< red primary chromaticity coordinate x"] - pub red_primary_x: f32, - #[doc = "!< red primary chromaticity coordinate y"] - pub red_primary_y: f32, - #[doc = "!< green primary chromaticity coordinate x"] - pub green_primary_x: f32, - #[doc = "!< green primary chromaticity coordinate y"] - pub green_primary_y: f32, - #[doc = "!< blue primary chromaticity coordinate x"] - pub blue_primary_x: f32, - #[doc = "!< blue primary chromaticity coordinate y"] - pub blue_primary_y: f32, - #[doc = "!< white point chromaticity coordinate x"] - pub white_point_x: f32, - #[doc = "!< white point chromaticity coordinate y"] - pub white_point_y: f32, -} -pub type NV_DISPLAY_COLORIMETRY_V1 = _NV_DISPLAY_COLORIMETRY_V1; -pub type NV_DISPLAY_COLORIMETRY = NV_DISPLAY_COLORIMETRY_V1; -#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_DISP_GetTiming()."] -#[repr(C)] -#[repr(align(4))] -#[derive(Copy, Clone)] -pub struct NV_TIMING_FLAG { - pub _bitfield_align_1: [u16; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>, - pub __bindgen_anon_1: NV_TIMING_FLAG__bindgen_ty_1, - pub _bitfield_align_2: [u8; 0], - pub _bitfield_2: __BindgenBitfieldUnit<[u8; 1usize]>, - pub __bindgen_padding_0: [u8; 5usize], -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union NV_TIMING_FLAG__bindgen_ty_1 { - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>, -} -impl NV_TIMING_FLAG__bindgen_ty_1 { - #[inline] - pub fn tvFormat(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) } - } - #[inline] - pub fn set_tvFormat(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 8u8, val as u64) - } - } - #[inline] - pub unsafe fn tvFormat_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 8u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_tvFormat_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 8u8, - val as u64, - ) - } - } - #[inline] - pub fn ceaId(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 8u8) as u32) } - } - #[inline] - pub fn set_ceaId(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(8usize, 8u8, val as u64) - } - } - #[inline] - pub unsafe fn ceaId_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 8usize, - 8u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_ceaId_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 8usize, - 8u8, - val as u64, - ) - } - } - #[inline] - pub fn nvPsfId(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 8u8) as u32) } - } - #[inline] - pub fn set_nvPsfId(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(16usize, 8u8, val as u64) - } - } - #[inline] - pub unsafe fn nvPsfId_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 16usize, - 8u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_nvPsfId_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 16usize, - 8u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - tvFormat: NvU32, - ceaId: NvU32, - nvPsfId: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 3usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 8u8, { - let tvFormat: u32 = unsafe { ::std::mem::transmute(tvFormat) }; - tvFormat as u64 - }); - __bindgen_bitfield_unit.set(8usize, 8u8, { - let ceaId: u32 = unsafe { ::std::mem::transmute(ceaId) }; - ceaId as u64 - }); - __bindgen_bitfield_unit.set(16usize, 8u8, { - let nvPsfId: u32 = unsafe { ::std::mem::transmute(nvPsfId) }; - nvPsfId as u64 - }); - __bindgen_bitfield_unit - } -} -impl NV_TIMING_FLAG { - #[inline] - pub fn isInterlaced(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32) } - } - #[inline] - pub fn set_isInterlaced(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 4u8, val as u64) - } - } - #[inline] - pub unsafe fn isInterlaced_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 4u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isInterlaced_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 4u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved0(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 12u8) as u32) } - } - #[inline] - pub fn set_reserved0(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 12u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved0_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 12u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved0_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 12u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isInterlaced: NvU32, - reserved0: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 2usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 4u8, { - let isInterlaced: u32 = unsafe { ::std::mem::transmute(isInterlaced) }; - isInterlaced as u64 - }); - __bindgen_bitfield_unit.set(4usize, 12u8, { - let reserved0: u32 = unsafe { ::std::mem::transmute(reserved0) }; - reserved0 as u64 - }); - __bindgen_bitfield_unit - } - #[inline] - pub fn scaling(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 8u8) as u32) } - } - #[inline] - pub fn set_scaling(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_2.set(0usize, 8u8, val as u64) - } - } - #[inline] - pub unsafe fn scaling_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_2), - 0usize, - 8u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_scaling_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_2), - 0usize, - 8u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_2(scaling: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 8u8, { - let scaling: u32 = unsafe { ::std::mem::transmute(scaling) }; - scaling as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_DISP_GetTiming()."] -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_TIMING_INPUT { - #[doc = "!< (IN) structure version"] - pub version: NvU32, - #[doc = "!< Visible horizontal size"] - pub width: NvU32, - #[doc = "!< Visible vertical size"] - pub height: NvU32, - #[doc = "!< Timing refresh rate"] - pub rr: f32, - #[doc = "!< Flag containing additional info for timing calculation."] - pub flag: NV_TIMING_FLAG, - #[doc = "!< Timing type(formula) to use for calculating the timing"] - pub type_: NV_TIMING_OVERRIDE, -} -#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_DISP_GetTiming()."] -pub type NV_TIMING_INPUT = _NV_TIMING_INPUT; -pub const NV_MONITOR_CAPS_TYPE_NV_MONITOR_CAPS_TYPE_HDMI_VSDB: NV_MONITOR_CAPS_TYPE = 4096; -pub const NV_MONITOR_CAPS_TYPE_NV_MONITOR_CAPS_TYPE_HDMI_VCDB: NV_MONITOR_CAPS_TYPE = 4097; -pub const NV_MONITOR_CAPS_TYPE_NV_MONITOR_CAPS_TYPE_GENERIC: NV_MONITOR_CAPS_TYPE = 4098; -#[doc = "! HDMI-related and extended CAPs"] -pub type NV_MONITOR_CAPS_TYPE = ::std::os::raw::c_int; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MONITOR_CAPS_VCDB { - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, -} -impl _NV_MONITOR_CAPS_VCDB { - #[inline] - pub fn quantizationRangeYcc(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) } - } - #[inline] - pub fn set_quantizationRangeYcc(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn quantizationRangeYcc_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_quantizationRangeYcc_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn quantizationRangeRgb(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) } - } - #[inline] - pub fn set_quantizationRangeRgb(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn quantizationRangeRgb_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_quantizationRangeRgb_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn scanInfoPreferredVideoFormat(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 2u8) as u8) } - } - #[inline] - pub fn set_scanInfoPreferredVideoFormat(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn scanInfoPreferredVideoFormat_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 2u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_scanInfoPreferredVideoFormat_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn scanInfoITVideoFormats(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 2u8) as u8) } - } - #[inline] - pub fn set_scanInfoITVideoFormats(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn scanInfoITVideoFormats_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 2u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_scanInfoITVideoFormats_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn scanInfoCEVideoFormats(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 2u8) as u8) } - } - #[inline] - pub fn set_scanInfoCEVideoFormats(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(6usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn scanInfoCEVideoFormats_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 6usize, - 2u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_scanInfoCEVideoFormats_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 6usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - quantizationRangeYcc: NvU8, - quantizationRangeRgb: NvU8, - scanInfoPreferredVideoFormat: NvU8, - scanInfoITVideoFormats: NvU8, - scanInfoCEVideoFormats: NvU8, - ) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let quantizationRangeYcc: u8 = unsafe { ::std::mem::transmute(quantizationRangeYcc) }; - quantizationRangeYcc as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let quantizationRangeRgb: u8 = unsafe { ::std::mem::transmute(quantizationRangeRgb) }; - quantizationRangeRgb as u64 - }); - __bindgen_bitfield_unit.set(2usize, 2u8, { - let scanInfoPreferredVideoFormat: u8 = - unsafe { ::std::mem::transmute(scanInfoPreferredVideoFormat) }; - scanInfoPreferredVideoFormat as u64 - }); - __bindgen_bitfield_unit.set(4usize, 2u8, { - let scanInfoITVideoFormats: u8 = - unsafe { ::std::mem::transmute(scanInfoITVideoFormats) }; - scanInfoITVideoFormats as u64 - }); - __bindgen_bitfield_unit.set(6usize, 2u8, { - let scanInfoCEVideoFormats: u8 = - unsafe { ::std::mem::transmute(scanInfoCEVideoFormats) }; - scanInfoCEVideoFormats as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_MONITOR_CAPS_VCDB = _NV_MONITOR_CAPS_VCDB; -#[doc = "! See NvAPI_DISP_GetMonitorCapabilities()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MONITOR_CAPS_VSDB { - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>, - #[doc = "!< Bye 4"] - pub maxTmdsClock: NvU8, - pub _bitfield_align_2: [u8; 0], - pub _bitfield_2: __BindgenBitfieldUnit<[u8; 1usize]>, - #[doc = "!< Byte 6"] - pub videoLatency: NvU8, - #[doc = "!< Byte 7"] - pub audioLatency: NvU8, - #[doc = "!< Byte 8"] - pub interlacedVideoLatency: NvU8, - #[doc = "!< Byte 9"] - pub interlacedAudioLatency: NvU8, - pub _bitfield_align_3: [u8; 0], - pub _bitfield_3: __BindgenBitfieldUnit<[u8; 2usize]>, - #[doc = "!< Keeping maximum length for 3 bits"] - pub hdmi_vic: [NvU8; 7usize], - #[doc = "!< Keeping maximum length for 5 bits"] - pub hdmi_3d: [NvU8; 31usize], -} -impl _NV_MONITOR_CAPS_VSDB { - #[inline] - pub fn sourcePhysicalAddressB(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u8) } - } - #[inline] - pub fn set_sourcePhysicalAddressB(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 4u8, val as u64) - } - } - #[inline] - pub unsafe fn sourcePhysicalAddressB_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 4u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_sourcePhysicalAddressB_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 4u8, - val as u64, - ) - } - } - #[inline] - pub fn sourcePhysicalAddressA(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u8) } - } - #[inline] - pub fn set_sourcePhysicalAddressA(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 4u8, val as u64) - } - } - #[inline] - pub unsafe fn sourcePhysicalAddressA_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 4u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_sourcePhysicalAddressA_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 4u8, - val as u64, - ) - } - } - #[inline] - pub fn sourcePhysicalAddressD(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 4u8) as u8) } - } - #[inline] - pub fn set_sourcePhysicalAddressD(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(8usize, 4u8, val as u64) - } - } - #[inline] - pub unsafe fn sourcePhysicalAddressD_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 8usize, - 4u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_sourcePhysicalAddressD_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 8usize, - 4u8, - val as u64, - ) - } - } - #[inline] - pub fn sourcePhysicalAddressC(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 4u8) as u8) } - } - #[inline] - pub fn set_sourcePhysicalAddressC(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(12usize, 4u8, val as u64) - } - } - #[inline] - pub unsafe fn sourcePhysicalAddressC_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 12usize, - 4u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_sourcePhysicalAddressC_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 12usize, - 4u8, - val as u64, - ) - } - } - #[inline] - pub fn supportDualDviOperation(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u8) } - } - #[inline] - pub fn set_supportDualDviOperation(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(16usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supportDualDviOperation_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 16usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_supportDualDviOperation_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 16usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved6(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 2u8) as u8) } - } - #[inline] - pub fn set_reserved6(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(17usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved6_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 17usize, - 2u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_reserved6_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 17usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn supportDeepColorYCbCr444(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u8) } - } - #[inline] - pub fn set_supportDeepColorYCbCr444(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(19usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supportDeepColorYCbCr444_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 19usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_supportDeepColorYCbCr444_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 19usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn supportDeepColor30bits(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u8) } - } - #[inline] - pub fn set_supportDeepColor30bits(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(20usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supportDeepColor30bits_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 20usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_supportDeepColor30bits_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 20usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn supportDeepColor36bits(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u8) } - } - #[inline] - pub fn set_supportDeepColor36bits(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(21usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supportDeepColor36bits_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 21usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_supportDeepColor36bits_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 21usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn supportDeepColor48bits(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u8) } - } - #[inline] - pub fn set_supportDeepColor48bits(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(22usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supportDeepColor48bits_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 22usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_supportDeepColor48bits_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 22usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn supportAI(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u8) } - } - #[inline] - pub fn set_supportAI(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(23usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supportAI_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 23usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_supportAI_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 23usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - sourcePhysicalAddressB: NvU8, - sourcePhysicalAddressA: NvU8, - sourcePhysicalAddressD: NvU8, - sourcePhysicalAddressC: NvU8, - supportDualDviOperation: NvU8, - reserved6: NvU8, - supportDeepColorYCbCr444: NvU8, - supportDeepColor30bits: NvU8, - supportDeepColor36bits: NvU8, - supportDeepColor48bits: NvU8, - supportAI: NvU8, - ) -> __BindgenBitfieldUnit<[u8; 3usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 4u8, { - let sourcePhysicalAddressB: u8 = - unsafe { ::std::mem::transmute(sourcePhysicalAddressB) }; - sourcePhysicalAddressB as u64 - }); - __bindgen_bitfield_unit.set(4usize, 4u8, { - let sourcePhysicalAddressA: u8 = - unsafe { ::std::mem::transmute(sourcePhysicalAddressA) }; - sourcePhysicalAddressA as u64 - }); - __bindgen_bitfield_unit.set(8usize, 4u8, { - let sourcePhysicalAddressD: u8 = - unsafe { ::std::mem::transmute(sourcePhysicalAddressD) }; - sourcePhysicalAddressD as u64 - }); - __bindgen_bitfield_unit.set(12usize, 4u8, { - let sourcePhysicalAddressC: u8 = - unsafe { ::std::mem::transmute(sourcePhysicalAddressC) }; - sourcePhysicalAddressC as u64 - }); - __bindgen_bitfield_unit.set(16usize, 1u8, { - let supportDualDviOperation: u8 = - unsafe { ::std::mem::transmute(supportDualDviOperation) }; - supportDualDviOperation as u64 - }); - __bindgen_bitfield_unit.set(17usize, 2u8, { - let reserved6: u8 = unsafe { ::std::mem::transmute(reserved6) }; - reserved6 as u64 - }); - __bindgen_bitfield_unit.set(19usize, 1u8, { - let supportDeepColorYCbCr444: u8 = - unsafe { ::std::mem::transmute(supportDeepColorYCbCr444) }; - supportDeepColorYCbCr444 as u64 - }); - __bindgen_bitfield_unit.set(20usize, 1u8, { - let supportDeepColor30bits: u8 = - unsafe { ::std::mem::transmute(supportDeepColor30bits) }; - supportDeepColor30bits as u64 - }); - __bindgen_bitfield_unit.set(21usize, 1u8, { - let supportDeepColor36bits: u8 = - unsafe { ::std::mem::transmute(supportDeepColor36bits) }; - supportDeepColor36bits as u64 - }); - __bindgen_bitfield_unit.set(22usize, 1u8, { - let supportDeepColor48bits: u8 = - unsafe { ::std::mem::transmute(supportDeepColor48bits) }; - supportDeepColor48bits as u64 - }); - __bindgen_bitfield_unit.set(23usize, 1u8, { - let supportAI: u8 = unsafe { ::std::mem::transmute(supportAI) }; - supportAI as u64 - }); - __bindgen_bitfield_unit - } - #[inline] - pub fn cnc0SupportGraphicsTextContent(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 1u8) as u8) } - } - #[inline] - pub fn set_cnc0SupportGraphicsTextContent(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_2.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn cnc0SupportGraphicsTextContent_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_2), - 0usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_cnc0SupportGraphicsTextContent_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_2), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn cnc1SupportPhotoContent(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_2.get(1usize, 1u8) as u8) } - } - #[inline] - pub fn set_cnc1SupportPhotoContent(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_2.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn cnc1SupportPhotoContent_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_2), - 1usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_cnc1SupportPhotoContent_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_2), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn cnc2SupportCinemaContent(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_2.get(2usize, 1u8) as u8) } - } - #[inline] - pub fn set_cnc2SupportCinemaContent(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_2.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn cnc2SupportCinemaContent_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_2), - 2usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_cnc2SupportCinemaContent_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_2), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn cnc3SupportGameContent(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_2.get(3usize, 1u8) as u8) } - } - #[inline] - pub fn set_cnc3SupportGameContent(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_2.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn cnc3SupportGameContent_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_2), - 3usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_cnc3SupportGameContent_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_2), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved8(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_2.get(4usize, 1u8) as u8) } - } - #[inline] - pub fn set_reserved8(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_2.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved8_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_2), - 4usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_reserved8_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_2), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn hasVicEntries(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_2.get(5usize, 1u8) as u8) } - } - #[inline] - pub fn set_hasVicEntries(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_2.set(5usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn hasVicEntries_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_2), - 5usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_hasVicEntries_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_2), - 5usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn hasInterlacedLatencyField(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_2.get(6usize, 1u8) as u8) } - } - #[inline] - pub fn set_hasInterlacedLatencyField(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_2.set(6usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn hasInterlacedLatencyField_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_2), - 6usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_hasInterlacedLatencyField_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_2), - 6usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn hasLatencyField(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_2.get(7usize, 1u8) as u8) } - } - #[inline] - pub fn set_hasLatencyField(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_2.set(7usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn hasLatencyField_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_2), - 7usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_hasLatencyField_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_2), - 7usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_2( - cnc0SupportGraphicsTextContent: NvU8, - cnc1SupportPhotoContent: NvU8, - cnc2SupportCinemaContent: NvU8, - cnc3SupportGameContent: NvU8, - reserved8: NvU8, - hasVicEntries: NvU8, - hasInterlacedLatencyField: NvU8, - hasLatencyField: NvU8, - ) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let cnc0SupportGraphicsTextContent: u8 = - unsafe { ::std::mem::transmute(cnc0SupportGraphicsTextContent) }; - cnc0SupportGraphicsTextContent as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let cnc1SupportPhotoContent: u8 = - unsafe { ::std::mem::transmute(cnc1SupportPhotoContent) }; - cnc1SupportPhotoContent as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let cnc2SupportCinemaContent: u8 = - unsafe { ::std::mem::transmute(cnc2SupportCinemaContent) }; - cnc2SupportCinemaContent as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let cnc3SupportGameContent: u8 = - unsafe { ::std::mem::transmute(cnc3SupportGameContent) }; - cnc3SupportGameContent as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let reserved8: u8 = unsafe { ::std::mem::transmute(reserved8) }; - reserved8 as u64 - }); - __bindgen_bitfield_unit.set(5usize, 1u8, { - let hasVicEntries: u8 = unsafe { ::std::mem::transmute(hasVicEntries) }; - hasVicEntries as u64 - }); - __bindgen_bitfield_unit.set(6usize, 1u8, { - let hasInterlacedLatencyField: u8 = - unsafe { ::std::mem::transmute(hasInterlacedLatencyField) }; - hasInterlacedLatencyField as u64 - }); - __bindgen_bitfield_unit.set(7usize, 1u8, { - let hasLatencyField: u8 = unsafe { ::std::mem::transmute(hasLatencyField) }; - hasLatencyField as u64 - }); - __bindgen_bitfield_unit - } - #[inline] - pub fn reserved13(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_3.get(0usize, 7u8) as u8) } - } - #[inline] - pub fn set_reserved13(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_3.set(0usize, 7u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved13_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_3), - 0usize, - 7u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_reserved13_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_3), - 0usize, - 7u8, - val as u64, - ) - } - } - #[inline] - pub fn has3dEntries(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_3.get(7usize, 1u8) as u8) } - } - #[inline] - pub fn set_has3dEntries(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_3.set(7usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn has3dEntries_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_3), - 7usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_has3dEntries_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_3), - 7usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn hdmi3dLength(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_3.get(8usize, 5u8) as u8) } - } - #[inline] - pub fn set_hdmi3dLength(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_3.set(8usize, 5u8, val as u64) - } - } - #[inline] - pub unsafe fn hdmi3dLength_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_3), - 8usize, - 5u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_hdmi3dLength_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_3), - 8usize, - 5u8, - val as u64, - ) - } - } - #[inline] - pub fn hdmiVicLength(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_3.get(13usize, 3u8) as u8) } - } - #[inline] - pub fn set_hdmiVicLength(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_3.set(13usize, 3u8, val as u64) - } - } - #[inline] - pub unsafe fn hdmiVicLength_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_3), - 13usize, - 3u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_hdmiVicLength_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_3), - 13usize, - 3u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_3( - reserved13: NvU8, - has3dEntries: NvU8, - hdmi3dLength: NvU8, - hdmiVicLength: NvU8, - ) -> __BindgenBitfieldUnit<[u8; 2usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 7u8, { - let reserved13: u8 = unsafe { ::std::mem::transmute(reserved13) }; - reserved13 as u64 - }); - __bindgen_bitfield_unit.set(7usize, 1u8, { - let has3dEntries: u8 = unsafe { ::std::mem::transmute(has3dEntries) }; - has3dEntries as u64 - }); - __bindgen_bitfield_unit.set(8usize, 5u8, { - let hdmi3dLength: u8 = unsafe { ::std::mem::transmute(hdmi3dLength) }; - hdmi3dLength as u64 - }); - __bindgen_bitfield_unit.set(13usize, 3u8, { - let hdmiVicLength: u8 = unsafe { ::std::mem::transmute(hdmiVicLength) }; - hdmiVicLength as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! See NvAPI_DISP_GetMonitorCapabilities()."] -pub type NV_MONITOR_CAPS_VSDB = _NV_MONITOR_CAPS_VSDB; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MONITOR_CAPS_GENERIC { - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, -} -impl _NV_MONITOR_CAPS_GENERIC { - #[inline] - pub fn supportVRR(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) } - } - #[inline] - pub fn set_supportVRR(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supportVRR_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_supportVRR_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn supportULMB(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) } - } - #[inline] - pub fn set_supportULMB(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supportULMB_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_supportULMB_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isTrueGsync(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) } - } - #[inline] - pub fn set_isTrueGsync(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isTrueGsync_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_isTrueGsync_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isRLACapable(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) } - } - #[inline] - pub fn set_isRLACapable(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isRLACapable_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_isRLACapable_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn currentlyCapableOfVRR(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) } - } - #[inline] - pub fn set_currentlyCapableOfVRR(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn currentlyCapableOfVRR_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_currentlyCapableOfVRR_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isBasicVRR(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) } - } - #[inline] - pub fn set_isBasicVRR(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isBasicVRR_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_isBasicVRR_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 2u8) as u8) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(6usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 6usize, - 2u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 6usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - supportVRR: NvU8, - supportULMB: NvU8, - isTrueGsync: NvU8, - isRLACapable: NvU8, - currentlyCapableOfVRR: NvU8, - isBasicVRR: NvU8, - reserved: NvU8, - ) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let supportVRR: u8 = unsafe { ::std::mem::transmute(supportVRR) }; - supportVRR as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let supportULMB: u8 = unsafe { ::std::mem::transmute(supportULMB) }; - supportULMB as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let isTrueGsync: u8 = unsafe { ::std::mem::transmute(isTrueGsync) }; - isTrueGsync as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let isRLACapable: u8 = unsafe { ::std::mem::transmute(isRLACapable) }; - isRLACapable as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let currentlyCapableOfVRR: u8 = unsafe { ::std::mem::transmute(currentlyCapableOfVRR) }; - currentlyCapableOfVRR as u64 - }); - __bindgen_bitfield_unit.set(5usize, 1u8, { - let isBasicVRR: u8 = unsafe { ::std::mem::transmute(isBasicVRR) }; - isBasicVRR as u64 - }); - __bindgen_bitfield_unit.set(6usize, 2u8, { - let reserved: u8 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_MONITOR_CAPS_GENERIC = _NV_MONITOR_CAPS_GENERIC; -#[doc = "! See NvAPI_DISP_GetMonitorCapabilities()."] -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_MONITOR_CAPABILITIES_V1 { - pub version: NvU32, - pub size: NvU16, - pub infoType: NvU32, - #[doc = "!< Out: VGA, TV, DVI, HDMI, DP"] - pub connectorType: NvU32, - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, - pub data: _NV_MONITOR_CAPABILITIES_V1__bindgen_ty_1, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union _NV_MONITOR_CAPABILITIES_V1__bindgen_ty_1 { - pub vsdb: NV_MONITOR_CAPS_VSDB, - pub vcdb: NV_MONITOR_CAPS_VCDB, - pub caps: NV_MONITOR_CAPS_GENERIC, -} -impl _NV_MONITOR_CAPABILITIES_V1 { - #[inline] - pub fn bIsValidInfo(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) } - } - #[inline] - pub fn set_bIsValidInfo(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsValidInfo_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_bIsValidInfo_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1(bIsValidInfo: NvU8) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsValidInfo: u8 = unsafe { ::std::mem::transmute(bIsValidInfo) }; - bIsValidInfo as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! See NvAPI_DISP_GetMonitorCapabilities()."] -pub type NV_MONITOR_CAPABILITIES_V1 = _NV_MONITOR_CAPABILITIES_V1; -#[doc = "! See NvAPI_DISP_GetMonitorCapabilities()."] -pub type NV_MONITOR_CAPABILITIES = NV_MONITOR_CAPABILITIES_V1; -#[doc = "! \\ingroup dispcontrol"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MONITOR_COLOR_DATA { - pub version: NvU32, - #[doc = "!< One of the supported color formats"] - pub colorFormat: NV_DP_COLOR_FORMAT, - #[doc = "!< One of the supported bit depths"] - pub backendBitDepths: NV_DP_BPC, -} -#[doc = "! \\ingroup dispcontrol"] -pub type NV_MONITOR_COLOR_CAPS_V1 = _NV_MONITOR_COLOR_DATA; -#[doc = "! \\ingroup dispcontrol"] -pub type NV_MONITOR_COLOR_CAPS = NV_MONITOR_COLOR_CAPS_V1; -#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_DISP_EnumCustomDisplay() and NvAPI_DISP_TryCustomDisplay()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_CUSTOM_DISPLAY { - pub version: NvU32, - #[doc = "!< Source surface(source mode) width"] - pub width: NvU32, - #[doc = "!< Source surface(source mode) height"] - pub height: NvU32, - #[doc = "!< Source surface color depth.\"0\" means all 8/16/32bpp"] - pub depth: NvU32, - #[doc = "!< Color format (optional)"] - pub colorFormat: NV_FORMAT, - #[doc = "!< For multimon support, should be set to (0,0,1.0,1.0) for now."] - pub srcPartition: NV_VIEWPORTF, - #[doc = "!< Horizontal scaling ratio"] - pub xRatio: f32, - #[doc = "!< Vertical scaling ratio"] - pub yRatio: f32, - #[doc = "!< Timing used to program TMDS/DAC/LVDS/HDMI/TVEncoder, etc."] - pub timing: NV_TIMING, - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, - pub __bindgen_padding_0: [u8; 3usize], -} -impl NV_CUSTOM_DISPLAY { - #[inline] - pub fn hwModeSetOnly(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_hwModeSetOnly(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn hwModeSetOnly_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_hwModeSetOnly_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1(hwModeSetOnly: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let hwModeSetOnly: u32 = unsafe { ::std::mem::transmute(hwModeSetOnly) }; - hwModeSetOnly as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! \\ingroup dispcontrol\n! @{"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_EDID_DATA_V1 { - #[doc = "!< Structure version."] - pub version: NvU32, - #[doc = "!< Pointer to EDID data."] - pub pEDID: *mut NvU8, - #[doc = "!< Size of EDID data."] - pub sizeOfEDID: NvU32, -} -#[doc = "! \\ingroup dispcontrol\n! @{"] -pub type NV_EDID_DATA_V1 = _NV_EDID_DATA_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_EDID_DATA_V2 { - #[doc = "!< Structure version."] - pub version: NvU32, - #[doc = "!< Pointer to EDID data."] - pub pEDID: *mut NvU8, - #[doc = "!< Size of EDID data."] - pub sizeOfEDID: NvU32, - #[doc = "!< Reserved for future use."] - pub reserved: [NvU32; 8usize], -} -pub type NV_EDID_DATA_V2 = _NV_EDID_DATA_V2; -pub type NV_EDID_DATA = NV_EDID_DATA_V2; -#[doc = "! @}"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GET_ADAPTIVE_SYNC_DATA_V1 { - #[doc = "!< [in] structure version"] - pub version: NvU32, - #[doc = "!< [out] maximum frame interval in micro seconds as set previously using NvAPI_DISP_SetAdaptiveSyncData function."] - pub maxFrameInterval: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< [out] Number of times the last flip was shown on the screen"] - pub lastFlipRefreshCount: NvU32, - #[doc = "!< [out] Timestamp for the lastest flip on the screen"] - pub lastFlipTimeStamp: NvU64, - #[doc = "!< reserved for future use."] - pub reservedEx: [NvU32; 4usize], -} -impl _NV_GET_ADAPTIVE_SYNC_DATA_V1 { - #[inline] - pub fn bDisableAdaptiveSync(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bDisableAdaptiveSync(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bDisableAdaptiveSync_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bDisableAdaptiveSync_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bDisableFrameSplitting(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_bDisableFrameSplitting(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bDisableFrameSplitting_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bDisableFrameSplitting_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 30u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 30u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 30u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bDisableAdaptiveSync: NvU32, - bDisableFrameSplitting: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bDisableAdaptiveSync: u32 = unsafe { ::std::mem::transmute(bDisableAdaptiveSync) }; - bDisableAdaptiveSync as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let bDisableFrameSplitting: u32 = - unsafe { ::std::mem::transmute(bDisableFrameSplitting) }; - bDisableFrameSplitting as u64 - }); - __bindgen_bitfield_unit.set(2usize, 30u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! @}"] -pub type NV_GET_ADAPTIVE_SYNC_DATA_V1 = _NV_GET_ADAPTIVE_SYNC_DATA_V1; -#[doc = "! @}"] -pub type NV_GET_ADAPTIVE_SYNC_DATA = NV_GET_ADAPTIVE_SYNC_DATA_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_SET_ADAPTIVE_SYNC_DATA_V1 { - #[doc = "!< [in] structure version"] - pub version: NvU32, - #[doc = "!< [in] deprecated, please use maxFrameIntervalNs instead\n!< If maxFrameInterval is sent as 0, default values from EDID will be used."] - pub maxFrameInterval: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Ensure the alignment is 8 bytes and reserve it for future use."] - pub reserved1: NvU32, - #[doc = "!< [in] maximum frame interval in nano seconds.\n!< If maxFrameIntervalNs is sent as 0, default values from EDID will be used."] - pub maxFrameIntervalNs: NvU64, - #[doc = "!< reserved for future use."] - pub reservedEx: [NvU32; 4usize], -} -impl _NV_SET_ADAPTIVE_SYNC_DATA_V1 { - #[inline] - pub fn bDisableAdaptiveSync(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bDisableAdaptiveSync(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bDisableAdaptiveSync_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bDisableAdaptiveSync_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bDisableFrameSplitting(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_bDisableFrameSplitting(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bDisableFrameSplitting_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bDisableFrameSplitting_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 30u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 30u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 30u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bDisableAdaptiveSync: NvU32, - bDisableFrameSplitting: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bDisableAdaptiveSync: u32 = unsafe { ::std::mem::transmute(bDisableAdaptiveSync) }; - bDisableAdaptiveSync as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let bDisableFrameSplitting: u32 = - unsafe { ::std::mem::transmute(bDisableFrameSplitting) }; - bDisableFrameSplitting as u64 - }); - __bindgen_bitfield_unit.set(2usize, 30u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_SET_ADAPTIVE_SYNC_DATA_V1 = _NV_SET_ADAPTIVE_SYNC_DATA_V1; -pub type NV_SET_ADAPTIVE_SYNC_DATA = NV_SET_ADAPTIVE_SYNC_DATA_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GET_VIRTUAL_REFRESH_RATE_DATA_V1 { - #[doc = "!< [in] structure version"] - pub version: NvU32, - #[doc = "!< [out] frame interval in micro seconds if Virtual RR is currently applied"] - pub frameIntervalUs: NvU32, - #[doc = "!< [out] Refresh Rate * 1000"] - pub rrx1k: NvU32, - #[doc = "!< [out] If the content is Gaming"] - pub bIsGamingVrr: NvU32, - #[doc = "!< reserved for future use."] - pub reservedEx: [NvU32; 6usize], -} -pub type NV_GET_VIRTUAL_REFRESH_RATE_DATA_V1 = _NV_GET_VIRTUAL_REFRESH_RATE_DATA_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GET_VIRTUAL_REFRESH_RATE_DATA_V2 { - #[doc = "!< [in] structure version"] - pub version: NvU32, - #[doc = "!< [out] frame interval in micro seconds if Virtual RR is currently applied. This variable is deprecated in V2 and should not be used."] - pub frameIntervalUs: NvU32, - #[doc = "!< [out] Refresh Rate * 1000"] - pub rrx1k: NvU32, - #[doc = "!< [out] If the content is Gaming"] - pub bIsGamingVrr: NvU32, - #[doc = "!< [out] frame interval in nano seconds if Virtual RR is currently applied"] - pub frameIntervalNs: NvU64, - #[doc = "!< reserved for future use."] - pub reservedEx: [NvU32; 4usize], -} -pub type NV_GET_VIRTUAL_REFRESH_RATE_DATA_V2 = _NV_GET_VIRTUAL_REFRESH_RATE_DATA_V2; -pub type NV_GET_VIRTUAL_REFRESH_RATE_DATA = NV_GET_VIRTUAL_REFRESH_RATE_DATA_V2; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_SET_VIRTUAL_REFRESH_RATE_DATA_V1 { - #[doc = "!< [in] structure version"] - pub version: NvU32, - #[doc = "!< [in] frame interval in micro seconds if Virtual RR is currently applied"] - pub frameIntervalUs: NvU32, - #[doc = "!< [in] Refresh Rate * 1000"] - pub rrx1k: NvU32, - #[doc = "!< [in] If the content is Gaming"] - pub bIsGamingVrr: NvU32, - #[doc = "!< reserved for future use."] - pub reservedEx: [NvU32; 6usize], -} -pub type NV_SET_VIRTUAL_REFRESH_RATE_DATA_V1 = _NV_SET_VIRTUAL_REFRESH_RATE_DATA_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_SET_VIRTUAL_REFRESH_RATE_DATA_V2 { - #[doc = "!< [in] structure version"] - pub version: NvU32, - #[doc = "!< [in] frame interval in micro seconds if Virtual RR is currently applied. This variable is deprecated in V2 and should not be used."] - pub frameIntervalUs: NvU32, - #[doc = "!< [in] Refresh Rate * 1000"] - pub rrx1k: NvU32, - #[doc = "!< [in] If the content is Gaming"] - pub bIsGamingVrr: NvU32, - #[doc = "!< [in] frame interval in nano seconds if Virtual RR is currently applied"] - pub frameIntervalNs: NvU64, - #[doc = "!< reserved for future use."] - pub reservedEx: [NvU32; 4usize], -} -pub type NV_SET_VIRTUAL_REFRESH_RATE_DATA_V2 = _NV_SET_VIRTUAL_REFRESH_RATE_DATA_V2; -pub type NV_SET_VIRTUAL_REFRESH_RATE_DATA = NV_SET_VIRTUAL_REFRESH_RATE_DATA_V2; -#[doc = "! \\ingroup dispcontrol"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_SET_PREFERRED_STEREO_DISPLAY_V1 { - #[doc = "!< [in] Structure version"] - pub version: NvU32, - #[doc = "!< [in] Monitor Identifier to be set"] - pub displayId: NvU32, - #[doc = "!< Reserved for future use without adding versioning"] - pub reserved: NvU32, -} -#[doc = "! \\ingroup dispcontrol"] -pub type NV_SET_PREFERRED_STEREO_DISPLAY = NV_SET_PREFERRED_STEREO_DISPLAY_V1; -#[doc = "! \\ingroup dispcontrol"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GET_PREFERRED_STEREO_DISPLAY_V1 { - #[doc = "!< [in] Structure version"] - pub version: NvU32, - #[doc = "!< [out] The queried stereo display"] - pub displayId: NvU32, - #[doc = "!< Reserved for future use without adding versioning"] - pub reserved: NvU32, -} -#[doc = "! \\ingroup dispcontrol"] -pub type NV_GET_PREFERRED_STEREO_DISPLAY = NV_GET_PREFERRED_STEREO_DISPLAY_V1; -#[doc = "! \\ingroup dispcontrol"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_DISPLAY_ID_INFO_DATA_V1 { - #[doc = "!< [in] Structure version"] - pub version: NvU32, - #[doc = "!< [out] Locally unique ID (LUID) of the display adapter on which the given display is present."] - pub adapterId: LUID, - #[doc = "!< [out] The target identifier of the given display. This is also called AdapterRelativeId."] - pub targetId: NvU32, - #[doc = "!< Reserved for future use."] - pub reserved: [NvU32; 4usize], -} -#[doc = "! \\ingroup dispcontrol"] -pub type NV_DISPLAY_ID_INFO_DATA_V1 = _NV_DISPLAY_ID_INFO_DATA_V1; -#[doc = "! \\ingroup dispcontrol"] -pub type NV_DISPLAY_ID_INFO_DATA = NV_DISPLAY_ID_INFO_DATA_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_TARGET_INFO_DATA_V1 { - #[doc = "!< [in] Structure version"] - pub version: NvU32, - #[doc = "!< [in] Locally unique ID (LUID) of the display adapter on which the target is present."] - pub adapterId: LUID, - #[doc = "!< [in] The target identifier. This is also called AdapterRelativeId."] - pub targetId: NvU32, - #[doc = "!< [out] An array of displayIds corresponding to the input adapterId and targetId.\n!< If the input (targetId, adapterId) pair is a display grid (Mosaic/Surround),\n!< then the output contains the displayId of every display that is part of the display grid.\n!< Otherwise, it contains exactly one displayId.\n!< These displayId values are unique to this (targetId, adapterId) pair."] - pub displayId: [NvU32; 128usize], - #[doc = "!< [out] The number of displays returned in displayId array."] - pub displayIdCount: NvU32, - #[doc = "!< Reserved for future use."] - pub reserved: [NvU32; 4usize], -} -pub type NV_TARGET_INFO_DATA_V1 = _NV_TARGET_INFO_DATA_V1; -pub type NV_TARGET_INFO_DATA = NV_TARGET_INFO_DATA_V1; -#[doc = "! \\ingroup dispcontrol"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GET_VRR_INFO_V1 { - #[doc = "!< [in] Structure version"] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Reserved for future use"] - pub reservedEx: [NvU32; 4usize], -} -impl _NV_GET_VRR_INFO_V1 { - #[inline] - pub fn bIsVRREnabled(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsVRREnabled(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsVRREnabled_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsVRREnabled_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bIsVRRPossible(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsVRRPossible(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsVRRPossible_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsVRRPossible_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bIsVRRRequested(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsVRRRequested(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsVRRRequested_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsVRRRequested_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bIsVRRIndicatorEnabled(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsVRRIndicatorEnabled(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsVRRIndicatorEnabled_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsVRRIndicatorEnabled_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bIsDisplayInVRRMode(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsDisplayInVRRMode(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsDisplayInVRRMode_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsDisplayInVRRMode_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 27u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 27u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 27u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bIsVRREnabled: NvU32, - bIsVRRPossible: NvU32, - bIsVRRRequested: NvU32, - bIsVRRIndicatorEnabled: NvU32, - bIsDisplayInVRRMode: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsVRREnabled: u32 = unsafe { ::std::mem::transmute(bIsVRREnabled) }; - bIsVRREnabled as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let bIsVRRPossible: u32 = unsafe { ::std::mem::transmute(bIsVRRPossible) }; - bIsVRRPossible as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let bIsVRRRequested: u32 = unsafe { ::std::mem::transmute(bIsVRRRequested) }; - bIsVRRRequested as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let bIsVRRIndicatorEnabled: u32 = - unsafe { ::std::mem::transmute(bIsVRRIndicatorEnabled) }; - bIsVRRIndicatorEnabled as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let bIsDisplayInVRRMode: u32 = unsafe { ::std::mem::transmute(bIsDisplayInVRRMode) }; - bIsDisplayInVRRMode as u64 - }); - __bindgen_bitfield_unit.set(5usize, 27u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! \\ingroup dispcontrol"] -pub type NV_GET_VRR_INFO_V1 = _NV_GET_VRR_INFO_V1; -#[doc = "! \\ingroup dispcontrol"] -pub type NV_GET_VRR_INFO = NV_GET_VRR_INFO_V1; -#[doc = "! This structure defines the topology details."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_MOSAIC_TOPO_DETAILS { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< Logical GPU for this topology"] - pub hLogicalGPU: NvLogicalGpuHandle, - #[doc = "!< 0 means topology is valid with the current hardware."] - pub validityMask: NvU32, - #[doc = "!< Number of displays in a row"] - pub rowCount: NvU32, - #[doc = "!< Number of displays in a column"] - pub colCount: NvU32, - pub gpuLayout: [[NV_MOSAIC_TOPO_DETAILS__bindgen_ty_1; 8usize]; 8usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_MOSAIC_TOPO_DETAILS__bindgen_ty_1 { - #[doc = "!< Physical GPU to be used in the topology (0 if GPU missing)"] - pub hPhysicalGPU: NvPhysicalGpuHandle, - #[doc = "!< Connected display target (0 if no display connected)"] - pub displayOutputId: NvU32, - #[doc = "!< Pixels of overlap on left of target: (+overlap, -gap)"] - pub overlapX: NvS32, - #[doc = "!< Pixels of overlap on top of target: (+overlap, -gap)"] - pub overlapY: NvS32, -} -#[doc = "!< All mosaic topologies"] -pub const NV_MOSAIC_TOPO_TYPE_NV_MOSAIC_TOPO_TYPE_ALL: NV_MOSAIC_TOPO_TYPE = 0; -#[doc = "!< Basic Mosaic topologies"] -pub const NV_MOSAIC_TOPO_TYPE_NV_MOSAIC_TOPO_TYPE_BASIC: NV_MOSAIC_TOPO_TYPE = 1; -#[doc = "!< Passive Stereo topologies"] -pub const NV_MOSAIC_TOPO_TYPE_NV_MOSAIC_TOPO_TYPE_PASSIVE_STEREO: NV_MOSAIC_TOPO_TYPE = 2; -#[doc = "!< Not supported at this time"] -pub const NV_MOSAIC_TOPO_TYPE_NV_MOSAIC_TOPO_TYPE_SCALED_CLONE: NV_MOSAIC_TOPO_TYPE = 3; -#[doc = "!< Not supported at this time"] -pub const NV_MOSAIC_TOPO_TYPE_NV_MOSAIC_TOPO_TYPE_PASSIVE_STEREO_SCALED_CLONE: NV_MOSAIC_TOPO_TYPE = - 4; -#[doc = "!< Always leave this at end of the enum"] -pub const NV_MOSAIC_TOPO_TYPE_NV_MOSAIC_TOPO_TYPE_MAX: NV_MOSAIC_TOPO_TYPE = 5; -#[doc = "! These values refer to the different types of Mosaic topologies that are possible. When\n! getting the supported Mosaic topologies, you can specify one of these types to narrow down\n! the returned list to only those that match the given type."] -pub type NV_MOSAIC_TOPO_TYPE = ::std::os::raw::c_int; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_NONE: NV_MOSAIC_TOPO = 0; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_BEGIN_BASIC: NV_MOSAIC_TOPO = 1; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x2_BASIC: NV_MOSAIC_TOPO = 1; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_2x1_BASIC: NV_MOSAIC_TOPO = 2; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x3_BASIC: NV_MOSAIC_TOPO = 3; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_3x1_BASIC: NV_MOSAIC_TOPO = 4; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x4_BASIC: NV_MOSAIC_TOPO = 5; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_4x1_BASIC: NV_MOSAIC_TOPO = 6; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_2x2_BASIC: NV_MOSAIC_TOPO = 7; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_2x3_BASIC: NV_MOSAIC_TOPO = 8; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_2x4_BASIC: NV_MOSAIC_TOPO = 9; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_3x2_BASIC: NV_MOSAIC_TOPO = 10; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_4x2_BASIC: NV_MOSAIC_TOPO = 11; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x5_BASIC: NV_MOSAIC_TOPO = 12; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x6_BASIC: NV_MOSAIC_TOPO = 13; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_7x1_BASIC: NV_MOSAIC_TOPO = 14; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_END_BASIC: NV_MOSAIC_TOPO = 23; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_BEGIN_PASSIVE_STEREO: NV_MOSAIC_TOPO = 24; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x2_PASSIVE_STEREO: NV_MOSAIC_TOPO = 24; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_2x1_PASSIVE_STEREO: NV_MOSAIC_TOPO = 25; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x3_PASSIVE_STEREO: NV_MOSAIC_TOPO = 26; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_3x1_PASSIVE_STEREO: NV_MOSAIC_TOPO = 27; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x4_PASSIVE_STEREO: NV_MOSAIC_TOPO = 28; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_4x1_PASSIVE_STEREO: NV_MOSAIC_TOPO = 29; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_2x2_PASSIVE_STEREO: NV_MOSAIC_TOPO = 30; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_END_PASSIVE_STEREO: NV_MOSAIC_TOPO = 34; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_MAX: NV_MOSAIC_TOPO = 35; -#[doc = "! This is a complete list of supported Mosaic topologies.\n!\n! Using a \"Basic\" topology combines multiple monitors to create a single desktop.\n!\n! Using a \"Passive\" topology combines multiples monitors to create a passive stereo desktop.\n! In passive stereo, two identical topologies combine - one topology is used for the right eye and the other identical //! topology (targeting different displays) is used for the left eye. \\n\n! NOTE: common\\inc\\nvEscDef.h shadows a couple PASSIVE_STEREO enums. If this\n! enum list changes and effects the value of NV_MOSAIC_TOPO_BEGIN_PASSIVE_STEREO\n! please update the corresponding value in nvEscDef.h"] -pub type NV_MOSAIC_TOPO = ::std::os::raw::c_int; -#[doc = "! This is a \"topology brief\" structure. It tells you what you need to know about\n! a topology at a high level. A list of these is returned when you query for the\n! supported Mosaic information.\n!\n! If you need more detailed information about the topology, call\n! NvAPI_Mosaic_GetTopoGroup() with the topology value from this structure."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_MOSAIC_TOPO_BRIEF { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< The topology"] - pub topo: NV_MOSAIC_TOPO, - #[doc = "!< 1 if topo is enabled, else 0"] - pub enabled: NvU32, - #[doc = "!< 1 if topo *can* be enabled, else 0"] - pub isPossible: NvU32, -} -#[doc = "! Basic per-display settings that are used in setting/getting the Mosaic mode"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MOSAIC_DISPLAY_SETTING_V1 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< Per-display width"] - pub width: NvU32, - #[doc = "!< Per-display height"] - pub height: NvU32, - #[doc = "!< Bits per pixel"] - pub bpp: NvU32, - #[doc = "!< Display frequency"] - pub freq: NvU32, -} -#[doc = "! Basic per-display settings that are used in setting/getting the Mosaic mode"] -pub type NV_MOSAIC_DISPLAY_SETTING_V1 = _NV_MOSAIC_DISPLAY_SETTING_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_MOSAIC_DISPLAY_SETTING_V2 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< Per-display width"] - pub width: NvU32, - #[doc = "!< Per-display height"] - pub height: NvU32, - #[doc = "!< Bits per pixel"] - pub bpp: NvU32, - #[doc = "!< Display frequency"] - pub freq: NvU32, - #[doc = "!< Display frequency in x1k"] - pub rrx1k: NvU32, -} -pub type NV_MOSAIC_DISPLAY_SETTING = NV_MOSAIC_DISPLAY_SETTING_V2; -#[doc = "! This structure is used to contain a list of supported Mosaic topologies\n! along with the display settings that can be used."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MOSAIC_SUPPORTED_TOPO_INFO_V1 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< Number of topologies in below array"] - pub topoBriefsCount: NvU32, - #[doc = "!< List of supported topologies with only brief details"] - pub topoBriefs: [NV_MOSAIC_TOPO_BRIEF; 35usize], - #[doc = "!< Number of display settings in below array"] - pub displaySettingsCount: NvU32, - #[doc = "!< List of per display settings possible"] - pub displaySettings: [NV_MOSAIC_DISPLAY_SETTING_V1; 40usize], -} -#[doc = "! This structure is used to contain a list of supported Mosaic topologies\n! along with the display settings that can be used."] -pub type NV_MOSAIC_SUPPORTED_TOPO_INFO_V1 = _NV_MOSAIC_SUPPORTED_TOPO_INFO_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MOSAIC_SUPPORTED_TOPO_INFO_V2 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< Number of topologies in below array"] - pub topoBriefsCount: NvU32, - #[doc = "!< List of supported topologies with only brief details"] - pub topoBriefs: [NV_MOSAIC_TOPO_BRIEF; 35usize], - #[doc = "!< Number of display settings in below array"] - pub displaySettingsCount: NvU32, - #[doc = "!< List of per display settings possible"] - pub displaySettings: [NV_MOSAIC_DISPLAY_SETTING_V2; 40usize], -} -pub type NV_MOSAIC_SUPPORTED_TOPO_INFO_V2 = _NV_MOSAIC_SUPPORTED_TOPO_INFO_V2; -pub type NV_MOSAIC_SUPPORTED_TOPO_INFO = NV_MOSAIC_SUPPORTED_TOPO_INFO_V2; -#[doc = "! This structure defines a group of topologies that work together to create one\n! overall layout. All of the supported topologies are represented with this\n! structure.\n!\n! For example, a 'Passive Stereo' topology would be represented with this\n! structure, and would have separate topology details for the left and right eyes.\n! The count would be 2. A 'Basic' topology is also represented by this structure,\n! with a count of 1.\n!\n! The structure is primarily used internally, but is exposed to applications in a\n! read-only fashion because there are some details in it that might be useful\n! (like the number of rows/cols, or connected display information). A user can\n! get the filled-in structure by calling NvAPI_Mosaic_GetTopoGroup().\n!\n! You can then look at the detailed values within the structure. There are no\n! entrypoints which take this structure as input (effectively making it read-only)."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_MOSAIC_TOPO_GROUP { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< The brief details of this topo"] - pub brief: NV_MOSAIC_TOPO_BRIEF, - #[doc = "!< Number of topos in array below"] - pub count: NvU32, - pub topos: [NV_MOSAIC_TOPO_DETAILS; 2usize], -} -#[doc = "! \\ingroup mosaicapi\n! @{"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MOSAIC_GRID_TOPO_DISPLAY_V1 { - #[doc = "!< DisplayID of the display"] - pub displayId: NvU32, - #[doc = "!< (+overlap, -gap)"] - pub overlapX: NvS32, - #[doc = "!< (+overlap, -gap)"] - pub overlapY: NvS32, - #[doc = "!< Rotation of display"] - pub rotation: NV_ROTATE, - #[doc = "!< Reserved, must be 0"] - pub cloneGroup: NvU32, -} -#[doc = "! \\ingroup mosaicapi\n! @{"] -pub type NV_MOSAIC_GRID_TOPO_DISPLAY_V1 = _NV_MOSAIC_GRID_TOPO_DISPLAY_V1; -#[doc = "!< No pixel shift will be applied to this display."] -pub const _NV_PIXEL_SHIFT_TYPE_NV_PIXEL_SHIFT_TYPE_NO_PIXEL_SHIFT: _NV_PIXEL_SHIFT_TYPE = 0; -#[doc = "!< This display will be used to scanout top left pixels in 2x2 PixelShift configuration"] -pub const _NV_PIXEL_SHIFT_TYPE_NV_PIXEL_SHIFT_TYPE_2x2_TOP_LEFT_PIXELS: _NV_PIXEL_SHIFT_TYPE = 1; -#[doc = "!< This display will be used to scanout bottom right pixels in 2x2 PixelShift configuration"] -pub const _NV_PIXEL_SHIFT_TYPE_NV_PIXEL_SHIFT_TYPE_2x2_BOTTOM_RIGHT_PIXELS: _NV_PIXEL_SHIFT_TYPE = - 2; -#[doc = "!< This display will be used to scanout top right pixels in 2x2 PixelShift configuration"] -pub const _NV_PIXEL_SHIFT_TYPE_NV_PIXEL_SHIFT_TYPE_2x2_TOP_RIGHT_PIXELS: _NV_PIXEL_SHIFT_TYPE = 4; -#[doc = "!< This display will be used to scanout bottom left pixels in 2x2 PixelShift configuration"] -pub const _NV_PIXEL_SHIFT_TYPE_NV_PIXEL_SHIFT_TYPE_2x2_BOTTOM_LEFT_PIXELS: _NV_PIXEL_SHIFT_TYPE = 8; -pub type _NV_PIXEL_SHIFT_TYPE = ::std::os::raw::c_int; -pub use self::_NV_PIXEL_SHIFT_TYPE as NV_PIXEL_SHIFT_TYPE; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MOSAIC_GRID_TOPO_DISPLAY_V2 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< DisplayID of the display"] - pub displayId: NvU32, - #[doc = "!< (+overlap, -gap)"] - pub overlapX: NvS32, - #[doc = "!< (+overlap, -gap)"] - pub overlapY: NvS32, - #[doc = "!< Rotation of display"] - pub rotation: NV_ROTATE, - #[doc = "!< Reserved, must be 0"] - pub cloneGroup: NvU32, - #[doc = "!< Type of the pixel shift enabled display"] - pub pixelShiftType: NV_PIXEL_SHIFT_TYPE, -} -pub type NV_MOSAIC_GRID_TOPO_DISPLAY_V2 = _NV_MOSAIC_GRID_TOPO_DISPLAY_V2; -#[doc = "! \\ingroup mosaicapi\n! @{"] -pub type NV_MOSAIC_GRID_TOPO_DISPLAY = NV_MOSAIC_GRID_TOPO_DISPLAY_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MOSAIC_GRID_TOPO_V1 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< Number of rows"] - pub rows: NvU32, - #[doc = "!< Number of columns"] - pub columns: NvU32, - #[doc = "!< Number of display details"] - pub displayCount: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Displays are done as [(row * columns) + column]"] - pub displays: [NV_MOSAIC_GRID_TOPO_DISPLAY_V1; 64usize], - #[doc = "!< Display settings"] - pub displaySettings: NV_MOSAIC_DISPLAY_SETTING_V1, -} -impl _NV_MOSAIC_GRID_TOPO_V1 { - #[inline] - pub fn applyWithBezelCorrect(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_applyWithBezelCorrect(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn applyWithBezelCorrect_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_applyWithBezelCorrect_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn immersiveGaming(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_immersiveGaming(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn immersiveGaming_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_immersiveGaming_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn baseMosaic(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_baseMosaic(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn baseMosaic_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_baseMosaic_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn driverReloadAllowed(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_driverReloadAllowed(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn driverReloadAllowed_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_driverReloadAllowed_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn acceleratePrimaryDisplay(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } - } - #[inline] - pub fn set_acceleratePrimaryDisplay(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn acceleratePrimaryDisplay_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_acceleratePrimaryDisplay_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 27u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 27u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 27u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - applyWithBezelCorrect: NvU32, - immersiveGaming: NvU32, - baseMosaic: NvU32, - driverReloadAllowed: NvU32, - acceleratePrimaryDisplay: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let applyWithBezelCorrect: u32 = - unsafe { ::std::mem::transmute(applyWithBezelCorrect) }; - applyWithBezelCorrect as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let immersiveGaming: u32 = unsafe { ::std::mem::transmute(immersiveGaming) }; - immersiveGaming as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let baseMosaic: u32 = unsafe { ::std::mem::transmute(baseMosaic) }; - baseMosaic as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let driverReloadAllowed: u32 = unsafe { ::std::mem::transmute(driverReloadAllowed) }; - driverReloadAllowed as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let acceleratePrimaryDisplay: u32 = - unsafe { ::std::mem::transmute(acceleratePrimaryDisplay) }; - acceleratePrimaryDisplay as u64 - }); - __bindgen_bitfield_unit.set(5usize, 27u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_MOSAIC_GRID_TOPO_V1 = _NV_MOSAIC_GRID_TOPO_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MOSAIC_GRID_TOPO_V2 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< Number of rows"] - pub rows: NvU32, - #[doc = "!< Number of columns"] - pub columns: NvU32, - #[doc = "!< Number of display details"] - pub displayCount: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Displays are done as [(row * columns) + column]"] - pub displays: [NV_MOSAIC_GRID_TOPO_DISPLAY_V2; 64usize], - #[doc = "!< Display settings"] - pub displaySettings: NV_MOSAIC_DISPLAY_SETTING_V1, -} -impl _NV_MOSAIC_GRID_TOPO_V2 { - #[inline] - pub fn applyWithBezelCorrect(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_applyWithBezelCorrect(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn applyWithBezelCorrect_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_applyWithBezelCorrect_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn immersiveGaming(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_immersiveGaming(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn immersiveGaming_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_immersiveGaming_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn baseMosaic(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_baseMosaic(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn baseMosaic_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_baseMosaic_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn driverReloadAllowed(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_driverReloadAllowed(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn driverReloadAllowed_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_driverReloadAllowed_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn acceleratePrimaryDisplay(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } - } - #[inline] - pub fn set_acceleratePrimaryDisplay(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn acceleratePrimaryDisplay_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_acceleratePrimaryDisplay_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn pixelShift(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } - } - #[inline] - pub fn set_pixelShift(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn pixelShift_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_pixelShift_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 26u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(6usize, 26u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 6usize, - 26u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 6usize, - 26u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - applyWithBezelCorrect: NvU32, - immersiveGaming: NvU32, - baseMosaic: NvU32, - driverReloadAllowed: NvU32, - acceleratePrimaryDisplay: NvU32, - pixelShift: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let applyWithBezelCorrect: u32 = - unsafe { ::std::mem::transmute(applyWithBezelCorrect) }; - applyWithBezelCorrect as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let immersiveGaming: u32 = unsafe { ::std::mem::transmute(immersiveGaming) }; - immersiveGaming as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let baseMosaic: u32 = unsafe { ::std::mem::transmute(baseMosaic) }; - baseMosaic as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let driverReloadAllowed: u32 = unsafe { ::std::mem::transmute(driverReloadAllowed) }; - driverReloadAllowed as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let acceleratePrimaryDisplay: u32 = - unsafe { ::std::mem::transmute(acceleratePrimaryDisplay) }; - acceleratePrimaryDisplay as u64 - }); - __bindgen_bitfield_unit.set(5usize, 1u8, { - let pixelShift: u32 = unsafe { ::std::mem::transmute(pixelShift) }; - pixelShift as u64 - }); - __bindgen_bitfield_unit.set(6usize, 26u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_MOSAIC_GRID_TOPO_V2 = _NV_MOSAIC_GRID_TOPO_V2; -pub type NV_MOSAIC_GRID_TOPO = NV_MOSAIC_GRID_TOPO_V2; -#[doc = "! \\ingroup mosaicapi"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_MOSAIC_DISPLAY_TOPO_STATUS { - pub version: NvU32, - #[doc = "!< (OUT) Any of the NV_MOSAIC_DISPLAYTOPO_ERROR_* flags."] - pub errorFlags: NvU32, - #[doc = "!< (OUT) Any of the NV_MOSAIC_DISPLAYTOPO_WARNING_* flags."] - pub warningFlags: NvU32, - #[doc = "!< (OUT) The number of valid entries in the displays array."] - pub displayCount: NvU32, - pub displays: [NV_MOSAIC_DISPLAY_TOPO_STATUS__bindgen_ty_1; 128usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_MOSAIC_DISPLAY_TOPO_STATUS__bindgen_ty_1 { - #[doc = "!< (OUT) The DisplayID of this display."] - pub displayId: NvU32, - #[doc = "!< (OUT) Any of the NV_MOSAIC_DISPLAYCAPS_PROBLEM_* flags."] - pub errorFlags: NvU32, - #[doc = "!< (OUT) Any of the NV_MOSAIC_DISPLAYTOPO_WARNING_* flags."] - pub warningFlags: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, -} -impl NV_MOSAIC_DISPLAY_TOPO_STATUS__bindgen_ty_1 { - #[inline] - pub fn supportsRotation(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_supportsRotation(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supportsRotation_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_supportsRotation_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - supportsRotation: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let supportsRotation: u32 = unsafe { ::std::mem::transmute(supportsRotation) }; - supportsRotation as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! Used in NvAPI_GetCurrentMosaicTopology() and NvAPI_SetCurrentMosaicTopology()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_MOSAIC_TOPOLOGY { - #[doc = "!< Version number of the mosaic topology"] - pub version: NvU32, - #[doc = "!< Horizontal display count"] - pub rowCount: NvU32, - #[doc = "!< Vertical display count"] - pub colCount: NvU32, - pub gpuLayout: [[NV_MOSAIC_TOPOLOGY__bindgen_ty_1; 8usize]; 8usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_MOSAIC_TOPOLOGY__bindgen_ty_1 { - #[doc = "!< Physical GPU to be used in the topology"] - pub hPhysicalGPU: NvPhysicalGpuHandle, - #[doc = "!< Connected display target"] - pub displayOutputId: NvU32, - #[doc = "!< Pixels of overlap on the left of target: (+overlap, -gap)"] - pub overlapX: NvS32, - #[doc = "!< Pixels of overlap on the top of target: (+overlap, -gap)"] - pub overlapY: NvS32, -} -#[doc = "! Used in NvAPI_GetSupportedMosaicTopologies()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_MOSAIC_SUPPORTED_TOPOLOGIES { - pub version: NvU32, - #[doc = "!< Count of valid topologies"] - pub totalCount: NvU32, - #[doc = "!< Maximum number of topologies"] - pub topos: [NV_MOSAIC_TOPOLOGY; 16usize], -} -#[doc = "! Used in NvAPI_GSync_QueryCapabilities()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GSYNC_CAPABILITIES_V1 { - #[doc = "!< Version of the structure"] - pub version: NvU32, - #[doc = "!< Board ID"] - pub boardId: NvU32, - #[doc = "!< FPGA Revision"] - pub revision: NvU32, - #[doc = "!< Capabilities of the Sync board. Reserved for future use"] - pub capFlags: NvU32, -} -#[doc = "! Used in NvAPI_GSync_QueryCapabilities()."] -pub type NV_GSYNC_CAPABILITIES_V1 = _NV_GSYNC_CAPABILITIES_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GSYNC_CAPABILITIES_V2 { - #[doc = "!< Version of the structure"] - pub version: NvU32, - #[doc = "!< Board ID"] - pub boardId: NvU32, - #[doc = "!< FPGA major revision"] - pub revision: NvU32, - #[doc = "!< Capabilities of the Sync board. Reserved for future use"] - pub capFlags: NvU32, - #[doc = "!< FPGA minor revision"] - pub extendedRevision: NvU32, -} -pub type NV_GSYNC_CAPABILITIES_V2 = _NV_GSYNC_CAPABILITIES_V2; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GSYNC_CAPABILITIES_V3 { - #[doc = "!< Version of the structure"] - pub version: NvU32, - #[doc = "!< Board ID"] - pub boardId: NvU32, - #[doc = "!< FPGA major revision"] - pub revision: NvU32, - #[doc = "!< Capabilities of the Sync board. Reserved for future use"] - pub capFlags: NvU32, - #[doc = "!< FPGA minor revision"] - pub extendedRevision: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< This parameter returns the maximum possible value that can be programmed\n!< for multiplying / dividing house sync. Only valid if bIsMulDivSupported is set to 1."] - pub maxMulDivValue: NvU32, -} -impl _NV_GSYNC_CAPABILITIES_V3 { - #[inline] - pub fn bIsMulDivSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsMulDivSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsMulDivSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsMulDivSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bIsMulDivSupported: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsMulDivSupported: u32 = unsafe { ::std::mem::transmute(bIsMulDivSupported) }; - bIsMulDivSupported as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_GSYNC_CAPABILITIES_V3 = _NV_GSYNC_CAPABILITIES_V3; -pub type NV_GSYNC_CAPABILITIES = NV_GSYNC_CAPABILITIES_V3; -pub const _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_NONE: - _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR = 0; -pub const _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_PRIMARY: - _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR = 1; -pub const _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_SECONDARY: - _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR = 2; -pub const _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_TERTIARY: - _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR = 3; -pub const _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_QUARTERNARY: - _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR = 4; -#[doc = "! Connector values for a GPU. Used in NV_GSYNC_GPU."] -pub type _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR = ::std::os::raw::c_int; -#[doc = "! Connector values for a GPU. Used in NV_GSYNC_GPU."] -pub use self::_NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR as NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR; -pub const _NVAPI_GSYNC_DISPLAY_SYNC_STATE_NVAPI_GSYNC_DISPLAY_SYNC_STATE_UNSYNCED: - _NVAPI_GSYNC_DISPLAY_SYNC_STATE = 0; -pub const _NVAPI_GSYNC_DISPLAY_SYNC_STATE_NVAPI_GSYNC_DISPLAY_SYNC_STATE_SLAVE: - _NVAPI_GSYNC_DISPLAY_SYNC_STATE = 1; -pub const _NVAPI_GSYNC_DISPLAY_SYNC_STATE_NVAPI_GSYNC_DISPLAY_SYNC_STATE_MASTER: - _NVAPI_GSYNC_DISPLAY_SYNC_STATE = 2; -#[doc = "! Display sync states. Used in NV_GSYNC_DISPLAY."] -pub type _NVAPI_GSYNC_DISPLAY_SYNC_STATE = ::std::os::raw::c_int; -#[doc = "! Display sync states. Used in NV_GSYNC_DISPLAY."] -pub use self::_NVAPI_GSYNC_DISPLAY_SYNC_STATE as NVAPI_GSYNC_DISPLAY_SYNC_STATE; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GSYNC_GPU { - #[doc = "!< Version of the structure"] - pub version: NvU32, - #[doc = "!< GPU handle"] - pub hPhysicalGpu: NvPhysicalGpuHandle, - #[doc = "!< Indicates which connector on the device the GPU is connected to."] - pub connector: NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR, - #[doc = "!< GPU through which hPhysicalGpu is connected to the Sync device (if not directly connected)\n!< - this is NULL otherwise"] - pub hProxyPhysicalGpu: NvPhysicalGpuHandle, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - pub __bindgen_padding_0: u32, -} -impl _NV_GSYNC_GPU { - #[inline] - pub fn isSynced(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isSynced(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isSynced_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isSynced_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1(isSynced: NvU32, reserved: NvU32) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isSynced: u32 = unsafe { ::std::mem::transmute(isSynced) }; - isSynced as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_GSYNC_GPU = _NV_GSYNC_GPU; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GSYNC_DISPLAY { - #[doc = "!< Version of the structure"] - pub version: NvU32, - #[doc = "!< display identifier for displays.The GPU to which it is connected, can be retireved from NvAPI_SYS_GetPhysicalGpuFromDisplayId"] - pub displayId: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Is this display slave/master\n!< (Retrieved with topology or set by caller for enable/disable sync)"] - pub syncState: NVAPI_GSYNC_DISPLAY_SYNC_STATE, -} -impl _NV_GSYNC_DISPLAY { - #[inline] - pub fn isMasterable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMasterable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMasterable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMasterable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isMasterable: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isMasterable: u32 = unsafe { ::std::mem::transmute(isMasterable) }; - isMasterable as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_GSYNC_DISPLAY = _NV_GSYNC_DISPLAY; -pub const _NVAPI_GSYNC_POLARITY_NVAPI_GSYNC_POLARITY_RISING_EDGE: _NVAPI_GSYNC_POLARITY = 0; -pub const _NVAPI_GSYNC_POLARITY_NVAPI_GSYNC_POLARITY_FALLING_EDGE: _NVAPI_GSYNC_POLARITY = 1; -pub const _NVAPI_GSYNC_POLARITY_NVAPI_GSYNC_POLARITY_BOTH_EDGES: _NVAPI_GSYNC_POLARITY = 2; -#[doc = "! Source signal edge to be used for output pulse. See NV_GSYNC_CONTROL_PARAMS."] -pub type _NVAPI_GSYNC_POLARITY = ::std::os::raw::c_int; -#[doc = "! Source signal edge to be used for output pulse. See NV_GSYNC_CONTROL_PARAMS."] -pub use self::_NVAPI_GSYNC_POLARITY as NVAPI_GSYNC_POLARITY; -pub const _NVAPI_GSYNC_VIDEO_MODE_NVAPI_GSYNC_VIDEO_MODE_NONE: _NVAPI_GSYNC_VIDEO_MODE = 0; -pub const _NVAPI_GSYNC_VIDEO_MODE_NVAPI_GSYNC_VIDEO_MODE_TTL: _NVAPI_GSYNC_VIDEO_MODE = 1; -pub const _NVAPI_GSYNC_VIDEO_MODE_NVAPI_GSYNC_VIDEO_MODE_NTSCPALSECAM: _NVAPI_GSYNC_VIDEO_MODE = 2; -pub const _NVAPI_GSYNC_VIDEO_MODE_NVAPI_GSYNC_VIDEO_MODE_HDTV: _NVAPI_GSYNC_VIDEO_MODE = 3; -pub const _NVAPI_GSYNC_VIDEO_MODE_NVAPI_GSYNC_VIDEO_MODE_COMPOSITE: _NVAPI_GSYNC_VIDEO_MODE = 4; -#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] -pub type _NVAPI_GSYNC_VIDEO_MODE = ::std::os::raw::c_int; -#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] -pub use self::_NVAPI_GSYNC_VIDEO_MODE as NVAPI_GSYNC_VIDEO_MODE; -pub const _NVAPI_GSYNC_SYNC_SOURCE_NVAPI_GSYNC_SYNC_SOURCE_VSYNC: _NVAPI_GSYNC_SYNC_SOURCE = 0; -pub const _NVAPI_GSYNC_SYNC_SOURCE_NVAPI_GSYNC_SYNC_SOURCE_HOUSESYNC: _NVAPI_GSYNC_SYNC_SOURCE = 1; -#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] -pub type _NVAPI_GSYNC_SYNC_SOURCE = ::std::os::raw::c_int; -#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] -pub use self::_NVAPI_GSYNC_SYNC_SOURCE as NVAPI_GSYNC_SYNC_SOURCE; -#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GSYNC_DELAY { - #[doc = "!< Version of the structure"] - pub version: NvU32, - #[doc = "!< delay to be induced in number of horizontal lines."] - pub numLines: NvU32, - #[doc = "!< delay to be induced in number of pixels."] - pub numPixels: NvU32, - #[doc = "!< maximum number of lines supported at current display mode to induce delay. Updated by NvAPI_GSync_GetControlParameters(). Read only."] - pub maxLines: NvU32, - #[doc = "!< minimum number of pixels required at current display mode to induce delay. Updated by NvAPI_GSync_GetControlParameters(). Read only."] - pub minPixels: NvU32, -} -#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] -pub type NV_GSYNC_DELAY = _NV_GSYNC_DELAY; -#[doc = "! Used in NvAPI_GSync_GetControlParameters() and NvAPI_GSync_SetControlParameters()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GSYNC_CONTROL_PARAMS_V1 { - #[doc = "!< Version of the structure"] - pub version: NvU32, - #[doc = "!< Leading edge / Falling edge / both"] - pub polarity: NVAPI_GSYNC_POLARITY, - #[doc = "!< None, TTL, NTSCPALSECAM, HDTV"] - pub vmode: NVAPI_GSYNC_VIDEO_MODE, - #[doc = "!< Number of pulses to wait between framelock signal generation"] - pub interval: NvU32, - #[doc = "!< VSync/House sync"] - pub source: NVAPI_GSYNC_SYNC_SOURCE, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< The time delay between the frame sync signal and the GPUs signal."] - pub syncSkew: NV_GSYNC_DELAY, - #[doc = "!< Sync start delay for master."] - pub startupDelay: NV_GSYNC_DELAY, -} -impl _NV_GSYNC_CONTROL_PARAMS_V1 { - #[inline] - pub fn interlaceMode(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_interlaceMode(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn interlaceMode_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_interlaceMode_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn syncSourceIsOutput(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_syncSourceIsOutput(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn syncSourceIsOutput_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_syncSourceIsOutput_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 30u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 30u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 30u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - interlaceMode: NvU32, - syncSourceIsOutput: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let interlaceMode: u32 = unsafe { ::std::mem::transmute(interlaceMode) }; - interlaceMode as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let syncSourceIsOutput: u32 = unsafe { ::std::mem::transmute(syncSourceIsOutput) }; - syncSourceIsOutput as u64 - }); - __bindgen_bitfield_unit.set(2usize, 30u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! Used in NvAPI_GSync_GetControlParameters() and NvAPI_GSync_SetControlParameters()."] -pub type NV_GSYNC_CONTROL_PARAMS_V1 = _NV_GSYNC_CONTROL_PARAMS_V1; -pub const _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE_NVAPI_GSYNC_UNDEFINED_MODE: - _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE = 0; -pub const _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE_NVAPI_GSYNC_MULTIPLY_MODE: - _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE = 1; -pub const _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE_NVAPI_GSYNC_DIVIDE_MODE: - _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE = 2; -#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] -pub type _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE = ::std::os::raw::c_int; -#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] -pub use self::_NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE as NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GSYNC_CONTROL_PARAMS_V2 { - #[doc = "!< Version of the structure"] - pub version: NvU32, - #[doc = "!< Leading edge / Falling edge / both"] - pub polarity: NVAPI_GSYNC_POLARITY, - #[doc = "!< None, TTL, NTSCPALSECAM, HDTV"] - pub vmode: NVAPI_GSYNC_VIDEO_MODE, - #[doc = "!< Number of pulses to wait between framelock signal generation"] - pub interval: NvU32, - #[doc = "!< VSync/House sync"] - pub source: NVAPI_GSYNC_SYNC_SOURCE, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< The time delay between the frame sync signal and the GPUs signal."] - pub syncSkew: NV_GSYNC_DELAY, - #[doc = "!< Sync start delay for master."] - pub startupDelay: NV_GSYNC_DELAY, - #[doc = "!< Indicates multiplier/divider mode for the housesync signal.\n!< While setting multiplyDivideMode, source needs to be set as NVAPI_GSYNC_SYNC_SOURCE_HOUSESYNC."] - pub multiplyDivideMode: NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE, - #[doc = "!< Indicates the multiplier/divider value for the housesync signal. Only supported if bIsMulDivSupported field of the structure NV_GSYNC_CAPABILITIES is set to 1.\n!< The maximum supported value for this field can be obtained from maxMulDivValue field of the structure NV_GSYNC_CAPABILITIES."] - pub multiplyDivideValue: NvU8, -} -impl _NV_GSYNC_CONTROL_PARAMS_V2 { - #[inline] - pub fn interlaceMode(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_interlaceMode(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn interlaceMode_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_interlaceMode_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn syncSourceIsOutput(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_syncSourceIsOutput(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn syncSourceIsOutput_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_syncSourceIsOutput_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 30u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 30u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 30u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - interlaceMode: NvU32, - syncSourceIsOutput: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let interlaceMode: u32 = unsafe { ::std::mem::transmute(interlaceMode) }; - interlaceMode as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let syncSourceIsOutput: u32 = unsafe { ::std::mem::transmute(syncSourceIsOutput) }; - syncSourceIsOutput as u64 - }); - __bindgen_bitfield_unit.set(2usize, 30u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_GSYNC_CONTROL_PARAMS_V2 = _NV_GSYNC_CONTROL_PARAMS_V2; -pub type NV_GSYNC_CONTROL_PARAMS = NV_GSYNC_CONTROL_PARAMS_V2; -#[doc = "! Used in NvAPI_GSync_GetSyncStatus()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GSYNC_STATUS { - #[doc = "!< Version of the structure"] - pub version: NvU32, - #[doc = "!< Is timing in sync?"] - pub bIsSynced: NvU32, - #[doc = "!< Does the phase of the timing signal from the GPU = the phase of the master sync signal?"] - pub bIsStereoSynced: NvU32, - #[doc = "!< Is the sync signal available?"] - pub bIsSyncSignalAvailable: NvU32, -} -#[doc = "! Used in NvAPI_GSync_GetSyncStatus()."] -pub type NV_GSYNC_STATUS = _NV_GSYNC_STATUS; -pub const _NVAPI_GSYNC_RJ45_IO_NVAPI_GSYNC_RJ45_OUTPUT: _NVAPI_GSYNC_RJ45_IO = 0; -pub const _NVAPI_GSYNC_RJ45_IO_NVAPI_GSYNC_RJ45_INPUT: _NVAPI_GSYNC_RJ45_IO = 1; -#[doc = "!< This field is used to notify that the framelock is not actually present."] -pub const _NVAPI_GSYNC_RJ45_IO_NVAPI_GSYNC_RJ45_UNUSED: _NVAPI_GSYNC_RJ45_IO = 2; -#[doc = "! Used in NV_GSYNC_STATUS_PARAMS."] -pub type _NVAPI_GSYNC_RJ45_IO = ::std::os::raw::c_int; -#[doc = "! Used in NV_GSYNC_STATUS_PARAMS."] -pub use self::_NVAPI_GSYNC_RJ45_IO as NVAPI_GSYNC_RJ45_IO; -#[doc = "! \\ingroup gsyncapi\n! Used in NvAPI_GSync_GetStatusParameters()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GSYNC_STATUS_PARAMS_V1 { - pub version: NvU32, - #[doc = "!< The refresh rate"] - pub refreshRate: NvU32, - #[doc = "!< Configured as input / output"] - pub RJ45_IO: [NVAPI_GSYNC_RJ45_IO; 2usize], - #[doc = "!< Connected to ethernet hub? [ERRONEOUSLY CONNECTED!]"] - pub RJ45_Ethernet: [NvU32; 2usize], - #[doc = "!< Incoming house sync frequency in Hz"] - pub houseSyncIncoming: NvU32, - #[doc = "!< Is house sync connected?"] - pub bHouseSync: NvU32, -} -#[doc = "! \\ingroup gsyncapi\n! Used in NvAPI_GSync_GetStatusParameters()."] -pub type NV_GSYNC_STATUS_PARAMS_V1 = _NV_GSYNC_STATUS_PARAMS_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GSYNC_STATUS_PARAMS_V2 { - pub version: NvU32, - #[doc = "!< The refresh rate"] - pub refreshRate: NvU32, - #[doc = "!< Configured as input / output"] - pub RJ45_IO: [NVAPI_GSYNC_RJ45_IO; 2usize], - #[doc = "!< Connected to ethernet hub? [ERRONEOUSLY CONNECTED!]"] - pub RJ45_Ethernet: [NvU32; 2usize], - #[doc = "!< Incoming house sync frequency in Hz"] - pub houseSyncIncoming: NvU32, - #[doc = "!< Is house sync connected?"] - pub bHouseSync: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, -} -impl _NV_GSYNC_STATUS_PARAMS_V2 { - #[inline] - pub fn bInternalSlave(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bInternalSlave(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bInternalSlave_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bInternalSlave_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bInternalSlave: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bInternalSlave: u32 = unsafe { ::std::mem::transmute(bInternalSlave) }; - bInternalSlave as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_GSYNC_STATUS_PARAMS_V2 = _NV_GSYNC_STATUS_PARAMS_V2; -pub type NV_GSYNC_STATUS_PARAMS = NV_GSYNC_STATUS_PARAMS_V2; -pub const _NV_RESOLVE_MODE_NV_RESOLVE_MODE_SAMPLE_0: _NV_RESOLVE_MODE = 0; -#[doc = "! \\ingroup dx\n! Valid modes for NvAPI_D3D11_ResolveSubresourceRegion() and NvAPI_D3D12_ResolveSubresourceRegion"] -pub type _NV_RESOLVE_MODE = ::std::os::raw::c_int; -#[doc = "! \\ingroup dx\n! Valid modes for NvAPI_D3D11_ResolveSubresourceRegion() and NvAPI_D3D12_ResolveSubresourceRegion"] -pub use self::_NV_RESOLVE_MODE as NV_RESOLVE_MODE; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of Single Pass Stereo HW feature\n! \\ingroup dx"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V1 { - pub version: NvU32, - pub bSinglePassStereoSupported: NvU32, -} -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of Single Pass Stereo HW feature\n! \\ingroup dx"] -pub type NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V1 = - _NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V2 { - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, -} -impl _NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V2 { - #[inline] - pub fn bSinglePassStereoSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bSinglePassStereoSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bSinglePassStereoSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bSinglePassStereoSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bSinglePassStereoXYZWSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_bSinglePassStereoXYZWSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bSinglePassStereoXYZWSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bSinglePassStereoXYZWSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 30u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 30u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 30u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bSinglePassStereoSupported: NvU32, - bSinglePassStereoXYZWSupported: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bSinglePassStereoSupported: u32 = - unsafe { ::std::mem::transmute(bSinglePassStereoSupported) }; - bSinglePassStereoSupported as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let bSinglePassStereoXYZWSupported: u32 = - unsafe { ::std::mem::transmute(bSinglePassStereoXYZWSupported) }; - bSinglePassStereoXYZWSupported as u64 - }); - __bindgen_bitfield_unit.set(2usize, 30u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V2 = - _NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V2; -pub type NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS = NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V2; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of MultiView HW feature\n! \\ingroup dx"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_QUERY_MULTIVIEW_SUPPORT_PARAMS_V1 { - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, -} -impl _NV_QUERY_MULTIVIEW_SUPPORT_PARAMS_V1 { - #[inline] - pub fn bMultiViewSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bMultiViewSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bMultiViewSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bMultiViewSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bSinglePassStereoSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_bSinglePassStereoSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bSinglePassStereoSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bSinglePassStereoSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bSinglePassStereoXYZWSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_bSinglePassStereoXYZWSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bSinglePassStereoXYZWSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bSinglePassStereoXYZWSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 29u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 29u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 29u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 29u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bMultiViewSupported: NvU32, - bSinglePassStereoSupported: NvU32, - bSinglePassStereoXYZWSupported: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bMultiViewSupported: u32 = unsafe { ::std::mem::transmute(bMultiViewSupported) }; - bMultiViewSupported as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let bSinglePassStereoSupported: u32 = - unsafe { ::std::mem::transmute(bSinglePassStereoSupported) }; - bSinglePassStereoSupported as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let bSinglePassStereoXYZWSupported: u32 = - unsafe { ::std::mem::transmute(bSinglePassStereoXYZWSupported) }; - bSinglePassStereoXYZWSupported as u64 - }); - __bindgen_bitfield_unit.set(3usize, 29u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of MultiView HW feature\n! \\ingroup dx"] -pub type NV_QUERY_MULTIVIEW_SUPPORT_PARAMS_V1 = _NV_QUERY_MULTIVIEW_SUPPORT_PARAMS_V1; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of MultiView HW feature\n! \\ingroup dx"] -pub type NV_QUERY_MULTIVIEW_SUPPORT_PARAMS = NV_QUERY_MULTIVIEW_SUPPORT_PARAMS_V1; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used for setting the Mode for MultiView HW Feature.\n! \\ingroup dx"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MULTIVIEW_PARAMS_V1 { - pub version: NvU32, - pub numViews: NvU32, - pub renderTargetIndexOffset: [NvU32; 4usize], - pub independentViewportMaskEnable: NvU8, -} -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used for setting the Mode for MultiView HW Feature.\n! \\ingroup dx"] -pub type NV_MULTIVIEW_PARAMS_V1 = _NV_MULTIVIEW_PARAMS_V1; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used for setting the Mode for MultiView HW Feature.\n! \\ingroup dx"] -pub type NV_MULTIVIEW_PARAMS = NV_MULTIVIEW_PARAMS_V1; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of Lens Matched Shading HW feature\n! \\ingroup dx"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_QUERY_MODIFIED_W_SUPPORT_PARAMS { - pub version: NvU32, - pub bModifiedWSupported: NvU32, -} -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of Lens Matched Shading HW feature\n! \\ingroup dx"] -pub type NV_QUERY_MODIFIED_W_SUPPORT_PARAMS_V1 = _NV_QUERY_MODIFIED_W_SUPPORT_PARAMS; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of Lens Matched Shading HW feature\n! \\ingroup dx"] -pub type NV_QUERY_MODIFIED_W_SUPPORT_PARAMS = NV_QUERY_MODIFIED_W_SUPPORT_PARAMS_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MODIFIED_W_COEFFICIENTS { - pub fA: f32, - pub fB: f32, - pub fAReserved: f32, - pub fBReserved: f32, - pub fReserved: [f32; 2usize], -} -pub type NV_MODIFIED_W_COEFFICIENTS = _NV_MODIFIED_W_COEFFICIENTS; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MODIFIED_W_PARAMS { - pub version: NvU32, - pub numEntries: NvU32, - pub modifiedWCoefficients: [NV_MODIFIED_W_COEFFICIENTS; 16usize], - pub id: NvU32, - pub reserved: [NvU32; 16usize], -} -pub type NV_MODIFIED_W_PARAMS_V1 = _NV_MODIFIED_W_PARAMS; -pub type NV_MODIFIED_W_PARAMS = NV_MODIFIED_W_PARAMS_V1; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to get sleep status\n! \\ingroup dx"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GET_SLEEP_STATUS_PARAMS { - #[doc = "!< (IN) Structure version"] - pub version: NvU32, - #[doc = "!< (OUT) Is low latency mode enabled?"] - pub bLowLatencyMode: NvBool, - #[doc = "!< (OUT) Is fullscreen VRR enabled?"] - pub bFsVrr: NvBool, - #[doc = "!< (OUT) Is Control Panel overriding VSYNC ON?"] - pub bCplVsyncOn: NvBool, - #[doc = "!< (OUT) Latest sleep interval in microseconds."] - pub sleepIntervalUs: NvU32, - #[doc = "!< (OUT) Is NvAPI_D3D_Sleep() being called?"] - pub bUseGameSleep: NvBool, - #[doc = "!< (OUT) Is in fullscreen/iFlip mode?"] - pub bFullscreenIFlip: NvBool, - #[doc = "!< (OUT) Latest Frame Generation multiplier used."] - pub fgMultiplier: NvU8, - #[doc = "!< (IN) Reserved. Must be set to 0s."] - pub rsvd: [NvU8; 119usize], -} -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to get sleep status\n! \\ingroup dx"] -pub type NV_GET_SLEEP_STATUS_PARAMS_V1 = _NV_GET_SLEEP_STATUS_PARAMS; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to get sleep status\n! \\ingroup dx"] -pub type NV_GET_SLEEP_STATUS_PARAMS = NV_GET_SLEEP_STATUS_PARAMS_V1; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to set sleep mode\n! \\ingroup dx"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_SET_SLEEP_MODE_PARAMS { - #[doc = "!< (IN) Structure version"] - pub version: NvU32, - #[doc = "!< (IN) Low latency mode enable/disable."] - pub bLowLatencyMode: NvBool, - #[doc = "!< (IN) Request maximum GPU clock frequency regardless of workload."] - pub bLowLatencyBoost: NvBool, - #[doc = "!< (IN) Minimum frame interval in microseconds. 0 = no frame rate limit."] - pub minimumIntervalUs: NvU32, - #[doc = "!< (IN) Allow latency markers to be used for runtime optimizations."] - pub bUseMarkersToOptimize: NvBool, - #[doc = "!< (IN) Consider all submission overlaps (both in between frames and within each frame)."] - pub bUseMinQueueTime: NvBool, - #[doc = "!< (IN) Reserved. Must be set to 0s."] - pub rsvd: [NvU8; 30usize], -} -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to set sleep mode\n! \\ingroup dx"] -pub type NV_SET_SLEEP_MODE_PARAMS_V1 = _NV_SET_SLEEP_MODE_PARAMS; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to set sleep mode\n! \\ingroup dx"] -pub type NV_SET_SLEEP_MODE_PARAMS = NV_SET_SLEEP_MODE_PARAMS_V1; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to send Reflex Sync data to UMD\n! \\ingroup dx"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_SET_REFLEX_SYNC_PARAMS { - #[doc = "!< (IN) Structure version"] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< (IN) Interval between VBLANKs in microseconds. (0 means N/A)"] - pub vblankIntervalUs: NvU32, - #[doc = "!< (IN) Amount of time in the completed frame queue. Can be negative. (0 means N/A)"] - pub timeInQueueUs: NvS32, - #[doc = "!< (IN) Target amount of time in the completed frame queue. (0 means N/A)"] - pub timeInQueueUsTarget: NvU32, - #[doc = "!< (IN) Specify the frame generation multipler to use. (0 means driver should auto-detect)"] - pub fgMultiplier: NvU8, - #[doc = "!< (IN) Reserved. Must be set to 0s."] - pub rsvd: [NvU8; 27usize], -} -impl _NV_SET_REFLEX_SYNC_PARAMS { - #[inline] - pub fn bEnable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bEnable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bEnable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bEnable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bDisable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_bDisable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bDisable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bDisable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn flagsRsvd(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } - } - #[inline] - pub fn set_flagsRsvd(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 30u8, val as u64) - } - } - #[inline] - pub unsafe fn flagsRsvd_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 30u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_flagsRsvd_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 30u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bEnable: NvU32, - bDisable: NvU32, - flagsRsvd: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bEnable: u32 = unsafe { ::std::mem::transmute(bEnable) }; - bEnable as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let bDisable: u32 = unsafe { ::std::mem::transmute(bDisable) }; - bDisable as u64 - }); - __bindgen_bitfield_unit.set(2usize, 30u8, { - let flagsRsvd: u32 = unsafe { ::std::mem::transmute(flagsRsvd) }; - flagsRsvd as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to send Reflex Sync data to UMD\n! \\ingroup dx"] -pub type NV_SET_REFLEX_SYNC_PARAMS_V1 = _NV_SET_REFLEX_SYNC_PARAMS; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to send Reflex Sync data to UMD\n! \\ingroup dx"] -pub type NV_SET_REFLEX_SYNC_PARAMS = NV_SET_REFLEX_SYNC_PARAMS_V1; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to get latency report.\n! \\ingroup dx"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LATENCY_RESULT_PARAMS { - #[doc = "!< (IN) Structure version"] - pub version: NvU32, - pub frameReport: [_NV_LATENCY_RESULT_PARAMS_FrameReport; 64usize], - pub rsvd: [NvU8; 32usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LATENCY_RESULT_PARAMS_FrameReport { - #[doc = "!< (OUT)"] - pub frameID: NvU64, - #[doc = "!< (OUT)"] - pub inputSampleTime: NvU64, - #[doc = "!< (OUT)"] - pub simStartTime: NvU64, - #[doc = "!< (OUT)"] - pub simEndTime: NvU64, - #[doc = "!< (OUT)"] - pub renderSubmitStartTime: NvU64, - #[doc = "!< (OUT)"] - pub renderSubmitEndTime: NvU64, - #[doc = "!< (OUT)"] - pub presentStartTime: NvU64, - #[doc = "!< (OUT)"] - pub presentEndTime: NvU64, - #[doc = "!< (OUT)"] - pub driverStartTime: NvU64, - #[doc = "!< (OUT)"] - pub driverEndTime: NvU64, - #[doc = "!< (OUT)"] - pub osRenderQueueStartTime: NvU64, - #[doc = "!< (OUT)"] - pub osRenderQueueEndTime: NvU64, - #[doc = "!< (OUT)"] - pub gpuRenderStartTime: NvU64, - #[doc = "!< (OUT)"] - pub gpuRenderEndTime: NvU64, - #[doc = "!< (OUT) Difference between gpuRenderStartTime and gpuRenderEndTime, excluding the idles in between, in microseconds."] - pub gpuActiveRenderTimeUs: NvU32, - #[doc = "!< (OUT) Difference between previous and current frame's gpuRenderEndTime, in microseconds."] - pub gpuFrameTimeUs: NvU32, - #[doc = "!< (OUT)"] - pub cameraConstructedTime: NvU64, - #[doc = "!< (OUT) Cross adapter copy time in microseconds."] - pub crossAdapterCopyTimeUs: NvU32, - #[doc = "!< (OUT) Frame generation time in microseconds."] - pub aiFrameTimeUs: NvU32, - pub rsvd: [NvU8; 104usize], -} -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to get latency report.\n! \\ingroup dx"] -pub type NV_LATENCY_RESULT_PARAMS_V1 = _NV_LATENCY_RESULT_PARAMS; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to get latency report.\n! \\ingroup dx"] -pub type NV_LATENCY_RESULT_PARAMS = NV_LATENCY_RESULT_PARAMS_V1; -pub const NV_LATENCY_MARKER_TYPE_SIMULATION_START: NV_LATENCY_MARKER_TYPE = 0; -pub const NV_LATENCY_MARKER_TYPE_SIMULATION_END: NV_LATENCY_MARKER_TYPE = 1; -pub const NV_LATENCY_MARKER_TYPE_RENDERSUBMIT_START: NV_LATENCY_MARKER_TYPE = 2; -pub const NV_LATENCY_MARKER_TYPE_RENDERSUBMIT_END: NV_LATENCY_MARKER_TYPE = 3; -pub const NV_LATENCY_MARKER_TYPE_PRESENT_START: NV_LATENCY_MARKER_TYPE = 4; -pub const NV_LATENCY_MARKER_TYPE_PRESENT_END: NV_LATENCY_MARKER_TYPE = 5; -pub const NV_LATENCY_MARKER_TYPE_INPUT_SAMPLE: NV_LATENCY_MARKER_TYPE = 6; -pub const NV_LATENCY_MARKER_TYPE_TRIGGER_FLASH: NV_LATENCY_MARKER_TYPE = 7; -pub const NV_LATENCY_MARKER_TYPE_PC_LATENCY_PING: NV_LATENCY_MARKER_TYPE = 8; -pub const NV_LATENCY_MARKER_TYPE_OUT_OF_BAND_RENDERSUBMIT_START: NV_LATENCY_MARKER_TYPE = 9; -pub const NV_LATENCY_MARKER_TYPE_OUT_OF_BAND_RENDERSUBMIT_END: NV_LATENCY_MARKER_TYPE = 10; -pub const NV_LATENCY_MARKER_TYPE_OUT_OF_BAND_PRESENT_START: NV_LATENCY_MARKER_TYPE = 11; -pub const NV_LATENCY_MARKER_TYPE_OUT_OF_BAND_PRESENT_END: NV_LATENCY_MARKER_TYPE = 12; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used define latency marker type\n! \\ingroup dx"] -pub type NV_LATENCY_MARKER_TYPE = ::std::os::raw::c_int; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used set latency markers\n! \\ingroup dx"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LATENCY_MARKER_PARAMS { - #[doc = "!< (IN) Structure version"] - pub version: NvU32, - pub frameID: NvU64, - pub markerType: NV_LATENCY_MARKER_TYPE, - pub rsvd0: NvU64, - pub rsvd: [NvU8; 56usize], -} -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used set latency markers\n! \\ingroup dx"] -pub type NV_LATENCY_MARKER_PARAMS_V1 = _NV_LATENCY_MARKER_PARAMS; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used set latency markers\n! \\ingroup dx"] -pub type NV_LATENCY_MARKER_PARAMS = NV_LATENCY_MARKER_PARAMS_V1; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used in NvAPI_D3D12_SetAsyncFrameMarker and NvAPI_D3D11_SetAsyncFrameMarker\n! \\ingroup dx"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_ASYNC_FRAME_MARKER_PARAMS_V1 { - #[doc = "!< (IN) Structure version"] - pub version: NvU32, - pub frameID: NvU64, - pub markerType: NV_LATENCY_MARKER_TYPE, - pub presentFrameID: NvU64, - pub vendorInternal: NvBool, - pub rsvd: [NvU8; 55usize], -} -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used in NvAPI_D3D12_SetAsyncFrameMarker and NvAPI_D3D11_SetAsyncFrameMarker\n! \\ingroup dx"] -pub type NV_ASYNC_FRAME_MARKER_PARAMS_V1 = _NV_ASYNC_FRAME_MARKER_PARAMS_V1; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used in NvAPI_D3D12_SetAsyncFrameMarker and NvAPI_D3D11_SetAsyncFrameMarker\n! \\ingroup dx"] -pub type NV_ASYNC_FRAME_MARKER_PARAMS = NV_ASYNC_FRAME_MARKER_PARAMS_V1; -pub const NV_OUT_OF_BAND_CQ_TYPE_OUT_OF_BAND_RENDER: NV_OUT_OF_BAND_CQ_TYPE = 0; -pub const NV_OUT_OF_BAND_CQ_TYPE_OUT_OF_BAND_PRESENT: NV_OUT_OF_BAND_CQ_TYPE = 1; -pub const NV_OUT_OF_BAND_CQ_TYPE_OUT_OF_BAND_IGNORE: NV_OUT_OF_BAND_CQ_TYPE = 2; -pub const NV_OUT_OF_BAND_CQ_TYPE_OUT_OF_BAND_RENDER_PRESENT: NV_OUT_OF_BAND_CQ_TYPE = 3; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used in NvAPI_D3D12_NotifyOutOfBandCommandQueue\n! \\ingroup dx"] -pub type NV_OUT_OF_BAND_CQ_TYPE = ::std::os::raw::c_int; -pub const _NV_D3D12_WORKSTATION_FEATURE_TYPE_NV_D3D12_WORKSTATION_FEATURE_TYPE_PRESENT_BARRIER: - _NV_D3D12_WORKSTATION_FEATURE_TYPE = 1; -pub const _NV_D3D12_WORKSTATION_FEATURE_TYPE_NV_D3D12_WORKSTATION_FEATURE_TYPE_RDMA_BAR1_SUPPORT: - _NV_D3D12_WORKSTATION_FEATURE_TYPE = 2; -#[doc = "! \\ingroup DX"] -pub type _NV_D3D12_WORKSTATION_FEATURE_TYPE = ::std::os::raw::c_int; -#[doc = "! \\ingroup DX"] -pub use self::_NV_D3D12_WORKSTATION_FEATURE_TYPE as NV_D3D12_WORKSTATION_FEATURE_TYPE; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_D3D12_WORKSTATION_FEATURE_RDMA_PROPERTIES { - pub rdmaHeapSize: NvU64, -} -pub type NV_D3D12_WORKSTATION_FEATURE_RDMA_PROPERTIES = - _NV_D3D12_WORKSTATION_FEATURE_RDMA_PROPERTIES; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_INITIALIZED: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 1; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_ENABLED: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 2; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_DLL_EXISTS: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 4; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_DLL_LOADED: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 8; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_DLL_SELECTED: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 16; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_PRESET: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 32; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_PERF_MODE: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 64; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_SCALING_RATIO: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 128; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_OPTIMAL_SETTINGS: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 256; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_CREATED: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 512; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_EVALUATE: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 1024; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_FG_MODE: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 8192; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_SR_DLAA_MODE: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 16384; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_FG_MULTI_FRAME: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 32768; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_ERR_FAILED: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 65536; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_ERR_DENIED: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 131072; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_ERR_DRS: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 262144; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_ERR_NOT_FOUND: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 524288; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_ERR_DLL_LOAD: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 1048576; -pub type NV_NGX_DLSS_OVERRIDE_BITFIELD = ::std::os::raw::c_int; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_NGX_DLSS_OVERRIDE_GET_STATE_PARAMS_V1 { - #[doc = "!< [in] Structure version"] - pub version: NvU32, - #[doc = "!< [in] Process Identifier"] - pub processIdentifier: NvU32, - #[doc = "!< [out] Feedback bits for Super Resolution"] - pub feedbackMaskSR: NvU64, - #[doc = "!< [out] Feedback bits for Ray Reconstruction"] - pub feedbackMaskRR: NvU64, - #[doc = "!< [out] Feedback bits for Frame Generation"] - pub feedbackMaskFG: NvU64, - #[doc = "!< [out] Scaling Ratio"] - pub scalingRatio: NvF32, - #[doc = "!< [out] Performance Mode"] - pub performanceMode: NvU32, - #[doc = "!< [out] Render Preset for SR/RR"] - pub renderPreset: NvU32, - #[doc = "!< [out] FG Override Frame Count Target"] - pub frameGenerationCount: NvU32, - #[doc = "!< [out] Render Preset for FG"] - pub frameGenerationPreset: NvU32, - #[doc = "!< [out] Frame Generation Mode"] - pub frameGenerationMode: NvU32, - #[doc = "!< Reserved for future use. Must be zero."] - pub reserved: [NvU32; 2usize], -} -pub type NV_NGX_DLSS_OVERRIDE_GET_STATE_PARAMS_V1 = _NV_NGX_DLSS_OVERRIDE_GET_STATE_PARAMS_V1; -pub type NV_NGX_DLSS_OVERRIDE_GET_STATE_PARAMS = NV_NGX_DLSS_OVERRIDE_GET_STATE_PARAMS_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_NGX_DLSS_OVERRIDE_SET_STATE_PARAMS_V1 { - #[doc = "!< [in] Structure version"] - pub version: NvU32, - #[doc = "!< [in] Process identifier of caller"] - pub processIdentifier: NvU32, - #[doc = "!< [in] DLSS feature ID"] - pub feature: NvU32, - #[doc = "!< [in] Feedback bits for DLSS feature"] - pub feedbackMask: NvU64, - #[doc = "!< Reserved for future use. Must be zero."] - pub reserved: [NvU64; 4usize], -} -pub type NV_NGX_DLSS_OVERRIDE_SET_STATE_PARAMS_V1 = _NV_NGX_DLSS_OVERRIDE_SET_STATE_PARAMS_V1; -pub type NV_NGX_DLSS_OVERRIDE_SET_STATE_PARAMS = NV_NGX_DLSS_OVERRIDE_SET_STATE_PARAMS_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NVVIOTOPOLOGYTARGET { - #[doc = "!< Handle to Physical GPU (This could be NULL for GVI device if its not binded)"] - pub hPhysicalGpu: NvPhysicalGpuHandle, - #[doc = "!, -} -impl _NV_DISPLAY_DRIVER_INFO { - #[inline] - pub fn bIsDCHDriver(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsDCHDriver(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsDCHDriver_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsDCHDriver_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bIsNVIDIAStudioPackage(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsNVIDIAStudioPackage(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsNVIDIAStudioPackage_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsNVIDIAStudioPackage_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bIsNVIDIAGameReadyPackage(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsNVIDIAGameReadyPackage(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsNVIDIAGameReadyPackage_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsNVIDIAGameReadyPackage_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bIsNVIDIARTXProductionBranchPackage(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsNVIDIARTXProductionBranchPackage(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsNVIDIARTXProductionBranchPackage_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsNVIDIARTXProductionBranchPackage_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bIsNVIDIARTXNewFeatureBranchPackage(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsNVIDIARTXNewFeatureBranchPackage(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsNVIDIARTXNewFeatureBranchPackage_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsNVIDIARTXNewFeatureBranchPackage_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 27u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 27u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 27u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bIsDCHDriver: NvU32, - bIsNVIDIAStudioPackage: NvU32, - bIsNVIDIAGameReadyPackage: NvU32, - bIsNVIDIARTXProductionBranchPackage: NvU32, - bIsNVIDIARTXNewFeatureBranchPackage: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsDCHDriver: u32 = unsafe { ::std::mem::transmute(bIsDCHDriver) }; - bIsDCHDriver as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let bIsNVIDIAStudioPackage: u32 = - unsafe { ::std::mem::transmute(bIsNVIDIAStudioPackage) }; - bIsNVIDIAStudioPackage as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let bIsNVIDIAGameReadyPackage: u32 = - unsafe { ::std::mem::transmute(bIsNVIDIAGameReadyPackage) }; - bIsNVIDIAGameReadyPackage as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let bIsNVIDIARTXProductionBranchPackage: u32 = - unsafe { ::std::mem::transmute(bIsNVIDIARTXProductionBranchPackage) }; - bIsNVIDIARTXProductionBranchPackage as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let bIsNVIDIARTXNewFeatureBranchPackage: u32 = - unsafe { ::std::mem::transmute(bIsNVIDIARTXNewFeatureBranchPackage) }; - bIsNVIDIARTXNewFeatureBranchPackage as u64 - }); - __bindgen_bitfield_unit.set(5usize, 27u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_DISPLAY_DRIVER_INFO_V1 = _NV_DISPLAY_DRIVER_INFO; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_DISPLAY_DRIVER_INFO_V2 { - #[doc = "!< Structure Version."] - pub version: NvU32, - #[doc = "!< Contains the driver version after successful return."] - pub driverVersion: NvU32, - #[doc = "!< Contains the driver-branch string after successful return."] - pub szBuildBranch: NvAPI_ShortString, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< (OUT) Contains the driver base branch string after successful return."] - pub szBuildBaseBranch: NvAPI_ShortString, - #[doc = "!< Reserved for future use"] - pub reservedEx: NvU32, -} -impl _NV_DISPLAY_DRIVER_INFO_V2 { - #[inline] - pub fn bIsDCHDriver(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsDCHDriver(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsDCHDriver_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsDCHDriver_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bIsNVIDIAStudioPackage(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsNVIDIAStudioPackage(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsNVIDIAStudioPackage_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsNVIDIAStudioPackage_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bIsNVIDIAGameReadyPackage(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsNVIDIAGameReadyPackage(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsNVIDIAGameReadyPackage_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsNVIDIAGameReadyPackage_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bIsNVIDIARTXProductionBranchPackage(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsNVIDIARTXProductionBranchPackage(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsNVIDIARTXProductionBranchPackage_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsNVIDIARTXProductionBranchPackage_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bIsNVIDIARTXNewFeatureBranchPackage(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsNVIDIARTXNewFeatureBranchPackage(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsNVIDIARTXNewFeatureBranchPackage_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsNVIDIARTXNewFeatureBranchPackage_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 27u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 27u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 27u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bIsDCHDriver: NvU32, - bIsNVIDIAStudioPackage: NvU32, - bIsNVIDIAGameReadyPackage: NvU32, - bIsNVIDIARTXProductionBranchPackage: NvU32, - bIsNVIDIARTXNewFeatureBranchPackage: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsDCHDriver: u32 = unsafe { ::std::mem::transmute(bIsDCHDriver) }; - bIsDCHDriver as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let bIsNVIDIAStudioPackage: u32 = - unsafe { ::std::mem::transmute(bIsNVIDIAStudioPackage) }; - bIsNVIDIAStudioPackage as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let bIsNVIDIAGameReadyPackage: u32 = - unsafe { ::std::mem::transmute(bIsNVIDIAGameReadyPackage) }; - bIsNVIDIAGameReadyPackage as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let bIsNVIDIARTXProductionBranchPackage: u32 = - unsafe { ::std::mem::transmute(bIsNVIDIARTXProductionBranchPackage) }; - bIsNVIDIARTXProductionBranchPackage as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let bIsNVIDIARTXNewFeatureBranchPackage: u32 = - unsafe { ::std::mem::transmute(bIsNVIDIARTXNewFeatureBranchPackage) }; - bIsNVIDIARTXNewFeatureBranchPackage as u64 - }); - __bindgen_bitfield_unit.set(5usize, 27u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_DISPLAY_DRIVER_INFO_V2 = _NV_DISPLAY_DRIVER_INFO_V2; -pub type NV_DISPLAY_DRIVER_INFO = NV_DISPLAY_DRIVER_INFO_V2; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_PHYSICAL_GPU_HANDLE_DATA { - pub hPhysicalGpu: NvPhysicalGpuHandle, - pub adapterType: NV_ADAPTER_TYPE, - pub reserved2: [NvU32; 4usize], -} -pub type NV_PHYSICAL_GPU_HANDLE_DATA = _NV_PHYSICAL_GPU_HANDLE_DATA; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_PHYSICAL_GPUS { - pub version: NvU32, - pub gpuHandleData: [NV_PHYSICAL_GPU_HANDLE_DATA; 64usize], - pub gpuHandleCount: NvU32, - pub reserved: [NvU32; 4usize], -} -pub type NV_PHYSICAL_GPUS_V1 = _NV_PHYSICAL_GPUS; -pub type NV_PHYSICAL_GPUS = NV_PHYSICAL_GPUS_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LOGICAL_GPU_HANDLE_DATA { - pub hLogicalGpu: NvLogicalGpuHandle, - pub adapterType: NV_ADAPTER_TYPE, - pub reserved: [NvU32; 4usize], -} -pub type NV_LOGICAL_GPU_HANDLE_DATA = _NV_LOGICAL_GPU_HANDLE_DATA; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LOGICAL_GPUS { - pub version: NvU32, - pub gpuHandleData: [NV_LOGICAL_GPU_HANDLE_DATA; 64usize], - pub gpuHandleCount: NvU32, - pub reserved: [NvU32; 4usize], -} -pub type NV_LOGICAL_GPUS_V1 = _NV_LOGICAL_GPUS; -pub type NV_LOGICAL_GPUS = NV_LOGICAL_GPUS_V1; -pub const _NV_NGX_DRIVER_FEATURE_ID_NV_NGX_DRIVER_FEATURE_ID_SET_FLIP_CONFIG_V2: - _NV_NGX_DRIVER_FEATURE_ID = 3423695; -pub type _NV_NGX_DRIVER_FEATURE_ID = ::std::os::raw::c_int; -pub use self::_NV_NGX_DRIVER_FEATURE_ID as NV_NGX_DRIVER_FEATURE_ID; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_NGX_DRIVER_FEATURE_SUPPORT_INFO { - #[doc = "!< [IN] Feature ID to query"] - pub featureId: NV_NGX_DRIVER_FEATURE_ID, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Reserved for future use"] - pub reserved2: [NvU32; 2usize], -} -impl _NV_NGX_DRIVER_FEATURE_SUPPORT_INFO { - #[inline] - pub fn bSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved1(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved1(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved1_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved1_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bSupported: NvU32, - reserved1: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bSupported: u32 = unsafe { ::std::mem::transmute(bSupported) }; - bSupported as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved1: u32 = unsafe { ::std::mem::transmute(reserved1) }; - reserved1 as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_NGX_DRIVER_FEATURE_SUPPORT_INFO = _NV_NGX_DRIVER_FEATURE_SUPPORT_INFO; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_NGX_GET_DRIVER_FEATURE_SUPPORT_PARAMS_V1 { - #[doc = "!< [IN] Structure version"] - pub version: NvU32, - #[doc = "!< [IN] Number of features to query (must be <= NVAPI_MAX_NGX_FEATURES_PER_QUERY)"] - pub featureCount: NvU32, - #[doc = "!< [INOUT] Feature query array"] - pub featureSupportInfo: [NV_NGX_DRIVER_FEATURE_SUPPORT_INFO; 16usize], - #[doc = "!< Reserved for future use"] - pub reserved: [NvU32; 6usize], -} -pub type NV_NGX_GET_DRIVER_FEATURE_SUPPORT_PARAMS_V1 = _NV_NGX_GET_DRIVER_FEATURE_SUPPORT_PARAMS_V1; -pub type NV_NGX_GET_DRIVER_FEATURE_SUPPORT_PARAMS = NV_NGX_GET_DRIVER_FEATURE_SUPPORT_PARAMS_V1; -#[doc = " Callback settings common to all client callbacks."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1 { - #[doc = " [in] Generic callback parameter which will be passed to the callback."] - pub pCallbackParam: *mut ::std::os::raw::c_void, - #[doc = " Reserved bytes for future expansion."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Callback settings common to all client callbacks."] -pub type NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1 = _NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1; -#[doc = " Callback settings common to all client callbacks."] -pub type NV_GPU_CLIENT_CALLBACK_SETTINGS_SUPER_V1 = NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1; -#[doc = " Callback settings common to all periodic client callbacks."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_PERIODIC_CALLBACK_SETTINGS_SUPER_V1 { - #[doc = " [in] Super class data."] - pub super_: NV_GPU_CLIENT_CALLBACK_SETTINGS_SUPER_V1, - #[doc = " [in] Minimum interval at which callback will be called.\n\n The callback may be invoked slower than this interval if underlying\n sampling rate does not align precisely to the provided period."] - pub callbackPeriodms: NvU32, - #[doc = " Reserved bytes for future expansion."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Callback settings common to all periodic client callbacks."] -pub type NV_GPU_CLIENT_PERIODIC_CALLBACK_SETTINGS_SUPER_V1 = - _NV_GPU_CLIENT_PERIODIC_CALLBACK_SETTINGS_SUPER_V1; -#[doc = " Callback data common to all client callbacks."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_CALLBACK_DATA_SUPER_V1 { - #[doc = " [out] Generic callback parameter which was passed in at registration time."] - pub pCallbackParam: *mut ::std::os::raw::c_void, - #[doc = " Reserved bytes for future expansion."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Callback data common to all client callbacks."] -pub type NV_GPU_CLIENT_CALLBACK_DATA_SUPER_V1 = _NV_GPU_CLIENT_CALLBACK_DATA_SUPER_V1; -pub const _NV_GPU_CLIENT_UTIL_DOMAIN_ID_NV_GPU_CLIENT_UTIL_DOMAIN_GRAPHICS: - _NV_GPU_CLIENT_UTIL_DOMAIN_ID = 0; -pub const _NV_GPU_CLIENT_UTIL_DOMAIN_ID_NV_GPU_CLIENT_UTIL_DOMAIN_FRAME_BUFFER: - _NV_GPU_CLIENT_UTIL_DOMAIN_ID = 1; -pub const _NV_GPU_CLIENT_UTIL_DOMAIN_ID_NV_GPU_CLIENT_UTIL_DOMAIN_VIDEO: - _NV_GPU_CLIENT_UTIL_DOMAIN_ID = 2; -#[doc = " Reserved for future use."] -pub const _NV_GPU_CLIENT_UTIL_DOMAIN_ID_NV_GPU_CLIENT_UTIL_DOMAIN_RSVD: - _NV_GPU_CLIENT_UTIL_DOMAIN_ID = 3; -#[doc = " Enumeration of different utilization domains"] -pub type _NV_GPU_CLIENT_UTIL_DOMAIN_ID = ::std::os::raw::c_int; -#[doc = " Enumeration of different utilization domains"] -pub use self::_NV_GPU_CLIENT_UTIL_DOMAIN_ID as NV_GPU_CLIENT_UTIL_DOMAIN_ID; -#[doc = " Data specific to a single utilization domain."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_UTILIZATION_DATA_V1 { - #[doc = " [out] Utilization domain identifier."] - pub utilId: NV_GPU_CLIENT_UTIL_DOMAIN_ID, - #[doc = " [out] Percentage of time where the domain is considered busy since the\n last sample. Units of percent*100; i.e. 5000 = 50%."] - pub utilizationPercent: NvU32, - #[doc = " Reserved bytes for future expansion."] - pub rsvd: [NvU8; 61usize], -} -#[doc = " Data specific to a single utilization domain."] -pub type NV_GPU_CLIENT_UTILIZATION_DATA_V1 = _NV_GPU_CLIENT_UTILIZATION_DATA_V1; -#[doc = " Data passed back to callback registered with\n @ref NvAPI_GPU_ClientRegisterForUtilizationSampleUpdates."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_CALLBACK_UTILIZATION_DATA_V1 { - #[doc = " [out] Super struct."] - pub super_: NV_GPU_CLIENT_CALLBACK_DATA_SUPER_V1, - #[doc = " [out] Number of valid entries in `utils` array."] - pub numUtils: NvU32, - #[doc = " [out] Time at which data was collected. Represented as elapsed\n microseconds since 00:00:00 UTC on January 1, 1970."] - pub timestamp: NvU64, - #[doc = " Reserved bytes for future expansion."] - pub rsvd: [NvU8; 64usize], - #[doc = " [out] Status data for each utilization domain."] - pub utils: [NV_GPU_CLIENT_UTILIZATION_DATA_V1; 4usize], -} -#[doc = " Data passed back to callback registered with\n @ref NvAPI_GPU_ClientRegisterForUtilizationSampleUpdates."] -pub type NV_GPU_CLIENT_CALLBACK_UTILIZATION_DATA_V1 = _NV_GPU_CLIENT_CALLBACK_UTILIZATION_DATA_V1; -#[doc = " Function prototype for a periodic utilization data callback that will be registered with NvAPI."] -pub type NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_V1 = ::std::option::Option< - unsafe extern "C" fn( - hPhysicalGpu: NvPhysicalGpuHandle, - pData: *mut NV_GPU_CLIENT_CALLBACK_UTILIZATION_DATA_V1, - ), ->; -#[doc = " Data required to register a periodic callback for utilization data."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_SETTINGS_V1 { - #[doc = " [in] Structure Version, must always be first."] - pub version: NvU32, - #[doc = " [in] Generic callback settings. Some data within will be passed to the\n callback when invoked."] - pub super_: NV_GPU_CLIENT_PERIODIC_CALLBACK_SETTINGS_SUPER_V1, - #[doc = " [in] Callback. Pass in NULL or nullptr to indicate request to unregister."] - pub callback: NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_V1, - #[doc = " Reserved bytes for future expansion."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Data required to register a periodic callback for utilization data."] -pub type NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_SETTINGS_V1 = - _NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_SETTINGS_V1; -#[doc = " Data required to register a periodic callback for utilization data."] -pub type NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_SETTINGS = - NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_SETTINGS_V1; -pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_INVALID: _NV_RISE_CONTENT_TYPE = 0; -pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_TEXT: _NV_RISE_CONTENT_TYPE = 1; -pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_GRAPH: _NV_RISE_CONTENT_TYPE = 2; -pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_CUSTOM_BEHAVIOR: _NV_RISE_CONTENT_TYPE = 3; -pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_CUSTOM_BEHAVIOR_RESULT: _NV_RISE_CONTENT_TYPE = - 4; -pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_INSTALLING: _NV_RISE_CONTENT_TYPE = 5; -pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_PROGRESS_UPDATE: _NV_RISE_CONTENT_TYPE = 6; -pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_READY: _NV_RISE_CONTENT_TYPE = 7; -pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_DOWNLOAD_REQUEST: _NV_RISE_CONTENT_TYPE = 8; -pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_UPDATE_INFO: _NV_RISE_CONTENT_TYPE = 9; -#[doc = " Enumeration of different RISE content types."] -pub type _NV_RISE_CONTENT_TYPE = ::std::os::raw::c_int; -#[doc = " Enumeration of different RISE content types."] -pub use self::_NV_RISE_CONTENT_TYPE as NV_RISE_CONTENT_TYPE; -#[doc = " Data passed back to callback."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_RISE_CALLBACK_DATA_V1 { - #[doc = " Super struct."] - pub super_: NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1, - #[doc = " RISE type of content"] - pub contentType: NV_RISE_CONTENT_TYPE, - #[doc = " RISE content."] - pub content: NvAPI_String, - #[doc = " Is this the last in the batch?"] - pub completed: NvBool, -} -#[doc = " Data passed back to callback."] -pub type NV_RISE_CALLBACK_DATA_V1 = _NV_RISE_CALLBACK_DATA_V1; -#[doc = " Callback for RISE update callbacks."] -pub type NV_RISE_CALLBACK_V1 = - ::std::option::Option; -#[doc = " Data required to register an update callback from the RISE."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_RISE_CALLBACK_SETTINGS_V1 { - #[doc = " [in] Structure Version, must always be first."] - pub version: NvU32, - #[doc = " [in] Generic callback parameter which will be passed to the callback."] - pub super_: NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1, - #[doc = " [in] Callback. Pass in NULL or nullptr to indicate request to unregister."] - pub callback: NV_RISE_CALLBACK_V1, - #[doc = " Reserved, must be set to zero by client."] - pub reserved: [NvU8; 32usize], -} -#[doc = " Data required to register an update callback from the RISE."] -pub type NV_RISE_CALLBACK_SETTINGS_V1 = _NV_RISE_CALLBACK_SETTINGS_V1; -#[doc = " Data required to register an update callback from the RISE."] -pub type NV_RISE_CALLBACK_SETTINGS = NV_RISE_CALLBACK_SETTINGS_V1; -#[doc = " Request contents sent to RISE."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_REQUEST_RISE_SETTINGS_V1 { - #[doc = " [in] Structure Version, must always be first."] - pub version: NvU32, - #[doc = " RISE type of content"] - pub contentType: NV_RISE_CONTENT_TYPE, - #[doc = " RISE request content."] - pub content: NvAPI_String, - #[doc = " Is the request fully sent?"] - pub completed: NvBool, - #[doc = " Reserved, must be set to zero by client."] - pub reserved: [NvU8; 32usize], -} -#[doc = " Request contents sent to RISE."] -pub type NV_REQUEST_RISE_SETTINGS_V1 = _NV_REQUEST_RISE_SETTINGS_V1; -#[doc = " Request contents sent to RISE."] -pub type NV_REQUEST_RISE_SETTINGS = NV_REQUEST_RISE_SETTINGS_V1; -#[doc = " Request contents sent to RISE."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_UNINSTALL_RISE_SETTINGS_V1 { - #[doc = " [in] Structure Version, must always be first."] - pub version: NvU32, - #[doc = " Reserved, must be set to zero by client."] - pub reserved: [NvU8; 32usize], -} -#[doc = " Request contents sent to RISE."] -pub type NV_UNINSTALL_RISE_SETTINGS_V1 = _NV_UNINSTALL_RISE_SETTINGS_V1; -#[doc = " Request contents sent to RISE."] -pub type NV_UNINSTALL_RISE_SETTINGS = NV_UNINSTALL_RISE_SETTINGS_V1; diff --git a/nvapi_trace/Cargo.toml b/nvapi_trace/Cargo.toml deleted file mode 100644 index ed86c5453..000000000 --- a/nvapi_trace/Cargo.toml +++ /dev/null @@ -1,29 +0,0 @@ -[package] -name = "nvapi_trace" -version = "0.0.0" -authors = ["Andrzej Janik "] -edition = "2021" - -[lib] -name = "nvapi_trace" -crate-type = ["cdylib"] - -[dependencies] -format = { path = "../format" } -dark_api = { path = "../dark_api" } -cuda_macros = { path = "../cuda_macros" } -cuda_types = { path = "../cuda_types" } -zluda_trace_common = { path = "../zluda_trace_common" } -libloading = "0.8" -paste = "1.0" -unwrap_or = "1.0.1" -cglue = "0.3.5" -dynasm = "5.0" -dynasmrt = "5.0" -rustc-hash = "2.0.0" - -[package.metadata.zluda] -windows_only = true -windows_paths = ["trace/nvapi64.dll"] -windows32_paths = ["trace/nvapi.dll"] -32bit = true diff --git a/nvapi_trace/src/lib.rs b/nvapi_trace/src/lib.rs deleted file mode 100644 index 9fcc8dd06..000000000 --- a/nvapi_trace/src/lib.rs +++ /dev/null @@ -1,704 +0,0 @@ -use libloading::Library; -use rustc_hash::FxHashMap; -use std::{ - collections::hash_map, - ffi::c_void, - mem, ptr, - sync::{LazyLock, Mutex}, -}; -use zluda_trace_common::ReprUsize; - -static GLOBAL_STATE: LazyLock)>> = - LazyLock::new(get_global_state); - -fn get_global_state() -> Option<(Library, Mutex)> { - let cuda_lib = std::env::var("ZLUDA_NVAPI_LIB").ok().unwrap_or_else(|| { - if cfg!(target_pointer_width = "64") { - r"C:\Windows\System32\nvapi64.dll".to_string() - } else { - r"C:\Windows\System32\nvapi.dll".to_string() - } - }); - let lib = zluda_trace_common::dlopen_local_noredirect(cuda_lib).ok()?; - Some((Library::from(lib), Mutex::new(GlobalState::new()))) -} - -struct GlobalState { - thunks: FxHashMap, -} - -impl GlobalState { - fn new() -> Self { - GlobalState { - thunks: FxHashMap::default(), - } - } - - fn get_thunk( - &mut self, - original: *mut c_void, - report_fn: unsafe extern "C" fn(i32, u32), - interface: u32, - ) -> *mut c_void { - match self.thunks.entry(interface) { - hash_map::Entry::Occupied(entry) => *entry.get() as *mut c_void, - hash_map::Entry::Vacant(entry) => { - let thunk = get_thunk(original, report_fn, interface); - entry.insert(thunk as usize); - thunk - } - } - } -} - -macro_rules! interface_to_name { - ($({ $name:literal, $id:literal }),* $(,)?) => { - fn interface_to_name(interface: u32) -> Option<&'static str> { - match interface { - $( - $id => Some($name), - )* - _ => None, - } - } - }; -} - -interface_to_name!( - { "NvAPI_Initialize", 0x0150e828 }, - { "NvAPI_Unload", 0xd22bdd7e }, - { "NvAPI_GetErrorMessage", 0x6c2d048c }, - { "NvAPI_GetInterfaceVersionString", 0x01053fa5 }, - { "NvAPI_GPU_GetEDID", 0x37d32e69 }, - { "NvAPI_SetView", 0x0957d7b6 }, - { "NvAPI_SetViewEx", 0x06b89e68 }, - { "NvAPI_GetDisplayDriverVersion", 0xf951a4d1 }, - { "NvAPI_SYS_GetDriverAndBranchVersion", 0x2926aaad }, - { "NvAPI_GPU_GetMemoryInfo", 0x07f9b368 }, - { "NvAPI_GPU_GetMemoryInfoEx", 0xc0599498 }, - { "NvAPI_OGL_ExpertModeSet", 0x3805ef7a }, - { "NvAPI_OGL_ExpertModeGet", 0x22ed9516 }, - { "NvAPI_OGL_ExpertModeDefaultsSet", 0xb47a657e }, - { "NvAPI_OGL_ExpertModeDefaultsGet", 0xae921f12 }, - { "NvAPI_EnumPhysicalGPUs", 0xe5ac921f }, - { "NvAPI_EnumTCCPhysicalGPUs", 0xd9930b07 }, - { "NvAPI_EnumLogicalGPUs", 0x48b3ea59 }, - { "NvAPI_GetPhysicalGPUsFromDisplay", 0x34ef9506 }, - { "NvAPI_GetPhysicalGPUFromUnAttachedDisplay", 0x5018ed61 }, - { "NvAPI_GetLogicalGPUFromDisplay", 0xee1370cf }, - { "NvAPI_GetLogicalGPUFromPhysicalGPU", 0xadd604d1 }, - { "NvAPI_GetPhysicalGPUsFromLogicalGPU", 0xaea3fa32 }, - { "NvAPI_GetPhysicalGPUFromGPUID", 0x5380ad1a }, - { "NvAPI_GetGPUIDfromPhysicalGPU", 0x6533ea3e }, - { "NvAPI_GPU_GetShaderSubPipeCount", 0x0be17923 }, - { "NvAPI_GPU_GetGpuCoreCount", 0xc7026a87 }, - { "NvAPI_GPU_GetAllOutputs", 0x7d554f8e }, - { "NvAPI_GPU_GetConnectedOutputs", 0x1730bfc9 }, - { "NvAPI_GPU_GetConnectedSLIOutputs", 0x0680de09 }, - { "NvAPI_GPU_GetConnectedDisplayIds", 0x0078dba2 }, - { "NvAPI_GPU_GetAllDisplayIds", 0x785210a2 }, - { "NvAPI_GPU_GetConnectedOutputsWithLidState", 0xcf8caf39 }, - { "NvAPI_GPU_GetConnectedSLIOutputsWithLidState", 0x96043cc7 }, - { "NvAPI_GPU_GetSystemType", 0xbaaabfcc }, - { "NvAPI_GPU_GetActiveOutputs", 0xe3e89b6f }, - { "NvAPI_GPU_SetEDID", 0xe83d6456 }, - { "NvAPI_GPU_GetOutputType", 0x40a505e4 }, - { "NvAPI_GPU_ValidateOutputCombination", 0x34c9c2d4 }, - { "NvAPI_GPU_GetFullName", 0xceee8e9f }, - { "NvAPI_GPU_GetPCIIdentifiers", 0x2ddfb66e }, - { "NvAPI_GPU_GetGPUType", 0xc33baeb1 }, - { "NvAPI_GPU_GetBusType", 0x1bb18724 }, - { "NvAPI_GPU_GetBusId", 0x1be0b8e5 }, - { "NvAPI_GPU_GetBusSlotId", 0x2a0a350f }, - { "NvAPI_GPU_GetIRQ", 0xe4715417 }, - { "NvAPI_GPU_GetVbiosRevision", 0xacc3da0a }, - { "NvAPI_GPU_GetVbiosOEMRevision", 0x2d43fb31 }, - { "NvAPI_GPU_GetVbiosVersionString", 0xa561fd7d }, - { "NvAPI_GPU_GetAGPAperture", 0x6e042794 }, - { "NvAPI_GPU_GetCurrentAGPRate", 0xc74925a0 }, - { "NvAPI_GPU_GetCurrentPCIEDownstreamWidth", 0xd048c3b1 }, - { "NvAPI_GPU_GetPhysicalFrameBufferSize", 0x46fbeb03 }, - { "NvAPI_GPU_GetVirtualFrameBufferSize", 0x5a04b644 }, - { "NvAPI_GPU_GetQuadroStatus", 0xe332fa47 }, - { "NvAPI_GPU_GetBoardInfo", 0x22d54523 }, - { "NvAPI_GPU_GetRamBusWidth", 0x7975c581 }, - { "NvAPI_GPU_GetArchInfo", 0xd8265d24 }, - { "NvAPI_I2CRead", 0x2fde12c5 }, - { "NvAPI_I2CWrite", 0xe812eb07 }, - { "NvAPI_GPU_WorkstationFeatureSetup", 0x6c1f3fe4 }, - { "NvAPI_GPU_WorkstationFeatureQuery", 0x004537df }, - { "NvAPI_GPU_GetHDCPSupportStatus", 0xf089eef5 }, - { "NvAPI_GPU_CudaEnumComputeCapableGpus", 0x5786cc6e }, - { "NvAPI_GPU_GetTachReading", 0x5f608315 }, - { "NvAPI_GPU_GetECCStatusInfo", 0xca1ddaf3 }, - { "NvAPI_GPU_GetECCErrorInfo", 0xc71f85a6 }, - { "NvAPI_GPU_ResetECCErrorInfo", 0xc02eec20 }, - { "NvAPI_GPU_GetECCConfigurationInfo", 0x77a796f3 }, - { "NvAPI_GPU_SetECCConfiguration", 0x1cf639d9 }, - { "NvAPI_GPU_QueryWorkstationFeatureSupport", 0x80b1abb9 }, - { "NvAPI_GPU_SetScanoutIntensity", 0xa57457a4 }, - { "NvAPI_GPU_GetScanoutIntensityState", 0xe81ce836 }, - { "NvAPI_GPU_SetScanoutWarping", 0xb34bab4f }, - { "NvAPI_GPU_GetScanoutWarpingState", 0x6f5435af }, - { "NvAPI_GPU_SetScanoutCompositionParameter", 0xf898247d }, - { "NvAPI_GPU_GetScanoutCompositionParameter", 0x58fe51e6 }, - { "NvAPI_GPU_GetScanoutConfiguration", 0x6a9f5b63 }, - { "NvAPI_GPU_GetScanoutConfigurationEx", 0xe2e1e6f0 }, - { "NvAPI_GPU_GetAdapterIdFromPhysicalGpu", 0x0ff07fde }, - { "NvAPI_GPU_GetVirtualizationInfo", 0x44e022a9 }, - { "NvAPI_GPU_GetLogicalGpuInfo", 0x842b066e }, - { "NvAPI_GPU_GetLicensableFeatures", 0x3fc596aa }, - { "NvAPI_GPU_GetEncoderStatistics", 0xf0a9aeeb }, - { "NvAPI_GPU_GetEncoderSessionsInfo", 0xd8a72ce5 }, - { "NvAPI_GPU_GetGPUInfo", 0xafd1b02c }, - { "NvAPI_GPU_GetVRReadyData", 0x81d629c5 }, - { "NvAPI_GPU_GetGspFeatures", 0x581c4391 }, - { "NvAPI_GPU_GetUUID", 0xdc95673d }, - { "NvAPI_GPU_NVLINK_GetCaps", 0xbef1119d }, - { "NvAPI_GPU_NVLINK_GetStatus", 0xc72a38e3 }, - { "NvAPI_GPU_GetPerfDecreaseInfo", 0x7f7f4600 }, - { "NvAPI_GPU_GetPstatesInfoEx", 0x843c0256 }, - { "NvAPI_GPU_GetPstates20", 0x6ff81213 }, - { "NvAPI_GPU_GetCurrentPstate", 0x927da4f6 }, - { "NvAPI_GPU_GetDynamicPstatesInfoEx", 0x60ded2ed }, - { "NvAPI_GPU_GetThermalSettings", 0xe3640a56 }, - { "NvAPI_GPU_GetAllClockFrequencies", 0xdcb616c3 }, - { "NvAPI_GPU_QueryIlluminationSupport", 0xa629da31 }, - { "NvAPI_GPU_GetIllumination", 0x9a1b9365 }, - { "NvAPI_GPU_SetIllumination", 0x0254a187 }, - { "NvAPI_GPU_ClientIllumDevicesGetInfo", 0xd4100e58 }, - { "NvAPI_GPU_ClientIllumDevicesGetControl", 0x73c01d58 }, - { "NvAPI_GPU_ClientIllumDevicesSetControl", 0x57024c62 }, - { "NvAPI_GPU_ClientIllumZonesGetInfo", 0x4b81241b }, - { "NvAPI_GPU_ClientIllumZonesGetControl", 0x3dbf5764 }, - { "NvAPI_GPU_ClientIllumZonesSetControl", 0x197d065e }, - { "NvAPI_Event_RegisterCallback", 0xe6dbea69 }, - { "NvAPI_Event_UnregisterCallback", 0xde1f9b45 }, - { "NvAPI_EnumNvidiaDisplayHandle", 0x9abdd40d }, - { "NvAPI_EnumNvidiaUnAttachedDisplayHandle", 0x20de9260 }, - { "NvAPI_CreateDisplayFromUnAttachedDisplay", 0x63f9799e }, - { "NvAPI_GetAssociatedNvidiaDisplayHandle", 0x35c29134 }, - { "NvAPI_DISP_GetAssociatedUnAttachedNvidiaDisplayHandle", 0xa70503b2 }, - { "NvAPI_GetAssociatedNvidiaDisplayName", 0x22a78b05 }, - { "NvAPI_GetUnAttachedAssociatedDisplayName", 0x4888d790 }, - { "NvAPI_EnableHWCursor", 0x2863148d }, - { "NvAPI_DisableHWCursor", 0xab163097 }, - { "NvAPI_GetVBlankCounter", 0x67b5db55 }, - { "NvAPI_SetRefreshRateOverride", 0x3092ac32 }, - { "NvAPI_GetAssociatedDisplayOutputId", 0xd995937e }, - { "NvAPI_GetDisplayPortInfo", 0xc64ff367 }, - { "NvAPI_SetDisplayPort", 0xfa13e65a }, - { "NvAPI_GetHDMISupportInfo", 0x6ae16ec3 }, - { "NvAPI_Disp_InfoFrameControl", 0x6067af3f }, - { "NvAPI_Disp_ColorControl", 0x92f9d80d }, - { "NvAPI_Disp_GetHdrCapabilities", 0x84f2a8df }, - { "NvAPI_Disp_HdrColorControl", 0x351da224 }, - { "NvAPI_Disp_SetSourceColorSpace", 0x473b6caf }, - { "NvAPI_Disp_GetSourceColorSpace", 0xceedc85b }, - { "NvAPI_Disp_SetSourceHdrMetadata", 0x905eb63b }, - { "NvAPI_Disp_GetSourceHdrMetadata", 0x0d3f52da }, - { "NvAPI_Disp_SetOutputMode", 0x98e7661a }, - { "NvAPI_Disp_GetOutputMode", 0x81fed88d }, - { "NvAPI_Disp_SetHdrToneMapping", 0xdd6da362 }, - { "NvAPI_Disp_GetHdrToneMapping", 0xfbd36e71 }, - { "NvAPI_Disp_GetColorimetry", 0x00b421ad }, - { "NvAPI_DISP_GetTiming", 0x175167e9 }, - { "NvAPI_DISP_GetMonitorCapabilities", 0x3b05c7e1 }, - { "NvAPI_DISP_GetMonitorColorCapabilities", 0x6ae4cfb5 }, - { "NvAPI_DISP_EnumCustomDisplay", 0xa2072d59 }, - { "NvAPI_DISP_TryCustomDisplay", 0x1f7db630 }, - { "NvAPI_DISP_DeleteCustomDisplay", 0x552e5b9b }, - { "NvAPI_DISP_SaveCustomDisplay", 0x49882876 }, - { "NvAPI_DISP_RevertCustomDisplayTrial", 0xcbbd40f0 }, - { "NvAPI_GetView", 0xd6b99d89 }, - { "NvAPI_GetViewEx", 0xdbbc0af4 }, - { "NvAPI_GetSupportedViews", 0x66fb7fc0 }, - { "NvAPI_DISP_GetDisplayIdByDisplayName", 0xae457190 }, - { "NvAPI_DISP_GetGDIPrimaryDisplayId", 0x1e9d8a31 }, - { "NvAPI_DISP_GetDisplayConfig", 0x11abccf8 }, - { "NvAPI_DISP_SetDisplayConfig", 0x5d8cf8de }, - { "NvAPI_DISP_GetEdidData", 0x436ced76 }, - { "NvAPI_DISP_GetAdaptiveSyncData", 0xb73d1ee9 }, - { "NvAPI_DISP_SetAdaptiveSyncData", 0x3eebba1d }, - { "NvAPI_DISP_GetVirtualRefreshRateData", 0x8c00429a }, - { "NvAPI_DISP_SetVirtualRefreshRateData", 0x5abbe6a3 }, - { "NvAPI_DISP_SetPreferredStereoDisplay", 0xc9d0e25f }, - { "NvAPI_DISP_GetPreferredStereoDisplay", 0x1f6b4666 }, - { "NvAPI_DISP_GetNvManagedDedicatedDisplays", 0xdbdf0cb2 }, - { "NvAPI_DISP_AcquireDedicatedDisplay", 0x47c917ba }, - { "NvAPI_DISP_ReleaseDedicatedDisplay", 0x1247825f }, - { "NvAPI_DISP_GetNvManagedDedicatedDisplayMetadata", 0xd645d80c }, - { "NvAPI_DISP_SetNvManagedDedicatedDisplayMetadata", 0x3d8b129a }, - { "NvAPI_Disp_GetDisplayIdInfo", 0xbae8aa5e }, - { "NvAPI_Disp_GetDisplayIdsFromTarget", 0xe7e5f89e }, - { "NvAPI_Disp_GetVRRInfo", 0xdf8fda57 }, - { "NvAPI_Mosaic_GetSupportedTopoInfo", 0xfdb63c81 }, - { "NvAPI_Mosaic_GetTopoGroup", 0xcb89381d }, - { "NvAPI_Mosaic_GetOverlapLimits", 0x989685f0 }, - { "NvAPI_Mosaic_SetCurrentTopo", 0x9b542831 }, - { "NvAPI_Mosaic_GetCurrentTopo", 0xec32944e }, - { "NvAPI_Mosaic_EnableCurrentTopo", 0x5f1aa66c }, - { "NvAPI_Mosaic_GetDisplayViewportsByResolution", 0xdc6dc8d3 }, - { "NvAPI_Mosaic_SetDisplayGrids", 0x4d959a89 }, - { "NvAPI_Mosaic_ValidateDisplayGrids", 0xcf43903d }, - { "NvAPI_Mosaic_EnumDisplayModes", 0x78db97d7 }, - { "NvAPI_Mosaic_EnumDisplayGrids", 0xdf2887af }, - { "NvAPI_GetSupportedMosaicTopologies", 0x410b5c25 }, - { "NvAPI_GetCurrentMosaicTopology", 0xf60852bd }, - { "NvAPI_SetCurrentMosaicTopology", 0xd54b8989 }, - { "NvAPI_EnableCurrentMosaicTopology", 0x74073cc9 }, - { "NvAPI_GSync_EnumSyncDevices", 0xd9639601 }, - { "NvAPI_GSync_QueryCapabilities", 0x44a3f1d1 }, - { "NvAPI_GSync_GetTopology", 0x4562bc38 }, - { "NvAPI_GSync_SetSyncStateSettings", 0x60acdfdd }, - { "NvAPI_GSync_GetControlParameters", 0x16de1c6a }, - { "NvAPI_GSync_SetControlParameters", 0x8bbff88b }, - { "NvAPI_GSync_AdjustSyncDelay", 0x2d11ff51 }, - { "NvAPI_GSync_GetSyncStatus", 0xf1f5b434 }, - { "NvAPI_GSync_GetStatusParameters", 0x70d404ec }, - { "NvAPI_D3D_GetCurrentSLIState", 0x4b708b54 }, - { "NvAPI_D3D9_RegisterResource", 0xa064bdfc }, - { "NvAPI_D3D9_UnregisterResource", 0xbb2b17aa }, - { "NvAPI_D3D9_AliasSurfaceAsTexture", 0xe5ceae41 }, - { "NvAPI_D3D9_StretchRectEx", 0x22de03aa }, - { "NvAPI_D3D9_ClearRT", 0x332d3942 }, - { "NvAPI_D3D_GetObjectHandleForResource", 0xfceac864 }, - { "NvAPI_D3D_SetResourceHint", 0x6c0ed98c }, - { "NvAPI_D3D_BeginResourceRendering", 0x91123d6a }, - { "NvAPI_D3D_EndResourceRendering", 0x37e7191c }, - { "NvAPI_D3D9_GetSurfaceHandle", 0x0f2dd3f2 }, - { "NvAPI_D3D9_VideoSetStereoInfo", 0xb852f4db }, - { "NvAPI_D3D10_SetDepthBoundsTest", 0x4eadf5d2 }, - { "NvAPI_D3D11_CreateDevice", 0x6a16d3a0 }, - { "NvAPI_D3D11_CreateDeviceAndSwapChain", 0xbb939ee5 }, - { "NvAPI_D3D11_SetDepthBoundsTest", 0x7aaf7a04 }, - { "NvAPI_D3D11_IsNvShaderExtnOpCodeSupported", 0x5f68da40 }, - { "NvAPI_D3D11_SetNvShaderExtnSlot", 0x8e90bb9f }, - { "NvAPI_D3D12_SetNvShaderExtnSlotSpace", 0xac2dfeb5 }, - { "NvAPI_D3D12_SetNvShaderExtnSlotSpaceLocalThread", 0x43d867c0 }, - { "NvAPI_D3D11_SetNvShaderExtnSlotLocalThread", 0x0e6482a0 }, - { "NvAPI_D3D11_BeginUAVOverlapEx", 0xba08208a }, - { "NvAPI_D3D11_BeginUAVOverlap", 0x65b93ca8 }, - { "NvAPI_D3D11_EndUAVOverlap", 0x2216a357 }, - { "NvAPI_D3D11_GetResourceHandle", 0x09d52986 }, - { "NvAPI_D3D_SetFPSIndicatorState", 0xa776e8db }, - { "NvAPI_D3D9_Present", 0x05650beb }, - { "NvAPI_D3D9_QueryFrameCount", 0x9083e53a }, - { "NvAPI_D3D9_ResetFrameCount", 0xfa6a0675 }, - { "NvAPI_D3D9_QueryMaxSwapGroup", 0x5995410d }, - { "NvAPI_D3D9_QuerySwapGroup", 0xeba4d232 }, - { "NvAPI_D3D9_JoinSwapGroup", 0x7d44bb54 }, - { "NvAPI_D3D9_BindSwapBarrier", 0x9c39c246 }, - { "NvAPI_D3D_SetVerticalSyncMode", 0x5526cfd1 }, - { "NvAPI_D3D1x_Present", 0x03b845a1 }, - { "NvAPI_D3D1x_QueryFrameCount", 0x9152e055 }, - { "NvAPI_D3D1x_ResetFrameCount", 0xfbbb031a }, - { "NvAPI_D3D1x_QueryMaxSwapGroup", 0x9bb9d68f }, - { "NvAPI_D3D1x_QuerySwapGroup", 0x407f67aa }, - { "NvAPI_D3D1x_JoinSwapGroup", 0x14610cd7 }, - { "NvAPI_D3D1x_BindSwapBarrier", 0x9de8c729 }, - { "NvAPI_D3D12_QueryPresentBarrierSupport", 0xa15faef7 }, - { "NvAPI_D3D12_CreatePresentBarrierClient", 0x4d815de9 }, - { "NvAPI_D3D12_RegisterPresentBarrierResources", 0xd53c9ef0 }, - { "NvAPI_DestroyPresentBarrierClient", 0x3c5c351b }, - { "NvAPI_JoinPresentBarrier", 0x17f6bf82 }, - { "NvAPI_LeavePresentBarrier", 0xc3ec5a7f }, - { "NvAPI_QueryPresentBarrierFrameStatistics", 0x61b844a1 }, - { "NvAPI_D3D12_CreateDDisplayPresentBarrierClient", 0xb5a21987 }, - { "NvAPI_D3D11_CreateRasterizerState", 0xdb8d28af }, - { "NvAPI_D3D_ConfigureAnsel", 0x341c6c7f }, - { "NvAPI_D3D11_CreateTiledTexture2DArray", 0x7886981a }, - { "NvAPI_D3D11_CheckFeatureSupport", 0x106a487e }, - { "NvAPI_D3D11_CreateImplicitMSAATexture2D", 0xb8f79632 }, - { "NvAPI_D3D12_CreateCommittedImplicitMSAATexture2D", 0x24c6a07b }, - { "NvAPI_D3D11_ResolveSubresourceRegion", 0xe6bfedd6 }, - { "NvAPI_D3D12_ResolveSubresourceRegion", 0xc24a15bf }, - { "NvAPI_D3D11_TiledTexture2DArrayGetDesc", 0xf1a2b9d5 }, - { "NvAPI_D3D11_UpdateTileMappings", 0x9a06ea07 }, - { "NvAPI_D3D11_CopyTileMappings", 0xc09ee6bc }, - { "NvAPI_D3D11_TiledResourceBarrier", 0xd6839099 }, - { "NvAPI_D3D11_AliasMSAATexture2DAsNonMSAA", 0xf1c54fc9 }, - { "NvAPI_D3D11_CreateGeometryShaderEx_2", 0x99ed5c1c }, - { "NvAPI_D3D11_CreateVertexShaderEx", 0x0beaa0b2 }, - { "NvAPI_D3D11_CreateHullShaderEx", 0xb53cab00 }, - { "NvAPI_D3D11_CreateDomainShaderEx", 0xa0d7180d }, - { "NvAPI_D3D11_CreatePixelShaderEx_2", 0x4162822b }, - { "NvAPI_D3D11_CreateFastGeometryShaderExplicit", 0x71ab7c9c }, - { "NvAPI_D3D11_CreateFastGeometryShader", 0x525d43be }, - { "NvAPI_D3D11_DecompressView", 0x3a94e822 }, - { "NvAPI_D3D12_CreateGraphicsPipelineState", 0x2fc28856 }, - { "NvAPI_D3D12_CreateComputePipelineState", 0x2762deac }, - { "NvAPI_D3D12_SetDepthBoundsTestValues", 0xb9333fe9 }, - { "NvAPI_D3D12_CreateReservedResource", 0x2c85f101 }, - { "NvAPI_D3D12_CreateHeap", 0x5cb397cf }, - { "NvAPI_D3D12_CreateHeap2", 0x924be9d6 }, - { "NvAPI_D3D12_QueryCpuVisibleVidmem", 0x26322bc3 }, - { "NvAPI_D3D12_ReservedResourceGetDesc", 0x9aa2aabb }, - { "NvAPI_D3D12_UpdateTileMappings", 0xc6017a7d }, - { "NvAPI_D3D12_CopyTileMappings", 0x47f78194 }, - { "NvAPI_D3D12_ResourceAliasingBarrier", 0xb942bab7 }, - { "NvAPI_D3D12_CaptureUAVInfo", 0x6e5ea9db }, - { "NvAPI_D3D11_GetResourceGPUVirtualAddressEx", 0xaf6d14da }, - { "NvAPI_D3D11_EnumerateMetaCommands", 0xc7453ba8 }, - { "NvAPI_D3D11_CreateMetaCommand", 0xf505fba0 }, - { "NvAPI_D3D11_InitializeMetaCommand", 0xaec629e9 }, - { "NvAPI_D3D11_ExecuteMetaCommand", 0x82236c47 }, - { "NvAPI_D3D12_EnumerateMetaCommands", 0xcd9141d8 }, - { "NvAPI_D3D12_CreateMetaCommand", 0xeb29634b }, - { "NvAPI_D3D12_InitializeMetaCommand", 0xa4125399 }, - { "NvAPI_D3D12_ExecuteMetaCommand", 0xde24fc3d }, - { "NvAPI_D3D12_CreateCommittedResource", 0x027e98ae }, - { "NvAPI_D3D12_GetCopyableFootprints", 0xf6305eb5 }, - { "NvAPI_D3D12_CopyTextureRegion", 0x82b91b25 }, - { "NvAPI_D3D12_IsNvShaderExtnOpCodeSupported", 0x3dfacec8 }, - { "NvAPI_D3D12_GetOptimalThreadCountForMesh", 0xb43995cb }, - { "NvAPI_D3D_IsGSyncCapable", 0x9c1eed78 }, - { "NvAPI_D3D_IsGSyncActive", 0xe942b0ff }, - { "NvAPI_D3D12_SetFlipConfig", 0xf3148c42 }, - { "NvAPI_D3D1x_DisableShaderDiskCache", 0xd0cbca7d }, - { "NvAPI_D3D11_MultiGPU_GetCaps", 0xd2d25687 }, - { "NvAPI_D3D11_MultiGPU_Init", 0x017be49e }, - { "NvAPI_D3D11_CreateMultiGPUDevice", 0xbdb20007 }, - { "NvAPI_D3D_QuerySinglePassStereoSupport", 0x6f5f0a6d }, - { "NvAPI_D3D_SetSinglePassStereoMode", 0xa39e6e6e }, - { "NvAPI_D3D12_QuerySinglePassStereoSupport", 0x3b03791b }, - { "NvAPI_D3D12_SetSinglePassStereoMode", 0x83556d87 }, - { "NvAPI_D3D_QueryMultiViewSupport", 0xb6e0a41c }, - { "NvAPI_D3D_SetMultiViewMode", 0x8285c8da }, - { "NvAPI_D3D_QueryModifiedWSupport", 0xcbf9f4f5 }, - { "NvAPI_D3D_SetModifiedWMode", 0x06ea4bf4 }, - { "NvAPI_D3D12_QueryModifiedWSupport", 0x51235248 }, - { "NvAPI_D3D12_SetModifiedWMode", 0xe1fdaba7 }, - { "NvAPI_D3D_CreateLateLatchObject", 0x2db27d09 }, - { "NvAPI_D3D_QueryLateLatchSupport", 0x8ceca0ec }, - { "NvAPI_D3D_RegisterDevice", 0x8c02c4d0 }, - { "NvAPI_D3D11_MultiDrawInstancedIndirect", 0xd4e26bbf }, - { "NvAPI_D3D11_MultiDrawIndexedInstancedIndirect", 0x59e890f9 }, - { "NvAPI_D3D_ImplicitSLIControl", 0x2aede111 }, - { "NvAPI_D3D12_GetNeedsAppFPBlendClamping", 0x6ef4d2d1 }, - { "NvAPI_D3D12_UseDriverHeapPriorities", 0xf0d978a8 }, - { "NvAPI_D3D12_Mosaic_GetCompanionAllocations", 0xa46022c7 }, - { "NvAPI_D3D12_Mosaic_GetViewportAndGpuPartitions", 0xb092b818 }, - { "NvAPI_D3D1x_GetGraphicsCapabilities", 0x52b1499a }, - { "NvAPI_D3D12_GetGraphicsCapabilities", 0x01e87354 }, - { "NvAPI_D3D11_RSSetExclusiveScissorRects", 0xae4d73ef }, - { "NvAPI_D3D11_RSSetViewportsPixelShadingRates", 0x34f7938f }, - { "NvAPI_D3D11_CreateShadingRateResourceView", 0x99ca2dff }, - { "NvAPI_D3D11_RSSetShadingRateResourceView", 0x1b0c2f83 }, - { "NvAPI_D3D11_RSGetPixelShadingRateSampleOrder", 0x092442a1 }, - { "NvAPI_D3D11_RSSetPixelShadingRateSampleOrder", 0xa942373a }, - { "NvAPI_D3D_InitializeVRSHelper", 0x4780d70b }, - { "NvAPI_D3D_InitializeNvGazeHandler", 0x5b3b7479 }, - { "NvAPI_D3D_InitializeSMPAssist", 0x42763d0c }, - { "NvAPI_D3D_QuerySMPAssistSupport", 0xc57921de }, - { "NvAPI_D3D_GetSleepStatus", 0xaef96ca1 }, - { "NvAPI_D3D_SetSleepMode", 0xac1ca9e0 }, - { "NvAPI_D3D_Sleep", 0x852cd1d2 }, - { "NvAPI_D3D_SetReflexSync", 0xb9f6faff }, - { "NvAPI_D3D_GetLatency", 0x1a587f9c }, - { "NvAPI_D3D_SetLatencyMarker", 0xd9984c05 }, - { "NvAPI_D3D12_SetAsyncFrameMarker", 0x13c98f73 }, - { "NvAPI_D3D11_SetAsyncFrameMarker", 0x59c2c510 }, - { "NvAPI_D3D12_NotifyOutOfBandCommandQueue", 0x03d6e8cb }, - { "NvAPI_D3D12_SetCreateCommandQueueLowLatencyHint", 0x548c224f }, - { "NvAPI_D3D12_CreateCubinComputeShaderExV2", 0x299f5fdc }, - { "NvAPI_D3D12_CreateCubinComputeShader", 0x2a2c79e8 }, - { "NvAPI_D3D12_CreateCubinComputeShaderEx", 0x3151211b }, - { "NvAPI_D3D12_CreateCubinComputeShaderWithName", 0x1dc7261f }, - { "NvAPI_D3D12_LaunchCubinShader", 0x5c52bb86 }, - { "NvAPI_D3D12_DestroyCubinComputeShader", 0x7fb785ba }, - { "NvAPI_D3D12_GetCudaMergedTextureSamplerObject", 0x329fe6e0 }, - { "NvAPI_D3D12_GetCudaIndependentDescriptorObject", 0x0ddac234 }, - { "NvAPI_D3D12_GetCudaTextureObject", 0x80403fc9 }, - { "NvAPI_D3D12_GetCudaSurfaceObject", 0x48f5b2ee }, - { "NvAPI_D3D12_IsFatbinPTXSupported", 0x70c07832 }, - { "NvAPI_D3D12_CreateCuModule", 0xad1a677d }, - { "NvAPI_D3D12_EnumFunctionsInModule", 0x7ab88d88 }, - { "NvAPI_D3D12_CreateCuFunction", 0xe2436e22 }, - { "NvAPI_D3D12_LaunchCuKernelChain", 0x24973538 }, - { "NvAPI_D3D12_LaunchCuKernelChainEx", 0x846a9bf0 }, - { "NvAPI_D3D12_DestroyCuModule", 0x41c65285 }, - { "NvAPI_D3D12_DestroyCuFunction", 0xdf295ea6 }, - { "NvAPI_D3D11_CreateCubinComputeShaderExV2", 0xf2c71d48 }, - { "NvAPI_D3D11_CreateCubinComputeShader", 0x0ed98181 }, - { "NvAPI_D3D11_CreateCubinComputeShaderEx", 0x32c2a0f6 }, - { "NvAPI_D3D11_CreateCubinComputeShaderWithName", 0xb672be19 }, - { "NvAPI_D3D11_LaunchCubinShader", 0x427e236d }, - { "NvAPI_D3D11_DestroyCubinComputeShader", 0x01682c86 }, - { "NvAPI_D3D11_IsFatbinPTXSupported", 0x6086bd93 }, - { "NvAPI_D3D11_GetCudaIndependentViewObject", 0x34d2afa8 }, - { "NvAPI_D3D11_GetCudaMergedTextureSamplerObject", 0x5d637d8f }, - { "NvAPI_D3D11_CreateUnorderedAccessView", 0x74a497a1 }, - { "NvAPI_D3D11_CreateShaderResourceView", 0x65cb431e }, - { "NvAPI_D3D11_CreateSamplerState", 0x89eca416 }, - { "NvAPI_D3D11_GetCudaTextureObject", 0x9006fa68 }, - { "NvAPI_D3D11_GetResourceGPUVirtualAddress", 0x1819b423 }, - { "NvAPI_D3D12_GetRaytracingCaps", 0x85a6c2a0 }, - { "NvAPI_D3D12_EnableRaytracingValidation", 0x1de5991b }, - { "NvAPI_D3D12_RegisterRaytracingValidationMessageCallback", 0x8554eb38 }, - { "NvAPI_D3D12_UnregisterRaytracingValidationMessageCallback", 0x26975da6 }, - { "NvAPI_D3D12_FlushRaytracingValidationMessages", 0xb8fb1fcb }, - { "NvAPI_D3D12_GetRaytracingDisplacementMicromapArrayPrebuildInfo", 0xfa99b6de }, - { "NvAPI_D3D12_GetRaytracingOpacityMicromapArrayPrebuildInfo", 0x4726d180 }, - { "NvAPI_D3D12_SetCreatePipelineStateOptions", 0x5c607a27 }, - { "NvAPI_D3D12_CheckDriverMatchingIdentifierEx", 0xafb237d4 }, - { "NvAPI_D3D12_GetRaytracingAccelerationStructurePrebuildInfoEx", 0x8d025b77 }, - { "NvAPI_D3D12_BuildRaytracingOpacityMicromapArray", 0x814f8d11 }, - { "NvAPI_D3D12_RelocateRaytracingOpacityMicromapArray", 0x0425c538 }, - { "NvAPI_D3D12_BuildRaytracingDisplacementMicromapArray", 0x066f569d }, - { "NvAPI_D3D12_RelocateRaytracingDisplacementMicromapArray", 0x1c142308 }, - { "NvAPI_D3D12_EmitRaytracingDisplacementMicromapArrayPostbuildInfo", 0x68b9a790 }, - { "NvAPI_D3D12_EmitRaytracingOpacityMicromapArrayPostbuildInfo", 0x1d9a39b6 }, - { "NvAPI_D3D12_BuildRaytracingAccelerationStructureEx", 0xe24ead45 }, - { "NvAPI_D3D12_QueryWorkstationFeatureProperties", 0xa92ea23a }, - { "NvAPI_D3D12_CreateCommittedRDMABuffer", 0xe78dcb44 }, - { "NvAPI_D3D12_ConvertCooperativeVectorMatrix", 0x0f252cb3 }, - { "NvAPI_D3D12_ConvertCooperativeVectorMatrixMultiple", 0x96ba5235 }, - { "NvAPI_D3D12_GetPhysicalDeviceCooperativeVectorProperties", 0x8f182aec }, - { "NvAPI_D3D12_GetRaytracingMultiIndirectClusterOperationRequirementsInfo", 0x5c9163f4 }, - { "NvAPI_D3D12_RaytracingExecuteMultiIndirectClusterOperation", 0x67c798af }, - { "NvAPI_D3D12_GetRaytracingPartitionedTlasIndirectPrebuildInfo", 0xcdfdc5f2 }, - { "NvAPI_D3D12_BuildRaytracingPartitionedTlasIndirect", 0x7cfc6fc3 }, - { "NvAPI_NGX_GetNGXOverrideState", 0x3fd96fba }, - { "NvAPI_NGX_SetNGXOverrideState", 0xb60fcb4e }, - { "NvAPI_DirectD3D12GraphicsCommandList_Create", 0x74a4e712 }, - { "NvAPI_DirectD3D12GraphicsCommandList_Release", 0x99da3dde }, - { "NvAPI_DirectD3D12GraphicsCommandList_Reset", 0x999c26d8 }, - { "NvAPI_VIO_GetCapabilities", 0x1dc91303 }, - { "NvAPI_VIO_Open", 0x44ee4841 }, - { "NvAPI_VIO_Close", 0xd01bd237 }, - { "NvAPI_VIO_Status", 0x0e6ce4f1 }, - { "NvAPI_VIO_SyncFormatDetect", 0x118d48a3 }, - { "NvAPI_VIO_GetConfig", 0xd34a789b }, - { "NvAPI_VIO_SetConfig", 0x0e4eec07 }, - { "NvAPI_VIO_SetCSC", 0xa1ec8d74 }, - { "NvAPI_VIO_GetCSC", 0x7b0d72a3 }, - { "NvAPI_VIO_SetGamma", 0x964bf452 }, - { "NvAPI_VIO_GetGamma", 0x51d53d06 }, - { "NvAPI_VIO_SetSyncDelay", 0x2697a8d1 }, - { "NvAPI_VIO_GetSyncDelay", 0x462214a9 }, - { "NvAPI_VIO_GetPCIInfo", 0xb981d935 }, - { "NvAPI_VIO_IsRunning", 0x96bd040e }, - { "NvAPI_VIO_Start", 0xcde8e1a3 }, - { "NvAPI_VIO_Stop", 0x6ba2a5d6 }, - { "NvAPI_VIO_IsFrameLockModeCompatible", 0x7bf0a94d }, - { "NvAPI_VIO_EnumDevices", 0xfd7c5557 }, - { "NvAPI_VIO_QueryTopology", 0x869534e2 }, - { "NvAPI_VIO_EnumSignalFormats", 0xead72fe4 }, - { "NvAPI_VIO_EnumDataFormats", 0x221fa8e8 }, - { "NvAPI_Stereo_CreateConfigurationProfileRegistryKey", 0xbe7692ec }, - { "NvAPI_Stereo_DeleteConfigurationProfileRegistryKey", 0xf117b834 }, - { "NvAPI_Stereo_SetConfigurationProfileValue", 0x24409f48 }, - { "NvAPI_Stereo_DeleteConfigurationProfileValue", 0x49bceecf }, - { "NvAPI_Stereo_Enable", 0x239c4545 }, - { "NvAPI_Stereo_Disable", 0x2ec50c2b }, - { "NvAPI_Stereo_IsEnabled", 0x348ff8e1 }, - { "NvAPI_Stereo_GetStereoSupport", 0x296c434d }, - { "NvAPI_Stereo_CreateHandleFromIUnknown", 0xac7e37f4 }, - { "NvAPI_Stereo_DestroyHandle", 0x3a153134 }, - { "NvAPI_Stereo_Activate", 0xf6a1ad68 }, - { "NvAPI_Stereo_Deactivate", 0x2d68de96 }, - { "NvAPI_Stereo_IsActivated", 0x1fb0bc30 }, - { "NvAPI_Stereo_GetSeparation", 0x451f2134 }, - { "NvAPI_Stereo_SetSeparation", 0x5c069fa3 }, - { "NvAPI_Stereo_DecreaseSeparation", 0xda044458 }, - { "NvAPI_Stereo_IncreaseSeparation", 0xc9a8ecec }, - { "NvAPI_Stereo_GetConvergence", 0x4ab00934 }, - { "NvAPI_Stereo_SetConvergence", 0x3dd6b54b }, - { "NvAPI_Stereo_DecreaseConvergence", 0x4c87e317 }, - { "NvAPI_Stereo_IncreaseConvergence", 0xa17daabe }, - { "NvAPI_Stereo_GetFrustumAdjustMode", 0xe6839b43 }, - { "NvAPI_Stereo_SetFrustumAdjustMode", 0x7be27fa2 }, - { "NvAPI_Stereo_CaptureJpegImage", 0x932cb140 }, - { "NvAPI_Stereo_InitActivation", 0xc7177702 }, - { "NvAPI_Stereo_Trigger_Activation", 0x0d6c6cd2 }, - { "NvAPI_Stereo_CapturePngImage", 0x8b7e99b5 }, - { "NvAPI_Stereo_ReverseStereoBlitControl", 0x3cd58f89 }, - { "NvAPI_Stereo_SetNotificationMessage", 0x6b9b409e }, - { "NvAPI_Stereo_SetActiveEye", 0x96eea9f8 }, - { "NvAPI_Stereo_SetDriverMode", 0x5e8f0bec }, - { "NvAPI_Stereo_GetEyeSeparation", 0xce653127 }, - { "NvAPI_Stereo_IsWindowedModeSupported", 0x40c8ed5e }, - { "NvAPI_Stereo_SetSurfaceCreationMode", 0xf5dcfcba }, - { "NvAPI_Stereo_GetSurfaceCreationMode", 0x36f1c736 }, - { "NvAPI_Stereo_Debug_WasLastDrawStereoized", 0xed4416c5 }, - { "NvAPI_Stereo_SetDefaultProfile", 0x44f0ecd1 }, - { "NvAPI_Stereo_GetDefaultProfile", 0x624e21c2 }, - { "NvAPI_D3D1x_CreateSwapChain", 0x1bc21b66 }, - { "NvAPI_D3D9_CreateSwapChain", 0x1a131e09 }, - { "NvAPI_Vulkan_InitLowLatencyDevice", 0x5c1696b6 }, - { "NvAPI_Vulkan_DestroyLowLatencyDevice", 0x11a5932b }, - { "NvAPI_Vulkan_GetSleepStatus", 0xadf966af }, - { "NvAPI_Vulkan_SetSleepMode", 0x2acfd162 }, - { "NvAPI_Vulkan_Sleep", 0x36732b1e }, - { "NvAPI_Vulkan_GetLatency", 0x3233d44a }, - { "NvAPI_Vulkan_SetLatencyMarker", 0xa17d13d6 }, - { "NvAPI_Vulkan_NotifyOutOfBandVkQueue", 0x5d6d3840 }, - { "NvAPI_DRS_CreateSession", 0x0694d52e }, - { "NvAPI_DRS_DestroySession", 0xdad9cff8 }, - { "NvAPI_DRS_LoadSettings", 0x375dbd6b }, - { "NvAPI_DRS_SaveSettings", 0xfcbc7e14 }, - { "NvAPI_DRS_LoadSettingsFromFile", 0xd3ede889 }, - { "NvAPI_DRS_SaveSettingsToFile", 0x2be25df8 }, - { "NvAPI_DRS_CreateProfile", 0xcc176068 }, - { "NvAPI_DRS_DeleteProfile", 0x17093206 }, - { "NvAPI_DRS_SetCurrentGlobalProfile", 0x1c89c5df }, - { "NvAPI_DRS_GetCurrentGlobalProfile", 0x617bff9f }, - { "NvAPI_DRS_GetProfileInfo", 0x61cd6fd6 }, - { "NvAPI_DRS_SetProfileInfo", 0x16abd3a9 }, - { "NvAPI_DRS_FindProfileByName", 0x7e4a9a0b }, - { "NvAPI_DRS_EnumProfiles", 0xbc371ee0 }, - { "NvAPI_DRS_GetNumProfiles", 0x1dae4fbc }, - { "NvAPI_DRS_CreateApplication", 0x4347a9de }, - { "NvAPI_DRS_DeleteApplicationEx", 0xc5ea85a1 }, - { "NvAPI_DRS_DeleteApplication", 0x2c694bc6 }, - { "NvAPI_DRS_GetApplicationInfo", 0xed1f8c69 }, - { "NvAPI_DRS_EnumApplications", 0x7fa2173a }, - { "NvAPI_DRS_FindApplicationByName", 0xeee566b2 }, - { "NvAPI_DRS_SetSetting", 0x577dd202 }, - { "NvAPI_DRS_GetSetting", 0x73bf8338 }, - { "NvAPI_DRS_EnumSettings", 0xae3039da }, - { "NvAPI_DRS_EnumAvailableSettingIds", 0xf020614a }, - { "NvAPI_DRS_EnumAvailableSettingValues", 0x2ec39f90 }, - { "NvAPI_DRS_GetSettingIdFromName", 0xcb7309cd }, - { "NvAPI_DRS_GetSettingNameFromId", 0xd61cbe6e }, - { "NvAPI_DRS_DeleteProfileSetting", 0xe4a26362 }, - { "NvAPI_DRS_RestoreAllDefaults", 0x5927b094 }, - { "NvAPI_DRS_RestoreProfileDefault", 0xfa5f6134 }, - { "NvAPI_DRS_RestoreProfileDefaultSetting", 0x53f0381e }, - { "NvAPI_DRS_GetBaseProfile", 0xda8466a0 }, - { "NvAPI_SYS_GetChipSetInfo", 0x53dabbca }, - { "NvAPI_SYS_GetLidAndDockInfo", 0xcda14d8a }, - { "NvAPI_SYS_GetDisplayIdFromGpuAndOutputId", 0x08f2bab4 }, - { "NvAPI_SYS_GetGpuAndOutputIdFromDisplayId", 0x112ba1a5 }, - { "NvAPI_SYS_GetPhysicalGpuFromDisplayId", 0x9ea74659 }, - { "NvAPI_SYS_GetDisplayDriverInfo", 0x721faceb }, - { "NvAPI_SYS_GetPhysicalGPUs", 0xd3b24d2d }, - { "NvAPI_SYS_GetLogicalGPUs", 0xccfffc10 }, - { "NvAPI_NGX_GetDriverFeatureSupport", 0x6194b19d }, - { "NvAPI_GPU_ClientRegisterForUtilizationSampleUpdates", 0xadeeaf67 }, - { "NvAPI_RegisterRiseCallback", 0x9cfe8f94 }, - { "NvAPI_RequestRise", 0x5047de98 }, - { "NvAPI_UninstallRise", 0xab8d09f6 }, -); - -#[no_mangle] -pub unsafe extern "C" fn nvapi_QueryInterface(interface: u32) -> *mut c_void { - let maybe_fn_ptr_global = (&*GLOBAL_STATE).as_ref().and_then(|(lib, state)| { - let fn_ptr = lib - .get:: *mut c_void>(b"nvapi_QueryInterface\0") - .ok()?; - Some((fn_ptr, state)) - }); - let (fn_ptr, global_state) = - unwrap_or::unwrap_some_or!(maybe_fn_ptr_global, return ptr::null_mut()); - let export_table = unwrap_or::unwrap_some_or!( - ::zluda_trace_common::get_export_table(), - return ptr::null_mut() - ); - let format_args = dark_api::FnFfiWrapper(|| { - use std::io::Write; - let mut writer = Vec::new(); - let name = interface_to_name(interface); - match name { - Some(name) => write!(&mut writer, "(interface: {})", name).ok(), - None => write!(&mut writer, "(interface: {:#010x})", interface).ok(), - }; - dark_api::ByteVecFfi::new(writer) - }); - let underlying_fn = dark_api::FnFfiWrapper(|| { - let result = fn_ptr(interface); - result as usize - }); - let original: *mut c_void = ReprUsize::from_usize(export_table.logged_call( - cglue::slice::CSliceRef::from_str("nvapi_QueryInterface"), - 0, - cglue::trait_obj!(&format_args as dark_api::FnFfi), - cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), - ptr::null_mut::() as usize, - <*mut c_void as ReprUsize>::format_status, - )); - if cfg!(target_pointer_width = "32") && !original.is_null() { - global_state - .lock() - .ok() - .map(|mut state| state.get_thunk(original, report_fn, interface)) - .unwrap_or_else(|| get_thunk(original, report_fn, interface)) - } else { - original - } -} - -unsafe extern "C" fn report_fn(result: i32, interface: u32) { - let export_table = unwrap_or::unwrap_some_or!(::zluda_trace_common::get_export_table(), return); - let format_args = - dark_api::FnFfiWrapper(|| dark_api::ByteVecFfi::new("(...)".as_bytes().to_vec())); - let underlying_fn = dark_api::FnFfiWrapper(|| ReprUsize::to_usize(result)); - let (fn_name, interface) = match interface_to_name(interface) { - Some(name) => (name, 0), - None => ("", interface), - }; - export_table.logged_call( - cglue::slice::CSliceRef::from_str(fn_name), - interface, - cglue::trait_obj!(&format_args as dark_api::FnFfi), - cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), - ::INTERNAL_ERROR, - ::format_status, - ); -} - -#[cfg(target_arch = "x86")] -pub fn get_thunk( - original_fn: *mut c_void, - report_fn: unsafe extern "C" fn(i32, u32), - interface: u32, -) -> *mut c_void { - use dynasmrt::{dynasm, DynasmApi}; - let mut ops = dynasmrt::x86::Assembler::new().unwrap(); - let start = ops.offset(); - dynasm!(ops - ; .arch x86 - ; push ebp - ; mov ebp, esp - ; push DWORD [ebp+68] - ; push DWORD [ebp+64] - ; push DWORD [ebp+60] - ; push DWORD [ebp+56] - ; push DWORD [ebp+52] - ; push DWORD [ebp+48] - ; push DWORD [ebp+44] - ; push DWORD [ebp+40] - ; push DWORD [ebp+36] - ; push DWORD [ebp+32] - ; push DWORD [ebp+28] - ; push DWORD [ebp+24] - ; push DWORD [ebp+20] - ; push DWORD [ebp+16] - ; push DWORD [ebp+12] - ; push DWORD [ebp+8] - ; mov eax, original_fn as i32 - ; call eax - ; push interface as i32 - ; push eax - ; mov eax, report_fn as i32 - ; call eax - ; pop eax - ; leave - ; ret - ; int 3 - ); - let exe_buf = ops.finalize().unwrap(); - let result_fn = exe_buf.ptr(start); - std::mem::forget(exe_buf); - result_fn as *mut _ -} - -#[cfg(target_arch = "x86_64")] -pub fn get_thunk( - _original_fn: *mut c_void, - _report_fn: unsafe extern "C" fn(i32, u32), - _interface: u32, -) -> *mut c_void { - todo!() -} diff --git a/ptx/src/pass/convert_32bit_to_64bit.rs b/ptx/src/pass/convert_32bit_to_64bit.rs index 5798f5071..9760b0da8 100644 --- a/ptx/src/pass/convert_32bit_to_64bit.rs +++ b/ptx/src/pass/convert_32bit_to_64bit.rs @@ -1,4 +1,4 @@ -// This pass modifies modifies 32 bit module to run on 64 bit implementation +// This pass modifies 32 bit module to run on 64 bit implementation // It extracts each global variable (except `.shared`) and then goes through // every global and: // * If it's a global variable it gets erased diff --git a/ptx/src/pass/hoist_globals.rs b/ptx/src/pass/hoist_globals.rs index b1a7c5ce0..8ad502fa7 100644 --- a/ptx/src/pass/hoist_globals.rs +++ b/ptx/src/pass/hoist_globals.rs @@ -1,53 +1,53 @@ -use super::*; - -pub(super) fn run<'input>( - directives: Vec, SpirvWord>>, -) -> Result, SpirvWord>>, TranslateError> { - let mut result = Vec::with_capacity(directives.len()); - for mut directive in directives.into_iter() { - run_directive(&mut result, &mut directive)?; - result.push(directive); - } - Ok(result) -} - -fn run_directive<'input>( - result: &mut Vec, SpirvWord>>, - directive: &mut Directive2, SpirvWord>, -) -> Result<(), TranslateError> { - match directive { - Directive2::Variable(..) => {} - Directive2::Method(function2) => run_function(result, function2), - } - Ok(()) -} - -fn run_function<'input>( - result: &mut Vec, SpirvWord>>, - function: &mut Function, SpirvWord>, -) { - function.body = function.body.take().map(|statements| { - statements - .into_iter() - .filter_map(|statement| match statement { - Statement::Variable( - var @ ast::Variable { - info: - ast::VariableInfo { - state_space: - ast::StateSpace::Global - | ast::StateSpace::Const - | ast::StateSpace::Shared, - .. - }, - .. - }, - ) => { - result.push(Directive2::Variable(ast::LinkingDirective::NONE, var)); - None - } - s => Some(s), - }) - .collect() - }); -} +use super::*; + +pub(super) fn run<'input>( + directives: Vec, SpirvWord>>, +) -> Result, SpirvWord>>, TranslateError> { + let mut result = Vec::with_capacity(directives.len()); + for mut directive in directives.into_iter() { + run_directive(&mut result, &mut directive)?; + result.push(directive); + } + Ok(result) +} + +fn run_directive<'input>( + result: &mut Vec, SpirvWord>>, + directive: &mut Directive2, SpirvWord>, +) -> Result<(), TranslateError> { + match directive { + Directive2::Variable(..) => {} + Directive2::Method(function2) => run_function(result, function2), + } + Ok(()) +} + +fn run_function<'input>( + result: &mut Vec, SpirvWord>>, + function: &mut Function, SpirvWord>, +) { + function.body = function.body.take().map(|statements| { + statements + .into_iter() + .filter_map(|statement| match statement { + Statement::Variable( + var @ ast::Variable { + info: + ast::VariableInfo { + state_space: + ast::StateSpace::Global + | ast::StateSpace::Const + | ast::StateSpace::Shared, + .. + }, + .. + }, + ) => { + result.push(Directive2::Variable(ast::LinkingDirective::NONE, var)); + None + } + s => Some(s), + }) + .collect() + }); +} diff --git a/ptx/src/pass/llvm/emit.rs b/ptx/src/pass/llvm/emit.rs index 905930bc4..5eae98702 100644 --- a/ptx/src/pass/llvm/emit.rs +++ b/ptx/src/pass/llvm/emit.rs @@ -773,18 +773,12 @@ impl<'a> MethodEmitContext<'a> { let src = self.resolver.value(conversion.src)?; let dst_type = get_type(self.context, &conversion.to_type)?; if let ( - Some(base32), + Some(_), ast::StateSpace::Global | ast::StateSpace::Generic | ast::StateSpace::Const, ) = (self.base_32bit_memory, conversion.to_space) { - let i64_type = get_scalar_type(self.context, ast::ScalarType::B64); - let base32 = self.resolver.value(base32)?; - let src_int = - unsafe { LLVMBuildPtrToInt(builder, src, i64_type, LLVM_UNNAMED.as_ptr()) }; - unsafe { LLVMBuildSub(builder, src_int, base32, LLVM_UNNAMED.as_ptr()) }; - self.resolver.with_result(conversion.dst, |dst| unsafe { - LLVMBuildTruncOrBitCast(builder, src, dst_type, dst) - }); + // Should never happen because globals are removed + return Err(error_unreachable()); } else { self.resolver.with_result(conversion.dst, |dst| unsafe { LLVMBuildPtrToInt(builder, src, dst_type, dst) diff --git a/ptx/src/pass/mod.rs b/ptx/src/pass/mod.rs index 04bceefb6..77f00bf6e 100644 --- a/ptx/src/pass/mod.rs +++ b/ptx/src/pass/mod.rs @@ -6,7 +6,6 @@ use std::{ borrow::Cow, collections::{hash_map, HashMap}, ffi::CString, - iter, }; use strum::IntoEnumIterator; use strum_macros::EnumIter; diff --git a/ptx/src/test/spirv_run/32/global_array.ptx b/ptx/src/test/spirv_run/32/global_array.ptx new file mode 100644 index 000000000..43f59c6d7 --- /dev/null +++ b/ptx/src/test/spirv_run/32/global_array.ptx @@ -0,0 +1,22 @@ +.version 6.5 +.target sm_30 +.address_size 32 + +.global .u8 foobar[4] = {1}; + +.visible .entry global_array( + .param .u32 input, + .param .u32 output +) +{ + .reg .u32 in_addr; + .reg .u32 out_addr; + .reg .b32 temp; + + mov.u32 in_addr, foobar; + ld.param.u32 out_addr, [output]; + + ld.global.u8 temp, [in_addr]; + st.global.u32 [out_addr], temp; + ret; +} diff --git a/ptx/src/test/spirv_run/mod.rs b/ptx/src/test/spirv_run/mod.rs index 4764021b6..faa2f3d50 100644 --- a/ptx/src/test/spirv_run/mod.rs +++ b/ptx/src/test/spirv_run/mod.rs @@ -6,7 +6,6 @@ use hip_runtime_sys::hipStream_t; use kernel_metadata::ArchivedModuleMetadata32Bit; use pretty_assertions; use std::alloc::Layout; -use std::borrow::Cow; use std::env; use std::error; use std::ffi::{CStr, CString}; @@ -264,7 +263,7 @@ test_ptx!( ); test_ptx!(min_nan_f16); test_ptx!(max, [555i32, 444i32], [555i32]); -test_ptx!(global_array, [0xDEADu32], [1u32]); +test_ptx_with_32!(global_array, [0xDEADu32], [1u32]); test_ptx!(global_array_f32, [0x0], [0f32]); test_ptx_with_32!(extern_shared, [127u64], [127u64]); test_ptx!(extern_shared_call, [121u64], [123u64]); @@ -1251,16 +1250,20 @@ fn test_llvm_assert( .unwrap(); let actual_ll = llvm_ir.llvm_ir.print_module_to_string(); let actual_ll = actual_ll.to_str(); - compare_llvm(name, actual_ll, expected_ll); + compare_llvm(name, actual_ll.trim(), expected_ll.trim()); let expected_attributes_ll = read_test_file!(concat!("../ll/_attributes.ll")); let actual_attributes_ll = llvm_ir.attributes_ir.print_module_to_string(); let actual_attributes_ll = actual_attributes_ll.to_str(); - compare_llvm("_attributes", actual_attributes_ll, &expected_attributes_ll); + compare_llvm( + "_attributes", + actual_attributes_ll.trim(), + expected_attributes_ll.trim(), + ); Ok(()) } -fn compare_llvm(name: &str, actual_ll: Cow, expected_ll: &str) { +fn compare_llvm(name: &str, actual_ll: &str, expected_ll: &str) { if actual_ll != expected_ll { let output_dir = env::var("TEST_PTX_LLVM_FAIL_DIR"); if let Ok(output_dir) = output_dir { diff --git a/ptx_parser/src/ast.rs b/ptx_parser/src/ast.rs index e2ddfbb60..48714296c 100644 --- a/ptx_parser/src/ast.rs +++ b/ptx_parser/src/ast.rs @@ -2567,7 +2567,7 @@ pub enum RightShiftKind { pub struct CvtaDetails { pub state_space: StateSpace, pub direction: CvtaDirection, - pub size: u8 + pub size: u8, } pub enum CvtaDirection { diff --git a/xtask/src/main.rs b/xtask/src/main.rs index 012e792b4..270464f7e 100644 --- a/xtask/src/main.rs +++ b/xtask/src/main.rs @@ -37,14 +37,11 @@ struct Cargo { release: Option, #[bpaf(long)] profile: Option, - #[bpaf(long)] - target: Option, #[bpaf(any("", Some), many)] _unused: Vec, } struct Project { - is_32bit: bool, #[cfg_attr(unix, allow(unused))] manifest_path: PathBuf, name: String, @@ -54,7 +51,7 @@ struct Project { } impl Project { - fn try_new(p: Package, is_32bit: bool) -> Option { + fn try_new(p: Package) -> Option { let name = p.name; let manifest_path = p.manifest_path.into(); serde_json::from_value::>(p.metadata) @@ -79,14 +76,13 @@ impl Project { target_name, target_kind, meta: m.zluda, - is_32bit, } }) } #[cfg(windows)] fn zip_compiler_output(&self) -> bool { - self.meta.windows_paths(self.is_32bit).is_empty() + self.meta.windows_paths.is_empty() } #[cfg(unix)] @@ -150,7 +146,7 @@ impl Project { target_dir, profile, libname, - self.meta.windows_paths(self.is_32bit).as_slice(), + self.meta.windows_paths.as_slice(), ) .map(move |(.., full_path, target)| { let copy_output = full_path.clone(); @@ -243,10 +239,6 @@ struct ZludaMetadata { linux_only: bool, #[serde(default)] windows_only: bool, - #[serde(default = "always_true", rename = "64bit")] - is_64bit: bool, - #[serde(default, rename = "32bit")] - is_32bit: bool, #[serde(default)] debug_only: bool, #[cfg_attr(not(unix), allow(unused))] @@ -257,26 +249,9 @@ struct ZludaMetadata { windows_paths: Vec, #[serde(default)] #[cfg_attr(unix, allow(unused))] - windows32_paths: Vec, - #[serde(default)] - #[cfg_attr(unix, allow(unused))] windows_extra_files: HashMap, } -impl ZludaMetadata { - fn windows_paths(&self, is_32bit: bool) -> &Vec { - if is_32bit && !self.windows32_paths.is_empty() { - &self.windows32_paths - } else { - &self.windows_paths - } - } -} - -fn always_true() -> bool { - true -} - fn main() { let options = match options().run_inner(Args::current_args()) { Ok(b) => b, @@ -297,33 +272,21 @@ fn main() { } fn compile(b: Build) -> (PathBuf, String, Vec) { - let cargo_flags = sniff_out_cargo_flags(&b.cargo_arguments); + let profile = sniff_out_profile_name(&b.cargo_arguments); let meta = MetadataCommand::new().no_deps().exec().unwrap(); - let mut target_directory = meta.target_directory.into_std_path_buf(); - if let Some(target) = &cargo_flags.target { - target_directory.push(target); - } + let target_directory = meta.target_directory.into_std_path_buf(); let projects = meta .packages .into_iter() - .filter_map(|pkg| Project::try_new(pkg, cargo_flags.is_32bit)) + .filter_map(Project::try_new) .filter(|project| { - if cargo_flags.is_32bit { - if !project.meta.is_32bit { - return false; - } - } else { - if !project.meta.is_64bit { - return false; - } - } if project.meta.linux_only && cfg!(windows) { return false; } if project.meta.windows_only && cfg!(not(windows)) { return false; } - if project.meta.debug_only && cargo_flags.profile != "debug" { + if project.meta.debug_only && profile != "debug" { return false; } true @@ -339,21 +302,13 @@ fn compile(b: Build) -> (PathBuf, String, Vec) { } command.args(b.cargo_arguments); assert!(command.status().unwrap().success()); - os::make_symlinks(&target_directory, &*projects, &*cargo_flags.profile); - (target_directory, cargo_flags.profile, projects) + os::make_symlinks(&target_directory, &*projects, &*profile); + (target_directory, profile, projects) } -fn sniff_out_cargo_flags(b: &[OsString]) -> CargoFlags { +fn sniff_out_profile_name(b: &[OsString]) -> String { let parsed_cargo_arguments = cargo().to_options().run_inner(b); - let (target, is_32bit) = match parsed_cargo_arguments.as_ref() { - Ok(Cargo { - target: Some(target), - .. - }) => (Some(target.clone()), target.starts_with("i686")), - Ok(Cargo { target: None, .. }) => (None, cfg!(target_pointer_width = "32")), - _ => (None, false), - }; - let profile = match parsed_cargo_arguments { + match parsed_cargo_arguments { Ok(Cargo { release: Some(true), .. @@ -363,20 +318,9 @@ fn sniff_out_cargo_flags(b: &[OsString]) -> CargoFlags { .. }) => profile, _ => "debug".to_string(), - }; - CargoFlags { - profile, - target, - is_32bit, } } -struct CargoFlags { - profile: String, - target: Option, - is_32bit: bool, -} - fn zip(zip: Build) { let (target_dir, profile, projects) = compile(zip); os::zip(target_dir, profile, projects) diff --git a/zluda32/Cargo.toml b/zluda32/Cargo.toml deleted file mode 100644 index c8e8bfd6e..000000000 --- a/zluda32/Cargo.toml +++ /dev/null @@ -1,41 +0,0 @@ -[package] -name = "zluda32" -version = "0.0.0" -authors = ["Andrzej Janik "] -edition = "2021" - -[lib] -name = "nvcuda" -crate-type = ["cdylib"] - -[dependencies] -cuda_types = { path = "../cuda_types" } -cuda_macros = { path = "../cuda_macros" } -zluda_windows = { path = "../zluda_windows" } -zluda_server_common = { path = "../zluda_server_common" } -dark_api = { path = "../dark_api" } -paste = "1.0" -ipc-channel = "^0.21.0" -windows = { version = "0.62.2", features = [ - "Win32_Foundation", - "Win32_Storage_FileSystem", - "Win32_System_IO", - "Win32_System_Pipes", - "Win32_Security", -] } -# windows-sys = { version = "0.61.2", features = [ -# "Win32_Foundation", -# "Win32_System_Pipes", -# "Win32_Storage_FileSystem", -# ] } -rand = "0.10.1" -widestring = "1.2.1" -bitcode = "0.6.9" -postcard = "1.1.3" -bincode = "2.0.1" -rkyv = "0.8.15" - -[package.metadata.zluda] -windows_only = true -64bit = false -32bit = true diff --git a/zluda32/src/ipc.rs b/zluda32/src/ipc.rs deleted file mode 100644 index 7aff6c120..000000000 --- a/zluda32/src/ipc.rs +++ /dev/null @@ -1,154 +0,0 @@ -use cuda_types::cuda::CUerror; -use rand::distr::{Alphanumeric, SampleString}; -use rkyv::api::high::HighSerializer; -use rkyv::de::Pool; -use rkyv::rancor::{Failure, Strategy}; -use rkyv::rend::u32_le; -use rkyv::ser::allocator::ArenaHandle; -use rkyv::util::AlignedVec; -use rkyv::{rancor, Archive, Deserialize, Portable, Serialize}; -use std::io::{Read, Write}; -use std::os::windows::io::{AsHandle, AsRawHandle, FromRawHandle}; -// use rkyv::util::AlignedVec; -use std::num::NonZeroU32; -use std::process::{Child, Command, Stdio}; -use std::sync::{Mutex, OnceLock}; -use std::{mem, ptr}; -use widestring::{u16str, U16CString}; -use windows::core::{Error, Owned, PCSTR}; -use windows::Win32::Foundation::*; -use windows::Win32::System::Pipes::*; -use zluda_server_common::Opcode; - -fn server_path() -> &'static str { - if cfg!(debug_assertions) { - r"C:\dev\ZLUDA\target\debug\zluda64_server.exe" - } else { - "zluda64_server.exe" - } -} - -pub(crate) struct Server { - pipe: std::fs::File, - _child: Child, - buffer: AlignedVec, -} - -unsafe impl Sync for Server {} -unsafe impl Send for Server {} - -impl Server { - fn new(pipe: std::fs::File, child: Child) -> Self { - Self { - pipe, - _child: child, - buffer: AlignedVec::new(), - } - } - - unsafe fn start() -> Result { - let name = Alphanumeric.sample_string(&mut rand::rng(), 32); - let pipe_path = format!("\\\\.\\pipe\\zluda-{name}\0"); - let pipe = std::fs::File::from_raw_handle( - CreateNamedPipeA( - PCSTR(pipe_path.as_ptr()), - windows::Win32::Storage::FileSystem::PIPE_ACCESS_DUPLEX, - PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT | PIPE_REJECT_REMOTE_CLIENTS, - 1, - 4 * 1024, - 4 * 1024, - 0, - None, - )? - .0, - ); - let child = Command::new(server_path()) - .arg(&pipe_path[..pipe_path.len() - 1]) - .stdin(Stdio::null()) - .stdout(Stdio::null()) - .stderr(Stdio::null()) - .spawn()?; - zluda_windows::kill_child_on_process_exit(child.as_handle().as_raw_handle())?; - match ConnectNamedPipe(HANDLE(pipe.as_raw_handle()), None) { - Ok(_) => Ok(Server::new(pipe, child)), - Err(e) if e.code() == ERROR_PIPE_CONNECTED.into() => Ok(Server::new(pipe, child)), - Err(e) => Err(e), - } - } - - fn get() -> Result<&'static Mutex, CUerror> { - static LOCK: OnceLock, Error>> = OnceLock::new(); - LOCK.get_or_init(|| Ok(Mutex::new(unsafe { Server::start()? }))) - .as_ref() - .map_err(|_| CUerror::UNKNOWN) - } - - pub(crate) fn remote_call_zero_copy( - opcode: Opcode, - data: impl for<'a, 'b> Serialize< - HighSerializer<&'a mut AlignedVec, ArenaHandle<'b>, rkyv::rancor::Failure>, - >, - ) -> Result { - let this = &mut *Self::get()?.lock().map_err(|_| CUerror::UNKNOWN)?; - this.buffer.clear(); - this.pipe - .write_all(&(opcode as u32).to_le_bytes()[..]) - .map_err(|_| CUerror::UNKNOWN)?; - let slice = - rkyv::api::high::to_bytes_in::<_, rkyv::rancor::Failure>(&data, &mut this.buffer) - .map_err(|_| CUerror::UNKNOWN)?; - this.pipe.write_all(&slice).map_err(|_| CUerror::UNKNOWN)?; - read_return_code(this)?; - this.buffer.resize(mem::size_of::(), 0); - this.pipe - .read_exact(&mut this.buffer) - .map_err(|_| CUerror::UNKNOWN)?; - let output = unsafe { rkyv::access_unchecked::(&this.buffer) }; - Ok(output.clone()) - } - - pub(crate) fn remote_call_framed( - opcode: Opcode, - data: impl for<'a, 'b> Serialize< - HighSerializer<&'a mut AlignedVec, ArenaHandle<'b>, rkyv::rancor::Failure>, - >, - ) -> Result - where - ::Archived: Deserialize>, - { - let this = &mut *Self::get()?.lock().map_err(|_| CUerror::UNKNOWN)?; - this.buffer.clear(); - this.pipe - .write_all(&(opcode as u32).to_le_bytes()[..]) - .map_err(|_| CUerror::UNKNOWN)?; - let slice = - rkyv::api::high::to_bytes_in::<_, rkyv::rancor::Failure>(&data, &mut this.buffer) - .map_err(|_| CUerror::UNKNOWN)?; - this.pipe.write_all(&slice).map_err(|_| CUerror::UNKNOWN)?; - read_return_code(this)?; - let out_size = read_u32(this)?; - this.buffer.resize(out_size as usize, 0); - this.pipe - .read_exact(&mut this.buffer) - .map_err(|_| CUerror::UNKNOWN)?; - unsafe { rkyv::from_bytes_unchecked::(&this.buffer) } - .map_err(|_| CUerror::UNKNOWN) - } -} - -fn read_return_code(this: &mut Server) -> Result<(), CUerror> { - let code = read_u32(this)?; - match NonZeroU32::new(code) { - None => Ok(()), - Some(code) => Err(CUerror(code)), - } -} - -fn read_u32(this: &mut Server) -> Result { - let mut code_buffer = [0u8; 4]; - this.pipe - .read_exact(&mut code_buffer) - .map_err(|_| CUerror::UNKNOWN)?; - let code = u32::from_le_bytes(code_buffer); - Ok(code) -} diff --git a/zluda32/src/lib.rs b/zluda32/src/lib.rs deleted file mode 100644 index bd9581b8c..000000000 --- a/zluda32/src/lib.rs +++ /dev/null @@ -1,717 +0,0 @@ -use cuda_macros::cuda_function_declarations; -use cuda_types::cuda::*; -use dark_api::cuda::CudaDarkApi; -use paste::paste; -use std::sync::{Mutex, OnceLock}; -use std::{cell::RefCell, ffi::c_void, ptr}; -use zluda_server_common::*; - -mod ipc; - -macro_rules! not_implemented { - ($($abi:literal fn $fn_name:ident( $($arg_id:ident : $arg_type:ty),* ) -> $ret_type:ty;)*) => { - $( - #[cfg_attr(not(test), no_mangle)] - #[allow(improper_ctypes)] - #[allow(improper_ctypes_definitions)] - #[allow(unused_variables)] - pub unsafe extern $abi fn $fn_name ( $( $arg_id : $arg_type),* ) -> $ret_type { - Err(cuda_types::cuda::CUerror::NOT_SUPPORTED) - } - )* - }; -} - -macro_rules! implemented { - ($($abi:literal fn $fn_name:ident( $($arg_id:ident : $arg_type:ty),* ) -> $ret_type:ty;)*) => { - $( - #[cfg_attr(not(test), no_mangle)] - #[allow(improper_ctypes)] - #[allow(improper_ctypes_definitions)] - pub unsafe extern $abi fn $fn_name ( $( $arg_id : $arg_type),* ) -> $ret_type { - paste!{ [< $fn_name:snake >] ( $( $arg_id ),* ) } - } - )* - - }; -} - -cuda_function_declarations! { - not_implemented, - implemented <= [ - cuCtxCreate_v2, - cuCtxDetach, - cuCtxGetApiVersion, - cuCtxGetCurrent, - cuCtxGetDevice, - cuCtxSynchronize, - cuDeviceComputeCapability, - cuDeviceGet, - cuDeviceGetAttribute, - cuDeviceGetCount, - cuDeviceGetName, - cuDeviceGetProperties, - cuDeviceTotalMem_v2, - cuDriverGetVersion, - cuEventCreate, - cuEventDestroy_v2, - cuGetExportTable, - cuInit, - cuLaunchKernel, - cuMemAlloc_v2, - cuMemFreeHost, - cuMemFree_v2, - cuMemGetAddressRange_v2, - cuMemHostAlloc, - cuMemcpyDtoDAsync_v2, - cuMemcpyDtoHAsync_v2, - cuMemcpyHtoDAsync_v2, - cuMemsetD8_v2, - cuModuleGetFunction, - cuModuleGetGlobal_v2, - cuModuleGetTexRef, - cuStreamCreate, - cuStreamDestroy_v2, - cuTexRefSetAddressMode, - cuTexRefSetAddress_v2, - cuTexRefSetFilterMode, - cuTexRefSetFlags, - cuTexRefSetFormat, - cuTexRefSetMaxAnisotropy, - cuTexRefSetMipmapFilterMode, - cuTexRefSetMipmapLevelBias, - cuTexRefSetMipmapLevelClamp, - ] -} - -thread_local! { - pub(crate) static CONTEXT_STACK: ContextStack = ContextStack::new(); -} - -struct ContextStack(RefCell>); - -impl ContextStack { - fn new() -> Self { - ContextStack(RefCell::new(Vec::new())) - } - - fn push(&self, ctx: CUcontext, dev: CUdevice) { - self.0.borrow_mut().push((ctx, dev)); - } - - fn unwrap(&self, ctx: CUcontext) -> Result { - if ctx.0.is_null() { - let stack = self.0.borrow(); - stack - .last() - .map(|(ctx, _)| *ctx) - .ok_or(CUerror::INVALID_VALUE) - } else { - Ok(ctx) - } - } - - fn current(&self) -> (CUcontext, CUdevice) { - self.0 - .borrow() - .last() - .copied() - .unwrap_or((CUcontext(ptr::null_mut()), 0)) - } -} - -pub(crate) fn cu_init(flags: u32) -> Result<(), CUerror> { - ipc::Server::remote_call_zero_copy::(Opcode::cuInit, cuInitIn { Flags: flags })?; - Ok(()) -} - -pub(crate) fn cu_ctx_create_v2( - pctx: *mut CUcontext, - flags: ::core::ffi::c_uint, - dev: CUdevice, -) -> Result<(), CUerror> { - let ctx_ref = unsafe { pctx.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - let cu_ctx = CudaEncode::decode( - ipc::Server::remote_call_zero_copy::( - Opcode::cuCtxCreate_v2, - cuCtxCreate_v2In { flags, dev }, - )? - .pctx, - ); - CONTEXT_STACK.with(|stack| { - stack.push(cu_ctx, dev); - }); - *ctx_ref = cu_ctx; - Ok(()) -} - -pub(crate) fn cu_ctx_detach(ctx: CUcontext) -> Result<(), CUerror> { - unimplemented!() -} - -pub(crate) fn cu_ctx_get_api_version( - ctx: CUcontext, - version: *mut ::core::ffi::c_uint, -) -> Result<(), CUerror> { - let version = unsafe { version.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - let ctx = CONTEXT_STACK.with(|s| s.unwrap(ctx))?; - *version = CudaEncode::decode( - ipc::Server::remote_call_zero_copy::( - Opcode::cuCtxGetApiVersion, - cuCtxGetApiVersionIn { - ctx: CudaEncode::encode(ctx), - }, - )? - .version, - ); - Ok(()) -} - -pub(crate) fn cu_ctx_get_current(pctx: *mut CUcontext) -> Result<(), CUerror> { - let pctx = unsafe { pctx.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - *pctx = CONTEXT_STACK.with(|s| s.current()).0; - Ok(()) -} - -pub(crate) fn cu_ctx_get_device(device: *mut CUdevice) -> Result<(), CUerror> { - let device = unsafe { device.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - let (_, dev) = CONTEXT_STACK.with(|s| s.current()); - *device = dev; - Ok(()) -} - -pub(crate) fn cu_ctx_synchronize() -> Result<(), CUerror> { - unimplemented!() -} - -pub(crate) fn cu_device_compute_capability( - major: *mut ::core::ffi::c_int, - minor: *mut ::core::ffi::c_int, - dev: CUdevice, -) -> Result<(), CUerror> { - unimplemented!() -} - -pub(crate) fn cu_device_get( - device: *mut CUdevice, - ordinal: ::core::ffi::c_int, -) -> Result<(), CUerror> { - let device = unsafe { device.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - *device = ipc::Server::remote_call_zero_copy::( - Opcode::cuDeviceGet, - cuDeviceGetIn { ordinal }, - )? - .device; - Ok(()) -} - -pub(crate) fn cu_device_get_attribute( - pi: *mut ::core::ffi::c_int, - attrib: CUdevice_attribute, - dev: CUdevice, -) -> Result<(), CUerror> { - let pi = unsafe { pi.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - *pi = ipc::Server::remote_call_zero_copy::( - Opcode::cuDeviceGetAttribute, - cuDeviceGetAttributeIn { - attrib: CudaEncode::encode(attrib), - dev, - }, - )? - .pi; - Ok(()) -} - -pub(crate) fn cu_device_get_count(count: *mut ::core::ffi::c_int) -> Result<(), CUerror> { - let count = unsafe { count.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - *count = ipc::Server::remote_call_zero_copy::( - Opcode::cuDeviceGetCount, - cuDeviceGetCountIn {}, - )? - .count; - Ok(()) -} - -pub(crate) fn cu_device_get_name( - name: *mut ::core::ffi::c_char, - len: ::core::ffi::c_int, - dev: CUdevice, -) -> Result<(), CUerror> { - if name.is_null() { - return Err(CUerror::INVALID_VALUE); - } - let name_out = ipc::Server::remote_call_framed::( - Opcode::cuDeviceGetName, - cuDeviceGetNameIn { len, dev }, - )?; - unsafe { - std::ptr::copy_nonoverlapping( - name_out.name.as_ptr() as *const i8, - name, - (len as usize).min(name_out.name.len()), - ) - }; - Ok(()) -} - -pub(crate) fn cu_device_get_properties(prop: *mut CUdevprop, dev: CUdevice) -> Result<(), CUerror> { - unimplemented!() -} - -pub(crate) fn cu_device_total_mem_v2(bytes: *mut usize, dev: CUdevice) -> Result<(), CUerror> { - let bytes = unsafe { bytes.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - *bytes = ipc::Server::remote_call_zero_copy::( - Opcode::cuDeviceTotalMem_v2, - cuDeviceTotalMem_v2In { dev }, - )? - .bytes - .to_native() - .min(u32::MAX as u64) as usize; - Ok(()) -} - -pub(crate) fn cu_driver_get_version( - driver_version: *mut ::core::ffi::c_int, -) -> Result<(), CUerror> { - let driver_version = unsafe { driver_version.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - *driver_version = ipc::Server::remote_call_zero_copy::( - Opcode::cuDriverGetVersion, - cuDriverGetVersionIn {}, - )? - .driverVersion; - Ok(()) -} - -pub(crate) fn cu_event_create( - phEvent: *mut CUevent, - Flags: ::core::ffi::c_uint, -) -> Result<(), CUerror> { - unimplemented!() -} - -pub(crate) fn cu_event_destroy_v2(hEvent: CUevent) -> Result<(), CUerror> { - unimplemented!() -} - -static EXPORT_TABLE: ::dark_api::cuda::CudaDarkApiGlobalTable = - ::dark_api::cuda::CudaDarkApiGlobalTable::new::(); - -pub(crate) fn cu_get_export_table( - pp_export_table: *mut *const ::core::ffi::c_void, - p_export_table_id: *const CUuuid, -) -> Result<(), CUerror> { - if let (Some(result), Some(guid)) = - unsafe { (pp_export_table.as_mut(), p_export_table_id.as_ref()) } - { - if let Some(table) = EXPORT_TABLE.get(guid) { - *result = table.start(); - cuda_types::cuda::CUresult::SUCCESS - } else { - cuda_types::cuda::CUresult::ERROR_NOT_SUPPORTED - } - } else { - cuda_types::cuda::CUresult::ERROR_INVALID_VALUE - } -} - -pub(crate) fn cu_launch_kernel( - f: CUfunction, - gridDimX: ::core::ffi::c_uint, - gridDimY: ::core::ffi::c_uint, - gridDimZ: ::core::ffi::c_uint, - blockDimX: ::core::ffi::c_uint, - blockDimY: ::core::ffi::c_uint, - blockDimZ: ::core::ffi::c_uint, - sharedMemBytes: ::core::ffi::c_uint, - hStream: CUstream, - kernelParams: *mut *mut ::core::ffi::c_void, - extra: *mut *mut ::core::ffi::c_void, -) -> Result<(), CUerror> { - unimplemented!() -} - -pub(crate) fn cu_mem_alloc_v2(dptr: *mut CUdeviceptr, bytesize: usize) -> Result<(), CUerror> { - unimplemented!() -} - -pub(crate) fn cu_mem_free_host(p: *mut ::core::ffi::c_void) -> Result<(), CUerror> { - unimplemented!() -} - -pub(crate) fn cu_mem_free_v2(dptr: CUdeviceptr) -> Result<(), CUerror> { - unimplemented!() -} - -pub(crate) fn cu_mem_get_address_range_v2( - pbase: *mut CUdeviceptr, - psize: *mut usize, - dptr: CUdeviceptr, -) -> Result<(), CUerror> { - unimplemented!() -} - -pub(crate) fn cu_mem_host_alloc( - pp: *mut *mut ::core::ffi::c_void, - bytesize: usize, - Flags: ::core::ffi::c_uint, -) -> Result<(), CUerror> { - unimplemented!() -} - -pub(crate) fn cu_memcpy_dto_d_async_v2( - dstDevice: CUdeviceptr, - srcDevice: CUdeviceptr, - ByteCount: usize, - hStream: CUstream, -) -> Result<(), CUerror> { - unimplemented!() -} - -pub(crate) fn cu_memcpy_dto_h_async_v2( - dstHost: *mut ::core::ffi::c_void, - srcDevice: CUdeviceptr, - ByteCount: usize, - hStream: CUstream, -) -> Result<(), CUerror> { - unimplemented!() -} - -pub(crate) fn cu_memcpy_hto_d_async_v2( - dstDevice: CUdeviceptr, - srcHost: *const ::core::ffi::c_void, - ByteCount: usize, - hStream: CUstream, -) -> Result<(), CUerror> { - unimplemented!() -} - -pub(crate) fn cu_memset_d8_v2( - dstDevice: CUdeviceptr, - uc: ::core::ffi::c_uchar, - N: usize, -) -> Result<(), CUerror> { - unimplemented!() -} - -pub(crate) fn cu_module_get_function( - hfunc: *mut CUfunction, - hmod: CUmodule, - name: *const ::core::ffi::c_char, -) -> Result<(), CUerror> { - unimplemented!() -} - -pub(crate) fn cu_module_get_global_v2( - dptr: *mut CUdeviceptr, - bytes: *mut usize, - hmod: CUmodule, - name: *const ::core::ffi::c_char, -) -> Result<(), CUerror> { - unimplemented!() -} - -pub(crate) fn cu_module_get_tex_ref( - pTexRef: *mut CUtexref, - hmod: CUmodule, - name: *const ::core::ffi::c_char, -) -> Result<(), CUerror> { - unimplemented!() -} - -pub(crate) fn cu_stream_create( - phStream: *mut CUstream, - Flags: ::core::ffi::c_uint, -) -> Result<(), CUerror> { - unimplemented!() -} - -pub(crate) fn cu_stream_destroy_v2(hStream: CUstream) -> Result<(), CUerror> { - unimplemented!() -} - -pub(crate) fn cu_tex_ref_set_address_mode( - hTexRef: CUtexref, - dim: ::core::ffi::c_int, - am: CUaddress_mode, -) -> Result<(), CUerror> { - unimplemented!() -} - -pub(crate) fn cu_tex_ref_set_address_v2( - ByteOffset: *mut usize, - hTexRef: CUtexref, - dptr: CUdeviceptr, - bytes: usize, -) -> Result<(), CUerror> { - unimplemented!() -} - -pub(crate) fn cu_tex_ref_set_filter_mode( - hTexRef: CUtexref, - fm: CUfilter_mode, -) -> Result<(), CUerror> { - unimplemented!() -} - -pub(crate) fn cu_tex_ref_set_flags( - hTexRef: CUtexref, - Flags: ::core::ffi::c_uint, -) -> Result<(), CUerror> { - unimplemented!() -} - -pub(crate) fn cu_tex_ref_set_format( - hTexRef: CUtexref, - fmt: CUarray_format, - NumPackedComponents: ::core::ffi::c_int, -) -> Result<(), CUerror> { - unimplemented!() -} - -pub(crate) fn cu_tex_ref_set_max_anisotropy( - hTexRef: CUtexref, - maxAniso: ::core::ffi::c_uint, -) -> Result<(), CUerror> { - unimplemented!() -} - -pub(crate) fn cu_tex_ref_set_mipmap_filter_mode( - hTexRef: CUtexref, - fm: CUfilter_mode, -) -> Result<(), CUerror> { - unimplemented!() -} - -pub(crate) fn cu_tex_ref_set_mipmap_level_bias( - hTexRef: CUtexref, - bias: f32, -) -> Result<(), CUerror> { - unimplemented!() -} - -pub(crate) fn cu_tex_ref_set_mipmap_level_clamp( - hTexRef: CUtexref, - minMipmapLevelClamp: f32, - maxMipmapLevelClamp: f32, -) -> Result<(), CUerror> { - unimplemented!() -} - -struct UnknownBuffer { - buffer: std::cell::UnsafeCell<[u32; S]>, -} - -impl UnknownBuffer { - const fn new() -> Self { - UnknownBuffer { - buffer: std::cell::UnsafeCell::new([0; S]), - } - } - const fn len(&self) -> usize { - S - } -} - -unsafe impl Sync for UnknownBuffer {} - -static UNKNOWN_BUFFER1: UnknownBuffer<1024> = UnknownBuffer::new(); -static UNKNOWN_BUFFER2: UnknownBuffer<14> = UnknownBuffer::new(); - -struct DarkApi32; - -#[repr(C)] -struct AllocRecord { - x: usize, - y: usize, -} - -impl CudaDarkApi for DarkApi32 { - unsafe extern "system" fn get_module_from_cubin( - module: *mut cuda_types::cuda::CUmodule, - fatbinc_wrapper: *const cuda_types::dark_api::FatbincWrapper, - ) -> cuda_types::cuda::CUresult { - unimplemented!() - } - - unsafe extern "system" fn cudart_interface_fn2( - pctx: *mut cuda_types::cuda::CUcontext, - _dev: cuda_types::cuda::CUdevice, - ) -> cuda_types::cuda::CUresult { - let ctx = unsafe { pctx.as_mut() }.ok_or(cuda_types::cuda::CUerror::INVALID_VALUE)?; - *ctx = CUcontext(0xDEADBEEFu32 as _); - cuda_types::cuda::CUresult::SUCCESS - } - - unsafe extern "system" fn get_module_from_cubin_ext1( - result: *mut cuda_types::cuda::CUmodule, - fatbinc_wrapper: *const cuda_types::dark_api::FatbincWrapper, - arg3: *mut std::ffi::c_void, - arg4: *mut std::ffi::c_void, - arg5: u32, - ) -> cuda_types::cuda::CUresult { - unimplemented!() - } - - unsafe extern "system" fn cudart_interface_fn7(arg1: usize) -> () { - unimplemented!() - } - - unsafe extern "system" fn get_module_from_cubin_ext2( - fatbin_header: *const cuda_types::dark_api::FatbinHeader, - result: *mut cuda_types::cuda::CUmodule, - arg3: *mut std::ffi::c_void, - arg4: *mut std::ffi::c_void, - arg5: u32, - ) -> cuda_types::cuda::CUresult { - unimplemented!() - } - - unsafe extern "system" fn load_compilers() -> cuda_types::cuda::CUresult { - unimplemented!() - } - - unsafe extern "system" fn get_unknown_buffer1( - ptr: *mut *mut std::ffi::c_void, - size: *mut usize, - ) -> () { - *ptr = UNKNOWN_BUFFER1.buffer.get() as *mut std::ffi::c_void; - *size = UNKNOWN_BUFFER1.len(); - } - - unsafe extern "system" fn get_unknown_buffer2( - ptr: *mut *mut std::ffi::c_void, - size: *mut usize, - ) -> () { - *ptr = UNKNOWN_BUFFER2.buffer.get() as *mut std::ffi::c_void; - *size = UNKNOWN_BUFFER2.len(); - } - - unsafe extern "system" fn context_local_storage_put( - cu_ctx: cuda_types::cuda::CUcontext, - key: *mut std::ffi::c_void, - value: *mut std::ffi::c_void, - _dtor_cb: Option< - extern "system" fn( - cuda_types::cuda::CUcontext, - *mut std::ffi::c_void, - *mut std::ffi::c_void, - ), - >, - ) -> cuda_types::cuda::CUresult { - let cu_ctx = CONTEXT_STACK.with(|s| s.unwrap(cu_ctx))?; - ipc::Server::remote_call_zero_copy::( - Opcode::ContextLocalStoragePut, - ContextLocalStoragePutIn { - cu_ctx: cu_ctx.encode().into(), - key: (key as u32).into(), - value: (value as u32).into(), - }, - )?; - Ok(()) - } - - unsafe extern "system" fn context_local_storage_delete( - context: cuda_types::cuda::CUcontext, - key: *mut std::ffi::c_void, - ) -> cuda_types::cuda::CUresult { - unimplemented!() - } - - unsafe extern "system" fn context_local_storage_get( - value: *mut *mut std::ffi::c_void, - cu_ctx: cuda_types::cuda::CUcontext, - key: *mut std::ffi::c_void, - ) -> cuda_types::cuda::CUresult { - let value = unsafe { value.as_mut() }.ok_or(cuda_types::cuda::CUerror::INVALID_VALUE)?; - let cu_ctx = CONTEXT_STACK.with(|s| s.unwrap(cu_ctx))?; - *value = ipc::Server::remote_call_zero_copy::( - Opcode::ContextLocalStorageGet, - ContextLocalStorageGetIn { - cu_ctx: cu_ctx.encode().into(), - key: (key as u32).into(), - }, - )? - .value - .to_native() as _; - Ok(()) - } - - unsafe extern "system" fn ctx_create_v2_bypass( - pctx: *mut cuda_types::cuda::CUcontext, - flags: ::std::os::raw::c_uint, - dev: cuda_types::cuda::CUdevice, - ) -> cuda_types::cuda::CUresult { - cu_ctx_create_v2(pctx, flags, dev) - } - - unsafe extern "system" fn heap_alloc( - heap_alloc_record_ptr: *mut *const std::ffi::c_void, - arg2: usize, - arg3: usize, - ) -> cuda_types::cuda::CUresult { - let heap_alloc_record_ptr = heap_alloc_record_ptr as *mut *mut AllocRecord; - let alloc_record = Box::into_raw(Box::new(AllocRecord { x: arg2, y: arg3 })); - *heap_alloc_record_ptr = alloc_record; - Ok(()) - } - - unsafe extern "system" fn heap_free( - heap_alloc_record_ptr: *const std::ffi::c_void, - arg2: *mut usize, - ) -> cuda_types::cuda::CUresult { - let heap_alloc_record_ptr = heap_alloc_record_ptr as *mut AllocRecord; - let record = Box::from_raw(heap_alloc_record_ptr); - if !arg2.is_null() { - *arg2 = record.y; - } - Ok(()) - } - - unsafe extern "system" fn device_get_attribute_ext( - dev: cuda_types::cuda::CUdevice, - attribute: std::ffi::c_uint, - unknown: std::ffi::c_int, - result: *mut [usize; 2], - ) -> cuda_types::cuda::CUresult { - unimplemented!() - } - - unsafe extern "system" fn device_get_something( - result: *mut std::ffi::c_uchar, - dev: cuda_types::cuda::CUdevice, - ) -> cuda_types::cuda::CUresult { - unimplemented!() - } - - unsafe extern "system" fn integrity_check( - version: u32, - unix_seconds: u64, - result: *mut [u64; 2], - ) -> cuda_types::cuda::CUresult { - unimplemented!() - } - - unsafe extern "system" fn context_check( - ctx_in: cuda_types::cuda::CUcontext, - result1: *mut u32, - result2: *mut *const std::ffi::c_void, - ) -> cuda_types::cuda::CUresult { - unimplemented!() - } - - unsafe extern "system" fn check_fn3() -> u32 { - unimplemented!() - } - - unsafe extern "system" fn hybrid_runtime_load_get_proc_address( - name: *const std::ffi::c_char, - fn_ptr: *mut *const std::ffi::c_void, - token: *mut usize, - ) -> cuda_types::cuda::CUresult { - unimplemented!() - } - - unsafe extern "system" fn hybrid_runtime_free(token: usize) -> cuda_types::cuda::CUresult { - unimplemented!() - } -} diff --git a/zluda64_server/Cargo.toml b/zluda64_server/Cargo.toml deleted file mode 100644 index a36c1d579..000000000 --- a/zluda64_server/Cargo.toml +++ /dev/null @@ -1,23 +0,0 @@ -[package] -name = "zluda64_server" -version = "0.0.0" -authors = ["Andrzej Janik "] -edition = "2021" - -[[bin]] -name = "zluda64_server" -path = "src/main.rs" - -[dependencies] -cuda_types = { path = "../cuda_types" } -cuda_macros = { path = "../cuda_macros" } -zluda_server_common = { path = "../zluda_server_common" } -dark_api = { path = "../dark_api" } -windows-sys = { version = "0.61.2", features = ["Win32_Foundation"] } -compio = { version = "0.18.0", features = ["macros", "fs"] } -slab = "0.4.12" -bincode = "2.0.1" -rkyv = "0.8.15" - -[package.metadata.zluda] -windows_only = true diff --git a/zluda64_server/src/main.rs b/zluda64_server/src/main.rs deleted file mode 100644 index 6aadad627..000000000 --- a/zluda64_server/src/main.rs +++ /dev/null @@ -1,504 +0,0 @@ -// Prevent the console window from appearing when running the server on Windows -#![windows_subsystem = "windows"] - -use compio::{ - buf::{buf_try, IoBuf, IoBufMut, ReserveError, ReserveExactError, SetLen}, - fs::named_pipe::{ClientOptions, NamedPipeClient}, - io::{AsyncRead, AsyncReadExt, AsyncReadManaged, AsyncWrite, AsyncWriteExt}, - BufResult, -}; -use cuda_macros::cuda_function_declarations; -use cuda_types::cuda::*; -use rkyv::{ - api::high::HighSerializer, - rend::{u32_le, u64_le}, - ser::allocator::ArenaHandle, - util::AlignedVec, - Archive, Portable, Serialize, -}; -use slab::Slab; -use std::{ - io::{self, Write}, - mem, ptr, -}; -use windows_sys::Win32::Foundation::ERROR_MORE_DATA; -use zluda_server_common::*; - -struct State { - handles: Slab, - dark_api: dark_api::cuda::ContextLocalStorageInterfaceV0301, -} - -impl State { - fn new() -> Result { - unsafe { cuInit(0) }?; - let mut table_ptr = std::ptr::null(); - unsafe { - cuGetExportTable( - &mut table_ptr, - &dark_api::cuda::ContextLocalStorageInterfaceV0301::GUID, - ) - }?; - let dark_api = unsafe { dark_api::cuda::ContextLocalStorageInterfaceV0301::new(table_ptr) }; - Ok(Self { - handles: Slab::new(), - dark_api, - }) - } - - fn insert(&mut self, handle: *mut T) -> u32 { - (self.handles.insert(handle as usize) as u32) + 1 - } - - fn get(&self, id: u32) -> Result<*mut T, CUerror> { - if id == 0 { - return Err(CUerror::INVALID_VALUE); - } - self.handles - .get((id - 1) as usize) - .map(|&handle| handle as *mut T) - .ok_or(CUerror::INVALID_VALUE) - } -} - -#[compio::main] -async fn main() -> std::io::Result<()> { - let pipe_name = std::env::args_os().nth(1).ok_or(std::io::Error::new( - std::io::ErrorKind::InvalidInput, - "Pipe name not provided", - ))?; - let mut client = ClientOptions::new() - .pipe_mode(compio::fs::named_pipe::PipeMode::Byte) - .read(true) - .write(true) - .open(pipe_name) - .await?; - let mut buffer = AlignedVecBuffer(AlignedVec::new()); - let mut state = State::new().map_err(|_| { - std::io::Error::new( - std::io::ErrorKind::Other, - "Failed to initialize CUDA context", - ) - })?; - loop { - let opcode = client.read_u32_le().await?; // Read the length prefix - buffer.clear(); - match Opcode::from_repr(opcode) { - Some(Opcode::cuInit) => { - buffer = handle_cuda_function::( - &mut client, - buffer, - cu_init, - ) - .await?; - } - Some(Opcode::cuDeviceGetCount) => { - buffer = handle_cuda_function::( - &mut client, - buffer, - cu_device_get_count, - ) - .await?; - } - Some(Opcode::cuDeviceGetAttribute) => { - buffer = handle_cuda_function::< - ArchivedcuDeviceGetAttributeIn, - cuDeviceGetAttributeOut, - >(&mut client, buffer, cu_device_get_attribute) - .await?; - } - Some(Opcode::cuDeviceGet) => { - buffer = handle_cuda_function::( - &mut client, - buffer, - cu_device_get, - ) - .await?; - } - Some(Opcode::cuCtxCreate_v2) => { - buffer = handle_cuda_function::( - &mut client, - buffer, - |input| cu_ctx_create_v2(input, &mut state), - ) - .await?; - } - Some(Opcode::cuDriverGetVersion) => { - buffer = - handle_cuda_function::( - &mut client, - buffer, - cu_driver_get_version, - ) - .await?; - } - Some(Opcode::cuDeviceGetName) => { - buffer = - handle_cuda_function_framed::( - &mut client, - buffer, - cu_device_get_name, - ) - .await?; - } - Some(Opcode::cuDeviceTotalMem_v2) => { - buffer = handle_cuda_function::< - ArchivedcuDeviceTotalMem_v2In, - cuDeviceTotalMem_v2Out, - >(&mut client, buffer, cu_device_total_mem_v2) - .await?; - } - Some(Opcode::ContextLocalStoragePut) => { - buffer = handle_cuda_function::< - ArchivedContextLocalStoragePutIn, - ContextLocalStoragePutOut, - >(&mut client, buffer, |input| { - context_local_storage_put(&mut state, input) - }) - .await?; - } - Some(Opcode::ContextLocalStorageGet) => { - buffer = handle_cuda_function::< - ArchivedContextLocalStorageGetIn, - ContextLocalStorageGetOut, - >(&mut client, buffer, |input| { - context_local_storage_get(&mut state, input) - }) - .await?; - } - Some(Opcode::cuCtxGetApiVersion) => { - buffer = - handle_cuda_function::( - &mut client, - buffer, - |input| cu_ctx_get_api_version(&mut state, input), - ) - .await?; - } - _ => { - client.write_u32_le(CUerror::NOT_SUPPORTED.0.get()).await?; - return Err(std::io::Error::new( - std::io::ErrorKind::Other, - "Unsupported operation", - )); - } - } - } -} - -fn cu_init(input: &ArchivedcuInitIn) -> Result { - unsafe { cuInit(input.Flags.to_native()) }?; - Ok(cuInitOut {}) -} - -fn cu_device_get_count( - _input: &ArchivedcuDeviceGetCountIn, -) -> Result { - let mut count = 0; - unsafe { cuDeviceGetCount(&mut count) }?; - Ok(cuDeviceGetCountOut { count }) -} - -fn cu_device_get_attribute( - input: &ArchivedcuDeviceGetAttributeIn, -) -> Result { - let mut pi = 0; - unsafe { - cuDeviceGetAttribute( - &mut pi, - CUdevice_attribute_enum(input.attrib.to_native()), - input.dev.to_native(), - ) - }?; - Ok(cuDeviceGetAttributeOut { pi }) -} - -fn cu_device_get(input: &ArchivedcuDeviceGetIn) -> Result { - let mut device = 0; - unsafe { cuDeviceGet(&mut device, input.ordinal.to_native()) }?; - Ok(cuDeviceGetOut { device }) -} - -fn cu_device_get_name(input: &ArchivedcuDeviceGetNameIn) -> Result { - let mut name = vec![0u8; input.len.to_native() as usize]; - unsafe { - cuDeviceGetName( - name.as_mut_ptr().cast(), - input.len.to_native(), - input.dev.to_native(), - ) - }?; - if let Some(pos) = name.iter().copied().position(|c| c == 0) { - name.truncate(pos); - } - Ok(cuDeviceGetNameOut { name }) -} - -fn cu_ctx_create_v2( - input: &ArchivedcuCtxCreate_v2In, - state: &mut State, -) -> Result { - let mut pctx = unsafe { mem::zeroed() }; - unsafe { cuCtxCreate_v2(&mut pctx, input.flags.to_native(), input.dev.to_native()) }?; - let pctx = state.insert(pctx.0); - Ok(cuCtxCreate_v2Out { pctx }) -} - -fn cu_device_total_mem_v2( - input: &ArchivedcuDeviceTotalMem_v2In, -) -> Result { - let mut bytes = 0usize; - unsafe { cuDeviceTotalMem_v2(&mut bytes, input.dev.to_native()) }?; - Ok(cuDeviceTotalMem_v2Out { - bytes: u64_le::from_native(bytes as u64), - }) -} - -fn cu_driver_get_version( - _input: &ArchivedcuDriverGetVersionIn, -) -> Result { - let mut driver_version = 0; - unsafe { cuDriverGetVersion(&mut driver_version) }?; - Ok(cuDriverGetVersionOut { - driverVersion: driver_version, - }) -} - -fn cu_ctx_get_api_version( - state: &mut State, - input: &ArchivedcuCtxGetApiVersionIn, -) -> Result { - let ctx = CUcontext(state.get(input.ctx.to_native())?); - let mut version = 0; - unsafe { cuCtxGetApiVersion(ctx, &mut version) }?; - Ok(cuCtxGetApiVersionOut { version }) -} - -fn context_local_storage_put( - state: &mut State, - input: &ArchivedContextLocalStoragePutIn, -) -> Result { - unsafe { - state.dark_api.context_local_storage_put( - CUcontext(state.get(input.cu_ctx.to_native())?), - input.key.to_native() as _, - input.value.to_native() as _, - None, - ) - }?; - Ok(ContextLocalStoragePutOut {}) -} - -fn context_local_storage_get( - state: &mut State, - input: &ArchivedContextLocalStorageGetIn, -) -> Result { - let mut value = ptr::null_mut(); - unsafe { - state.dark_api.context_local_storage_get( - &mut value, - CUcontext(state.get(input.cu_ctx.to_native())?), - input.key.to_native() as _, - ) - }?; - Ok(ContextLocalStorageGetOut { - value: u32_le::from_native(value as u32), - }) -} - -async fn handle_cuda_function( - client: &mut NamedPipeClient, - mut buffer: AlignedVecBuffer, - handler: impl FnOnce(&In) -> Result, -) -> std::io::Result -where - Out: for<'a, 'b> Serialize< - HighSerializer<&'a mut AlignedVec, ArenaHandle<'b>, rkyv::rancor::Failure>, - >, -{ - buffer = read_all::(buffer, client).await?; - let input = unsafe { rkyv::access_unchecked::(buffer.as_init()) }; - match handler(input) { - Ok(output) => { - buffer.clear(); - client.write_u32_le(0).await?; - rkyv::api::high::to_bytes_in::<_, rkyv::rancor::Failure>(&output, &mut buffer.0) - .map_err(|_| { - std::io::Error::new(std::io::ErrorKind::Other, "Failed to serialize response") - })?; - let ((), new_buffer) = buf_try!(@try client.write_all(buffer).await); - Ok(new_buffer) - } - Err(e) => { - client.write_u32_le(e.0.get()).await?; - Ok(buffer) - } - } -} - -async fn handle_cuda_function_framed( - client: &mut NamedPipeClient, - mut buffer: AlignedVecBuffer, - handler: impl FnOnce(&In) -> Result, -) -> std::io::Result -where - Out: for<'a, 'b> Serialize< - HighSerializer<&'a mut AlignedVec, ArenaHandle<'b>, rkyv::rancor::Failure>, - >, -{ - buffer = read_all::(buffer, client).await?; - let input = unsafe { rkyv::access_unchecked::(buffer.as_init()) }; - match handler(input) { - Ok(output) => { - buffer.clear(); - rkyv::api::high::to_bytes_in::<_, rkyv::rancor::Failure>(&output, &mut buffer.0) - .map_err(|_| { - std::io::Error::new(std::io::ErrorKind::Other, "Failed to serialize response") - })?; - let code_and_len = unsafe { - std::mem::transmute::<(u32, u32), [u8; 8]>((0u32, buffer.0.len() as u32)) - }; - client.write_all(code_and_len).await.0?; - let ((), new_buffer) = buf_try!(@try client.write_all(buffer).await); - Ok(new_buffer) - } - Err(e) => { - client.write_u32_le(e.0.get()).await?; - Ok(buffer) - } - } -} - -async fn read_all( - mut buffer: AlignedVecBuffer, - client: &mut NamedPipeClient, -) -> std::io::Result { - let mut remaining_read = mem::size_of::(); - buffer.clear(); - buffer.reserve(remaining_read)?; - while remaining_read > 0 { - let BufResult(read_result, new_buffer) = client.append(buffer).await; - let n = read_result?; - remaining_read = remaining_read.checked_sub(n).ok_or_else(|| { - std::io::Error::new( - std::io::ErrorKind::InvalidData, - "Read more bytes than expected", - ) - })?; - buffer = new_buffer; - } - Ok(buffer) -} - -struct AlignedVecBuffer(AlignedVec); - -impl AlignedVecBuffer { - fn clear(&mut self) { - self.0.clear(); - } -} - -impl IoBuf for AlignedVecBuffer { - fn as_init(&self) -> &[u8] { - self.0.as_slice() - } -} - -impl SetLen for AlignedVecBuffer { - unsafe fn set_len(&mut self, len: usize) { - unsafe { self.0.set_len(len) } - } -} - -impl IoBufMut for AlignedVecBuffer { - fn as_uninit(&mut self) -> &mut [std::mem::MaybeUninit] { - let ptr = self.0.as_mut_ptr() as *mut std::mem::MaybeUninit; - let cap = self.0.capacity(); - unsafe { std::slice::from_raw_parts_mut(ptr, cap) } - } - - fn reserve(&mut self, len: usize) -> Result<(), ReserveError> { - self.0.reserve(len); - Ok(()) - } - - fn reserve_exact(&mut self, len: usize) -> Result<(), ReserveExactError> { - if self.0.capacity() - self.0.len() >= len { - return Ok(()); - } - - self.0.reserve_exact(len); - - if self.0.capacity() - self.0.len() != len { - return Err(ReserveExactError::ExactSizeMismatch { - reserved: self.0.capacity() - self.0.len(), - expected: len, - }); - } - Ok(()) - } -} - -macro_rules! nop { - ($($abi:literal fn $fn_name:ident( $($arg_id:ident : $arg_type:ty),* ) -> $ret_type:ty;)*) => {}; -} - -macro_rules! implemented { - ($($abi:literal fn $fn_name:ident( $($arg_id:ident : $arg_type:ty),* ) -> $ret_type:ty;)*) => { - $( - #[link(name = "nvcuda", kind = "raw-dylib")] - unsafe extern $abi { - fn $fn_name ( $( $arg_id : $arg_type),* ) -> $ret_type; - } - )* - - }; -} - -cuda_function_declarations! { - nop, - implemented <= [ - cuCtxCreate_v2, - // cuCtxDetach, - cuCtxGetApiVersion, - // cuCtxGetCurrent, - // cuCtxGetDevice, - // cuCtxSynchronize, - // cuDeviceComputeCapability, - cuDeviceGet, - cuDeviceGetAttribute, - cuDeviceGetCount, - cuDeviceGetName, - // cuDeviceGetProperties, - cuDeviceTotalMem_v2, - cuDriverGetVersion, - // cuEventCreate, - // cuEventDestroy_v2, - cuGetExportTable, - cuInit, - // cuLaunchKernel, - // cuMemAlloc_v2, - // cuMemFreeHost, - // cuMemFree_v2, - // cuMemGetAddressRange_v2, - // cuMemHostAlloc, - // cuMemcpyDtoDAsync_v2, - // cuMemcpyDtoHAsync_v2, - // cuMemcpyHtoDAsync_v2, - // cuMemsetD8_v2, - // cuModuleGetFunction, - // cuModuleGetGlobal_v2, - // cuModuleGetTexRef, - // cuStreamCreate, - // cuStreamDestroy_v2, - // cuTexRefSetAddressMode, - // cuTexRefSetAddress_v2, - // cuTexRefSetFilterMode, - // cuTexRefSetFlags, - // cuTexRefSetFormat, - // cuTexRefSetMaxAnisotropy, - // cuTexRefSetMipmapFilterMode, - // cuTexRefSetMipmapLevelBias, - // cuTexRefSetMipmapLevelClamp, - ] -} diff --git a/zluda_common/src/constants.rs b/zluda_common/src/constants.rs index fb468e9bf..8d316211b 100644 --- a/zluda_common/src/constants.rs +++ b/zluda_common/src/constants.rs @@ -2,7 +2,6 @@ pub const PROJECT_SUFFIX: &[u8] = b" [ZLUDA]\0"; const COMPUTE_CAPABILITY_MAJOR: i32 = 8; const COMPUTE_CAPABILITY_MINOR: i32 = 8; -#[cfg(target_pointer_width = "64")] pub const BLAS_HANDLE_COOKIE: usize = 0x57c3fdb0fd72b08e; pub fn compute_capability() -> (i32, i32) { diff --git a/zluda_common/src/lib.rs b/zluda_common/src/lib.rs index 02fa9817a..8b2c19b5a 100644 --- a/zluda_common/src/lib.rs +++ b/zluda_common/src/lib.rs @@ -135,7 +135,6 @@ macro_rules! from_cuda_nop { macro_rules! from_cuda_transmute { ($($from:ty => $to:ty),*) => { $( - #[cfg(target_pointer_width = "64")] impl<'a, E: CudaErrorType> FromCuda<'a, $from, E> for $to { fn from_cuda(x: &'a $from) -> Result { Ok(unsafe { std::mem::transmute(*x) }) diff --git a/zluda_inject/Cargo.toml b/zluda_inject/Cargo.toml index a8bd44775..a334ded57 100644 --- a/zluda_inject/Cargo.toml +++ b/zluda_inject/Cargo.toml @@ -13,6 +13,7 @@ windows = { version = "0.62.2", features = [ "Win32_Foundation", "Win32_System_Threading", "Win32_Security", + "Win32_System_JobObjects", "Win32_System_Diagnostics_Debug", "Win32_System_LibraryLoader", ] } @@ -33,4 +34,3 @@ zluda_ml = { path = "../zluda_ml" } [package.metadata.zluda] windows_only = true -32bit = true diff --git a/zluda_inject/src/bin.rs b/zluda_inject/src/bin.rs index dd571fbe1..a75ee40f6 100644 --- a/zluda_inject/src/bin.rs +++ b/zluda_inject/src/bin.rs @@ -7,6 +7,10 @@ use std::ffi::{CString, OsStr}; use std::path::PathBuf; use std::{env, mem, process, ptr}; use windows::Win32::Foundation::{HANDLE, WAIT_FAILED}; +use windows::Win32::System::JobObjects::{ + AssignProcessToJobObject, JobObjectExtendedLimitInformation, SetInformationJobObject, + JOBOBJECT_EXTENDED_LIMIT_INFORMATION, JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE, +}; use windows::Win32::System::Threading::{ self, GetExitCodeProcess, ResumeThread, WaitForSingleObject, CREATE_SUSPENDED, CREATE_UNICODE_ENVIRONMENT, @@ -65,7 +69,7 @@ pub fn main_impl() -> Result<(), Box> { Option::None ) }; - zluda_windows::kill_child_on_process_exit(proc_info.hProcess)?; + kill_child_on_process_exit(proc_info.hProcess)?; injection_env.copy_payloads_to_process(proc_info.hProcess)?; os_call! { ResumeThread(HANDLE(proc_info.hThread)), |x| x == -1i32 as u32 }; os_call! { WaitForSingleObject(HANDLE(proc_info.hProcess), Threading::INFINITE), |x| x == WAIT_FAILED }; @@ -334,3 +338,19 @@ impl InjectionConfig { Ok(result.into_vec()) } } + +fn kill_child_on_process_exit(child: detours_sys::HANDLE) -> Result<(), Box> { + let job_handle = unsafe { windows::Win32::System::JobObjects::CreateJobObjectA(None, None) }?; + let mut info = JOBOBJECT_EXTENDED_LIMIT_INFORMATION::default(); + info.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE; + unsafe { + SetInformationJobObject( + job_handle, + JobObjectExtendedLimitInformation, + &mut info as *mut _ as *mut _, + size_of_val(&info) as u32, + ) + }?; + unsafe { AssignProcessToJobObject(job_handle, HANDLE(child)) }?; + Ok(()) +} diff --git a/zluda_redirect/Cargo.toml b/zluda_redirect/Cargo.toml index 9133e6567..e216fd7b2 100644 --- a/zluda_redirect/Cargo.toml +++ b/zluda_redirect/Cargo.toml @@ -36,4 +36,3 @@ rustc-hash = "2.0.0" [package.metadata.zluda] windows_only = true -32bit = true diff --git a/zluda_server_common/Cargo.toml b/zluda_server_common/Cargo.toml deleted file mode 100644 index 21d395b4f..000000000 --- a/zluda_server_common/Cargo.toml +++ /dev/null @@ -1,16 +0,0 @@ -[package] -name = "zluda_server_common" -version = "0.0.0" -authors = ["Andrzej Janik "] -edition = "2021" - -[dependencies] -cuda_types = { path = "../cuda_types" } -cuda_macros = { path = "../cuda_macros" } -bitcode = "0.6.9" -paste = "1" -postcard = "1.1.3" -bincode = "2.0.1" -rkyv = "0.8.15" -strum = "0.28" -strum_macros = "0.28" diff --git a/zluda_server_common/src/lib.rs b/zluda_server_common/src/lib.rs deleted file mode 100644 index 4c1880d64..000000000 --- a/zluda_server_common/src/lib.rs +++ /dev/null @@ -1,216 +0,0 @@ -use bincode::{Decode, Encode}; -use cuda_macros::{cuda_function_declarations, generate_input_struct, generate_output_struct}; -use cuda_types::cuda::*; -use paste::paste; -use rkyv::rend::{u32_le, u64_le}; -use rkyv::{rend, Archive, Deserialize, Portable, Serialize}; -use std::ffi::CString; -use std::num::NonZeroU32; -use std::{ffi::CStr, num::NonZero}; -use strum_macros::FromRepr; - -macro_rules! noop { - ($($abi:literal fn $fn_name:ident( $($arg_id:ident : $arg_type:ty),* ) -> $ret_type:ty;)*) => {}; -} - -macro_rules! generate_messages_inout { - ($($abi:literal fn $fn_name:ident( $($arg_id:ident : $arg_type:ty),* ) -> $ret_type:ty;)*) => { - $( - generate_input_struct!($fn_name, $($arg_id : $arg_type),*); - generate_output_struct!($fn_name, $($arg_id : $arg_type),*); - )* - - #[repr(u32)] - #[derive(FromRepr)] - pub enum Opcode { - System = 0, - $( - $fn_name, - )* - cuDeviceGetName, - cuDeviceTotalMem_v2, - ContextLocalStoragePut, - ContextLocalStorageGet, - } - }; -} - -macro_rules! generate_messages_in { - ($($abi:literal fn $fn_name:ident( $($arg_id:ident : $arg_type:ty),* ) -> $ret_type:ty;)*) => { - $( - generate_input_struct!($fn_name, $($arg_id : $arg_type),*); - )* - }; -} - -cuda_function_declarations! { - noop, - generate_messages_inout <= [ - cuCtxCreate_v2, - cuCtxDetach, - cuCtxGetApiVersion, - cuCtxGetCurrent, - cuCtxGetDevice, - cuCtxSynchronize, - cuDeviceComputeCapability, - cuDeviceGet, - cuDeviceGetAttribute, - cuDeviceGetCount, - cuDeviceGetProperties, - cuDriverGetVersion, - cuEventCreate, - cuEventDestroy_v2, - //cuGetExportTable, - cuInit, - //cuLaunchKernel, - // cuMemAlloc_v2, - //cuMemFreeHost, - //cuMemFree_v2, - // cuMemGetAddressRange_v2, - //cuMemHostAlloc, - //cuMemcpyDtoDAsync_v2, - //cuMemcpyDtoHAsync_v2, - //cuMemcpyHtoDAsync_v2, - // cuMemsetD8_v2, - // cuModuleGetFunction, - // cuModuleGetGlobal_v2, - // cuModuleGetTexRef, - cuStreamCreate, - cuStreamDestroy_v2, - cuTexRefSetAddressMode, - // cuTexRefSetAddress_v2, - cuTexRefSetFilterMode, - cuTexRefSetFlags, - cuTexRefSetFormat, - cuTexRefSetMaxAnisotropy, - cuTexRefSetMipmapFilterMode, - cuTexRefSetMipmapLevelBias, - cuTexRefSetMipmapLevelClamp, - ], - generate_messages_in <= [ - cuDeviceGetName, - cuDeviceTotalMem_v2 - ] -} - -pub trait CudaEncode: Copy { - type WireObject; - fn encode(self) -> Self::WireObject; - fn decode(o: Self::WireObject) -> Self; -} - -macro_rules! encode_as_self { - ($type_:ty) => { - impl CudaEncode for $type_ { - type WireObject = Self; - fn encode(self) -> Self { - self - } - fn decode(o: Self::WireObject) -> Self { - o - } - } - }; -} - -macro_rules! encode_as_proxy { - ($type_:ty, $proxy_type:ty) => { - impl CudaEncode for $type_ { - type WireObject = $proxy_type; - fn encode(self) -> $proxy_type { - unsafe { std::mem::transmute::(self) } - } - fn decode(o: Self::WireObject) -> Self { - unsafe { std::mem::transmute::<$proxy_type, Self>(o) } - } - } - }; -} - -macro_rules! encode_as_u32 { - ($type_:ty) => { - impl CudaEncode for $type_ { - type WireObject = u32; - fn encode(self) -> u32 { - unsafe { std::mem::transmute_copy::(&self) } - } - fn decode(o: Self::WireObject) -> Self { - unsafe { std::mem::transmute_copy::(&o) } - } - } - }; -} - -encode_as_self!(u8); -encode_as_self!(i8); -encode_as_self!(u32); -encode_as_self!(i32); -encode_as_self!(f32); - -encode_as_proxy!(CUdevprop_v1, CUdevprop_v1_Wire); -encode_as_proxy!(CUdevice_attribute, u32); -encode_as_proxy!(CUfilter_mode, u32); -encode_as_proxy!(CUaddress_mode, u32); -encode_as_proxy!(CUarray_format, u32); - -encode_as_u32!(CUcontext); -encode_as_u32!(CUdeviceptr_v2); -encode_as_u32!(CUevent); -encode_as_u32!(CUfunction); -encode_as_u32!(CUmodule); -encode_as_u32!(CUstream); -encode_as_u32!(CUtexref); - -#[repr(C)] -#[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] -pub struct CUdevprop_v1_Wire { - pub maxThreadsPerBlock: ::core::ffi::c_int, - pub maxThreadsDim: [::core::ffi::c_int; 3usize], - pub maxGridSize: [::core::ffi::c_int; 3usize], - pub sharedMemPerBlock: ::core::ffi::c_int, - pub totalConstantMemory: ::core::ffi::c_int, - pub SIMDWidth: ::core::ffi::c_int, - pub memPitch: ::core::ffi::c_int, - pub regsPerBlock: ::core::ffi::c_int, - pub clockRate: ::core::ffi::c_int, - pub textureAlign: ::core::ffi::c_int, -} - -unsafe impl Portable for CUdevprop_v1_Wire {} - -#[repr(C)] -#[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] -pub struct cuDeviceGetNameOut { - pub name: Vec, -} - -#[repr(C)] -#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] -pub struct cuDeviceTotalMem_v2Out { - pub bytes: u64_le, -} - -#[repr(C)] -#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] -pub struct ContextLocalStoragePutIn { - pub cu_ctx: u32_le, - pub key: u32_le, - pub value: u32_le, -} - -#[repr(C)] -#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] -pub struct ContextLocalStoragePutOut {} - -#[repr(C)] -#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] -pub struct ContextLocalStorageGetIn { - pub cu_ctx: u32_le, - pub key: u32_le, -} - -#[repr(C)] -#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] -pub struct ContextLocalStorageGetOut { - pub value: u32_le, -} diff --git a/zluda_trace/Cargo.toml b/zluda_trace/Cargo.toml index decfa48f7..d36cb1cb1 100644 --- a/zluda_trace/Cargo.toml +++ b/zluda_trace/Cargo.toml @@ -9,14 +9,15 @@ name = "zluda_trace" crate-type = ["cdylib"] [dependencies] +ptx = { path = "../ptx" } ptx_parser = { path = "../ptx_parser" } zluda_trace_common = { path = "../zluda_trace_common" } zluda_common = { path = "../zluda_common" } format = { path = "../format" } dark_api = { path = "../dark_api" } regex = "1.4" -dynasm = "5.0" -dynasmrt = "5.0" +dynasm = "1.2" +dynasmrt = "1.2" # we don't need elf32, but goblin has a bug where elf64 does not build without elf32 goblin = { version = "0.9", default-features = false, features = [ "elf64", @@ -51,4 +52,3 @@ linux_symlinks = [ "trace_nvidia/libcuda.so.1", ] windows_paths = ["trace/nvcuda.dll"] -32bit = true diff --git a/zluda_trace/src/lib.rs b/zluda_trace/src/lib.rs index 967387497..b813f631e 100644 --- a/zluda_trace/src/lib.rs +++ b/zluda_trace/src/lib.rs @@ -147,19 +147,13 @@ struct InternalTableImpl; impl ::dark_api::zluda_trace::CudaDarkApi for InternalTableImpl { unsafe extern "system" fn logged_call( fn_name: cglue::slice::CSliceRef<'static, u8>, - nvapi_interface: u32, args: ::dark_api::FnFfiRef<::dark_api::ByteVecFfi>, fn_: ::dark_api::FnFfiRef, internal_error: usize, format_status: extern "C" fn(usize) -> ::dark_api::ByteVecFfi, ) -> usize { - let fn_name = if nvapi_interface == 0 { - CudaFunctionName::Normal(unsafe { fn_name.into_str() }) - } else { - CudaFunctionName::Nvapi(nvapi_interface) - }; GlobalState2::under_lock( - fn_name, + CudaFunctionName::Normal(unsafe { fn_name.into_str() }), Some(|| args.call().to_vec()), internal_error, |status| format_status(status).to_vec(), diff --git a/zluda_trace/src/log.rs b/zluda_trace/src/log.rs index 023d7979d..5915f1938 100644 --- a/zluda_trace/src/log.rs +++ b/zluda_trace/src/log.rs @@ -236,7 +236,6 @@ impl Write for WriteBuffer { pub(crate) enum CudaFunctionName { Normal(&'static str), Dark { guid: CUuuid, index: usize }, - Nvapi(u32) } impl Display for CudaFunctionName { @@ -258,9 +257,6 @@ impl Display for CudaFunctionName { } } } - CudaFunctionName::Nvapi(interface) => { - write!(f, "{{nvapi:{:#010x}}}", interface) - } } } } diff --git a/zluda_trace_blas/src/lib.rs b/zluda_trace_blas/src/lib.rs index 0ef7600eb..b1bc28fdc 100644 --- a/zluda_trace_blas/src/lib.rs +++ b/zluda_trace_blas/src/lib.rs @@ -35,7 +35,6 @@ macro_rules! unimplemented { }); ReprUsize::from_usize(export_table.logged_call( cglue::slice::CSliceRef::from_str(stringify!($fn_name)), - 0, cglue::trait_obj!(&format_args as dark_api::FnFfi), cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), internal_error_untyped, diff --git a/zluda_trace_blaslt/src/lib.rs b/zluda_trace_blaslt/src/lib.rs index e1c4b1f1a..5202a79dc 100644 --- a/zluda_trace_blaslt/src/lib.rs +++ b/zluda_trace_blaslt/src/lib.rs @@ -35,7 +35,6 @@ macro_rules! unimplemented { }); ReprUsize::from_usize(export_table.logged_call( cglue::slice::CSliceRef::from_str(stringify!($fn_name)), - 0, cglue::trait_obj!(&format_args as dark_api::FnFfi), cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), internal_error_untyped, diff --git a/zluda_trace_dnn8/src/lib.rs b/zluda_trace_dnn8/src/lib.rs index f0ebd0402..6e98a384b 100644 --- a/zluda_trace_dnn8/src/lib.rs +++ b/zluda_trace_dnn8/src/lib.rs @@ -35,7 +35,6 @@ macro_rules! unimplemented { }); ReprUsize::from_usize(export_table.logged_call( cglue::slice::CSliceRef::from_str(stringify!($fn_name)), - 0, cglue::trait_obj!(&format_args as dark_api::FnFfi), cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), internal_error_untyped, diff --git a/zluda_trace_dnn9/src/lib.rs b/zluda_trace_dnn9/src/lib.rs index 96e1a7536..5989ccb3a 100644 --- a/zluda_trace_dnn9/src/lib.rs +++ b/zluda_trace_dnn9/src/lib.rs @@ -35,7 +35,6 @@ macro_rules! unimplemented { }); ReprUsize::from_usize(export_table.logged_call( cglue::slice::CSliceRef::from_str(stringify!($fn_name)), - 0, cglue::trait_obj!(&format_args as dark_api::FnFfi), cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), internal_error_untyped, diff --git a/zluda_trace_fft/src/lib.rs b/zluda_trace_fft/src/lib.rs index ca1f83881..dbedc29fd 100644 --- a/zluda_trace_fft/src/lib.rs +++ b/zluda_trace_fft/src/lib.rs @@ -35,7 +35,6 @@ macro_rules! unimplemented { }); ReprUsize::from_usize(export_table.logged_call( cglue::slice::CSliceRef::from_str(stringify!($fn_name)), - 0, cglue::trait_obj!(&format_args as dark_api::FnFfi), cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), internal_error_untyped, diff --git a/zluda_trace_nvml/src/lib.rs b/zluda_trace_nvml/src/lib.rs index 8fe8b5b51..4eed6940f 100644 --- a/zluda_trace_nvml/src/lib.rs +++ b/zluda_trace_nvml/src/lib.rs @@ -35,7 +35,6 @@ macro_rules! unimplemented { }); ReprUsize::from_usize(export_table.logged_call( cglue::slice::CSliceRef::from_str(stringify!($fn_name)), - 0, cglue::trait_obj!(&format_args as dark_api::FnFfi), cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), internal_error_untyped, diff --git a/zluda_trace_sparse/src/lib.rs b/zluda_trace_sparse/src/lib.rs index 2e2d7683a..44a286d0c 100644 --- a/zluda_trace_sparse/src/lib.rs +++ b/zluda_trace_sparse/src/lib.rs @@ -35,7 +35,6 @@ macro_rules! unimplemented { }); ReprUsize::from_usize(export_table.logged_call( cglue::slice::CSliceRef::from_str(stringify!($fn_name)), - 0, cglue::trait_obj!(&format_args as dark_api::FnFfi), cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), internal_error_untyped, diff --git a/zluda_windows/src/lib.rs b/zluda_windows/src/lib.rs index 26ba82846..c9d482e70 100644 --- a/zluda_windows/src/lib.rs +++ b/zluda_windows/src/lib.rs @@ -13,19 +13,11 @@ use widestring::{u16str, U16Str, U16String}; use windows::{ core::{w, HRESULT, PCWSTR}, Win32::{ - Foundation::{HANDLE, HINSTANCE, HMODULE, HWND, LPARAM, S_OK, WPARAM}, - System::{ - JobObjects::{ - AssignProcessToJobObject, JobObjectExtendedLimitInformation, - SetInformationJobObject, JOBOBJECT_EXTENDED_LIMIT_INFORMATION, - JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE, - }, - LibraryLoader::{ - GetModuleFileNameA, GetModuleFileNameW, GetModuleHandleExW, LoadLibraryExW, - GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, - GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, LOAD_LIBRARY_SEARCH_DEFAULT_DIRS, - LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR, - }, + Foundation::{HINSTANCE, HMODULE, HWND, LPARAM, S_OK, WPARAM}, + System::LibraryLoader::{ + GetModuleFileNameA, GetModuleFileNameW, GetModuleHandleExW, LoadLibraryExW, + GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, + LOAD_LIBRARY_SEARCH_DEFAULT_DIRS, LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR, }, UI::{ Controls::{ @@ -38,13 +30,9 @@ use windows::{ }, }; -#[cfg(target_pointer_width = "32")] -pub static LIBRARIES: [LibraryInfo; 2] = [NVCUDA, NVAPI]; - -#[cfg(target_pointer_width = "64")] -pub static LIBRARIES: [LibraryInfo; 17] = [ +pub static LIBRARIES: [LibraryInfo; 16] = [ NVCUDA, NVML, DNN8, DNN9, BLAS13, BLAS12, BLAS11, BLAS_LT13, BLAS_LT12, BLAS_LT11, SPARSE12, - SPARSE11, SPARSE10, FFT12, FFT11, FFT10, NVAPI, + SPARSE11, SPARSE10, FFT12, FFT11, FFT10, ]; pub const NVCUDA: LibraryInfo = LibraryInfo { @@ -207,22 +195,6 @@ pub const FFT10: LibraryInfo = LibraryInfo { in_system32: false, }; -pub const NVAPI: LibraryInfo = LibraryInfo { - short_name: "nvapi", - is_alias: false, - #[cfg(target_pointer_width = "32")] - ascii_name: "nvapi.dll", - #[cfg(target_pointer_width = "64")] - ascii_name: "nvapi64.dll", - #[cfg(target_pointer_width = "32")] - utf16_name: u16str!("nvapi.dll"), - #[cfg(target_pointer_width = "64")] - utf16_name: u16str!("nvapi64.dll"), - guid: uuid!("f7449ed6-d01c-4376-9fc4-446eb2e4cf70"), - trace_env_var: "ZLUDA_NVAPI_LIB", - in_system32: true, -}; - #[derive(Debug)] pub struct LibraryInfo { pub short_name: &'static str, @@ -611,22 +583,6 @@ pub fn get_module_path_utf16(hm: HMODULE) -> OsString { OsString::from_wide(&buffer) } -pub fn kill_child_on_process_exit(child: *mut c_void) -> windows::core::Result<()> { - let job_handle = unsafe { windows::Win32::System::JobObjects::CreateJobObjectA(None, None) }?; - let mut info = JOBOBJECT_EXTENDED_LIMIT_INFORMATION::default(); - info.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE; - unsafe { - SetInformationJobObject( - job_handle, - JobObjectExtendedLimitInformation, - &mut info as *mut _ as *mut _, - size_of_val(&info) as u32, - ) - }?; - unsafe { AssignProcessToJobObject(job_handle, HANDLE(child)) }?; - Ok(()) -} - #[cfg(test)] mod tests { use super::*; From 788f31dee7987227c3dbf0a2d899e580238cb87a Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Thu, 14 May 2026 00:23:10 -0700 Subject: [PATCH 37/85] More compatible nvapi launch --- Cargo.lock | 1308 +- Cargo.toml | 5 + cuda_check/Cargo.toml | 2 +- cuda_macros/src/lib.rs | 92 +- dark_api/src/lib.rs | 1 + nvapi/Cargo.toml | 26 + nvapi/src/lib.rs | 726 ++ nvapi/src/nvapi.rs | 19879 +++++++++++++++++++++++++++++++ nvapi_trace/Cargo.toml | 29 + nvapi_trace/src/lib.rs | 704 ++ xtask/src/main.rs | 78 +- zluda32/Cargo.toml | 41 + zluda32/src/ipc.rs | 154 + zluda32/src/lib.rs | 717 ++ zluda64_server/Cargo.toml | 23 + zluda64_server/src/main.rs | 504 + zluda_common/src/constants.rs | 1 + zluda_common/src/lib.rs | 1 + zluda_inject/Cargo.toml | 2 +- zluda_inject/src/bin.rs | 22 +- zluda_redirect/Cargo.toml | 1 + zluda_server_common/Cargo.toml | 16 + zluda_server_common/src/lib.rs | 216 + zluda_trace/Cargo.toml | 6 +- zluda_trace/src/lib.rs | 8 +- zluda_trace/src/log.rs | 4 + zluda_trace_blas/src/lib.rs | 1 + zluda_trace_blaslt/src/lib.rs | 1 + zluda_trace_dnn8/src/lib.rs | 1 + zluda_trace_dnn9/src/lib.rs | 1 + zluda_trace_fft/src/lib.rs | 1 + zluda_trace_nvml/src/lib.rs | 1 + zluda_trace_sparse/src/lib.rs | 1 + zluda_windows/src/lib.rs | 58 +- 34 files changed, 24426 insertions(+), 205 deletions(-) create mode 100644 nvapi/Cargo.toml create mode 100644 nvapi/src/lib.rs create mode 100644 nvapi/src/nvapi.rs create mode 100644 nvapi_trace/Cargo.toml create mode 100644 nvapi_trace/src/lib.rs create mode 100644 zluda32/Cargo.toml create mode 100644 zluda32/src/ipc.rs create mode 100644 zluda32/src/lib.rs create mode 100644 zluda64_server/Cargo.toml create mode 100644 zluda64_server/src/main.rs create mode 100644 zluda_server_common/Cargo.toml create mode 100644 zluda_server_common/src/lib.rs diff --git a/Cargo.lock b/Cargo.lock index eb27ec012..1976b0fa8 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -84,7 +84,7 @@ dependencies = [ "argh_shared", "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -108,6 +108,21 @@ version = "0.7.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50" +[[package]] +name = "async-task" +version = "4.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de" + +[[package]] +name = "atomic-polyfill" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8cf2bce30dfe09ef0bfaef228b9d414faaf7e563035494d7fe092dba54b300f4" +dependencies = [ + "critical-section", +] + [[package]] name = "autocfg" version = "1.4.0" @@ -120,13 +135,33 @@ version = "0.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3a8241f3ebb85c056b509d4327ad0358fbbba6ffb340bf388f26350aeda225b1" +[[package]] +name = "bincode" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "36eaf5d7b090263e8150820482d5d93cd964a81e4019913c972f4edcc6edb740" +dependencies = [ + "bincode_derive", + "serde", + "unty", +] + +[[package]] +name = "bincode_derive" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bf95709a440f45e986983918d0e8a1f30a9b1df04918fc828670606804ac3c09" +dependencies = [ + "virtue", +] + [[package]] name = "bindgen" version = "0.70.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f49d8fed880d473ea71efb9bf597651e77201bdd4893efe54c9e5d65ae04ce6f" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", "cexpr", "clang-sys", "itertools 0.13.0", @@ -137,7 +172,7 @@ dependencies = [ "regex", "rustc-hash 1.1.0", "shlex", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -146,7 +181,7 @@ version = "0.71.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5f58bf3d7db68cfbac37cfc485a8d711e87e064c3d0fe0435b92f7a407f9d6b3" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", "cexpr", "clang-sys", "itertools 0.13.0", @@ -157,7 +192,7 @@ dependencies = [ "regex", "rustc-hash 2.1.1", "shlex", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -166,6 +201,30 @@ version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7" +[[package]] +name = "bitcode" +version = "0.6.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0a6ed1b54d8dc333e7be604d00fa9262f4635485ffea923647b6521a5fff045d" +dependencies = [ + "arrayvec", + "bitcode_derive", + "bytemuck", + "glam", + "serde", +] + +[[package]] +name = "bitcode_derive" +version = "0.6.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "238b90427dfad9da4a9abd60f3ec1cdee6b80454bde49ed37f1781dd8e9dc7f9" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.117", +] + [[package]] name = "bitflags" version = "1.3.2" @@ -174,9 +233,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" [[package]] name = "bitflags" -version = "2.9.1" +version = "2.11.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1b8e56985ec62d17e9c1001dc89c88ecd7dc08e47eba5ec7c29c7b5eeecde967" +checksum = "c4512299f36f043ab09a583e57bceb5a5aab7a73db1805848e8fef3c9e8c78b3" [[package]] name = "blake3" @@ -219,7 +278,7 @@ checksum = "fefb4feeec9a091705938922f26081aad77c64cd2e76cd1c4a9ece8e42e1618a" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -259,7 +318,7 @@ checksum = "89385e82b5d1821d2219e0b095efa2cc1f246cbf99080f3be46a1a85c0d392d9" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -279,7 +338,7 @@ checksum = "f9abbd1bc6865053c427f7198e6af43bfdedc55ab791faed4fbd361d789575ff" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -314,10 +373,10 @@ dependencies = [ "gemm", "half", "libm", - "memmap2 0.9.7", + "memmap2", "num-traits", "num_cpus", - "rand", + "rand 0.9.2", "rand_distr", "rayon", "safetensors", @@ -376,6 +435,12 @@ version = "1.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" +[[package]] +name = "cfg_aliases" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724" + [[package]] name = "cglue" version = "0.3.5" @@ -414,6 +479,17 @@ dependencies = [ "syn 1.0.109", ] +[[package]] +name = "chacha20" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6f8d983286843e49675a4b7a2d174efe136dc93a18d69130dd18198a6c167601" +dependencies = [ + "cfg-if", + "cpufeatures 0.3.0", + "rand_core 0.10.0", +] + [[package]] name = "clang-sys" version = "1.8.1" @@ -440,6 +516,15 @@ dependencies = [ "cc", ] +[[package]] +name = "cobs" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fa961b519f0b462e3a3b4a34b64d119eeaca1d59af726fe450bbba07a9fc0a1" +dependencies = [ + "thiserror 2.0.12", +] + [[package]] name = "compiler" version = "0.0.0" @@ -453,6 +538,143 @@ dependencies = [ "thiserror 2.0.12", ] +[[package]] +name = "compio" +version = "0.18.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b84ee96a86948d04388f3a0b8c36b9f0a6b40b3528ac0d65737e53632fb37fe" +dependencies = [ + "compio-buf", + "compio-driver", + "compio-fs", + "compio-io", + "compio-log", + "compio-macros", + "compio-runtime", +] + +[[package]] +name = "compio-buf" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a00d719dbd8c602ab0d25d219cbc6b517008858de7a8d6c51b4dc95aefff4dce" +dependencies = [ + "arrayvec", + "bytes", + "libc", +] + +[[package]] +name = "compio-driver" +version = "0.11.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "74d42d98dc890ee4db00c1e68a723391711aab6d67085880d716b72830f7c715" +dependencies = [ + "cfg-if", + "cfg_aliases", + "compio-buf", + "compio-log", + "crossbeam-queue", + "flume", + "futures-util", + "io-uring", + "io_uring_buf_ring", + "libc", + "once_cell", + "paste", + "pin-project-lite", + "polling", + "slab", + "smallvec", + "socket2", + "synchrony", + "thin-cell", + "windows-sys 0.61.2", +] + +[[package]] +name = "compio-fs" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "65ee36e1acf2cec4835efe9a986c012b2462c5ef53580e4ee84ae6d5a3d8e3b3" +dependencies = [ + "cfg-if", + "cfg_aliases", + "compio-buf", + "compio-driver", + "compio-io", + "compio-runtime", + "libc", + "os_pipe", + "pin-project-lite", + "widestring", + "windows-sys 0.61.2", +] + +[[package]] +name = "compio-io" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "637522f28a64fd5f7dcceaa4ddef13fa8d8020025e8c993f7a069e237835580e" +dependencies = [ + "compio-buf", + "futures-util", + "paste", + "synchrony", +] + +[[package]] +name = "compio-log" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc4e560213c1996b618da369b7c9109564b41af9033802ae534465c4ee4e132f" +dependencies = [ + "tracing", +] + +[[package]] +name = "compio-macros" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f05ed201484967dc70de77a8f7a02b29aaa8e6c81cbea2e75492ee0c8d97766b" +dependencies = [ + "proc-macro-crate 3.3.0", + "proc-macro2", + "quote", + "syn 2.0.117", +] + +[[package]] +name = "compio-runtime" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6c1c71f011bdd9c8f30e97d877b606505ee6d241c7782cfaed172f66acbd9cd" +dependencies = [ + "async-task", + "compio-buf", + "compio-driver", + "compio-log", + "core_affinity", + "crossbeam-queue", + "futures-util", + "libc", + "once_cell", + "pin-project-lite", + "scoped-tls", + "slab", + "socket2", + "windows-sys 0.61.2", +] + +[[package]] +name = "concurrent-queue" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4ca0197aee26d1ae37445ee532fefce43251d24cc7c166799f4d46817f1d3973" +dependencies = [ + "crossbeam-utils", +] + [[package]] name = "console" version = "0.16.1" @@ -481,6 +703,17 @@ dependencies = [ "unicode-segmentation", ] +[[package]] +name = "core_affinity" +version = "0.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a034b3a7b624016c6e13f5df875747cc25f884156aad2abd12b6c46797971342" +dependencies = [ + "libc", + "num_cpus", + "winapi", +] + [[package]] name = "cpufeatures" version = "0.2.17" @@ -490,6 +723,15 @@ dependencies = [ "libc", ] +[[package]] +name = "cpufeatures" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b2a41393f66f16b0823bb79094d54ac5fbd34ab292ddafb9a0456ac9f87d201" +dependencies = [ + "libc", +] + [[package]] name = "crc32fast" version = "1.5.0" @@ -499,6 +741,21 @@ dependencies = [ "cfg-if", ] +[[package]] +name = "critical-section" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "790eea4361631c5e7d22598ecd5723ff611904e3344ce8720784c93e3d83d40b" + +[[package]] +name = "crossbeam-channel" +version = "0.5.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2" +dependencies = [ + "crossbeam-utils", +] + [[package]] name = "crossbeam-deque" version = "0.8.6" @@ -518,6 +775,15 @@ dependencies = [ "crossbeam-utils", ] +[[package]] +name = "crossbeam-queue" +version = "0.3.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0f58bbc28f91df819d0aa2a2c00cd19754769c2fad90579b3592b1c9ba7a3115" +dependencies = [ + "crossbeam-utils", +] + [[package]] name = "crossbeam-utils" version = "0.8.21" @@ -548,8 +814,8 @@ dependencies = [ "cuda_types", "libloading", "owo-colors", - "rand", - "windows", + "rand 0.10.1", + "windows 0.62.2", "zluda_windows", ] @@ -560,14 +826,14 @@ dependencies = [ "proc-macro2", "quote", "rustc-hash 2.1.1", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] name = "cuda_types" version = "0.0.0" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", "cuda_macros", "hip_runtime-sys", "hipblaslt-sys", @@ -612,7 +878,7 @@ dependencies = [ "proc-macro2", "quote", "strsim", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -623,7 +889,7 @@ checksum = "fc34b93ccb385b40dc71c6fceac4b2ad23662c7eeb248cf10d529b7e055b6ead" dependencies = [ "darling_core", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -668,7 +934,7 @@ checksum = "30542c1ad912e0e3d22a1935c290e12e8a29d704a420177a31faad4a601a0800" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -689,7 +955,7 @@ dependencies = [ "darling", "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -699,7 +965,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ab63b0e2bf4d5928aff72e83a7dace85d7bba5fe12dcc3c5a572d78caffd3f3c" dependencies = [ "derive_builder_core", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -719,7 +985,7 @@ checksum = "cb7330aeadfbe296029522e6c40f315320aba36fc43a5b3632f3795348f3bd22" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", "unicode-xid", ] @@ -752,7 +1018,7 @@ dependencies = [ "dsl_auto_type", "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -772,7 +1038,7 @@ version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "209c735641a413bc68c4923a9d6ad4bcb3ca306b794edaa7eb0b3228a99ffb25" dependencies = [ - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -820,7 +1086,7 @@ checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -834,7 +1100,7 @@ dependencies = [ "heck", "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -876,28 +1142,29 @@ checksum = "e1d926b4d407d372f141f93bb444696142c29d32962ccbd3531117cf3aa0bfa9" [[package]] name = "dynasm" -version = "1.2.3" +version = "5.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "add9a102807b524ec050363f09e06f1504214b0e1c7797f64261c891022dce8b" +checksum = "df4bf11ba8aecc00489b7ec4e8963cd3860651c3ea2a114394f8ba7e92a0e94a" dependencies = [ - "bitflags 1.3.2", + "bitflags 2.11.1", "byteorder", "lazy_static", - "proc-macro-error", + "proc-macro-error2", "proc-macro2", "quote", - "syn 1.0.109", + "syn 2.0.117", ] [[package]] name = "dynasmrt" -version = "1.2.3" +version = "5.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "64fba5a42bd76a17cad4bfa00de168ee1cbfa06a5e8ce992ae880218c05641a9" +checksum = "b38e5331d851567729d892ed28d898d22f49a96940b29e23b5c3e681bd30ffb3" dependencies = [ "byteorder", "dynasm", - "memmap2 0.5.10", + "fnv", + "memmap2", ] [[package]] @@ -920,6 +1187,18 @@ dependencies = [ "winreg", ] +[[package]] +name = "embedded-io" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ef1a6892d9eef45c8fa6b9e0086428a2cca8491aca8f787c534a3d6d0bcb3ced" + +[[package]] +name = "embedded-io" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "edd0f118536f44f5ccd48bcb8b111bdc3de888b58c74639dfb034a357d0f206d" + [[package]] name = "encode_unicode" version = "1.0.0" @@ -944,7 +1223,7 @@ dependencies = [ "heck", "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -978,7 +1257,7 @@ version = "0.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7223ae2d2f179b803433d9c830478527e92b8117eab39460edae7f1614d9fb73" dependencies = [ - "heapless", + "heapless 0.8.0", "serde", ] @@ -1031,10 +1310,19 @@ checksum = "719a903cc23e4a89e87962c2a80fdb45cdaad0983a89bd150bb57b4c8571a7d5" dependencies = [ "half", "num-traits", - "rand", + "rand 0.9.2", "rand_distr", ] +[[package]] +name = "flume" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5e139bc46ca777eb5efaf62df0ab8cc5fd400866427e56c68b22e414e53bd3be" +dependencies = [ + "spin", +] + [[package]] name = "fnv" version = "1.0.7" @@ -1070,6 +1358,49 @@ dependencies = [ "uuid", ] +[[package]] +name = "futures-core" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d" + +[[package]] +name = "futures-macro" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e835b70203e41293343137df5c0664546da5745f82ec9b84d40be8336958447b" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.117", +] + +[[package]] +name = "futures-sink" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c39754e157331b013978ec91992bde1ac089843443c49cbc7f46150b0fad0893" + +[[package]] +name = "futures-task" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393" + +[[package]] +name = "futures-util" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6" +dependencies = [ + "futures-core", + "futures-macro", + "futures-sink", + "futures-task", + "pin-project-lite", + "slab", +] + [[package]] name = "gemm" version = "0.19.0" @@ -1189,6 +1520,21 @@ dependencies = [ "seq-macro", ] +[[package]] +name = "generator" +version = "0.8.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52f04ae4152da20c76fe800fa48659201d5cf627c5149ca0b707b69d7eef6cf9" +dependencies = [ + "cc", + "cfg-if", + "libc", + "log", + "rustversion", + "windows-link 0.2.1", + "windows-result 0.4.1", +] + [[package]] name = "generic-array" version = "0.14.7" @@ -1218,10 +1564,24 @@ checksum = "26145e563e54f2cadc477553f1ec5ee650b00862f0a58bcd12cbdc5f0ea2d2f4" dependencies = [ "cfg-if", "libc", - "r-efi", + "r-efi 5.3.0", "wasi 0.14.2+wasi-0.2.4", ] +[[package]] +name = "getrandom" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0de51e6874e94e7bf76d726fc5d13ba782deca734ff60d5bb2fb2607c7406555" +dependencies = [ + "cfg-if", + "libc", + "r-efi 6.0.0", + "rand_core 0.10.0", + "wasip2", + "wasip3", +] + [[package]] name = "gix" version = "0.71.0" @@ -1345,7 +1705,7 @@ dependencies = [ "bstr", "gix-chunk", "gix-hash 0.17.0", - "memmap2 0.9.7", + "memmap2", "thiserror 2.0.12", ] @@ -1376,7 +1736,7 @@ version = "0.14.12" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8dc2c844c4cf141884678cabef736fd91dd73068b9146e6f004ba1a0457944b6" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", "bstr", "gix-path", "libc", @@ -1540,7 +1900,7 @@ version = "0.19.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "20972499c03473e773a2099e5fd0c695b9b72465837797a51a43391a1635a030" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", "bstr", "gix-features 0.41.1", "gix-path", @@ -1600,7 +1960,7 @@ version = "0.39.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "855bece2d4153453aa5d0a80d51deea1ce8cd6a3b4cf213da85ac344ccb908a7" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", "bstr", "filetime", "fnv", @@ -1616,7 +1976,7 @@ dependencies = [ "hashbrown 0.14.5", "itoa", "libc", - "memmap2 0.9.7", + "memmap2", "rustix 0.38.37", "smallvec", "thiserror 2.0.12", @@ -1688,7 +2048,7 @@ dependencies = [ "gix-hashtable", "gix-object", "gix-path", - "memmap2 0.9.7", + "memmap2", "smallvec", "thiserror 2.0.12", ] @@ -1737,7 +2097,7 @@ version = "0.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "fef8422c3c9066d649074b24025125963f85232bfad32d6d16aea9453b82ec14" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", "bstr", "gix-attributes", "gix-config-value", @@ -1792,7 +2152,7 @@ dependencies = [ "gix-tempfile", "gix-utils 0.2.0", "gix-validate 0.9.4", - "memmap2 0.9.7", + "memmap2", "thiserror 2.0.12", "winnow 0.7.10", ] @@ -1817,7 +2177,7 @@ version = "0.33.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "342caa4e158df3020cadf62f656307c3948fe4eacfdf67171d7212811860c3e9" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", "bstr", "gix-commitgraph", "gix-date", @@ -1850,7 +2210,7 @@ version = "0.10.12" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "47aeb0f13de9ef2f3033f5ff218de30f44db827ac9f1286f9ef050aacddd5888" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", "gix-path", "libc", "windows-sys 0.52.0", @@ -1950,7 +2310,7 @@ version = "0.45.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "36c0b049f8bdb61b20016694102f7b507f2e1727e83e9c5e6dad4f7d84ff7384" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", "gix-commitgraph", "gix-date", "gix-hash 0.17.0", @@ -2035,6 +2395,12 @@ dependencies = [ "gix-validate 0.9.4", ] +[[package]] +name = "glam" +version = "0.32.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f70749695b063ecbf6b62949ccccde2e733ec3ecbbd71d467dca4e5c6c97cca0" + [[package]] name = "glob" version = "0.3.1" @@ -2062,11 +2428,20 @@ dependencies = [ "cfg-if", "crunchy", "num-traits", - "rand", + "rand 0.9.2", "rand_distr", "zerocopy", ] +[[package]] +name = "hash32" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b0c35f58762feb77d74ebe43bdbc3210f09be9fe6742234d573bacc26ed92b67" +dependencies = [ + "byteorder", +] + [[package]] name = "hash32" version = "0.3.1" @@ -2108,13 +2483,27 @@ dependencies = [ "serde_core", ] +[[package]] +name = "heapless" +version = "0.7.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cdc6457c0eb62c71aac4bc17216026d8410337c4126773b9c5daba343f17964f" +dependencies = [ + "atomic-polyfill", + "hash32 0.2.1", + "rustc_version", + "serde", + "spin", + "stable_deref_trait", +] + [[package]] name = "heapless" version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0bfb9eb618601c89945a70e254898da93b13be0388091d42117462b265bb3fad" dependencies = [ - "hash32", + "hash32 0.3.1", "stable_deref_trait", ] @@ -2255,6 +2644,12 @@ dependencies = [ "zerovec", ] +[[package]] +name = "id-arena" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954" + [[package]] name = "ident_case" version = "1.0.1" @@ -2299,6 +2694,7 @@ checksum = "8c9c992b02b5b4c94ea26e32fe5bccb7aa7d9f390ab5c1221ff895bc7ea8b652" dependencies = [ "equivalent", "hashbrown 0.15.2", + "serde", ] [[package]] @@ -2323,24 +2719,65 @@ dependencies = [ "proc-macro2", "proc-macro2-diagnostics", "quote", - "syn 2.0.89", + "syn 2.0.117", "version_check", ] [[package]] -name = "is-terminal" -version = "0.4.17" +name = "io-uring" +version = "0.7.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3640c1c38b8e4e43584d8df18be5fc6b0aa314ce6ebf51b53313d4306cca8e46" +checksum = "fdd7bddefd0a8833b88a4b68f90dae22c7450d11b354198baee3874fd811b344" dependencies = [ - "hermit-abi", + "bitflags 2.11.1", + "cfg-if", "libc", - "windows-sys 0.61.2", ] [[package]] -name = "is_ci" -version = "1.2.0" +name = "io_uring_buf_ring" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1838759bb8c2f24cf05a35429d83145c4aa6af43f8ad38477295e12a7320a80e" +dependencies = [ + "bytes", + "io-uring", + "rustix 1.1.4", +] + +[[package]] +name = "ipc-channel" +version = "0.21.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a441490012d80e9aea75fb27503df8e87e9557dcfc6fe4244dde86bfc12e94e3" +dependencies = [ + "crossbeam-channel", + "libc", + "mio", + "postcard", + "rand 0.9.2", + "rustc-hash 2.1.1", + "serde_core", + "tempfile", + "thiserror 2.0.12", + "uuid", + "windows 0.61.3", +] + +[[package]] +name = "is-terminal" +version = "0.4.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3640c1c38b8e4e43584d8df18be5fc6b0aa314ce6ebf51b53313d4306cca8e46" +dependencies = [ + "hermit-abi", + "libc", + "windows-sys 0.61.2", +] + +[[package]] +name = "is_ci" +version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7655c9839580ee829dfacba1d1278c2b7883e50a277ff7541299489d6bdfdc45" @@ -2442,11 +2879,17 @@ version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe" +[[package]] +name = "leb128fmt" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2" + [[package]] name = "libc" -version = "0.2.174" +version = "0.2.184" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1171693293099992e19cddea4e8b849964e9846f4acee11b3948bcc337be8776" +checksum = "48f5d2a454e16a5ea0f4ced81bd44e4cfc7bd3a507b61887c99fd3538b28e4af" [[package]] name = "libloading" @@ -2470,7 +2913,7 @@ version = "0.1.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", "libc", "redox_syscall", ] @@ -2503,9 +2946,9 @@ checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89" [[package]] name = "linux-raw-sys" -version = "0.9.3" +version = "0.12.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fe7db12097d22ec582439daf8618b8fdd1a7bef6270e9af3b1ebcd30893cf413" +checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53" [[package]] name = "litemap" @@ -2581,7 +3024,7 @@ dependencies = [ "proc-macro2", "quote", "regex-syntax", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -2593,6 +3036,20 @@ dependencies = [ "logos-codegen", ] +[[package]] +name = "loom" +version = "0.7.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "419e0dc8046cb947daa77eb95ae174acfbddb7673b4151f56d1eed8e93fbfaca" +dependencies = [ + "cfg-if", + "generator", + "pin-utils", + "scoped-tls", + "tracing", + "tracing-subscriber", +] + [[package]] name = "lz4-sys" version = "1.11.1+lz4-1.10.0" @@ -2603,6 +3060,15 @@ dependencies = [ "libc", ] +[[package]] +name = "matchers" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d1525a2a28c7f4fa0fc98bb91ae755d1e2d1505079e05539e35bc876b5d65ae9" +dependencies = [ + "regex-automata", +] + [[package]] name = "maybe-async" version = "0.2.10" @@ -2611,7 +3077,7 @@ checksum = "5cf92c10c7e361d6b99666ec1c6f9805b0bea2c3bd8c78dc6fe98ac5bd78db11" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -2622,18 +3088,9 @@ checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3" [[package]] name = "memmap2" -version = "0.5.10" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "83faa42c0a078c393f6b29d5db232d8be22776a891f8f56e5284faee4a20b327" -dependencies = [ - "libc", -] - -[[package]] -name = "memmap2" -version = "0.9.7" +version = "0.9.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "483758ad303d734cec05e5c12b41d7e93e6a6390c5e9dae6bdeb7c1259012d28" +checksum = "714098028fe011992e1c3962653c96b2d578c4b4bce9036e15ff220319b1e0e3" dependencies = [ "libc", "stable_deref_trait", @@ -2675,6 +3132,17 @@ dependencies = [ "adler2", ] +[[package]] +name = "mio" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50b7e5b27aa02a74bac8c3f23f448f8d87ff11f92d3aac1a6ed369ee08cc56c1" +dependencies = [ + "libc", + "wasi 0.11.1+wasi-snapshot-preview1", + "windows-sys 0.61.2", +] + [[package]] name = "miopen-sys" version = "0.0.0" @@ -2699,7 +3167,7 @@ checksum = "4568f25ccbd45ab5d5603dc34318c1ec56b117531781260002151b8530a9f931" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -2718,6 +3186,15 @@ dependencies = [ "minimal-lexical", ] +[[package]] +name = "nu-ansi-term" +version = "0.50.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5" +dependencies = [ + "windows-sys 0.61.2", +] + [[package]] name = "num" version = "0.4.3" @@ -2828,6 +3305,40 @@ dependencies = [ "libc", ] +[[package]] +name = "nvapi" +version = "0.0.0" +dependencies = [ + "cglue", + "cuda_macros", + "cuda_types", + "dark_api", + "format", + "libloading", + "paste", + "rustc-hash 2.1.1", + "unwrap_or", + "zluda_trace_common", +] + +[[package]] +name = "nvapi_trace" +version = "0.0.0" +dependencies = [ + "cglue", + "cuda_macros", + "cuda_types", + "dark_api", + "dynasm", + "dynasmrt", + "format", + "libloading", + "paste", + "rustc-hash 2.1.1", + "unwrap_or", + "zluda_trace_common", +] + [[package]] name = "object" version = "0.38.1" @@ -2854,6 +3365,16 @@ version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d" +[[package]] +name = "os_pipe" +version = "1.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d8fae84b431384b68627d0f9b3b1245fcf9f46f6c0e3dc902e9dce64edd1967" +dependencies = [ + "libc", + "windows-sys 0.61.2", +] + [[package]] name = "owo-colors" version = "4.2.3" @@ -2915,6 +3436,18 @@ dependencies = [ "indexmap", ] +[[package]] +name = "pin-project-lite" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd" + +[[package]] +name = "pin-utils" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" + [[package]] name = "pkg-config" version = "0.3.32" @@ -2927,6 +3460,20 @@ version = "0.2.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6" +[[package]] +name = "polling" +version = "3.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d0e4f59085d47d8241c88ead0f274e8a0cb551f3625263c05eb8dd897c34218" +dependencies = [ + "cfg-if", + "concurrent-queue", + "hermit-abi", + "pin-project-lite", + "rustix 1.1.4", + "windows-sys 0.61.2", +] + [[package]] name = "portable-atomic" version = "1.11.1" @@ -2942,6 +3489,19 @@ dependencies = [ "portable-atomic", ] +[[package]] +name = "postcard" +version = "1.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6764c3b5dd454e283a30e6dfe78e9b31096d9e32036b5d1eaac7a6119ccb9a24" +dependencies = [ + "cobs", + "embedded-io 0.4.0", + "embedded-io 0.6.1", + "heapless 0.7.17", + "serde", +] + [[package]] name = "potential_utf" version = "0.1.2" @@ -2983,7 +3543,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "64d1ec885c64d0457d564db4ec299b2dae3f9c02808b8ad9c3a089c591b18033" dependencies = [ "proc-macro2", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -3005,34 +3565,32 @@ dependencies = [ ] [[package]] -name = "proc-macro-error" -version = "1.0.4" +name = "proc-macro-error-attr2" +version = "2.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c" +checksum = "96de42df36bb9bba5542fe9f1a054b8cc87e172759a1868aa05c1f3acc89dfc5" dependencies = [ - "proc-macro-error-attr", "proc-macro2", "quote", - "syn 1.0.109", - "version_check", ] [[package]] -name = "proc-macro-error-attr" -version = "1.0.4" +name = "proc-macro-error2" +version = "2.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869" +checksum = "11ec05c52be0a07b08061f7dd003e7d7092e0472bc731b4af7bb1ef876109802" dependencies = [ + "proc-macro-error-attr2", "proc-macro2", "quote", - "version_check", + "syn 2.0.117", ] [[package]] name = "proc-macro2" -version = "1.0.92" +version = "1.0.106" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "37d3544b3f2748c54e147655edb5025752e2303145b5aefb3c3ea2c78b973bb0" +checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934" dependencies = [ "unicode-ident", ] @@ -3045,7 +3603,7 @@ checksum = "af066a9c399a26e020ada66a034357a868728e72cd426f3adcd35f80d88d88c8" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", "version_check", "yansi", ] @@ -3077,7 +3635,7 @@ checksum = "7347867d0a7e1208d93b46767be83e2b8f978c3dad35f775ac8d8847551d6fe1" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -3134,7 +3692,7 @@ dependencies = [ "ptx_parser_macros_impl", "quote", "rustc-hash 2.1.1", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -3144,7 +3702,7 @@ dependencies = [ "proc-macro2", "quote", "rustc-hash 2.1.1", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -3188,9 +3746,9 @@ checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0" [[package]] name = "quote" -version = "1.0.37" +version = "1.0.45" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af" +checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924" dependencies = [ "proc-macro2", ] @@ -3201,6 +3759,12 @@ version = "5.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f" +[[package]] +name = "r-efi" +version = "6.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf" + [[package]] name = "rancor" version = "0.1.1" @@ -3217,7 +3781,18 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1" dependencies = [ "rand_chacha", - "rand_core", + "rand_core 0.9.5", +] + +[[package]] +name = "rand" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d2e8e8bcc7961af1fdac401278c6a831614941f6164ee3bf4ce61b7edb162207" +dependencies = [ + "chacha20", + "getrandom 0.4.2", + "rand_core 0.10.0", ] [[package]] @@ -3227,7 +3802,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb" dependencies = [ "ppv-lite86", - "rand_core", + "rand_core 0.9.5", ] [[package]] @@ -3239,6 +3814,12 @@ dependencies = [ "getrandom 0.3.3", ] +[[package]] +name = "rand_core" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c8d0fd677905edcbeedbf2edb6494d676f0e98d54d5cf9bda0b061cb8fb8aba" + [[package]] name = "rand_distr" version = "0.5.1" @@ -3246,7 +3827,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6a8615d50dcf34fa31f7ab52692afec947c4dd0ab803cc87cb3b0b4570ff7463" dependencies = [ "num-traits", - "rand", + "rand 0.9.2", ] [[package]] @@ -3255,7 +3836,7 @@ version = "11.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "498cd0dc59d73224351ee52a95fee0f1a617a2eae0e7d9d720cc622c73a54186" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", ] [[package]] @@ -3290,7 +3871,7 @@ version = "0.5.11" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d2f103c6d277498fbceb16e84d317e2a400f160f46904d5f5410848c829511a3" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", ] [[package]] @@ -3375,7 +3956,7 @@ checksum = "8100bb34c0a1d0f907143db3149e6b4eea3c33b9ee8b189720168e818303986f" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -3423,7 +4004,7 @@ version = "0.38.37" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8acb788b847c24f28525660c4d7758620a7210875711f79e7f663cc152726811" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", "errno", "libc", "linux-raw-sys 0.4.14", @@ -3432,15 +4013,15 @@ dependencies = [ [[package]] name = "rustix" -version = "1.0.5" +version = "1.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d97817398dd4bb2e6da002002db259209759911da105da92bec29ccb12cf58bf" +checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", "errno", "libc", - "linux-raw-sys 0.9.3", - "windows-sys 0.59.0", + "linux-raw-sys 0.12.1", + "windows-sys 0.61.2", ] [[package]] @@ -3484,6 +4065,12 @@ dependencies = [ "winapi-util", ] +[[package]] +name = "scoped-tls" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294" + [[package]] name = "scopeguard" version = "1.2.0" @@ -3507,7 +4094,7 @@ checksum = "1783eabc414609e28a5ba76aee5ddd52199f7107a0b24c2e9746a1ecc34a683d" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -3552,7 +4139,7 @@ checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -3583,7 +4170,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba" dependencies = [ "cfg-if", - "cpufeatures", + "cpufeatures 0.2.17", "digest", ] @@ -3597,6 +4184,15 @@ dependencies = [ "sha1", ] +[[package]] +name = "sharded-slab" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6" +dependencies = [ + "lazy_static", +] + [[package]] name = "shell-words" version = "1.1.0" @@ -3640,12 +4236,37 @@ version = "0.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e" +[[package]] +name = "slab" +version = "0.4.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5" + [[package]] name = "smallvec" version = "1.15.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03" +[[package]] +name = "socket2" +version = "0.6.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3a766e1110788c36f4fa1c2b71b387a7815aa65f88ce0229841826633d93723e" +dependencies = [ + "libc", + "windows-sys 0.61.2", +] + +[[package]] +name = "spin" +version = "0.9.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67" +dependencies = [ + "lock_api", +] + [[package]] name = "stable_deref_trait" version = "1.2.0" @@ -3689,7 +4310,7 @@ dependencies = [ "proc-macro2", "quote", "rustversion", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -3701,7 +4322,7 @@ dependencies = [ "heck", "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -3736,15 +4357,25 @@ dependencies = [ [[package]] name = "syn" -version = "2.0.89" +version = "2.0.117" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "44d46482f1c1c87acd84dea20c1bf5ebff4c757009ed6bf19cfd36fb10e92c4e" +checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99" dependencies = [ "proc-macro2", "quote", "unicode-ident", ] +[[package]] +name = "synchrony" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c174d82fd56da8214ec095cfe4568e59e5ccb49d060e70c2f98e3ba352b23e45" +dependencies = [ + "futures-util", + "loom", +] + [[package]] name = "synstructure" version = "0.13.2" @@ -3753,7 +4384,7 @@ checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -3762,7 +4393,7 @@ version = "0.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "01198a2debb237c62b6826ec7081082d951f46dbb64b0e8c7649a452230d1dfc" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", "byteorder", "enum-as-inner", "libc", @@ -3796,10 +4427,16 @@ dependencies = [ "fastrand", "getrandom 0.3.3", "once_cell", - "rustix 1.0.5", + "rustix 1.1.4", "windows-sys 0.59.0", ] +[[package]] +name = "thin-cell" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4164c6c316ba9733b0ab021e7f9852c788a4b991b49c25820f1be48e1d41345b" + [[package]] name = "thiserror" version = "1.0.64" @@ -3826,7 +4463,7 @@ checksum = "08904e7672f5eb876eaaf87e0ce17857500934f4981c4a0ab2b4aa98baac7fc3" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -3837,7 +4474,16 @@ checksum = "7f7cf42b4507d8ea322120659672cf1b9dbb93f8f2d4ecfd6e51350ff5b17a1d" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", +] + +[[package]] +name = "thread_local" +version = "1.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f60246a4944f24f6e018aa17cdeffb7818b76356965d03b07d6a9886e8962185" +dependencies = [ + "cfg-if", ] [[package]] @@ -3963,6 +4609,55 @@ version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "fcc842091f2def52017664b53082ecbbeb5c7731092bad69d2c63050401dfd64" +[[package]] +name = "tracing" +version = "0.1.44" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100" +dependencies = [ + "pin-project-lite", + "tracing-core", +] + +[[package]] +name = "tracing-core" +version = "0.1.36" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a" +dependencies = [ + "once_cell", + "valuable", +] + +[[package]] +name = "tracing-log" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3" +dependencies = [ + "log", + "once_cell", + "tracing-core", +] + +[[package]] +name = "tracing-subscriber" +version = "0.3.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cb7f578e5945fb242538965c2d0b04418d38ec25c79d160cd279bf0731c8d319" +dependencies = [ + "matchers", + "nu-ansi-term", + "once_cell", + "regex-automata", + "sharded-slab", + "smallvec", + "thread_local", + "tracing", + "tracing-core", + "tracing-log", +] + [[package]] name = "trie-hard" version = "0.1.0" @@ -4032,6 +4727,12 @@ version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "323402cff2dd658f39ca17c789b502021b3f18707c91cdf22e3838e1b4023817" +[[package]] +name = "unty" +version = "0.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6d49784317cd0d1ee7ec5c716dd598ec5b4483ea832a2dced265471cc0f690ae" + [[package]] name = "unwrap_or" version = "1.0.1" @@ -4061,10 +4762,17 @@ version = "1.18.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2f87b8aa10b915a06587d0dec516c282ff295b475d94abf425d62b57710070a2" dependencies = [ + "getrandom 0.3.3", "js-sys", "wasm-bindgen", ] +[[package]] +name = "valuable" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65" + [[package]] name = "vcpkg" version = "0.2.15" @@ -4115,6 +4823,12 @@ version = "0.9.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" +[[package]] +name = "virtue" +version = "0.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "051eb1abcf10076295e815102942cc58f9d5e3b4560e46e53c21e8ff6f3af7b1" + [[package]] name = "vswhom" version = "0.1.0" @@ -4160,6 +4874,24 @@ dependencies = [ "wit-bindgen-rt", ] +[[package]] +name = "wasip2" +version = "1.0.2+wasi-0.2.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9517f9239f02c069db75e65f174b3da828fe5f5b945c4dd26bd25d89c03ebcf5" +dependencies = [ + "wit-bindgen", +] + +[[package]] +name = "wasip3" +version = "0.4.0+wasi-0.3.0-rc-2026-01-06" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5" +dependencies = [ + "wit-bindgen", +] + [[package]] name = "wasm-bindgen" version = "0.2.104" @@ -4183,7 +4915,7 @@ dependencies = [ "log", "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", "wasm-bindgen-shared", ] @@ -4205,7 +4937,7 @@ checksum = "9f07d2f20d4da7b26400c9f4a0511e6e0345b040694e8a75bd41d578fa4421d7" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", "wasm-bindgen-backend", "wasm-bindgen-shared", ] @@ -4219,6 +4951,40 @@ dependencies = [ "unicode-ident", ] +[[package]] +name = "wasm-encoder" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319" +dependencies = [ + "leb128fmt", + "wasmparser", +] + +[[package]] +name = "wasm-metadata" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909" +dependencies = [ + "anyhow", + "indexmap", + "wasm-encoder", + "wasmparser", +] + +[[package]] +name = "wasmparser" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe" +dependencies = [ + "bitflags 2.11.1", + "hashbrown 0.15.2", + "indexmap", + "semver", +] + [[package]] name = "web-time" version = "1.1.0" @@ -4266,16 +5032,38 @@ version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" +[[package]] +name = "windows" +version = "0.61.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9babd3a767a4c1aef6900409f85f5d53ce2544ccdfaa86dad48c91782c6d6893" +dependencies = [ + "windows-collections 0.2.0", + "windows-core 0.61.2", + "windows-future 0.2.1", + "windows-link 0.1.3", + "windows-numerics 0.2.0", +] + [[package]] name = "windows" version = "0.62.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "527fadee13e0c05939a6a05d5bd6eec6cd2e3dbd648b9f8e447c6518133d8580" dependencies = [ - "windows-collections", - "windows-core", - "windows-future", - "windows-numerics", + "windows-collections 0.3.2", + "windows-core 0.62.2", + "windows-future 0.3.2", + "windows-numerics 0.3.1", +] + +[[package]] +name = "windows-collections" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3beeceb5e5cfd9eb1d76b381630e82c4241ccd0d27f1a39ed41b2760b255c5e8" +dependencies = [ + "windows-core 0.61.2", ] [[package]] @@ -4284,7 +5072,20 @@ version = "0.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "23b2d95af1a8a14a3c7367e1ed4fc9c20e0a26e79551b1454d72583c97cc6610" dependencies = [ - "windows-core", + "windows-core 0.62.2", +] + +[[package]] +name = "windows-core" +version = "0.61.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3" +dependencies = [ + "windows-implement", + "windows-interface", + "windows-link 0.1.3", + "windows-result 0.3.4", + "windows-strings 0.4.2", ] [[package]] @@ -4295,9 +5096,20 @@ checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb" dependencies = [ "windows-implement", "windows-interface", - "windows-link", - "windows-result", - "windows-strings", + "windows-link 0.2.1", + "windows-result 0.4.1", + "windows-strings 0.5.1", +] + +[[package]] +name = "windows-future" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc6a41e98427b19fe4b73c550f060b59fa592d7d686537eebf9385621bfbad8e" +dependencies = [ + "windows-core 0.61.2", + "windows-link 0.1.3", + "windows-threading 0.1.0", ] [[package]] @@ -4306,9 +5118,9 @@ version = "0.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e1d6f90251fe18a279739e78025bd6ddc52a7e22f921070ccdc67dde84c605cb" dependencies = [ - "windows-core", - "windows-link", - "windows-threading", + "windows-core 0.62.2", + "windows-link 0.2.1", + "windows-threading 0.2.1", ] [[package]] @@ -4319,7 +5131,7 @@ checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -4330,23 +5142,48 @@ checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] +[[package]] +name = "windows-link" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a" + [[package]] name = "windows-link" version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" +[[package]] +name = "windows-numerics" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9150af68066c4c5c07ddc0ce30421554771e528bde427614c61038bc2c92c2b1" +dependencies = [ + "windows-core 0.61.2", + "windows-link 0.1.3", +] + [[package]] name = "windows-numerics" version = "0.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6e2e40844ac143cdb44aead537bbf727de9b044e107a0f1220392177d15b0f26" dependencies = [ - "windows-core", - "windows-link", + "windows-core 0.62.2", + "windows-link 0.2.1", +] + +[[package]] +name = "windows-result" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6" +dependencies = [ + "windows-link 0.1.3", ] [[package]] @@ -4355,7 +5192,16 @@ version = "0.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5" dependencies = [ - "windows-link", + "windows-link 0.2.1", +] + +[[package]] +name = "windows-strings" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57" +dependencies = [ + "windows-link 0.1.3", ] [[package]] @@ -4364,7 +5210,7 @@ version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091" dependencies = [ - "windows-link", + "windows-link 0.2.1", ] [[package]] @@ -4391,7 +5237,7 @@ version = "0.61.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" dependencies = [ - "windows-link", + "windows-link 0.2.1", ] [[package]] @@ -4410,13 +5256,22 @@ dependencies = [ "windows_x86_64_msvc", ] +[[package]] +name = "windows-threading" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b66463ad2e0ea3bbf808b7f1d371311c80e115c0b71d60efc142cafbcfb057a6" +dependencies = [ + "windows-link 0.1.3", +] + [[package]] name = "windows-threading" version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3949bd5b99cafdf1c7ca86b43ca564028dfe27d66958f2470940f73d86d75b37" dependencies = [ - "windows-link", + "windows-link 0.2.1", ] [[package]] @@ -4495,13 +5350,101 @@ dependencies = [ "windows-sys 0.59.0", ] +[[package]] +name = "wit-bindgen" +version = "0.51.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5" +dependencies = [ + "wit-bindgen-rust-macro", +] + +[[package]] +name = "wit-bindgen-core" +version = "0.51.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc" +dependencies = [ + "anyhow", + "heck", + "wit-parser", +] + [[package]] name = "wit-bindgen-rt" version = "0.39.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6f42320e61fe2cfd34354ecb597f86f413484a798ba44a8ca1165c58d42da6c1" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", +] + +[[package]] +name = "wit-bindgen-rust" +version = "0.51.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21" +dependencies = [ + "anyhow", + "heck", + "indexmap", + "prettyplease", + "syn 2.0.117", + "wasm-metadata", + "wit-bindgen-core", + "wit-component", +] + +[[package]] +name = "wit-bindgen-rust-macro" +version = "0.51.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c0f9bfd77e6a48eccf51359e3ae77140a7f50b1e2ebfe62422d8afdaffab17a" +dependencies = [ + "anyhow", + "prettyplease", + "proc-macro2", + "quote", + "syn 2.0.117", + "wit-bindgen-core", + "wit-bindgen-rust", +] + +[[package]] +name = "wit-component" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2" +dependencies = [ + "anyhow", + "bitflags 2.11.1", + "indexmap", + "log", + "serde", + "serde_derive", + "serde_json", + "wasm-encoder", + "wasm-metadata", + "wasmparser", + "wit-parser", +] + +[[package]] +name = "wit-parser" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736" +dependencies = [ + "anyhow", + "id-arena", + "indexmap", + "log", + "semver", + "serde", + "serde_derive", + "serde_json", + "unicode-xid", + "wasmparser", ] [[package]] @@ -4517,7 +5460,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0d65cbf2f12c15564212d48f4e3dfb87923d25d611f2aed18f4cb23f0413d89e" dependencies = [ "libc", - "rustix 1.0.5", + "rustix 1.1.4", ] [[package]] @@ -4560,7 +5503,7 @@ checksum = "38da3c9736e16c5d3c8c597a9aaa5d1fa565d0532ae05e27c24aa62fb32c0ab6" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", "synstructure", ] @@ -4581,7 +5524,7 @@ checksum = "9ecf5b4cc5364572d7f4c329661bcc82724222973f2cab6f050a4e5c22f75181" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -4601,7 +5544,7 @@ checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", "synstructure", ] @@ -4635,7 +5578,7 @@ checksum = "5b96237efa0c878c64bd89c436f661be4e46b2f3eff1ebb976f7ef2321d2f58f" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -4697,12 +5640,47 @@ dependencies = [ "serde_json", "tempfile", "vergen-gix", - "windows", + "windows 0.62.2", "zluda_cache", "zluda_common", "zluda_windows", ] +[[package]] +name = "zluda32" +version = "0.0.0" +dependencies = [ + "bincode", + "bitcode", + "cuda_macros", + "cuda_types", + "dark_api", + "ipc-channel", + "paste", + "postcard", + "rand 0.10.1", + "rkyv", + "widestring", + "windows 0.62.2", + "zluda_server_common", + "zluda_windows", +] + +[[package]] +name = "zluda64_server" +version = "0.0.0" +dependencies = [ + "bincode", + "compio", + "cuda_macros", + "cuda_types", + "dark_api", + "rkyv", + "slab", + "windows-sys 0.61.2", + "zluda_server_common", +] + [[package]] name = "zluda_bindgen" version = "0.1.0" @@ -4714,7 +5692,7 @@ dependencies = [ "proc-macro2", "quote", "rustc-hash 2.1.1", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -4811,9 +5789,9 @@ dependencies = [ "half", "libloading", "paste", - "rand", + "rand 0.9.2", "rand_chacha", - "windows", + "windows 0.62.2", "zluda_common", "zluda_dnn", "zluda_windows", @@ -4837,8 +5815,8 @@ dependencies = [ "rustc-hash 2.1.1", "tempfile", "widestring", - "windows", - "windows-core", + "windows 0.62.2", + "windows-core 0.62.2", "zluda_ml", "zluda_redirect", "zluda_trace", @@ -4882,12 +5860,27 @@ dependencies = [ "rustc-hash 2.1.1", "unwrap_or", "widestring", - "windows", + "windows 0.62.2", "windows-sys 0.61.2", "winnow 0.6.20", "zluda_windows", ] +[[package]] +name = "zluda_server_common" +version = "0.0.0" +dependencies = [ + "bincode", + "bitcode", + "cuda_macros", + "cuda_types", + "paste", + "postcard", + "rkyv", + "strum 0.28.0", + "strum_macros 0.28.0", +] + [[package]] name = "zluda_sparse" version = "0.0.0" @@ -4919,12 +5912,11 @@ dependencies = [ "libloading", "parking_lot", "paste", - "ptx", "ptx_parser", "regex", "rustc-hash 2.1.1", "unwrap_or", - "windows", + "windows 0.62.2", "zluda_common", "zluda_trace_common", "zstd-safe", @@ -5055,7 +6047,7 @@ dependencies = [ "trie-hard", "uuid", "widestring", - "windows", + "windows 0.62.2", ] [[package]] diff --git a/Cargo.toml b/Cargo.toml index d199126eb..066ca9602 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -16,6 +16,8 @@ members = [ "ext/rocblas-sys", "format", "kernel_metadata", + "nvapi", + "nvapi_trace", "ptx_parser_macros_impl", "ptx_parser_macros", "ptx_parser", @@ -36,6 +38,7 @@ members = [ "zluda_ml", "zluda_precompile", "zluda_redirect", + "zluda_server_common", "zluda_sparse", "zluda_trace_blas", "zluda_trace_blaslt", @@ -47,6 +50,8 @@ members = [ "zluda_trace_sparse", "zluda_trace", "zluda", + "zluda32", + "zluda64_server", ] default-members = ["zluda", "zluda_ml", "zluda_inject", "zluda_redirect", "compiler"] diff --git a/cuda_check/Cargo.toml b/cuda_check/Cargo.toml index c0b9c3d4d..baefa150c 100644 --- a/cuda_check/Cargo.toml +++ b/cuda_check/Cargo.toml @@ -13,7 +13,7 @@ cuda_types = { path = "../cuda_types" } zluda_windows = { path = "../zluda_windows" } bpaf = { version = "0.9.19", features = ["derive", "bright-color"] } owo-colors = { version = "4", features = ["supports-colors"] } -rand = "0.9.2" +rand = "0.10.1" libloading = "0.8" [target.'cfg(windows)'.dependencies] diff --git a/cuda_macros/src/lib.rs b/cuda_macros/src/lib.rs index 769a672b9..1267860b9 100644 --- a/cuda_macros/src/lib.rs +++ b/cuda_macros/src/lib.rs @@ -9,8 +9,7 @@ use syn::parse::{Parse, ParseStream}; use syn::punctuated::Punctuated; use syn::visit_mut::VisitMut; use syn::{ - bracketed, parse_macro_input, File, ForeignItem, ForeignItemFn, Ident, Item, Path, Signature, - Token + File, ForeignItem, ForeignItemFn, Ident, Item, PatType, Path, Signature, Token, TypeGroup, bracketed, parse_macro_input }; const CUDA_RS: &'static str = include_str! {"cuda.rs"}; @@ -301,6 +300,95 @@ pub fn nvml_normalize_fn(tokens: TokenStream) -> TokenStream { normalize_fn_impl("nvml", None, tokens) } +#[proc_macro] +pub fn generate_input_struct(tokens: TokenStream) -> TokenStream { + let input = parse_macro_input!(tokens as FnWithFields); + let struct_name = format_ident!("{}In", input.fn_name); + let fields = input.fields.iter().filter(|pat| is_input_field(&pat.ty)).map(use_wire_object); + quote! { + #[derive(Archive, Deserialize, Serialize, Debug, PartialEq)] + #[repr(C)] + pub struct #struct_name { + #(#fields),* + } + unsafe impl Portable for #struct_name {} + }.into() +} + +#[proc_macro] +pub fn generate_output_struct(tokens: TokenStream) -> TokenStream { + let input = parse_macro_input!(tokens as FnWithFields); + let struct_name = format_ident!("{}Out", input.fn_name); + let fields = input.fields.iter().filter(|pat| !is_input_field(&pat.ty)).map(strip_mut_ptr); + quote! { + #[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] + #[repr(C)] + pub struct #struct_name { + #(#fields),* + } + unsafe impl Portable for #struct_name {} + }.into() +} + +fn is_input_field(ty: &syn::Type) -> bool { + match ty { + syn::Type::Ptr(token) if token.mutability.is_some() => false, + syn::Type::Group(TypeGroup {elem, ..}) => is_input_field(&*elem), + _ => true + } +} + +fn use_wire_object(ty: &syn::PatType) -> proc_macro2::TokenStream { + let pat = &ty.pat; + let type_ = &ty.ty; + quote! { pub #pat : <#type_ as crate::CudaEncode>::WireObject } +} + +fn strip_mut_ptr(ty: &syn::PatType) -> proc_macro2::TokenStream { + fn strip_mut_ptr_from_type(ty: &syn::Type) -> proc_macro2::TokenStream { + match ty { + syn::Type::Ptr(token) => { + let elem = &token.elem; + quote! { #elem } + }, + _ => unreachable!() + } + } + let pat = &ty.pat; + match &*ty.ty { + syn::Type::Ptr(token) => { + let type_ = strip_mut_ptr_from_type(&*token.elem); + quote! { pub #pat : <#type_ as crate::CudaEncode>::WireObject } + }, + syn::Type::Group(TypeGroup {elem, ..}) => { + let type_ = strip_mut_ptr_from_type(&*elem); + quote! { pub #pat : <#type_ as crate::CudaEncode>::WireObject } + }, + _ => unreachable!() + } +} + +struct FnWithFields { + fn_name: Ident, + fields: Punctuated, +} + +impl Parse for FnWithFields { + fn parse(input: ParseStream) -> syn::Result { + let fn_name = input.parse::()?; + let fields = if input.is_empty() { + Punctuated::new() + } else { + input.parse::()?; + input.parse_terminated(PatType::parse, Token![,])? + }; + Ok(Self { + fn_name, + fields, + }) + } +} + fn split(fn_: &str) -> Vec { let mut result = Vec::new(); let mut chars: iter::Peekable<_> = fn_.chars().peekable(); diff --git a/dark_api/src/lib.rs b/dark_api/src/lib.rs index cfd8c928e..6b2d452e9 100644 --- a/dark_api/src/lib.rs +++ b/dark_api/src/lib.rs @@ -354,6 +354,7 @@ dark_api! { #[noformat] [0] = logged_call( fn_name: cglue::slice::CSliceRef<'static, u8>, + nvapi_interface: u32, args: crate::FnFfiRef, fn_: crate::FnFfiRef, internal_error: usize, diff --git a/nvapi/Cargo.toml b/nvapi/Cargo.toml new file mode 100644 index 000000000..a3699b162 --- /dev/null +++ b/nvapi/Cargo.toml @@ -0,0 +1,26 @@ +[package] +name = "nvapi" +version = "0.0.0" +authors = ["Andrzej Janik "] +edition = "2021" + +[lib] +name = "nvapi64" +crate-type = ["cdylib"] + +[dependencies] +format = { path = "../format" } +dark_api = { path = "../dark_api" } +cuda_macros = { path = "../cuda_macros" } +cuda_types = { path = "../cuda_types" } +zluda_trace_common = { path = "../zluda_trace_common" } +libloading = "0.8" +paste = "1.0" +unwrap_or = "1.0.1" +cglue = "0.3.5" +rustc-hash = "2.0.0" + +[package.metadata.zluda] +windows_only = true +windows32_paths = ["nvapi.dll"] +32bit = true diff --git a/nvapi/src/lib.rs b/nvapi/src/lib.rs new file mode 100644 index 000000000..a44cd3582 --- /dev/null +++ b/nvapi/src/lib.rs @@ -0,0 +1,726 @@ +use crate::nvapi::*; +use libloading::Library; +use rustc_hash::FxHashMap; +use std::{ + collections::hash_map, + ffi::c_void, + mem, ptr, + sync::{LazyLock, Mutex}, +}; + +#[allow(warnings)] +mod nvapi; + +macro_rules! interface_to_name { + ($({ $name:ident, $id:literal }),* $(,)?) => { + fn interface_to_fn(interface: u32) -> Option<*mut c_void> { + match interface { + $( + $id => Some($name as *mut c_void), + )* + _ => None, + } + } + }; +} + +interface_to_name!( + { NvAPI_Initialize, 0x0150e828 }, + { NvAPI_Unload, 0xd22bdd7e }, + // { NvAPI_GetErrorMessage, 0x6c2d048c }, + // { NvAPI_GetInterfaceVersionString, 0x01053fa5 }, + // { NvAPI_GPU_GetEDID, 0x37d32e69 }, + // { NvAPI_SetView, 0x0957d7b6 }, + // { NvAPI_SetViewEx, 0x06b89e68 }, + { NvAPI_GetDisplayDriverVersion, 0xf951a4d1 }, + { NvAPI_SYS_GetDriverAndBranchVersion, 0x2926aaad }, + // { NvAPI_GPU_GetMemoryInfo, 0x07f9b368 }, + // { NvAPI_GPU_GetMemoryInfoEx, 0xc0599498 }, + // { NvAPI_OGL_ExpertModeSet, 0x3805ef7a }, + // { NvAPI_OGL_ExpertModeGet, 0x22ed9516 }, + // { NvAPI_OGL_ExpertModeDefaultsSet, 0xb47a657e }, + // { NvAPI_OGL_ExpertModeDefaultsGet, 0xae921f12 }, + // { NvAPI_EnumPhysicalGPUs, 0xe5ac921f }, + // { NvAPI_EnumTCCPhysicalGPUs, 0xd9930b07 }, + // { NvAPI_EnumLogicalGPUs, 0x48b3ea59 }, + // { NvAPI_GetPhysicalGPUsFromDisplay, 0x34ef9506 }, + // { NvAPI_GetPhysicalGPUFromUnAttachedDisplay, 0x5018ed61 }, + // { NvAPI_GetLogicalGPUFromDisplay, 0xee1370cf }, + // { NvAPI_GetLogicalGPUFromPhysicalGPU, 0xadd604d1 }, + // { NvAPI_GetPhysicalGPUsFromLogicalGPU, 0xaea3fa32 }, + { NvAPI_GetPhysicalGPUFromGPUID, 0x5380ad1a }, + { NvAPI_GetGPUIDfromPhysicalGPU, 0x6533ea3e }, + // { NvAPI_GPU_GetShaderSubPipeCount, 0x0be17923 }, + // { NvAPI_GPU_GetGpuCoreCount, 0xc7026a87 }, + // { NvAPI_GPU_GetAllOutputs, 0x7d554f8e }, + // { NvAPI_GPU_GetConnectedOutputs, 0x1730bfc9 }, + // { NvAPI_GPU_GetConnectedSLIOutputs, 0x0680de09 }, + // { NvAPI_GPU_GetConnectedDisplayIds, 0x0078dba2 }, + // { NvAPI_GPU_GetAllDisplayIds, 0x785210a2 }, + // { NvAPI_GPU_GetConnectedOutputsWithLidState, 0xcf8caf39 }, + // { NvAPI_GPU_GetConnectedSLIOutputsWithLidState, 0x96043cc7 }, + // { NvAPI_GPU_GetSystemType, 0xbaaabfcc }, + // { NvAPI_GPU_GetActiveOutputs, 0xe3e89b6f }, + // { NvAPI_GPU_SetEDID, 0xe83d6456 }, + // { NvAPI_GPU_GetOutputType, 0x40a505e4 }, + // { NvAPI_GPU_ValidateOutputCombination, 0x34c9c2d4 }, + // { NvAPI_GPU_GetFullName, 0xceee8e9f }, + // { NvAPI_GPU_GetPCIIdentifiers, 0x2ddfb66e }, + // { NvAPI_GPU_GetGPUType, 0xc33baeb1 }, + // { NvAPI_GPU_GetBusType, 0x1bb18724 }, + // { NvAPI_GPU_GetBusId, 0x1be0b8e5 }, + // { NvAPI_GPU_GetBusSlotId, 0x2a0a350f }, + // { NvAPI_GPU_GetIRQ, 0xe4715417 }, + // { NvAPI_GPU_GetVbiosRevision, 0xacc3da0a }, + // { NvAPI_GPU_GetVbiosOEMRevision, 0x2d43fb31 }, + // { NvAPI_GPU_GetVbiosVersionString, 0xa561fd7d }, + // { NvAPI_GPU_GetAGPAperture, 0x6e042794 }, + // { NvAPI_GPU_GetCurrentAGPRate, 0xc74925a0 }, + // { NvAPI_GPU_GetCurrentPCIEDownstreamWidth, 0xd048c3b1 }, + // { NvAPI_GPU_GetPhysicalFrameBufferSize, 0x46fbeb03 }, + // { NvAPI_GPU_GetVirtualFrameBufferSize, 0x5a04b644 }, + // { NvAPI_GPU_GetQuadroStatus, 0xe332fa47 }, + // { NvAPI_GPU_GetBoardInfo, 0x22d54523 }, + // { NvAPI_GPU_GetRamBusWidth, 0x7975c581 }, + // { NvAPI_GPU_GetArchInfo, 0xd8265d24 }, + // { NvAPI_I2CRead, 0x2fde12c5 }, + // { NvAPI_I2CWrite, 0xe812eb07 }, + // { NvAPI_GPU_WorkstationFeatureSetup, 0x6c1f3fe4 }, + // { NvAPI_GPU_WorkstationFeatureQuery, 0x004537df }, + // { NvAPI_GPU_GetHDCPSupportStatus, 0xf089eef5 }, + { NvAPI_GPU_CudaEnumComputeCapableGpus, 0x5786cc6e }, + // { NvAPI_GPU_GetTachReading, 0x5f608315 }, + // { NvAPI_GPU_GetECCStatusInfo, 0xca1ddaf3 }, + // { NvAPI_GPU_GetECCErrorInfo, 0xc71f85a6 }, + // { NvAPI_GPU_ResetECCErrorInfo, 0xc02eec20 }, + // { NvAPI_GPU_GetECCConfigurationInfo, 0x77a796f3 }, + // { NvAPI_GPU_SetECCConfiguration, 0x1cf639d9 }, + // { NvAPI_GPU_QueryWorkstationFeatureSupport, 0x80b1abb9 }, + // { NvAPI_GPU_SetScanoutIntensity, 0xa57457a4 }, + // { NvAPI_GPU_GetScanoutIntensityState, 0xe81ce836 }, + // { NvAPI_GPU_SetScanoutWarping, 0xb34bab4f }, + // { NvAPI_GPU_GetScanoutWarpingState, 0x6f5435af }, + // { NvAPI_GPU_SetScanoutCompositionParameter, 0xf898247d }, + // { NvAPI_GPU_GetScanoutCompositionParameter, 0x58fe51e6 }, + // { NvAPI_GPU_GetScanoutConfiguration, 0x6a9f5b63 }, + // { NvAPI_GPU_GetScanoutConfigurationEx, 0xe2e1e6f0 }, + // { NvAPI_GPU_GetAdapterIdFromPhysicalGpu, 0x0ff07fde }, + // { NvAPI_GPU_GetVirtualizationInfo, 0x44e022a9 }, + // { NvAPI_GPU_GetLogicalGpuInfo, 0x842b066e }, + // { NvAPI_GPU_GetLicensableFeatures, 0x3fc596aa }, + // { NvAPI_GPU_GetEncoderStatistics, 0xf0a9aeeb }, + // { NvAPI_GPU_GetEncoderSessionsInfo, 0xd8a72ce5 }, + // { NvAPI_GPU_GetGPUInfo, 0xafd1b02c }, + // { NvAPI_GPU_GetVRReadyData, 0x81d629c5 }, + // { NvAPI_GPU_GetGspFeatures, 0x581c4391 }, + // { NvAPI_GPU_GetUUID, 0xdc95673d }, + // { NvAPI_GPU_NVLINK_GetCaps, 0xbef1119d }, + // { NvAPI_GPU_NVLINK_GetStatus, 0xc72a38e3 }, + // { NvAPI_GPU_GetPerfDecreaseInfo, 0x7f7f4600 }, + // { NvAPI_GPU_GetPstatesInfoEx, 0x843c0256 }, + // { NvAPI_GPU_GetPstates20, 0x6ff81213 }, + // { NvAPI_GPU_GetCurrentPstate, 0x927da4f6 }, + // { NvAPI_GPU_GetDynamicPstatesInfoEx, 0x60ded2ed }, + // { NvAPI_GPU_GetThermalSettings, 0xe3640a56 }, + // { NvAPI_GPU_GetAllClockFrequencies, 0xdcb616c3 }, + // { NvAPI_GPU_QueryIlluminationSupport, 0xa629da31 }, + // { NvAPI_GPU_GetIllumination, 0x9a1b9365 }, + // { NvAPI_GPU_SetIllumination, 0x0254a187 }, + // { NvAPI_GPU_ClientIllumDevicesGetInfo, 0xd4100e58 }, + // { NvAPI_GPU_ClientIllumDevicesGetControl, 0x73c01d58 }, + // { NvAPI_GPU_ClientIllumDevicesSetControl, 0x57024c62 }, + // { NvAPI_GPU_ClientIllumZonesGetInfo, 0x4b81241b }, + // { NvAPI_GPU_ClientIllumZonesGetControl, 0x3dbf5764 }, + // { NvAPI_GPU_ClientIllumZonesSetControl, 0x197d065e }, + // { NvAPI_Event_RegisterCallback, 0xe6dbea69 }, + // { NvAPI_Event_UnregisterCallback, 0xde1f9b45 }, + // { NvAPI_EnumNvidiaDisplayHandle, 0x9abdd40d }, + // { NvAPI_EnumNvidiaUnAttachedDisplayHandle, 0x20de9260 }, + // { NvAPI_CreateDisplayFromUnAttachedDisplay, 0x63f9799e }, + // { NvAPI_GetAssociatedNvidiaDisplayHandle, 0x35c29134 }, + // { NvAPI_DISP_GetAssociatedUnAttachedNvidiaDisplayHandle, 0xa70503b2 }, + // { NvAPI_GetAssociatedNvidiaDisplayName, 0x22a78b05 }, + // { NvAPI_GetUnAttachedAssociatedDisplayName, 0x4888d790 }, + // { NvAPI_EnableHWCursor, 0x2863148d }, + // { NvAPI_DisableHWCursor, 0xab163097 }, + // { NvAPI_GetVBlankCounter, 0x67b5db55 }, + // { NvAPI_SetRefreshRateOverride, 0x3092ac32 }, + // { NvAPI_GetAssociatedDisplayOutputId, 0xd995937e }, + // { NvAPI_GetDisplayPortInfo, 0xc64ff367 }, + // { NvAPI_SetDisplayPort, 0xfa13e65a }, + // { NvAPI_GetHDMISupportInfo, 0x6ae16ec3 }, + // { NvAPI_Disp_InfoFrameControl, 0x6067af3f }, + // { NvAPI_Disp_ColorControl, 0x92f9d80d }, + // { NvAPI_Disp_GetHdrCapabilities, 0x84f2a8df }, + // { NvAPI_Disp_HdrColorControl, 0x351da224 }, + // { NvAPI_Disp_SetSourceColorSpace, 0x473b6caf }, + // { NvAPI_Disp_GetSourceColorSpace, 0xceedc85b }, + // { NvAPI_Disp_SetSourceHdrMetadata, 0x905eb63b }, + // { NvAPI_Disp_GetSourceHdrMetadata, 0x0d3f52da }, + // { NvAPI_Disp_SetOutputMode, 0x98e7661a }, + // { NvAPI_Disp_GetOutputMode, 0x81fed88d }, + // { NvAPI_Disp_SetHdrToneMapping, 0xdd6da362 }, + // { NvAPI_Disp_GetHdrToneMapping, 0xfbd36e71 }, + // { NvAPI_Disp_GetColorimetry, 0x00b421ad }, + // { NvAPI_DISP_GetTiming, 0x175167e9 }, + // { NvAPI_DISP_GetMonitorCapabilities, 0x3b05c7e1 }, + // { NvAPI_DISP_GetMonitorColorCapabilities, 0x6ae4cfb5 }, + // { NvAPI_DISP_EnumCustomDisplay, 0xa2072d59 }, + // { NvAPI_DISP_TryCustomDisplay, 0x1f7db630 }, + // { NvAPI_DISP_DeleteCustomDisplay, 0x552e5b9b }, + // { NvAPI_DISP_SaveCustomDisplay, 0x49882876 }, + // { NvAPI_DISP_RevertCustomDisplayTrial, 0xcbbd40f0 }, + // { NvAPI_GetView, 0xd6b99d89 }, + // { NvAPI_GetViewEx, 0xdbbc0af4 }, + // { NvAPI_GetSupportedViews, 0x66fb7fc0 }, + // { NvAPI_DISP_GetDisplayIdByDisplayName, 0xae457190 }, + // { NvAPI_DISP_GetGDIPrimaryDisplayId, 0x1e9d8a31 }, + // { NvAPI_DISP_GetDisplayConfig, 0x11abccf8 }, + // { NvAPI_DISP_SetDisplayConfig, 0x5d8cf8de }, + // { NvAPI_DISP_GetEdidData, 0x436ced76 }, + // { NvAPI_DISP_GetAdaptiveSyncData, 0xb73d1ee9 }, + // { NvAPI_DISP_SetAdaptiveSyncData, 0x3eebba1d }, + // { NvAPI_DISP_GetVirtualRefreshRateData, 0x8c00429a }, + // { NvAPI_DISP_SetVirtualRefreshRateData, 0x5abbe6a3 }, + // { NvAPI_DISP_SetPreferredStereoDisplay, 0xc9d0e25f }, + // { NvAPI_DISP_GetPreferredStereoDisplay, 0x1f6b4666 }, + // { NvAPI_DISP_GetNvManagedDedicatedDisplays, 0xdbdf0cb2 }, + // { NvAPI_DISP_AcquireDedicatedDisplay, 0x47c917ba }, + // { NvAPI_DISP_ReleaseDedicatedDisplay, 0x1247825f }, + // { NvAPI_DISP_GetNvManagedDedicatedDisplayMetadata, 0xd645d80c }, + // { NvAPI_DISP_SetNvManagedDedicatedDisplayMetadata, 0x3d8b129a }, + // { NvAPI_Disp_GetDisplayIdInfo, 0xbae8aa5e }, + // { NvAPI_Disp_GetDisplayIdsFromTarget, 0xe7e5f89e }, + // { NvAPI_Disp_GetVRRInfo, 0xdf8fda57 }, + // { NvAPI_Mosaic_GetSupportedTopoInfo, 0xfdb63c81 }, + // { NvAPI_Mosaic_GetTopoGroup, 0xcb89381d }, + // { NvAPI_Mosaic_GetOverlapLimits, 0x989685f0 }, + // { NvAPI_Mosaic_SetCurrentTopo, 0x9b542831 }, + // { NvAPI_Mosaic_GetCurrentTopo, 0xec32944e }, + // { NvAPI_Mosaic_EnableCurrentTopo, 0x5f1aa66c }, + // { NvAPI_Mosaic_GetDisplayViewportsByResolution, 0xdc6dc8d3 }, + // { NvAPI_Mosaic_SetDisplayGrids, 0x4d959a89 }, + // { NvAPI_Mosaic_ValidateDisplayGrids, 0xcf43903d }, + // { NvAPI_Mosaic_EnumDisplayModes, 0x78db97d7 }, + // { NvAPI_Mosaic_EnumDisplayGrids, 0xdf2887af }, + // { NvAPI_GetSupportedMosaicTopologies, 0x410b5c25 }, + // { NvAPI_GetCurrentMosaicTopology, 0xf60852bd }, + // { NvAPI_SetCurrentMosaicTopology, 0xd54b8989 }, + // { NvAPI_EnableCurrentMosaicTopology, 0x74073cc9 }, + // { NvAPI_GSync_EnumSyncDevices, 0xd9639601 }, + // { NvAPI_GSync_QueryCapabilities, 0x44a3f1d1 }, + // { NvAPI_GSync_GetTopology, 0x4562bc38 }, + // { NvAPI_GSync_SetSyncStateSettings, 0x60acdfdd }, + // { NvAPI_GSync_GetControlParameters, 0x16de1c6a }, + // { NvAPI_GSync_SetControlParameters, 0x8bbff88b }, + // { NvAPI_GSync_AdjustSyncDelay, 0x2d11ff51 }, + // { NvAPI_GSync_GetSyncStatus, 0xf1f5b434 }, + // { NvAPI_GSync_GetStatusParameters, 0x70d404ec }, + // { NvAPI_D3D_GetCurrentSLIState, 0x4b708b54 }, + // { NvAPI_D3D9_RegisterResource, 0xa064bdfc }, + // { NvAPI_D3D9_UnregisterResource, 0xbb2b17aa }, + // { NvAPI_D3D9_AliasSurfaceAsTexture, 0xe5ceae41 }, + // { NvAPI_D3D9_StretchRectEx, 0x22de03aa }, + // { NvAPI_D3D9_ClearRT, 0x332d3942 }, + // { NvAPI_D3D_GetObjectHandleForResource, 0xfceac864 }, + // { NvAPI_D3D_SetResourceHint, 0x6c0ed98c }, + // { NvAPI_D3D_BeginResourceRendering, 0x91123d6a }, + // { NvAPI_D3D_EndResourceRendering, 0x37e7191c }, + // { NvAPI_D3D9_GetSurfaceHandle, 0x0f2dd3f2 }, + // { NvAPI_D3D9_VideoSetStereoInfo, 0xb852f4db }, + // { NvAPI_D3D10_SetDepthBoundsTest, 0x4eadf5d2 }, + // { NvAPI_D3D11_CreateDevice, 0x6a16d3a0 }, + // { NvAPI_D3D11_CreateDeviceAndSwapChain, 0xbb939ee5 }, + // { NvAPI_D3D11_SetDepthBoundsTest, 0x7aaf7a04 }, + // { NvAPI_D3D11_IsNvShaderExtnOpCodeSupported, 0x5f68da40 }, + // { NvAPI_D3D11_SetNvShaderExtnSlot, 0x8e90bb9f }, + // { NvAPI_D3D12_SetNvShaderExtnSlotSpace, 0xac2dfeb5 }, + // { NvAPI_D3D12_SetNvShaderExtnSlotSpaceLocalThread, 0x43d867c0 }, + // { NvAPI_D3D11_SetNvShaderExtnSlotLocalThread, 0x0e6482a0 }, + // { NvAPI_D3D11_BeginUAVOverlapEx, 0xba08208a }, + // { NvAPI_D3D11_BeginUAVOverlap, 0x65b93ca8 }, + // { NvAPI_D3D11_EndUAVOverlap, 0x2216a357 }, + // { NvAPI_D3D11_GetResourceHandle, 0x09d52986 }, + // { NvAPI_D3D_SetFPSIndicatorState, 0xa776e8db }, + // { NvAPI_D3D9_Present, 0x05650beb }, + // { NvAPI_D3D9_QueryFrameCount, 0x9083e53a }, + // { NvAPI_D3D9_ResetFrameCount, 0xfa6a0675 }, + // { NvAPI_D3D9_QueryMaxSwapGroup, 0x5995410d }, + // { NvAPI_D3D9_QuerySwapGroup, 0xeba4d232 }, + // { NvAPI_D3D9_JoinSwapGroup, 0x7d44bb54 }, + // { NvAPI_D3D9_BindSwapBarrier, 0x9c39c246 }, + // { NvAPI_D3D_SetVerticalSyncMode, 0x5526cfd1 }, + // { NvAPI_D3D1x_Present, 0x03b845a1 }, + // { NvAPI_D3D1x_QueryFrameCount, 0x9152e055 }, + // { NvAPI_D3D1x_ResetFrameCount, 0xfbbb031a }, + // { NvAPI_D3D1x_QueryMaxSwapGroup, 0x9bb9d68f }, + // { NvAPI_D3D1x_QuerySwapGroup, 0x407f67aa }, + // { NvAPI_D3D1x_JoinSwapGroup, 0x14610cd7 }, + // { NvAPI_D3D1x_BindSwapBarrier, 0x9de8c729 }, + // { NvAPI_D3D12_QueryPresentBarrierSupport, 0xa15faef7 }, + // { NvAPI_D3D12_CreatePresentBarrierClient, 0x4d815de9 }, + // { NvAPI_D3D12_RegisterPresentBarrierResources, 0xd53c9ef0 }, + // { NvAPI_DestroyPresentBarrierClient, 0x3c5c351b }, + // { NvAPI_JoinPresentBarrier, 0x17f6bf82 }, + // { NvAPI_LeavePresentBarrier, 0xc3ec5a7f }, + // { NvAPI_QueryPresentBarrierFrameStatistics, 0x61b844a1 }, + // { NvAPI_D3D12_CreateDDisplayPresentBarrierClient, 0xb5a21987 }, + // { NvAPI_D3D11_CreateRasterizerState, 0xdb8d28af }, + // { NvAPI_D3D_ConfigureAnsel, 0x341c6c7f }, + // { NvAPI_D3D11_CreateTiledTexture2DArray, 0x7886981a }, + // { NvAPI_D3D11_CheckFeatureSupport, 0x106a487e }, + // { NvAPI_D3D11_CreateImplicitMSAATexture2D, 0xb8f79632 }, + // { NvAPI_D3D12_CreateCommittedImplicitMSAATexture2D, 0x24c6a07b }, + // { NvAPI_D3D11_ResolveSubresourceRegion, 0xe6bfedd6 }, + // { NvAPI_D3D12_ResolveSubresourceRegion, 0xc24a15bf }, + // { NvAPI_D3D11_TiledTexture2DArrayGetDesc, 0xf1a2b9d5 }, + // { NvAPI_D3D11_UpdateTileMappings, 0x9a06ea07 }, + // { NvAPI_D3D11_CopyTileMappings, 0xc09ee6bc }, + // { NvAPI_D3D11_TiledResourceBarrier, 0xd6839099 }, + // { NvAPI_D3D11_AliasMSAATexture2DAsNonMSAA, 0xf1c54fc9 }, + // { NvAPI_D3D11_CreateGeometryShaderEx_2, 0x99ed5c1c }, + // { NvAPI_D3D11_CreateVertexShaderEx, 0x0beaa0b2 }, + // { NvAPI_D3D11_CreateHullShaderEx, 0xb53cab00 }, + // { NvAPI_D3D11_CreateDomainShaderEx, 0xa0d7180d }, + // { NvAPI_D3D11_CreatePixelShaderEx_2, 0x4162822b }, + // { NvAPI_D3D11_CreateFastGeometryShaderExplicit, 0x71ab7c9c }, + // { NvAPI_D3D11_CreateFastGeometryShader, 0x525d43be }, + // { NvAPI_D3D11_DecompressView, 0x3a94e822 }, + // { NvAPI_D3D12_CreateGraphicsPipelineState, 0x2fc28856 }, + // { NvAPI_D3D12_CreateComputePipelineState, 0x2762deac }, + // { NvAPI_D3D12_SetDepthBoundsTestValues, 0xb9333fe9 }, + // { NvAPI_D3D12_CreateReservedResource, 0x2c85f101 }, + // { NvAPI_D3D12_CreateHeap, 0x5cb397cf }, + // { NvAPI_D3D12_CreateHeap2, 0x924be9d6 }, + // { NvAPI_D3D12_QueryCpuVisibleVidmem, 0x26322bc3 }, + // { NvAPI_D3D12_ReservedResourceGetDesc, 0x9aa2aabb }, + // { NvAPI_D3D12_UpdateTileMappings, 0xc6017a7d }, + // { NvAPI_D3D12_CopyTileMappings, 0x47f78194 }, + // { NvAPI_D3D12_ResourceAliasingBarrier, 0xb942bab7 }, + // { NvAPI_D3D12_CaptureUAVInfo, 0x6e5ea9db }, + // { NvAPI_D3D11_GetResourceGPUVirtualAddressEx, 0xaf6d14da }, + // { NvAPI_D3D11_EnumerateMetaCommands, 0xc7453ba8 }, + // { NvAPI_D3D11_CreateMetaCommand, 0xf505fba0 }, + // { NvAPI_D3D11_InitializeMetaCommand, 0xaec629e9 }, + // { NvAPI_D3D11_ExecuteMetaCommand, 0x82236c47 }, + // { NvAPI_D3D12_EnumerateMetaCommands, 0xcd9141d8 }, + // { NvAPI_D3D12_CreateMetaCommand, 0xeb29634b }, + // { NvAPI_D3D12_InitializeMetaCommand, 0xa4125399 }, + // { NvAPI_D3D12_ExecuteMetaCommand, 0xde24fc3d }, + // { NvAPI_D3D12_CreateCommittedResource, 0x027e98ae }, + // { NvAPI_D3D12_GetCopyableFootprints, 0xf6305eb5 }, + // { NvAPI_D3D12_CopyTextureRegion, 0x82b91b25 }, + // { NvAPI_D3D12_IsNvShaderExtnOpCodeSupported, 0x3dfacec8 }, + // { NvAPI_D3D12_GetOptimalThreadCountForMesh, 0xb43995cb }, + // { NvAPI_D3D_IsGSyncCapable, 0x9c1eed78 }, + // { NvAPI_D3D_IsGSyncActive, 0xe942b0ff }, + // { NvAPI_D3D12_SetFlipConfig, 0xf3148c42 }, + // { NvAPI_D3D1x_DisableShaderDiskCache, 0xd0cbca7d }, + // { NvAPI_D3D11_MultiGPU_GetCaps, 0xd2d25687 }, + // { NvAPI_D3D11_MultiGPU_Init, 0x017be49e }, + // { NvAPI_D3D11_CreateMultiGPUDevice, 0xbdb20007 }, + // { NvAPI_D3D_QuerySinglePassStereoSupport, 0x6f5f0a6d }, + // { NvAPI_D3D_SetSinglePassStereoMode, 0xa39e6e6e }, + // { NvAPI_D3D12_QuerySinglePassStereoSupport, 0x3b03791b }, + // { NvAPI_D3D12_SetSinglePassStereoMode, 0x83556d87 }, + // { NvAPI_D3D_QueryMultiViewSupport, 0xb6e0a41c }, + // { NvAPI_D3D_SetMultiViewMode, 0x8285c8da }, + // { NvAPI_D3D_QueryModifiedWSupport, 0xcbf9f4f5 }, + // { NvAPI_D3D_SetModifiedWMode, 0x06ea4bf4 }, + // { NvAPI_D3D12_QueryModifiedWSupport, 0x51235248 }, + // { NvAPI_D3D12_SetModifiedWMode, 0xe1fdaba7 }, + // { NvAPI_D3D_CreateLateLatchObject, 0x2db27d09 }, + // { NvAPI_D3D_QueryLateLatchSupport, 0x8ceca0ec }, + // { NvAPI_D3D_RegisterDevice, 0x8c02c4d0 }, + // { NvAPI_D3D11_MultiDrawInstancedIndirect, 0xd4e26bbf }, + // { NvAPI_D3D11_MultiDrawIndexedInstancedIndirect, 0x59e890f9 }, + // { NvAPI_D3D_ImplicitSLIControl, 0x2aede111 }, + // { NvAPI_D3D12_GetNeedsAppFPBlendClamping, 0x6ef4d2d1 }, + // { NvAPI_D3D12_UseDriverHeapPriorities, 0xf0d978a8 }, + // { NvAPI_D3D12_Mosaic_GetCompanionAllocations, 0xa46022c7 }, + // { NvAPI_D3D12_Mosaic_GetViewportAndGpuPartitions, 0xb092b818 }, + // { NvAPI_D3D1x_GetGraphicsCapabilities, 0x52b1499a }, + // { NvAPI_D3D12_GetGraphicsCapabilities, 0x01e87354 }, + // { NvAPI_D3D11_RSSetExclusiveScissorRects, 0xae4d73ef }, + // { NvAPI_D3D11_RSSetViewportsPixelShadingRates, 0x34f7938f }, + // { NvAPI_D3D11_CreateShadingRateResourceView, 0x99ca2dff }, + // { NvAPI_D3D11_RSSetShadingRateResourceView, 0x1b0c2f83 }, + // { NvAPI_D3D11_RSGetPixelShadingRateSampleOrder, 0x092442a1 }, + // { NvAPI_D3D11_RSSetPixelShadingRateSampleOrder, 0xa942373a }, + // { NvAPI_D3D_InitializeVRSHelper, 0x4780d70b }, + // { NvAPI_D3D_InitializeNvGazeHandler, 0x5b3b7479 }, + // { NvAPI_D3D_InitializeSMPAssist, 0x42763d0c }, + // { NvAPI_D3D_QuerySMPAssistSupport, 0xc57921de }, + // { NvAPI_D3D_GetSleepStatus, 0xaef96ca1 }, + // { NvAPI_D3D_SetSleepMode, 0xac1ca9e0 }, + // { NvAPI_D3D_Sleep, 0x852cd1d2 }, + // { NvAPI_D3D_SetReflexSync, 0xb9f6faff }, + // { NvAPI_D3D_GetLatency, 0x1a587f9c }, + // { NvAPI_D3D_SetLatencyMarker, 0xd9984c05 }, + // { NvAPI_D3D12_SetAsyncFrameMarker, 0x13c98f73 }, + // { NvAPI_D3D11_SetAsyncFrameMarker, 0x59c2c510 }, + // { NvAPI_D3D12_NotifyOutOfBandCommandQueue, 0x03d6e8cb }, + // { NvAPI_D3D12_SetCreateCommandQueueLowLatencyHint, 0x548c224f }, + // { NvAPI_D3D12_CreateCubinComputeShaderExV2, 0x299f5fdc }, + // { NvAPI_D3D12_CreateCubinComputeShader, 0x2a2c79e8 }, + // { NvAPI_D3D12_CreateCubinComputeShaderEx, 0x3151211b }, + // { NvAPI_D3D12_CreateCubinComputeShaderWithName, 0x1dc7261f }, + // { NvAPI_D3D12_LaunchCubinShader, 0x5c52bb86 }, + // { NvAPI_D3D12_DestroyCubinComputeShader, 0x7fb785ba }, + // { NvAPI_D3D12_GetCudaMergedTextureSamplerObject, 0x329fe6e0 }, + // { NvAPI_D3D12_GetCudaIndependentDescriptorObject, 0x0ddac234 }, + // { NvAPI_D3D12_GetCudaTextureObject, 0x80403fc9 }, + // { NvAPI_D3D12_GetCudaSurfaceObject, 0x48f5b2ee }, + // { NvAPI_D3D12_IsFatbinPTXSupported, 0x70c07832 }, + // { NvAPI_D3D12_CreateCuModule, 0xad1a677d }, + // { NvAPI_D3D12_EnumFunctionsInModule, 0x7ab88d88 }, + // { NvAPI_D3D12_CreateCuFunction, 0xe2436e22 }, + // { NvAPI_D3D12_LaunchCuKernelChain, 0x24973538 }, + // { NvAPI_D3D12_LaunchCuKernelChainEx, 0x846a9bf0 }, + // { NvAPI_D3D12_DestroyCuModule, 0x41c65285 }, + // { NvAPI_D3D12_DestroyCuFunction, 0xdf295ea6 }, + // { NvAPI_D3D11_CreateCubinComputeShaderExV2, 0xf2c71d48 }, + // { NvAPI_D3D11_CreateCubinComputeShader, 0x0ed98181 }, + // { NvAPI_D3D11_CreateCubinComputeShaderEx, 0x32c2a0f6 }, + // { NvAPI_D3D11_CreateCubinComputeShaderWithName, 0xb672be19 }, + // { NvAPI_D3D11_LaunchCubinShader, 0x427e236d }, + // { NvAPI_D3D11_DestroyCubinComputeShader, 0x01682c86 }, + // { NvAPI_D3D11_IsFatbinPTXSupported, 0x6086bd93 }, + // { NvAPI_D3D11_GetCudaIndependentViewObject, 0x34d2afa8 }, + // { NvAPI_D3D11_GetCudaMergedTextureSamplerObject, 0x5d637d8f }, + // { NvAPI_D3D11_CreateUnorderedAccessView, 0x74a497a1 }, + // { NvAPI_D3D11_CreateShaderResourceView, 0x65cb431e }, + // { NvAPI_D3D11_CreateSamplerState, 0x89eca416 }, + // { NvAPI_D3D11_GetCudaTextureObject, 0x9006fa68 }, + // { NvAPI_D3D11_GetResourceGPUVirtualAddress, 0x1819b423 }, + // { NvAPI_D3D12_GetRaytracingCaps, 0x85a6c2a0 }, + // { NvAPI_D3D12_EnableRaytracingValidation, 0x1de5991b }, + // { NvAPI_D3D12_RegisterRaytracingValidationMessageCallback, 0x8554eb38 }, + // { NvAPI_D3D12_UnregisterRaytracingValidationMessageCallback, 0x26975da6 }, + // { NvAPI_D3D12_FlushRaytracingValidationMessages, 0xb8fb1fcb }, + // { NvAPI_D3D12_GetRaytracingDisplacementMicromapArrayPrebuildInfo, 0xfa99b6de }, + // { NvAPI_D3D12_GetRaytracingOpacityMicromapArrayPrebuildInfo, 0x4726d180 }, + // { NvAPI_D3D12_SetCreatePipelineStateOptions, 0x5c607a27 }, + // { NvAPI_D3D12_CheckDriverMatchingIdentifierEx, 0xafb237d4 }, + // { NvAPI_D3D12_GetRaytracingAccelerationStructurePrebuildInfoEx, 0x8d025b77 }, + // { NvAPI_D3D12_BuildRaytracingOpacityMicromapArray, 0x814f8d11 }, + // { NvAPI_D3D12_RelocateRaytracingOpacityMicromapArray, 0x0425c538 }, + // { NvAPI_D3D12_BuildRaytracingDisplacementMicromapArray, 0x066f569d }, + // { NvAPI_D3D12_RelocateRaytracingDisplacementMicromapArray, 0x1c142308 }, + // { NvAPI_D3D12_EmitRaytracingDisplacementMicromapArrayPostbuildInfo, 0x68b9a790 }, + // { NvAPI_D3D12_EmitRaytracingOpacityMicromapArrayPostbuildInfo, 0x1d9a39b6 }, + // { NvAPI_D3D12_BuildRaytracingAccelerationStructureEx, 0xe24ead45 }, + // { NvAPI_D3D12_QueryWorkstationFeatureProperties, 0xa92ea23a }, + // { NvAPI_D3D12_CreateCommittedRDMABuffer, 0xe78dcb44 }, + // { NvAPI_D3D12_ConvertCooperativeVectorMatrix, 0x0f252cb3 }, + // { NvAPI_D3D12_ConvertCooperativeVectorMatrixMultiple, 0x96ba5235 }, + // { NvAPI_D3D12_GetPhysicalDeviceCooperativeVectorProperties, 0x8f182aec }, + // { NvAPI_D3D12_GetRaytracingMultiIndirectClusterOperationRequirementsInfo, 0x5c9163f4 }, + // { NvAPI_D3D12_RaytracingExecuteMultiIndirectClusterOperation, 0x67c798af }, + // { NvAPI_D3D12_GetRaytracingPartitionedTlasIndirectPrebuildInfo, 0xcdfdc5f2 }, + // { NvAPI_D3D12_BuildRaytracingPartitionedTlasIndirect, 0x7cfc6fc3 }, + // { NvAPI_NGX_GetNGXOverrideState, 0x3fd96fba }, + // { NvAPI_NGX_SetNGXOverrideState, 0xb60fcb4e }, + // { NvAPI_DirectD3D12GraphicsCommandList_Create, 0x74a4e712 }, + // { NvAPI_DirectD3D12GraphicsCommandList_Release, 0x99da3dde }, + // { NvAPI_DirectD3D12GraphicsCommandList_Reset, 0x999c26d8 }, + // { NvAPI_VIO_GetCapabilities, 0x1dc91303 }, + // { NvAPI_VIO_Open, 0x44ee4841 }, + // { NvAPI_VIO_Close, 0xd01bd237 }, + // { NvAPI_VIO_Status, 0x0e6ce4f1 }, + // { NvAPI_VIO_SyncFormatDetect, 0x118d48a3 }, + // { NvAPI_VIO_GetConfig, 0xd34a789b }, + // { NvAPI_VIO_SetConfig, 0x0e4eec07 }, + // { NvAPI_VIO_SetCSC, 0xa1ec8d74 }, + // { NvAPI_VIO_GetCSC, 0x7b0d72a3 }, + // { NvAPI_VIO_SetGamma, 0x964bf452 }, + // { NvAPI_VIO_GetGamma, 0x51d53d06 }, + // { NvAPI_VIO_SetSyncDelay, 0x2697a8d1 }, + // { NvAPI_VIO_GetSyncDelay, 0x462214a9 }, + // { NvAPI_VIO_GetPCIInfo, 0xb981d935 }, + // { NvAPI_VIO_IsRunning, 0x96bd040e }, + // { NvAPI_VIO_Start, 0xcde8e1a3 }, + // { NvAPI_VIO_Stop, 0x6ba2a5d6 }, + // { NvAPI_VIO_IsFrameLockModeCompatible, 0x7bf0a94d }, + // { NvAPI_VIO_EnumDevices, 0xfd7c5557 }, + // { NvAPI_VIO_QueryTopology, 0x869534e2 }, + // { NvAPI_VIO_EnumSignalFormats, 0xead72fe4 }, + // { NvAPI_VIO_EnumDataFormats, 0x221fa8e8 }, + // { NvAPI_Stereo_CreateConfigurationProfileRegistryKey, 0xbe7692ec }, + // { NvAPI_Stereo_DeleteConfigurationProfileRegistryKey, 0xf117b834 }, + // { NvAPI_Stereo_SetConfigurationProfileValue, 0x24409f48 }, + // { NvAPI_Stereo_DeleteConfigurationProfileValue, 0x49bceecf }, + // { NvAPI_Stereo_Enable, 0x239c4545 }, + // { NvAPI_Stereo_Disable, 0x2ec50c2b }, + // { NvAPI_Stereo_IsEnabled, 0x348ff8e1 }, + // { NvAPI_Stereo_GetStereoSupport, 0x296c434d }, + // { NvAPI_Stereo_CreateHandleFromIUnknown, 0xac7e37f4 }, + // { NvAPI_Stereo_DestroyHandle, 0x3a153134 }, + // { NvAPI_Stereo_Activate, 0xf6a1ad68 }, + // { NvAPI_Stereo_Deactivate, 0x2d68de96 }, + // { NvAPI_Stereo_IsActivated, 0x1fb0bc30 }, + // { NvAPI_Stereo_GetSeparation, 0x451f2134 }, + // { NvAPI_Stereo_SetSeparation, 0x5c069fa3 }, + // { NvAPI_Stereo_DecreaseSeparation, 0xda044458 }, + // { NvAPI_Stereo_IncreaseSeparation, 0xc9a8ecec }, + // { NvAPI_Stereo_GetConvergence, 0x4ab00934 }, + // { NvAPI_Stereo_SetConvergence, 0x3dd6b54b }, + // { NvAPI_Stereo_DecreaseConvergence, 0x4c87e317 }, + // { NvAPI_Stereo_IncreaseConvergence, 0xa17daabe }, + // { NvAPI_Stereo_GetFrustumAdjustMode, 0xe6839b43 }, + // { NvAPI_Stereo_SetFrustumAdjustMode, 0x7be27fa2 }, + // { NvAPI_Stereo_CaptureJpegImage, 0x932cb140 }, + // { NvAPI_Stereo_InitActivation, 0xc7177702 }, + // { NvAPI_Stereo_Trigger_Activation, 0x0d6c6cd2 }, + // { NvAPI_Stereo_CapturePngImage, 0x8b7e99b5 }, + // { NvAPI_Stereo_ReverseStereoBlitControl, 0x3cd58f89 }, + // { NvAPI_Stereo_SetNotificationMessage, 0x6b9b409e }, + // { NvAPI_Stereo_SetActiveEye, 0x96eea9f8 }, + // { NvAPI_Stereo_SetDriverMode, 0x5e8f0bec }, + // { NvAPI_Stereo_GetEyeSeparation, 0xce653127 }, + // { NvAPI_Stereo_IsWindowedModeSupported, 0x40c8ed5e }, + // { NvAPI_Stereo_SetSurfaceCreationMode, 0xf5dcfcba }, + // { NvAPI_Stereo_GetSurfaceCreationMode, 0x36f1c736 }, + // { NvAPI_Stereo_Debug_WasLastDrawStereoized, 0xed4416c5 }, + // { NvAPI_Stereo_SetDefaultProfile, 0x44f0ecd1 }, + // { NvAPI_Stereo_GetDefaultProfile, 0x624e21c2 }, + // { NvAPI_D3D1x_CreateSwapChain, 0x1bc21b66 }, + // { NvAPI_D3D9_CreateSwapChain, 0x1a131e09 }, + // { NvAPI_Vulkan_InitLowLatencyDevice, 0x5c1696b6 }, + // { NvAPI_Vulkan_DestroyLowLatencyDevice, 0x11a5932b }, + // { NvAPI_Vulkan_GetSleepStatus, 0xadf966af }, + // { NvAPI_Vulkan_SetSleepMode, 0x2acfd162 }, + // { NvAPI_Vulkan_Sleep, 0x36732b1e }, + // { NvAPI_Vulkan_GetLatency, 0x3233d44a }, + // { NvAPI_Vulkan_SetLatencyMarker, 0xa17d13d6 }, + // { NvAPI_Vulkan_NotifyOutOfBandVkQueue, 0x5d6d3840 }, + // { NvAPI_DRS_CreateSession, 0x0694d52e }, + // { NvAPI_DRS_DestroySession, 0xdad9cff8 }, + // { NvAPI_DRS_LoadSettings, 0x375dbd6b }, + // { NvAPI_DRS_SaveSettings, 0xfcbc7e14 }, + // { NvAPI_DRS_LoadSettingsFromFile, 0xd3ede889 }, + // { NvAPI_DRS_SaveSettingsToFile, 0x2be25df8 }, + // { NvAPI_DRS_CreateProfile, 0xcc176068 }, + // { NvAPI_DRS_DeleteProfile, 0x17093206 }, + // { NvAPI_DRS_SetCurrentGlobalProfile, 0x1c89c5df }, + // { NvAPI_DRS_GetCurrentGlobalProfile, 0x617bff9f }, + // { NvAPI_DRS_GetProfileInfo, 0x61cd6fd6 }, + // { NvAPI_DRS_SetProfileInfo, 0x16abd3a9 }, + // { NvAPI_DRS_FindProfileByName, 0x7e4a9a0b }, + // { NvAPI_DRS_EnumProfiles, 0xbc371ee0 }, + // { NvAPI_DRS_GetNumProfiles, 0x1dae4fbc }, + // { NvAPI_DRS_CreateApplication, 0x4347a9de }, + // { NvAPI_DRS_DeleteApplicationEx, 0xc5ea85a1 }, + // { NvAPI_DRS_DeleteApplication, 0x2c694bc6 }, + // { NvAPI_DRS_GetApplicationInfo, 0xed1f8c69 }, + // { NvAPI_DRS_EnumApplications, 0x7fa2173a }, + // { NvAPI_DRS_FindApplicationByName, 0xeee566b2 }, + // { NvAPI_DRS_SetSetting, 0x577dd202 }, + // { NvAPI_DRS_GetSetting, 0x73bf8338 }, + // { NvAPI_DRS_EnumSettings, 0xae3039da }, + // { NvAPI_DRS_EnumAvailableSettingIds, 0xf020614a }, + // { NvAPI_DRS_EnumAvailableSettingValues, 0x2ec39f90 }, + // { NvAPI_DRS_GetSettingIdFromName, 0xcb7309cd }, + // { NvAPI_DRS_GetSettingNameFromId, 0xd61cbe6e }, + // { NvAPI_DRS_DeleteProfileSetting, 0xe4a26362 }, + // { NvAPI_DRS_RestoreAllDefaults, 0x5927b094 }, + // { NvAPI_DRS_RestoreProfileDefault, 0xfa5f6134 }, + // { NvAPI_DRS_RestoreProfileDefaultSetting, 0x53f0381e }, + // { NvAPI_DRS_GetBaseProfile, 0xda8466a0 }, + // { NvAPI_SYS_GetChipSetInfo, 0x53dabbca }, + // { NvAPI_SYS_GetLidAndDockInfo, 0xcda14d8a }, + // { NvAPI_SYS_GetDisplayIdFromGpuAndOutputId, 0x08f2bab4 }, + // { NvAPI_SYS_GetGpuAndOutputIdFromDisplayId, 0x112ba1a5 }, + // { NvAPI_SYS_GetPhysicalGpuFromDisplayId, 0x9ea74659 }, + // { NvAPI_SYS_GetDisplayDriverInfo, 0x721faceb }, + // { NvAPI_SYS_GetPhysicalGPUs, 0xd3b24d2d }, + // { NvAPI_SYS_GetLogicalGPUs, 0xccfffc10 }, + // { NvAPI_NGX_GetDriverFeatureSupport, 0x6194b19d }, + // { NvAPI_GPU_ClientRegisterForUtilizationSampleUpdates, 0xadeeaf67 }, + // { NvAPI_RegisterRiseCallback, 0x9cfe8f94 }, + // { NvAPI_RequestRise, 0x5047de98 }, + // { NvAPI_UninstallRise, 0xab8d09f6 }, + // Undocumented: + // Not sure what is the deal with this function, but looking at the + // implementation of NvAPI_GPU_CudaEnumComputeCapableGpus it seems to just + // call it with the same argument? + { NvAPI_Unknown_36e39e6b, 0x36e39e6b } + +); + +const NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_CAPABLE: u32 = 1 << 0; +const NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_ENABLE: u32 = 1 << 1; +// const NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_DEDICATED: u32 = 1 << 2; +const NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_RECOMMENDED: u32 = 1 << 3; +const NV_COMPUTE_GPU_TOPOLOGY_CUDA_AVAILABLE: u32 = 1 << 4; +const NV_COMPUTE_GPU_TOPOLOGY_CUDA_CAPABLE: u32 = 1 << 16; +// const NV_COMPUTE_GPU_TOPOLOGY_CUDA_DISABLED: u32 = 1 << 17; +const NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_AVAILABLE: u32 = 1 << 21; + +fn make_nvapi_version(ver: u32) -> u32 { + let size = std::mem::size_of::() as u32; + size | (ver << 16) +} + +#[no_mangle] +pub unsafe extern "C" fn nvapi_QueryInterface(interface: u32) -> *mut c_void { + interface_to_fn(interface).unwrap_or(std::ptr::null_mut()) +} + +#[allow(non_snake_case)] +unsafe extern "C" fn NvAPI_Initialize() -> i32 { + 0 +} + +#[allow(non_snake_case)] +unsafe extern "C" fn NvAPI_Unload() -> i32 { + 0 +} + +#[allow(non_snake_case)] +unsafe extern "C" fn NvAPI_GetDisplayDriverVersion( + _display: NvDisplayHandle, + version: *mut NV_DISPLAY_DRIVER_VERSION, +) -> i32 { + // return 0; + let version = version.as_mut(); + let version = unwrap_or::unwrap_some_or!(version, return _NvAPI_Status_NVAPI_INVALID_ARGUMENT); + if version.version != make_nvapi_version::(1) { + return _NvAPI_Status_NVAPI_INCOMPATIBLE_STRUCT_VERSION; + } + version.drvVersion = 99999; + version.bldChangeListNum = 0; + version.szBuildBranchString.fill(0); + version.szAdapterString.fill(0); + let device_name = b"ZLUDA Graphics Device"; + std::ptr::copy_nonoverlapping( + device_name.as_ptr() as _, + version.szAdapterString.as_mut_ptr() as _, + device_name.len(), + ); + 0 +} + +#[allow(non_snake_case)] +unsafe extern "C" fn NvAPI_GPU_CudaEnumComputeCapableGpus(version_ptr: *mut NvU32) -> i32 { + let version = version_ptr.as_mut(); + let version = unwrap_or::unwrap_some_or!(version, return _NvAPI_Status_NVAPI_INVALID_ARGUMENT); + if *version == make_nvapi_version::(1) { + NvAPI_GPU_CudaEnumComputeCapableGpus_v1( + version_ptr + .cast::() + .as_mut() + .unwrap(), + ) + } else if *version == make_nvapi_version::(2) { + NvAPI_GPU_CudaEnumComputeCapableGpus_v2( + version_ptr + .cast::() + .as_mut() + .unwrap(), + ) + } else { + _NvAPI_Status_NVAPI_INCOMPATIBLE_STRUCT_VERSION + } +} + +#[allow(non_snake_case)] +unsafe fn NvAPI_GPU_CudaEnumComputeCapableGpus_v1( + compute_topo: &mut NV_COMPUTE_GPU_TOPOLOGY_V1, +) -> i32 { + compute_topo.gpuCount = 1; + compute_topo.computeGpus[0] = NV_COMPUTE_GPU_TOPOLOGY_V1__bindgen_ty_1 { + hPhysicalGpu: 1 as _, + flags: NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_CAPABLE + | NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_ENABLE + | NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_RECOMMENDED + | NV_COMPUTE_GPU_TOPOLOGY_CUDA_AVAILABLE + | NV_COMPUTE_GPU_TOPOLOGY_CUDA_CAPABLE + | NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_AVAILABLE, + }; + 0 +} + +#[repr(transparent)] +struct NvComputeGpuSync(NV_COMPUTE_GPU); + +unsafe impl Sync for NvComputeGpuSync {} + +#[allow(non_snake_case)] +unsafe fn NvAPI_GPU_CudaEnumComputeCapableGpus_v2( + compute_topo: &mut NV_COMPUTE_GPU_TOPOLOGY_V2, +) -> i32 { + static mut FAKE_GPU: NvComputeGpuSync = NvComputeGpuSync(NV_COMPUTE_GPU { + hPhysicalGpu: 1 as _, + flags: NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_CAPABLE + | NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_ENABLE + | NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_RECOMMENDED + | NV_COMPUTE_GPU_TOPOLOGY_CUDA_AVAILABLE + | NV_COMPUTE_GPU_TOPOLOGY_CUDA_CAPABLE + | NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_AVAILABLE, + }); + compute_topo.gpuCount = 1; + compute_topo.computeGpus = (&raw mut FAKE_GPU).cast(); + 0 +} + +#[allow(non_snake_case)] +unsafe extern "C" fn NvAPI_GetGPUIDfromPhysicalGPU( + physical_gpu: NvPhysicalGpuHandle, + gpu_id: *mut NvU32, +) -> i32 { + if physical_gpu != 1 as _ { + return _NvAPI_Status_NVAPI_INVALID_ARGUMENT; + } + let gpu_id = gpu_id.as_mut(); + let gpu_id = unwrap_or::unwrap_some_or!(gpu_id, return _NvAPI_Status_NVAPI_INVALID_ARGUMENT); + *gpu_id = 1; + 0 +} + +#[allow(non_snake_case)] +unsafe extern "C" fn NvAPI_GetPhysicalGPUFromGPUID( + gpu_id: NvU32, + physical_gpu: *mut NvPhysicalGpuHandle, +) -> i32 { + if gpu_id != 1 { + return _NvAPI_Status_NVAPI_INVALID_ARGUMENT; + } + let physical_gpu = physical_gpu.as_mut(); + let physical_gpu = + unwrap_or::unwrap_some_or!(physical_gpu, return _NvAPI_Status_NVAPI_INVALID_ARGUMENT); + *physical_gpu = 1 as _; + 0 +} + +#[allow(non_snake_case)] +unsafe extern "C" fn NvAPI_SYS_GetDriverAndBranchVersion( + driver_version: *mut NvU32, + build_branch_string: *mut NvAPI_ShortString, +) -> i32 { + let driver_version = driver_version.as_mut(); + let driver_version = + unwrap_or::unwrap_some_or!(driver_version, return _NvAPI_Status_NVAPI_INVALID_ARGUMENT); + let build_branch_string = build_branch_string.as_mut(); + let build_branch_string = unwrap_or::unwrap_some_or!( + build_branch_string, + return _NvAPI_Status_NVAPI_INVALID_ARGUMENT + ); + *driver_version = 99999; + build_branch_string.fill(0); + let version_string = b"r999_99"; + std::ptr::copy_nonoverlapping( + version_string.as_ptr().cast(), + build_branch_string.as_mut_ptr(), + version_string.len(), + ); + 0 +} + +#[allow(non_snake_case)] +unsafe extern "C" fn NvAPI_Unknown_36e39e6b(compute_topo: *mut NV_COMPUTE_GPU_TOPOLOGY_V2) -> i32 { + let compute_topo = compute_topo.as_mut(); + let compute_topo = + unwrap_or::unwrap_some_or!(compute_topo, return _NvAPI_Status_NVAPI_INVALID_ARGUMENT); + NvAPI_GPU_CudaEnumComputeCapableGpus_v2(compute_topo) +} diff --git a/nvapi/src/nvapi.rs b/nvapi/src/nvapi.rs new file mode 100644 index 000000000..718bd0a38 --- /dev/null +++ b/nvapi/src/nvapi.rs @@ -0,0 +1,19879 @@ +// bindgen nvapi.h -o nvapi.rs --no-layout-tests --allowlist-type "Nv.*" --allowlist-type "NV_.*" +/* automatically generated by rust-bindgen 0.72.1 */ + +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8).offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { + byte | mask + } else { + byte & !mask + } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8).offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::()); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::()); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +pub type DWORD = ::std::os::raw::c_ulong; +pub type ULONG_PTR = ::std::os::raw::c_ulonglong; +pub type SIZE_T = ULONG_PTR; +pub type LONG = ::std::os::raw::c_long; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _LUID { + pub LowPart: DWORD, + pub HighPart: LONG, +} +pub type LUID = _LUID; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MEMORY_RANGE { + pub BaseAddress: *mut ::std::os::raw::c_void, + pub Length: SIZE_T, +} +pub type NV_MEMORY_RANGE = _NV_MEMORY_RANGE; +pub type NvU64 = ::std::os::raw::c_ulonglong; +pub type NvS64 = ::std::os::raw::c_longlong; +pub type NvS32 = ::std::os::raw::c_int; +pub type NvU32 = ::std::os::raw::c_uint; +pub type NvS16 = ::std::os::raw::c_short; +pub type NvU16 = ::std::os::raw::c_ushort; +pub type NvU8 = ::std::os::raw::c_uchar; +pub type NvS8 = ::std::os::raw::c_schar; +pub type NvF32 = f32; +pub type NvF64 = f64; +pub type NvBool = NvU8; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_RECT { + pub left: NvU32, + pub top: NvU32, + pub right: NvU32, + pub bottom: NvU32, +} +pub type NV_RECT = _NV_RECT; +#[doc = "! \\addtogroup nvapihandles\n! NVAPI Handles - These handles are retrieved from various calls and passed in to others in NvAPI\n! These are meant to be opaque types. Do not assume they correspond to indices, HDCs,\n! display indexes or anything else.\n!\n! Most handles remain valid until a display re-configuration (display mode set) or GPU\n! reconfiguration (going into or out of SLI modes) occurs. If NVAPI_HANDLE_INVALIDATED\n! is received by an app, it should discard all handles, and re-enumerate them.\n! @{"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvLogicalGpuHandle__ { + pub unused: ::std::os::raw::c_int, +} +#[doc = "! \\addtogroup nvapihandles\n! NVAPI Handles - These handles are retrieved from various calls and passed in to others in NvAPI\n! These are meant to be opaque types. Do not assume they correspond to indices, HDCs,\n! display indexes or anything else.\n!\n! Most handles remain valid until a display re-configuration (display mode set) or GPU\n! reconfiguration (going into or out of SLI modes) occurs. If NVAPI_HANDLE_INVALIDATED\n! is received by an app, it should discard all handles, and re-enumerate them.\n! @{"] +pub type NvLogicalGpuHandle = *mut NvLogicalGpuHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvPhysicalGpuHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvPhysicalGpuHandle = *mut NvPhysicalGpuHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvDisplayHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvDisplayHandle = *mut NvDisplayHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvMonitorHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvMonitorHandle = *mut NvMonitorHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvUnAttachedDisplayHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvUnAttachedDisplayHandle = *mut NvUnAttachedDisplayHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvVisualComputingDeviceHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvVisualComputingDeviceHandle = *mut NvVisualComputingDeviceHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvEventHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvEventHandle = *mut NvEventHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvHICHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvHICHandle = *mut NvHICHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvGSyncDeviceHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvGSyncDeviceHandle = *mut NvGSyncDeviceHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvVioHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvVioHandle = *mut NvVioHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvTransitionHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvTransitionHandle = *mut NvTransitionHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvAudioHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvAudioHandle = *mut NvAudioHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Nv3DVPContextHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type Nv3DVPContextHandle = *mut Nv3DVPContextHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Nv3DVPTransceiverHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type Nv3DVPTransceiverHandle = *mut Nv3DVPTransceiverHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Nv3DVPGlassesHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type Nv3DVPGlassesHandle = *mut Nv3DVPGlassesHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvPcfClientHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvPcfClientHandle = *mut NvPcfClientHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvSourceHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvSourceHandle = *mut NvSourceHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvTargetHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvTargetHandle = *mut NvTargetHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvPresentBarrierClientHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvPresentBarrierClientHandle = *mut NvPresentBarrierClientHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvSBox { + pub sX: NvS32, + pub sY: NvS32, + pub sWidth: NvS32, + pub sHeight: NvS32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvGUID { + pub data1: NvU32, + pub data2: NvU16, + pub data3: NvU16, + pub data4: [NvU8; 8usize], +} +pub type NvLUID = NvGUID; +pub type NvAPI_String = [::std::os::raw::c_char; 4096usize]; +pub type NvAPI_LongString = [::std::os::raw::c_char; 256usize]; +pub type NvAPI_ShortString = [::std::os::raw::c_char; 64usize]; +pub type NvAPI_UnicodeShortString = [NvU16; 64usize]; +#[doc = "!< Success. Request is completed."] +pub const _NvAPI_Status_NVAPI_OK: _NvAPI_Status = 0; +#[doc = "!< Generic error"] +pub const _NvAPI_Status_NVAPI_ERROR: _NvAPI_Status = -1; +#[doc = "!< NVAPI support library cannot be loaded."] +pub const _NvAPI_Status_NVAPI_LIBRARY_NOT_FOUND: _NvAPI_Status = -2; +#[doc = "!< not implemented in current driver installation"] +pub const _NvAPI_Status_NVAPI_NO_IMPLEMENTATION: _NvAPI_Status = -3; +#[doc = "!< NvAPI_Initialize has not been called (successfully)"] +pub const _NvAPI_Status_NVAPI_API_NOT_INITIALIZED: _NvAPI_Status = -4; +#[doc = "!< The argument/parameter value is not valid or NULL."] +pub const _NvAPI_Status_NVAPI_INVALID_ARGUMENT: _NvAPI_Status = -5; +#[doc = "!< No NVIDIA display driver, or NVIDIA GPU driving a display, was found."] +pub const _NvAPI_Status_NVAPI_NVIDIA_DEVICE_NOT_FOUND: _NvAPI_Status = -6; +#[doc = "!< No more items to enumerate"] +pub const _NvAPI_Status_NVAPI_END_ENUMERATION: _NvAPI_Status = -7; +#[doc = "!< Invalid handle"] +pub const _NvAPI_Status_NVAPI_INVALID_HANDLE: _NvAPI_Status = -8; +#[doc = "!< An argument's structure version is not supported"] +pub const _NvAPI_Status_NVAPI_INCOMPATIBLE_STRUCT_VERSION: _NvAPI_Status = -9; +#[doc = "!< The handle is no longer valid (likely due to GPU or display re-configuration)"] +pub const _NvAPI_Status_NVAPI_HANDLE_INVALIDATED: _NvAPI_Status = -10; +#[doc = "!< No NVIDIA OpenGL context is current (but needs to be)"] +pub const _NvAPI_Status_NVAPI_OPENGL_CONTEXT_NOT_CURRENT: _NvAPI_Status = -11; +#[doc = "!< An invalid pointer, usually NULL, was passed as a parameter"] +pub const _NvAPI_Status_NVAPI_INVALID_POINTER: _NvAPI_Status = -14; +#[doc = "!< OpenGL Expert is not supported by the current drivers"] +pub const _NvAPI_Status_NVAPI_NO_GL_EXPERT: _NvAPI_Status = -12; +#[doc = "!< OpenGL Expert is supported, but driver instrumentation is currently disabled"] +pub const _NvAPI_Status_NVAPI_INSTRUMENTATION_DISABLED: _NvAPI_Status = -13; +#[doc = "!< OpenGL does not support Nsight"] +pub const _NvAPI_Status_NVAPI_NO_GL_NSIGHT: _NvAPI_Status = -15; +#[doc = "!< Expected a logical GPU handle for one or more parameters"] +pub const _NvAPI_Status_NVAPI_EXPECTED_LOGICAL_GPU_HANDLE: _NvAPI_Status = -100; +#[doc = "!< Expected a physical GPU handle for one or more parameters"] +pub const _NvAPI_Status_NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE: _NvAPI_Status = -101; +#[doc = "!< Expected an NV display handle for one or more parameters"] +pub const _NvAPI_Status_NVAPI_EXPECTED_DISPLAY_HANDLE: _NvAPI_Status = -102; +#[doc = "!< The combination of parameters is not valid."] +pub const _NvAPI_Status_NVAPI_INVALID_COMBINATION: _NvAPI_Status = -103; +#[doc = "!< Requested feature is not supported in the selected GPU"] +pub const _NvAPI_Status_NVAPI_NOT_SUPPORTED: _NvAPI_Status = -104; +#[doc = "!< No port ID was found for the I2C transaction"] +pub const _NvAPI_Status_NVAPI_PORTID_NOT_FOUND: _NvAPI_Status = -105; +#[doc = "!< Expected an unattached display handle as one of the input parameters."] +pub const _NvAPI_Status_NVAPI_EXPECTED_UNATTACHED_DISPLAY_HANDLE: _NvAPI_Status = -106; +#[doc = "!< Invalid perf level"] +pub const _NvAPI_Status_NVAPI_INVALID_PERF_LEVEL: _NvAPI_Status = -107; +#[doc = "!< Device is busy; request not fulfilled"] +pub const _NvAPI_Status_NVAPI_DEVICE_BUSY: _NvAPI_Status = -108; +#[doc = "!< NV persist file is not found"] +pub const _NvAPI_Status_NVAPI_NV_PERSIST_FILE_NOT_FOUND: _NvAPI_Status = -109; +#[doc = "!< NV persist data is not found"] +pub const _NvAPI_Status_NVAPI_PERSIST_DATA_NOT_FOUND: _NvAPI_Status = -110; +#[doc = "!< Expected a TV output display"] +pub const _NvAPI_Status_NVAPI_EXPECTED_TV_DISPLAY: _NvAPI_Status = -111; +#[doc = "!< Expected a TV output on the D Connector - HDTV_EIAJ4120."] +pub const _NvAPI_Status_NVAPI_EXPECTED_TV_DISPLAY_ON_DCONNECTOR: _NvAPI_Status = -112; +#[doc = "!< SLI is not active on this device."] +pub const _NvAPI_Status_NVAPI_NO_ACTIVE_SLI_TOPOLOGY: _NvAPI_Status = -113; +#[doc = "!< Setup of SLI rendering mode is not possible right now."] +pub const _NvAPI_Status_NVAPI_SLI_RENDERING_MODE_NOTALLOWED: _NvAPI_Status = -114; +#[doc = "!< Expected a digital flat panel."] +pub const _NvAPI_Status_NVAPI_EXPECTED_DIGITAL_FLAT_PANEL: _NvAPI_Status = -115; +#[doc = "!< Argument exceeds the expected size."] +pub const _NvAPI_Status_NVAPI_ARGUMENT_EXCEED_MAX_SIZE: _NvAPI_Status = -116; +#[doc = "!< Inhibit is ON due to one of the flags in NV_GPU_DISPLAY_CHANGE_INHIBIT or SLI active."] +pub const _NvAPI_Status_NVAPI_DEVICE_SWITCHING_NOT_ALLOWED: _NvAPI_Status = -117; +#[doc = "!< Testing of clocks is not supported."] +pub const _NvAPI_Status_NVAPI_TESTING_CLOCKS_NOT_SUPPORTED: _NvAPI_Status = -118; +#[doc = "!< The specified underscan config is from an unknown source (e.g. INF)"] +pub const _NvAPI_Status_NVAPI_UNKNOWN_UNDERSCAN_CONFIG: _NvAPI_Status = -119; +#[doc = "!< Timeout while reconfiguring GPUs"] +pub const _NvAPI_Status_NVAPI_TIMEOUT_RECONFIGURING_GPU_TOPO: _NvAPI_Status = -120; +#[doc = "!< Requested data was not found"] +pub const _NvAPI_Status_NVAPI_DATA_NOT_FOUND: _NvAPI_Status = -121; +#[doc = "!< Expected an analog display"] +pub const _NvAPI_Status_NVAPI_EXPECTED_ANALOG_DISPLAY: _NvAPI_Status = -122; +#[doc = "!< No SLI video bridge is present"] +pub const _NvAPI_Status_NVAPI_NO_VIDLINK: _NvAPI_Status = -123; +#[doc = "!< NVAPI requires a reboot for the settings to take effect"] +pub const _NvAPI_Status_NVAPI_REQUIRES_REBOOT: _NvAPI_Status = -124; +#[doc = "!< The function is not supported with the current Hybrid mode."] +pub const _NvAPI_Status_NVAPI_INVALID_HYBRID_MODE: _NvAPI_Status = -125; +#[doc = "!< The target types are not all the same"] +pub const _NvAPI_Status_NVAPI_MIXED_TARGET_TYPES: _NvAPI_Status = -126; +#[doc = "!< The function is not supported from 32-bit on a 64-bit system."] +pub const _NvAPI_Status_NVAPI_SYSWOW64_NOT_SUPPORTED: _NvAPI_Status = -127; +#[doc = "!< There is no implicit GPU topology active. Use NVAPI_SetHybridMode to change topology."] +pub const _NvAPI_Status_NVAPI_IMPLICIT_SET_GPU_TOPOLOGY_CHANGE_NOT_ALLOWED: _NvAPI_Status = -128; +#[doc = "!< Prompt the user to close all non-migratable applications."] +pub const _NvAPI_Status_NVAPI_REQUEST_USER_TO_CLOSE_NON_MIGRATABLE_APPS: _NvAPI_Status = -129; +#[doc = "!< Could not allocate sufficient memory to complete the call."] +pub const _NvAPI_Status_NVAPI_OUT_OF_MEMORY: _NvAPI_Status = -130; +#[doc = "!< The previous operation that is transferring information to or from this surface is incomplete."] +pub const _NvAPI_Status_NVAPI_WAS_STILL_DRAWING: _NvAPI_Status = -131; +#[doc = "!< The file was not found."] +pub const _NvAPI_Status_NVAPI_FILE_NOT_FOUND: _NvAPI_Status = -132; +#[doc = "!< There are too many unique instances of a particular type of state object."] +pub const _NvAPI_Status_NVAPI_TOO_MANY_UNIQUE_STATE_OBJECTS: _NvAPI_Status = -133; +#[doc = "!< The method call is invalid. For example, a method's parameter may not be a valid pointer."] +pub const _NvAPI_Status_NVAPI_INVALID_CALL: _NvAPI_Status = -134; +#[doc = "!< d3d10_1.dll cannot be loaded."] +pub const _NvAPI_Status_NVAPI_D3D10_1_LIBRARY_NOT_FOUND: _NvAPI_Status = -135; +#[doc = "!< Couldn't find the function in the loaded DLL."] +pub const _NvAPI_Status_NVAPI_FUNCTION_NOT_FOUND: _NvAPI_Status = -136; +#[doc = "!< The application will require Administrator privileges to access this API.\n!< The application can be elevated to a higher permission level by selecting \"Run as Administrator\"."] +pub const _NvAPI_Status_NVAPI_INVALID_USER_PRIVILEGE: _NvAPI_Status = -137; +#[doc = "!< The handle corresponds to GDIPrimary."] +pub const _NvAPI_Status_NVAPI_EXPECTED_NON_PRIMARY_DISPLAY_HANDLE: _NvAPI_Status = -138; +#[doc = "!< Setting Physx GPU requires that the GPU is compute-capable."] +pub const _NvAPI_Status_NVAPI_EXPECTED_COMPUTE_GPU_HANDLE: _NvAPI_Status = -139; +#[doc = "!< The Stereo part of NVAPI failed to initialize completely. Check if the stereo driver is installed."] +pub const _NvAPI_Status_NVAPI_STEREO_NOT_INITIALIZED: _NvAPI_Status = -140; +#[doc = "!< Access to stereo-related registry keys or values has failed."] +pub const _NvAPI_Status_NVAPI_STEREO_REGISTRY_ACCESS_FAILED: _NvAPI_Status = -141; +#[doc = "!< The given registry profile type is not supported."] +pub const _NvAPI_Status_NVAPI_STEREO_REGISTRY_PROFILE_TYPE_NOT_SUPPORTED: _NvAPI_Status = -142; +#[doc = "!< The given registry value is not supported."] +pub const _NvAPI_Status_NVAPI_STEREO_REGISTRY_VALUE_NOT_SUPPORTED: _NvAPI_Status = -143; +#[doc = "!< Stereo is not enabled and the function needed it to execute completely."] +pub const _NvAPI_Status_NVAPI_STEREO_NOT_ENABLED: _NvAPI_Status = -144; +#[doc = "!< Stereo is not turned on and the function needed it to execute completely."] +pub const _NvAPI_Status_NVAPI_STEREO_NOT_TURNED_ON: _NvAPI_Status = -145; +#[doc = "!< Invalid device interface."] +pub const _NvAPI_Status_NVAPI_STEREO_INVALID_DEVICE_INTERFACE: _NvAPI_Status = -146; +#[doc = "!< Separation percentage or JPEG image capture quality is out of [0-100] range."] +pub const _NvAPI_Status_NVAPI_STEREO_PARAMETER_OUT_OF_RANGE: _NvAPI_Status = -147; +#[doc = "!< The given frustum adjust mode is not supported."] +pub const _NvAPI_Status_NVAPI_STEREO_FRUSTUM_ADJUST_MODE_NOT_SUPPORTED: _NvAPI_Status = -148; +#[doc = "!< The mosaic topology is not possible given the current state of the hardware."] +pub const _NvAPI_Status_NVAPI_TOPO_NOT_POSSIBLE: _NvAPI_Status = -149; +#[doc = "!< An attempt to do a display resolution mode change has failed."] +pub const _NvAPI_Status_NVAPI_MODE_CHANGE_FAILED: _NvAPI_Status = -150; +#[doc = "!< d3d11.dll/d3d11_beta.dll cannot be loaded."] +pub const _NvAPI_Status_NVAPI_D3D11_LIBRARY_NOT_FOUND: _NvAPI_Status = -151; +#[doc = "!< Address is outside of valid range."] +pub const _NvAPI_Status_NVAPI_INVALID_ADDRESS: _NvAPI_Status = -152; +#[doc = "!< The pre-allocated string is too small to hold the result."] +pub const _NvAPI_Status_NVAPI_STRING_TOO_SMALL: _NvAPI_Status = -153; +#[doc = "!< The input does not match any of the available devices."] +pub const _NvAPI_Status_NVAPI_MATCHING_DEVICE_NOT_FOUND: _NvAPI_Status = -154; +#[doc = "!< Driver is running."] +pub const _NvAPI_Status_NVAPI_DRIVER_RUNNING: _NvAPI_Status = -155; +#[doc = "!< Driver is not running."] +pub const _NvAPI_Status_NVAPI_DRIVER_NOTRUNNING: _NvAPI_Status = -156; +#[doc = "!< A driver reload is required to apply these settings."] +pub const _NvAPI_Status_NVAPI_ERROR_DRIVER_RELOAD_REQUIRED: _NvAPI_Status = -157; +#[doc = "!< Intended setting is not allowed."] +pub const _NvAPI_Status_NVAPI_SET_NOT_ALLOWED: _NvAPI_Status = -158; +#[doc = "!< Information can't be returned due to \"advanced display topology\"."] +pub const _NvAPI_Status_NVAPI_ADVANCED_DISPLAY_TOPOLOGY_REQUIRED: _NvAPI_Status = -159; +#[doc = "!< Setting is not found."] +pub const _NvAPI_Status_NVAPI_SETTING_NOT_FOUND: _NvAPI_Status = -160; +#[doc = "!< Setting size is too large."] +pub const _NvAPI_Status_NVAPI_SETTING_SIZE_TOO_LARGE: _NvAPI_Status = -161; +#[doc = "!< There are too many settings for a profile."] +pub const _NvAPI_Status_NVAPI_TOO_MANY_SETTINGS_IN_PROFILE: _NvAPI_Status = -162; +#[doc = "!< Profile is not found."] +pub const _NvAPI_Status_NVAPI_PROFILE_NOT_FOUND: _NvAPI_Status = -163; +#[doc = "!< Profile name is duplicated."] +pub const _NvAPI_Status_NVAPI_PROFILE_NAME_IN_USE: _NvAPI_Status = -164; +#[doc = "!< Profile name is empty."] +pub const _NvAPI_Status_NVAPI_PROFILE_NAME_EMPTY: _NvAPI_Status = -165; +#[doc = "!< Application not found in the Profile."] +pub const _NvAPI_Status_NVAPI_EXECUTABLE_NOT_FOUND: _NvAPI_Status = -166; +#[doc = "!< Application already exists in the other profile."] +pub const _NvAPI_Status_NVAPI_EXECUTABLE_ALREADY_IN_USE: _NvAPI_Status = -167; +#[doc = "!< Data Type mismatch"] +pub const _NvAPI_Status_NVAPI_DATATYPE_MISMATCH: _NvAPI_Status = -168; +#[doc = "!< The profile passed as parameter has been removed and is no longer valid."] +pub const _NvAPI_Status_NVAPI_PROFILE_REMOVED: _NvAPI_Status = -169; +#[doc = "!< An unregistered resource was passed as a parameter."] +pub const _NvAPI_Status_NVAPI_UNREGISTERED_RESOURCE: _NvAPI_Status = -170; +#[doc = "!< The DisplayId corresponds to a display which is not within the normal outputId range."] +pub const _NvAPI_Status_NVAPI_ID_OUT_OF_RANGE: _NvAPI_Status = -171; +#[doc = "!< Display topology is not valid so the driver cannot do a mode set on this configuration."] +pub const _NvAPI_Status_NVAPI_DISPLAYCONFIG_VALIDATION_FAILED: _NvAPI_Status = -172; +#[doc = "!< Display Port Multi-Stream topology has been changed."] +pub const _NvAPI_Status_NVAPI_DPMST_CHANGED: _NvAPI_Status = -173; +#[doc = "!< Input buffer is insufficient to hold the contents."] +pub const _NvAPI_Status_NVAPI_INSUFFICIENT_BUFFER: _NvAPI_Status = -174; +#[doc = "!< No access to the caller."] +pub const _NvAPI_Status_NVAPI_ACCESS_DENIED: _NvAPI_Status = -175; +#[doc = "!< The requested action cannot be performed without Mosaic being enabled."] +pub const _NvAPI_Status_NVAPI_MOSAIC_NOT_ACTIVE: _NvAPI_Status = -176; +#[doc = "!< The surface is relocated away from video memory."] +pub const _NvAPI_Status_NVAPI_SHARE_RESOURCE_RELOCATED: _NvAPI_Status = -177; +#[doc = "!< The user should disable DWM before calling NvAPI."] +pub const _NvAPI_Status_NVAPI_REQUEST_USER_TO_DISABLE_DWM: _NvAPI_Status = -178; +#[doc = "!< D3D device status is D3DERR_DEVICELOST or D3DERR_DEVICENOTRESET - the user has to reset the device."] +pub const _NvAPI_Status_NVAPI_D3D_DEVICE_LOST: _NvAPI_Status = -179; +#[doc = "!< The requested action cannot be performed in the current state."] +pub const _NvAPI_Status_NVAPI_INVALID_CONFIGURATION: _NvAPI_Status = -180; +#[doc = "!< Call failed as stereo handshake not completed."] +pub const _NvAPI_Status_NVAPI_STEREO_HANDSHAKE_NOT_DONE: _NvAPI_Status = -181; +#[doc = "!< The path provided was too short to determine the correct NVDRS_APPLICATION"] +pub const _NvAPI_Status_NVAPI_EXECUTABLE_PATH_IS_AMBIGUOUS: _NvAPI_Status = -182; +#[doc = "!< Default stereo profile is not currently defined"] +pub const _NvAPI_Status_NVAPI_DEFAULT_STEREO_PROFILE_IS_NOT_DEFINED: _NvAPI_Status = -183; +#[doc = "!< Default stereo profile does not exist"] +pub const _NvAPI_Status_NVAPI_DEFAULT_STEREO_PROFILE_DOES_NOT_EXIST: _NvAPI_Status = -184; +#[doc = "!< A cluster is already defined with the given configuration."] +pub const _NvAPI_Status_NVAPI_CLUSTER_ALREADY_EXISTS: _NvAPI_Status = -185; +#[doc = "!< The input display id is not that of a multi stream enabled connector or a display device in a multi stream topology"] +pub const _NvAPI_Status_NVAPI_DPMST_DISPLAY_ID_EXPECTED: _NvAPI_Status = -186; +#[doc = "!< The input display id is not valid or the monitor associated to it does not support the current operation"] +pub const _NvAPI_Status_NVAPI_INVALID_DISPLAY_ID: _NvAPI_Status = -187; +#[doc = "!< While playing secure audio stream, stream goes out of sync"] +pub const _NvAPI_Status_NVAPI_STREAM_IS_OUT_OF_SYNC: _NvAPI_Status = -188; +#[doc = "!< Older audio driver version than required"] +pub const _NvAPI_Status_NVAPI_INCOMPATIBLE_AUDIO_DRIVER: _NvAPI_Status = -189; +#[doc = "!< Value already set, setting again not allowed."] +pub const _NvAPI_Status_NVAPI_VALUE_ALREADY_SET: _NvAPI_Status = -190; +#[doc = "!< Requested operation timed out"] +pub const _NvAPI_Status_NVAPI_TIMEOUT: _NvAPI_Status = -191; +#[doc = "!< The requested workstation feature set has incomplete driver internal allocation resources"] +pub const _NvAPI_Status_NVAPI_GPU_WORKSTATION_FEATURE_INCOMPLETE: _NvAPI_Status = -192; +#[doc = "!< Call failed because InitActivation was not called."] +pub const _NvAPI_Status_NVAPI_STEREO_INIT_ACTIVATION_NOT_DONE: _NvAPI_Status = -193; +#[doc = "!< The requested action cannot be performed without Sync being enabled."] +pub const _NvAPI_Status_NVAPI_SYNC_NOT_ACTIVE: _NvAPI_Status = -194; +#[doc = "!< The requested action cannot be performed without Sync Master being enabled."] +pub const _NvAPI_Status_NVAPI_SYNC_MASTER_NOT_FOUND: _NvAPI_Status = -195; +#[doc = "!< Invalid displays passed in the NV_GSYNC_DISPLAY pointer."] +pub const _NvAPI_Status_NVAPI_INVALID_SYNC_TOPOLOGY: _NvAPI_Status = -196; +#[doc = "!< The specified signing algorithm is not supported. Either an incorrect value was entered or the current installed driver/hardware does not support the input value."] +pub const _NvAPI_Status_NVAPI_ECID_SIGN_ALGO_UNSUPPORTED: _NvAPI_Status = -197; +#[doc = "!< The encrypted public key verification has failed."] +pub const _NvAPI_Status_NVAPI_ECID_KEY_VERIFICATION_FAILED: _NvAPI_Status = -198; +#[doc = "!< The device's firmware is out of date."] +pub const _NvAPI_Status_NVAPI_FIRMWARE_OUT_OF_DATE: _NvAPI_Status = -199; +#[doc = "!< The device's firmware is not supported."] +pub const _NvAPI_Status_NVAPI_FIRMWARE_REVISION_NOT_SUPPORTED: _NvAPI_Status = -200; +#[doc = "!< The caller is not authorized to modify the License."] +pub const _NvAPI_Status_NVAPI_LICENSE_CALLER_AUTHENTICATION_FAILED: _NvAPI_Status = -201; +#[doc = "!< The user tried to use a deferred context without registering the device first"] +pub const _NvAPI_Status_NVAPI_D3D_DEVICE_NOT_REGISTERED: _NvAPI_Status = -202; +#[doc = "!< Head or SourceId was not reserved for the VR Display before doing the Modeset or the dedicated display."] +pub const _NvAPI_Status_NVAPI_RESOURCE_NOT_ACQUIRED: _NvAPI_Status = -203; +#[doc = "!< Provided timing is not supported."] +pub const _NvAPI_Status_NVAPI_TIMING_NOT_SUPPORTED: _NvAPI_Status = -204; +#[doc = "!< HDCP Encryption Failed for the device. Would be applicable when the device is HDCP Capable."] +pub const _NvAPI_Status_NVAPI_HDCP_ENCRYPTION_FAILED: _NvAPI_Status = -205; +#[doc = "!< Provided mode is over sink device pclk limitation."] +pub const _NvAPI_Status_NVAPI_PCLK_LIMITATION_FAILED: _NvAPI_Status = -206; +#[doc = "!< No connector on GPU found."] +pub const _NvAPI_Status_NVAPI_NO_CONNECTOR_FOUND: _NvAPI_Status = -207; +#[doc = "!< When a non-HDCP capable HMD is connected, we would inform user by this code."] +pub const _NvAPI_Status_NVAPI_HDCP_DISABLED: _NvAPI_Status = -208; +#[doc = "!< Atleast an API is still being called"] +pub const _NvAPI_Status_NVAPI_API_IN_USE: _NvAPI_Status = -209; +#[doc = "!< No display found on Nvidia GPU(s)."] +pub const _NvAPI_Status_NVAPI_NVIDIA_DISPLAY_NOT_FOUND: _NvAPI_Status = -210; +#[doc = "!< Priv security violation, improper access to a secured register."] +pub const _NvAPI_Status_NVAPI_PRIV_SEC_VIOLATION: _NvAPI_Status = -211; +#[doc = "!< NVAPI cannot be called by this vendor"] +pub const _NvAPI_Status_NVAPI_INCORRECT_VENDOR: _NvAPI_Status = -212; +#[doc = "!< DirectMode Display is already in use"] +pub const _NvAPI_Status_NVAPI_DISPLAY_IN_USE: _NvAPI_Status = -213; +#[doc = "!< The Config is having Non-NVidia GPU with Non-HDCP HMD connected"] +pub const _NvAPI_Status_NVAPI_UNSUPPORTED_CONFIG_NON_HDCP_HMD: _NvAPI_Status = -214; +#[doc = "!< GPU's Max Display Limit has Reached"] +pub const _NvAPI_Status_NVAPI_MAX_DISPLAY_LIMIT_REACHED: _NvAPI_Status = -215; +#[doc = "!< DirectMode not Enabled on the Display"] +pub const _NvAPI_Status_NVAPI_INVALID_DIRECT_MODE_DISPLAY: _NvAPI_Status = -216; +#[doc = "!< GPU is in debug mode, OC is NOT allowed."] +pub const _NvAPI_Status_NVAPI_GPU_IN_DEBUG_MODE: _NvAPI_Status = -217; +#[doc = "!< No NvAPI context was found for this D3D object"] +pub const _NvAPI_Status_NVAPI_D3D_CONTEXT_NOT_FOUND: _NvAPI_Status = -218; +#[doc = "!< there is version mismatch between stereo driver and dx driver"] +pub const _NvAPI_Status_NVAPI_STEREO_VERSION_MISMATCH: _NvAPI_Status = -219; +#[doc = "!< GPU is not powered and so the request cannot be completed."] +pub const _NvAPI_Status_NVAPI_GPU_NOT_POWERED: _NvAPI_Status = -220; +#[doc = "!< The display driver update in progress."] +pub const _NvAPI_Status_NVAPI_ERROR_DRIVER_RELOAD_IN_PROGRESS: _NvAPI_Status = -221; +#[doc = "!< Wait for HW resources allocation"] +pub const _NvAPI_Status_NVAPI_WAIT_FOR_HW_RESOURCE: _NvAPI_Status = -222; +#[doc = "!< operation requires further HDCP action"] +pub const _NvAPI_Status_NVAPI_REQUIRE_FURTHER_HDCP_ACTION: _NvAPI_Status = -223; +#[doc = "!< Dynamic Mux transition failure"] +pub const _NvAPI_Status_NVAPI_DISPLAY_MUX_TRANSITION_FAILED: _NvAPI_Status = -224; +#[doc = "!< Invalid DSC version"] +pub const _NvAPI_Status_NVAPI_INVALID_DSC_VERSION: _NvAPI_Status = -225; +#[doc = "!< Invalid DSC slice count"] +pub const _NvAPI_Status_NVAPI_INVALID_DSC_SLICECOUNT: _NvAPI_Status = -226; +#[doc = "!< Invalid DSC output BPP"] +pub const _NvAPI_Status_NVAPI_INVALID_DSC_OUTPUT_BPP: _NvAPI_Status = -227; +#[doc = "!< There was an error while loading nvapi.dll from the driver store."] +pub const _NvAPI_Status_NVAPI_FAILED_TO_LOAD_FROM_DRIVER_STORE: _NvAPI_Status = -228; +#[doc = "!< OpenGL does not export Vulkan fake extensions"] +pub const _NvAPI_Status_NVAPI_NO_VULKAN: _NvAPI_Status = -229; +#[doc = "!< A request for NvTOPPs telemetry CData has already been made and is pending a response."] +pub const _NvAPI_Status_NVAPI_REQUEST_PENDING: _NvAPI_Status = -230; +#[doc = "!< Operation cannot be performed because the resource is in use."] +pub const _NvAPI_Status_NVAPI_RESOURCE_IN_USE: _NvAPI_Status = -231; +#[doc = "!< Device kernel image is invalid"] +pub const _NvAPI_Status_NVAPI_INVALID_IMAGE: _NvAPI_Status = -232; +#[doc = "!< PTX JIT compilation failed"] +pub const _NvAPI_Status_NVAPI_INVALID_PTX: _NvAPI_Status = -233; +#[doc = "!< Uncorrectable NVLink error was detected during the execution"] +pub const _NvAPI_Status_NVAPI_NVLINK_UNCORRECTABLE: _NvAPI_Status = -234; +#[doc = "!< PTX JIT compiler library was not found."] +pub const _NvAPI_Status_NVAPI_JIT_COMPILER_NOT_FOUND: _NvAPI_Status = -235; +#[doc = "!< Device kernel source is invalid."] +pub const _NvAPI_Status_NVAPI_INVALID_SOURCE: _NvAPI_Status = -236; +#[doc = "!< While executing a kernel, the device encountered an illegal instruction."] +pub const _NvAPI_Status_NVAPI_ILLEGAL_INSTRUCTION: _NvAPI_Status = -237; +#[doc = "!< While executing a kernel, the device program counter wrapped its address space"] +pub const _NvAPI_Status_NVAPI_INVALID_PC: _NvAPI_Status = -238; +#[doc = "!< An exception occurred on the device while executing a kernel"] +pub const _NvAPI_Status_NVAPI_LAUNCH_FAILED: _NvAPI_Status = -239; +#[doc = "!< Attempted operation is not permitted."] +pub const _NvAPI_Status_NVAPI_NOT_PERMITTED: _NvAPI_Status = -240; +#[doc = "!< The callback function has already been registered."] +pub const _NvAPI_Status_NVAPI_CALLBACK_ALREADY_REGISTERED: _NvAPI_Status = -241; +#[doc = "!< The callback function is not found or not registered."] +pub const _NvAPI_Status_NVAPI_CALLBACK_NOT_FOUND: _NvAPI_Status = -242; +#[doc = "!< Invalid Wire Format for the VR HMD"] +pub const _NvAPI_Status_NVAPI_INVALID_OUTPUT_WIRE_FORMAT: _NvAPI_Status = -243; +#[doc = "! NvAPI Status Values\n! All NvAPI functions return one of these codes.\n! \\ingroup nvapistatus"] +pub type _NvAPI_Status = ::std::os::raw::c_int; +#[doc = "! NvAPI Status Values\n! All NvAPI functions return one of these codes.\n! \\ingroup nvapistatus"] +pub use self::_NvAPI_Status as NvAPI_Status; +#[doc = "! \\ingroup driverapi\n! Used in NvAPI_GPU_GetMemoryInfo()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_DISPLAY_DRIVER_MEMORY_INFO_V1 { + #[doc = "!< Version info"] + pub version: NvU32, + #[doc = "!< Size(in kb) of the physical framebuffer."] + pub dedicatedVideoMemory: NvU32, + #[doc = "!< Size(in kb) of the available physical framebuffer for allocating video memory surfaces."] + pub availableDedicatedVideoMemory: NvU32, + #[doc = "!< Size(in kb) of system memory the driver allocates at load time."] + pub systemVideoMemory: NvU32, + #[doc = "!< Size(in kb) of shared system memory that driver is allowed to commit for surfaces across all allocations."] + pub sharedSystemMemory: NvU32, +} +#[doc = "! \\ingroup driverapi\n! Used in NvAPI_GPU_GetMemoryInfo()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_DISPLAY_DRIVER_MEMORY_INFO_V2 { + #[doc = "!< Version info"] + pub version: NvU32, + #[doc = "!< Size(in kb) of the physical framebuffer."] + pub dedicatedVideoMemory: NvU32, + #[doc = "!< Size(in kb) of the available physical framebuffer for allocating video memory surfaces."] + pub availableDedicatedVideoMemory: NvU32, + #[doc = "!< Size(in kb) of system memory the driver allocates at load time."] + pub systemVideoMemory: NvU32, + #[doc = "!< Size(in kb) of shared system memory that driver is allowed to commit for surfaces across all allocations."] + pub sharedSystemMemory: NvU32, + #[doc = "!< Size(in kb) of the current available physical framebuffer for allocating video memory surfaces."] + pub curAvailableDedicatedVideoMemory: NvU32, +} +#[doc = "! \\ingroup driverapi\n! Used in NvAPI_GPU_GetMemoryInfo()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_DISPLAY_DRIVER_MEMORY_INFO_V3 { + #[doc = "!< Version info"] + pub version: NvU32, + #[doc = "!< Size(in kb) of the physical framebuffer."] + pub dedicatedVideoMemory: NvU32, + #[doc = "!< Size(in kb) of the available physical framebuffer for allocating video memory surfaces."] + pub availableDedicatedVideoMemory: NvU32, + #[doc = "!< Size(in kb) of system memory the driver allocates at load time."] + pub systemVideoMemory: NvU32, + #[doc = "!< Size(in kb) of shared system memory that driver is allowed to commit for surfaces across all allocations."] + pub sharedSystemMemory: NvU32, + #[doc = "!< Size(in kb) of the current available physical framebuffer for allocating video memory surfaces."] + pub curAvailableDedicatedVideoMemory: NvU32, + #[doc = "!< Size(in kb) of the total size of memory released as a result of the evictions."] + pub dedicatedVideoMemoryEvictionsSize: NvU32, + #[doc = "!< Indicates the number of eviction events that caused an allocation to be removed from dedicated video memory to free GPU\n!< video memory to make room for other allocations."] + pub dedicatedVideoMemoryEvictionCount: NvU32, +} +#[doc = "! \\ingroup driverapi"] +pub type NV_DISPLAY_DRIVER_MEMORY_INFO = NV_DISPLAY_DRIVER_MEMORY_INFO_V3; +#[doc = "! \\ingroup driverapi\n! Used in NvAPI_GPU_GetMemoryInfoEx()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_MEMORY_INFO_EX_V1 { + #[doc = "!< Structure version"] + pub version: NvU32, + #[doc = "!< Size(in bytes) of the physical framebuffer. Refers to the dedicated video memory on discrete GPUs."] + pub dedicatedVideoMemory: NvU64, + #[doc = "!< Size(in bytes) of the available physical framebuffer for allocating video memory surfaces."] + pub availableDedicatedVideoMemory: NvU64, + #[doc = "!< Size(in bytes) of system memory the driver allocates at load time. It is a substitute for dedicated video memory.\n!< Typically used with integrated GPUs that do not have dedicated video memory."] + pub systemVideoMemory: NvU64, + #[doc = "!< Size(in bytes) of shared system memory that driver is allowed to commit for surfaces across all allocations.\n!< On discrete GPUs, it is used to utilize system memory for various operations. It does not need to be reserved during boot.\n!< It may be used by both GPU and CPU, and has an \"on-demand\" type of usage."] + pub sharedSystemMemory: NvU64, + #[doc = "!< Size(in bytes) of the current available physical framebuffer for allocating video memory surfaces."] + pub curAvailableDedicatedVideoMemory: NvU64, + #[doc = "!< Size(in bytes) of the total size of memory released as a result of the evictions."] + pub dedicatedVideoMemoryEvictionsSize: NvU64, + #[doc = "!< Indicates the number of eviction events that caused an allocation to be removed from dedicated video memory to free GPU\n!< video memory to make room for other allocations."] + pub dedicatedVideoMemoryEvictionCount: NvU64, + #[doc = "!< Size(in bytes) of the total size of memory allocated as a result of the promotions."] + pub dedicatedVideoMemoryPromotionsSize: NvU64, + #[doc = "!< Indicates the number of promotion events that caused an allocation to be promoted to dedicated video memory"] + pub dedicatedVideoMemoryPromotionCount: NvU64, +} +#[doc = "! \\ingroup driverapi"] +pub type NV_GPU_MEMORY_INFO_EX = NV_GPU_MEMORY_INFO_EX_V1; +#[doc = "! \\ingroup dx\n! Used in NvAPI_D3D10_GetCurrentSLIState(), and NvAPI_D3D_GetCurrentSLIState()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GET_CURRENT_SLI_STATE_V1 { + #[doc = "!< Structure version"] + pub version: NvU32, + #[doc = "!< [OUT] The maximum possible value of numAFRGroups"] + pub maxNumAFRGroups: NvU32, + #[doc = "!< [OUT] The number of AFR groups enabled in the system"] + pub numAFRGroups: NvU32, + #[doc = "!< [OUT] The AFR group index for the frame currently being rendered"] + pub currentAFRIndex: NvU32, + #[doc = "!< [OUT] What the AFR group index will be for the next frame (i.e. after calling Present)"] + pub nextFrameAFRIndex: NvU32, + #[doc = "!< [OUT] The AFR group index that was used for the previous frame (~0 if more than one frame has not been rendered yet)"] + pub previousFrameAFRIndex: NvU32, + #[doc = "!< [OUT] Boolean: Is this frame the first time running on the current AFR group"] + pub bIsCurAFRGroupNew: NvU32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GET_CURRENT_SLI_STATE_V2 { + #[doc = "!< Structure version"] + pub version: NvU32, + #[doc = "!< [OUT] The maximum possible value of numAFRGroups"] + pub maxNumAFRGroups: NvU32, + #[doc = "!< [OUT] The number of AFR groups enabled in the system"] + pub numAFRGroups: NvU32, + #[doc = "!< [OUT] The AFR group index for the frame currently being rendered"] + pub currentAFRIndex: NvU32, + #[doc = "!< [OUT] What the AFR group index will be for the next frame (i.e. after calling Present)"] + pub nextFrameAFRIndex: NvU32, + #[doc = "!< [OUT] The AFR group index that was used for the previous frame (~0 if more than one frame has not been rendered yet)"] + pub previousFrameAFRIndex: NvU32, + #[doc = "!< [OUT] Boolean: Is this frame the first time running on the current AFR group"] + pub bIsCurAFRGroupNew: NvU32, + #[doc = "!< [OUT] The number of GPUs used in VR-SLI. If it is 0 VR-SLI is not active"] + pub numVRSLIGpus: NvU32, +} +pub const _NV_StereoActiveEye_NVAPI_STEREO_EYE_RIGHT: _NV_StereoActiveEye = 1; +pub const _NV_StereoActiveEye_NVAPI_STEREO_EYE_LEFT: _NV_StereoActiveEye = 2; +pub const _NV_StereoActiveEye_NVAPI_STEREO_EYE_MONO: _NV_StereoActiveEye = 3; +#[doc = "! \\ingroup stereoapi"] +pub type _NV_StereoActiveEye = ::std::os::raw::c_int; +#[doc = "! \\ingroup stereoapi"] +pub use self::_NV_StereoActiveEye as NV_STEREO_ACTIVE_EYE; +pub const _NV_StereoDriverMode_NVAPI_STEREO_DRIVER_MODE_AUTOMATIC: _NV_StereoDriverMode = 0; +pub const _NV_StereoDriverMode_NVAPI_STEREO_DRIVER_MODE_DIRECT: _NV_StereoDriverMode = 2; +#[doc = "! \\ingroup stereoapi"] +pub type _NV_StereoDriverMode = ::std::os::raw::c_int; +#[doc = "! \\ingroup stereoapi"] +pub use self::_NV_StereoDriverMode as NV_STEREO_DRIVER_MODE; +pub const _NV_DP_LINK_RATE_NV_DP_1_62GBPS: _NV_DP_LINK_RATE = 6; +pub const _NV_DP_LINK_RATE_NV_DP_2_70GBPS: _NV_DP_LINK_RATE = 10; +pub const _NV_DP_LINK_RATE_NV_DP_5_40GBPS: _NV_DP_LINK_RATE = 20; +pub const _NV_DP_LINK_RATE_NV_DP_8_10GBPS: _NV_DP_LINK_RATE = 30; +pub const _NV_DP_LINK_RATE_NV_EDP_2_16GBPS: _NV_DP_LINK_RATE = 8; +pub const _NV_DP_LINK_RATE_NV_EDP_2_43GBPS: _NV_DP_LINK_RATE = 9; +pub const _NV_DP_LINK_RATE_NV_EDP_3_24GBPS: _NV_DP_LINK_RATE = 12; +pub const _NV_DP_LINK_RATE_NV_EDP_4_32GBPS: _NV_DP_LINK_RATE = 16; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub type _NV_DP_LINK_RATE = ::std::os::raw::c_int; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub use self::_NV_DP_LINK_RATE as NV_DP_LINK_RATE; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_1_62Gbps: _NV_DP2X_LINK_RATE = 162; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_2_16Gbps: _NV_DP2X_LINK_RATE = 216; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_2_43Gbps: _NV_DP2X_LINK_RATE = 243; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_2_50Gbps: _NV_DP2X_LINK_RATE = 250; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_2_70Gbps: _NV_DP2X_LINK_RATE = 270; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_3_24Gbps: _NV_DP2X_LINK_RATE = 324; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_4_32Gbps: _NV_DP2X_LINK_RATE = 432; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_5_40Gbps: _NV_DP2X_LINK_RATE = 540; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_6_75Gbps: _NV_DP2X_LINK_RATE = 675; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_8_10Gbps: _NV_DP2X_LINK_RATE = 810; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_10_0Gbps: _NV_DP2X_LINK_RATE = 1000; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_13_5Gbps: _NV_DP2X_LINK_RATE = 1350; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_20_0Gbps: _NV_DP2X_LINK_RATE = 2000; +pub type _NV_DP2X_LINK_RATE = ::std::os::raw::c_int; +pub use self::_NV_DP2X_LINK_RATE as NV_DP2X_LINK_RATE; +pub const _NV_DP_LANE_COUNT_NV_DP_1_LANE: _NV_DP_LANE_COUNT = 1; +pub const _NV_DP_LANE_COUNT_NV_DP_2_LANE: _NV_DP_LANE_COUNT = 2; +pub const _NV_DP_LANE_COUNT_NV_DP_4_LANE: _NV_DP_LANE_COUNT = 4; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub type _NV_DP_LANE_COUNT = ::std::os::raw::c_int; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub use self::_NV_DP_LANE_COUNT as NV_DP_LANE_COUNT; +pub const _NV_DP_COLOR_FORMAT_NV_DP_COLOR_FORMAT_RGB: _NV_DP_COLOR_FORMAT = 0; +pub const _NV_DP_COLOR_FORMAT_NV_DP_COLOR_FORMAT_YCbCr422: _NV_DP_COLOR_FORMAT = 1; +pub const _NV_DP_COLOR_FORMAT_NV_DP_COLOR_FORMAT_YCbCr444: _NV_DP_COLOR_FORMAT = 2; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub type _NV_DP_COLOR_FORMAT = ::std::os::raw::c_int; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub use self::_NV_DP_COLOR_FORMAT as NV_DP_COLOR_FORMAT; +pub const _NV_DP_COLORIMETRY_NV_DP_COLORIMETRY_RGB: _NV_DP_COLORIMETRY = 0; +pub const _NV_DP_COLORIMETRY_NV_DP_COLORIMETRY_YCbCr_ITU601: _NV_DP_COLORIMETRY = 1; +pub const _NV_DP_COLORIMETRY_NV_DP_COLORIMETRY_YCbCr_ITU709: _NV_DP_COLORIMETRY = 2; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub type _NV_DP_COLORIMETRY = ::std::os::raw::c_int; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub use self::_NV_DP_COLORIMETRY as NV_DP_COLORIMETRY; +pub const _NV_DP_DYNAMIC_RANGE_NV_DP_DYNAMIC_RANGE_VESA: _NV_DP_DYNAMIC_RANGE = 0; +pub const _NV_DP_DYNAMIC_RANGE_NV_DP_DYNAMIC_RANGE_CEA: _NV_DP_DYNAMIC_RANGE = 1; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub type _NV_DP_DYNAMIC_RANGE = ::std::os::raw::c_int; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub use self::_NV_DP_DYNAMIC_RANGE as NV_DP_DYNAMIC_RANGE; +pub const _NV_DP_BPC_NV_DP_BPC_DEFAULT: _NV_DP_BPC = 0; +pub const _NV_DP_BPC_NV_DP_BPC_6: _NV_DP_BPC = 1; +pub const _NV_DP_BPC_NV_DP_BPC_8: _NV_DP_BPC = 2; +pub const _NV_DP_BPC_NV_DP_BPC_10: _NV_DP_BPC = 3; +pub const _NV_DP_BPC_NV_DP_BPC_12: _NV_DP_BPC = 4; +pub const _NV_DP_BPC_NV_DP_BPC_16: _NV_DP_BPC = 5; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub type _NV_DP_BPC = ::std::os::raw::c_int; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub use self::_NV_DP_BPC as NV_DP_BPC; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_EDID_V1 { + pub version: NvU32, + pub EDID_Data: [NvU8; 256usize], +} +#[doc = "! Used in NvAPI_GPU_GetEDID()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_EDID_V2 { + #[doc = "!< Structure version"] + pub version: NvU32, + pub EDID_Data: [NvU8; 256usize], + pub sizeofEDID: NvU32, +} +#[doc = "! Used in NvAPI_GPU_GetEDID()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_EDID_V3 { + #[doc = "!< Structure version"] + pub version: NvU32, + pub EDID_Data: [NvU8; 256usize], + pub sizeofEDID: NvU32, + #[doc = "!< ID which always returned in a monotonically increasing counter.\n!< Across a split-EDID read we need to verify that all calls returned the same edidId.\n!< This counter is incremented if we get the updated EDID."] + pub edidId: NvU32, + #[doc = "!< Which 256-byte page of the EDID we want to read. Start at 0.\n!< If the read succeeds with edidSize > NV_EDID_DATA_SIZE,\n!< call back again with offset+256 until we have read the entire buffer"] + pub offset: NvU32, +} +#[doc = "! Used in NvAPI_GPU_GetEDID()"] +pub type NV_EDID = NV_EDID_V3; +#[doc = "!< the EDID which is actively used by the driver, it could be _RAW/_COOKED/_FORCED/_INF."] +pub const NV_EDID_FLAG_NV_EDID_FLAG_DEFAULT: NV_EDID_FLAG = 0; +#[doc = "!< the EDID which is not modified by the driver. If there's no _FORCED edid engaged, it\n!< will be the unmodified monitor EDID from the I2C bus. Otherwise it is original _FORCED edid."] +pub const NV_EDID_FLAG_NV_EDID_FLAG_RAW: NV_EDID_FLAG = 1; +#[doc = "!< the EDID has been modified by the driver for compatibility"] +pub const NV_EDID_FLAG_NV_EDID_FLAG_COOKED: NV_EDID_FLAG = 2; +#[doc = "!< the EDID is forced by the end-user over s/w interface,"] +pub const NV_EDID_FLAG_NV_EDID_FLAG_FORCED: NV_EDID_FLAG = 3; +#[doc = "!< the EDID is from monitor INF"] +pub const NV_EDID_FLAG_NV_EDID_FLAG_INF: NV_EDID_FLAG = 4; +#[doc = "!< the EDID is from the monitor over I2C bus without any modification."] +pub const NV_EDID_FLAG_NV_EDID_FLAG_HW: NV_EDID_FLAG = 5; +pub type NV_EDID_FLAG = ::std::os::raw::c_int; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_VGA_15_PIN: _NV_GPU_CONNECTOR_TYPE = 0; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_TV_COMPOSITE: _NV_GPU_CONNECTOR_TYPE = 16; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_TV_SVIDEO: _NV_GPU_CONNECTOR_TYPE = 17; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_TV_HDTV_COMPONENT: _NV_GPU_CONNECTOR_TYPE = 19; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_TV_SCART: _NV_GPU_CONNECTOR_TYPE = 20; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_TV_COMPOSITE_SCART_ON_EIAJ4120: + _NV_GPU_CONNECTOR_TYPE = 22; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_TV_HDTV_EIAJ4120: _NV_GPU_CONNECTOR_TYPE = 23; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_PC_POD_HDTV_YPRPB: _NV_GPU_CONNECTOR_TYPE = 24; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_PC_POD_SVIDEO: _NV_GPU_CONNECTOR_TYPE = 25; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_PC_POD_COMPOSITE: _NV_GPU_CONNECTOR_TYPE = 26; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DVI_I_TV_SVIDEO: _NV_GPU_CONNECTOR_TYPE = 32; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DVI_I_TV_COMPOSITE: _NV_GPU_CONNECTOR_TYPE = + 33; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DVI_I: _NV_GPU_CONNECTOR_TYPE = 48; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DVI_D: _NV_GPU_CONNECTOR_TYPE = 49; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_ADC: _NV_GPU_CONNECTOR_TYPE = 50; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_LFH_DVI_I_1: _NV_GPU_CONNECTOR_TYPE = 56; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_LFH_DVI_I_2: _NV_GPU_CONNECTOR_TYPE = 57; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_SPWG: _NV_GPU_CONNECTOR_TYPE = 64; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_OEM: _NV_GPU_CONNECTOR_TYPE = 65; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DISPLAYPORT_EXTERNAL: _NV_GPU_CONNECTOR_TYPE = + 70; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DISPLAYPORT_INTERNAL: _NV_GPU_CONNECTOR_TYPE = + 71; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DISPLAYPORT_MINI_EXT: _NV_GPU_CONNECTOR_TYPE = + 72; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_HDMI_A: _NV_GPU_CONNECTOR_TYPE = 97; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_HDMI_C_MINI: _NV_GPU_CONNECTOR_TYPE = 99; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_LFH_DISPLAYPORT_1: _NV_GPU_CONNECTOR_TYPE = + 100; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_LFH_DISPLAYPORT_2: _NV_GPU_CONNECTOR_TYPE = + 101; +#[doc = "!< Deprecated."] +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_VIRTUAL_WFD: _NV_GPU_CONNECTOR_TYPE = 112; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_USB_C: _NV_GPU_CONNECTOR_TYPE = 113; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_UNKNOWN: _NV_GPU_CONNECTOR_TYPE = -1; +#[doc = "! \\ingroup gpu\n! Used in NV_GPU_CONNECTOR_DATA"] +pub type _NV_GPU_CONNECTOR_TYPE = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpu\n! Used in NV_GPU_CONNECTOR_DATA"] +pub use self::_NV_GPU_CONNECTOR_TYPE as NV_GPU_CONNECTOR_TYPE; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_NONE: _NV_DISPLAY_TV_FORMAT = 0; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_NTSCM: _NV_DISPLAY_TV_FORMAT = 1; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_NTSCJ: _NV_DISPLAY_TV_FORMAT = 2; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_PALM: _NV_DISPLAY_TV_FORMAT = 4; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_PALBDGH: _NV_DISPLAY_TV_FORMAT = 8; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_PALN: _NV_DISPLAY_TV_FORMAT = 16; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_PALNC: _NV_DISPLAY_TV_FORMAT = 32; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_576i: _NV_DISPLAY_TV_FORMAT = 256; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_480i: _NV_DISPLAY_TV_FORMAT = 512; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_ED_480p: _NV_DISPLAY_TV_FORMAT = 1024; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_ED_576p: _NV_DISPLAY_TV_FORMAT = 2048; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_720p: _NV_DISPLAY_TV_FORMAT = 4096; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_1080i: _NV_DISPLAY_TV_FORMAT = 8192; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_1080p: _NV_DISPLAY_TV_FORMAT = 16384; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_720p50: _NV_DISPLAY_TV_FORMAT = 32768; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_1080p24: _NV_DISPLAY_TV_FORMAT = 65536; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_1080i50: _NV_DISPLAY_TV_FORMAT = 131072; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_1080p50: _NV_DISPLAY_TV_FORMAT = 262144; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp30: _NV_DISPLAY_TV_FORMAT = 524288; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp30_3840: _NV_DISPLAY_TV_FORMAT = 524288; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp25: _NV_DISPLAY_TV_FORMAT = 1048576; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp25_3840: _NV_DISPLAY_TV_FORMAT = + 1048576; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp24: _NV_DISPLAY_TV_FORMAT = 2097152; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp24_3840: _NV_DISPLAY_TV_FORMAT = + 2097152; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp24_SMPTE: _NV_DISPLAY_TV_FORMAT = + 4194304; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp50_3840: _NV_DISPLAY_TV_FORMAT = + 8388608; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp60_3840: _NV_DISPLAY_TV_FORMAT = + 9437184; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp30_4096: _NV_DISPLAY_TV_FORMAT = + 10485760; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp25_4096: _NV_DISPLAY_TV_FORMAT = + 11534336; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp24_4096: _NV_DISPLAY_TV_FORMAT = + 12582912; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp50_4096: _NV_DISPLAY_TV_FORMAT = + 13631488; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp60_4096: _NV_DISPLAY_TV_FORMAT = + 14680064; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp24_7680: _NV_DISPLAY_TV_FORMAT = + 16777216; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp25_7680: _NV_DISPLAY_TV_FORMAT = + 33554432; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp30_7680: _NV_DISPLAY_TV_FORMAT = + 67108864; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp48_7680: _NV_DISPLAY_TV_FORMAT = + 134217728; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp50_7680: _NV_DISPLAY_TV_FORMAT = + 150994944; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp60_7680: _NV_DISPLAY_TV_FORMAT = + 167772160; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp100_7680: _NV_DISPLAY_TV_FORMAT = + 184549376; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp120_7680: _NV_DISPLAY_TV_FORMAT = + 201326592; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp48_3840: _NV_DISPLAY_TV_FORMAT = + 218103808; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp48_4096: _NV_DISPLAY_TV_FORMAT = + 234881024; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp100_4096: _NV_DISPLAY_TV_FORMAT = + 251658240; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp100_3840: _NV_DISPLAY_TV_FORMAT = + 268435456; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp120_4096: _NV_DISPLAY_TV_FORMAT = + 285212672; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp120_3840: _NV_DISPLAY_TV_FORMAT = + 301989888; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp100_5120: _NV_DISPLAY_TV_FORMAT = + 318767104; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp120_5120: _NV_DISPLAY_TV_FORMAT = + 335544320; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp24_5120: _NV_DISPLAY_TV_FORMAT = + 352321536; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp25_5120: _NV_DISPLAY_TV_FORMAT = + 369098752; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp30_5120: _NV_DISPLAY_TV_FORMAT = + 385875968; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp48_5120: _NV_DISPLAY_TV_FORMAT = + 402653184; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp50_5120: _NV_DISPLAY_TV_FORMAT = + 419430400; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp60_5120: _NV_DISPLAY_TV_FORMAT = + 536870912; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp24_10240: _NV_DISPLAY_TV_FORMAT = + 553648128; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp25_10240: _NV_DISPLAY_TV_FORMAT = + 570425344; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp30_10240: _NV_DISPLAY_TV_FORMAT = + 587202560; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp48_10240: _NV_DISPLAY_TV_FORMAT = + 603979776; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp50_10240: _NV_DISPLAY_TV_FORMAT = + 620756992; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp60_10240: _NV_DISPLAY_TV_FORMAT = + 637534208; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp100_10240: _NV_DISPLAY_TV_FORMAT = + 654311424; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp120_10240: _NV_DISPLAY_TV_FORMAT = + 671088640; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_OTHER: _NV_DISPLAY_TV_FORMAT = 805306368; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_ED_OTHER: _NV_DISPLAY_TV_FORMAT = 1073741824; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_OTHER: _NV_DISPLAY_TV_FORMAT = 1342177280; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_ANY: _NV_DISPLAY_TV_FORMAT = -2147483648; +#[doc = "! \\ingroup tvapi\n! Used in NV_DISPLAY_TV_OUTPUT_INFO"] +pub type _NV_DISPLAY_TV_FORMAT = ::std::os::raw::c_int; +#[doc = "! \\ingroup tvapi\n! Used in NV_DISPLAY_TV_OUTPUT_INFO"] +pub use self::_NV_DISPLAY_TV_FORMAT as NV_DISPLAY_TV_FORMAT; +pub const _NV_TARGET_VIEW_MODE_NV_VIEW_MODE_STANDARD: _NV_TARGET_VIEW_MODE = 0; +pub const _NV_TARGET_VIEW_MODE_NV_VIEW_MODE_CLONE: _NV_TARGET_VIEW_MODE = 1; +pub const _NV_TARGET_VIEW_MODE_NV_VIEW_MODE_HSPAN: _NV_TARGET_VIEW_MODE = 2; +pub const _NV_TARGET_VIEW_MODE_NV_VIEW_MODE_VSPAN: _NV_TARGET_VIEW_MODE = 3; +pub const _NV_TARGET_VIEW_MODE_NV_VIEW_MODE_DUALVIEW: _NV_TARGET_VIEW_MODE = 4; +pub const _NV_TARGET_VIEW_MODE_NV_VIEW_MODE_MULTIVIEW: _NV_TARGET_VIEW_MODE = 5; +#[doc = "! Used in NvAPI_SetView()."] +pub type _NV_TARGET_VIEW_MODE = ::std::os::raw::c_int; +#[doc = "! Used in NvAPI_SetView()."] +pub use self::_NV_TARGET_VIEW_MODE as NV_TARGET_VIEW_MODE; +#[doc = "!< No change"] +pub const _NV_SCALING_NV_SCALING_DEFAULT: _NV_SCALING = 0; +#[doc = "!< Balanced - Full Screen"] +pub const _NV_SCALING_NV_SCALING_GPU_SCALING_TO_CLOSEST: _NV_SCALING = 1; +#[doc = "!< Force GPU - Full Screen"] +pub const _NV_SCALING_NV_SCALING_GPU_SCALING_TO_NATIVE: _NV_SCALING = 2; +#[doc = "!< Force GPU - Centered\\No Scaling"] +pub const _NV_SCALING_NV_SCALING_GPU_SCANOUT_TO_NATIVE: _NV_SCALING = 3; +#[doc = "!< Force GPU - Aspect Ratio"] +pub const _NV_SCALING_NV_SCALING_GPU_SCALING_TO_ASPECT_SCANOUT_TO_NATIVE: _NV_SCALING = 5; +#[doc = "!< Balanced - Aspect Ratio"] +pub const _NV_SCALING_NV_SCALING_GPU_SCALING_TO_ASPECT_SCANOUT_TO_CLOSEST: _NV_SCALING = 6; +#[doc = "!< Balanced - Centered\\No Scaling"] +pub const _NV_SCALING_NV_SCALING_GPU_SCANOUT_TO_CLOSEST: _NV_SCALING = 7; +#[doc = "!< Force GPU - Integer Scaling"] +pub const _NV_SCALING_NV_SCALING_GPU_INTEGER_ASPECT_SCALING: _NV_SCALING = 8; +pub const _NV_SCALING_NV_SCALING_MONITOR_SCALING: _NV_SCALING = 1; +pub const _NV_SCALING_NV_SCALING_ADAPTER_SCALING: _NV_SCALING = 2; +pub const _NV_SCALING_NV_SCALING_CENTERED: _NV_SCALING = 3; +pub const _NV_SCALING_NV_SCALING_ASPECT_SCALING: _NV_SCALING = 5; +#[doc = "!< For future use"] +pub const _NV_SCALING_NV_SCALING_CUSTOMIZED: _NV_SCALING = 255; +#[doc = "! Scaling modes - used in NvAPI_SetViewEx().\n! \\ingroup dispcontrol"] +pub type _NV_SCALING = ::std::os::raw::c_int; +#[doc = "! Scaling modes - used in NvAPI_SetViewEx().\n! \\ingroup dispcontrol"] +pub use self::_NV_SCALING as NV_SCALING; +pub const _NV_ROTATE_NV_ROTATE_0: _NV_ROTATE = 0; +pub const _NV_ROTATE_NV_ROTATE_90: _NV_ROTATE = 1; +pub const _NV_ROTATE_NV_ROTATE_180: _NV_ROTATE = 2; +pub const _NV_ROTATE_NV_ROTATE_270: _NV_ROTATE = 3; +pub const _NV_ROTATE_NV_ROTATE_IGNORED: _NV_ROTATE = 4; +#[doc = "! \\ingroup dispcontrol"] +pub type _NV_ROTATE = ::std::os::raw::c_int; +#[doc = "! \\ingroup dispcontrol"] +pub use self::_NV_ROTATE as NV_ROTATE; +#[doc = "!< unknown. Driver will choose one as following value."] +pub const _NV_FORMAT_NV_FORMAT_UNKNOWN: _NV_FORMAT = 0; +#[doc = "!< for 8bpp mode"] +pub const _NV_FORMAT_NV_FORMAT_P8: _NV_FORMAT = 41; +#[doc = "!< for 16bpp mode"] +pub const _NV_FORMAT_NV_FORMAT_R5G6B5: _NV_FORMAT = 23; +#[doc = "!< for 32bpp mode"] +pub const _NV_FORMAT_NV_FORMAT_A8R8G8B8: _NV_FORMAT = 21; +#[doc = "!< for 64bpp(floating point) mode."] +pub const _NV_FORMAT_NV_FORMAT_A16B16G16R16F: _NV_FORMAT = 113; +#[doc = "! Color formats- used in NvAPI_SetViewEx().\n! \\ingroup dispcontrol"] +pub type _NV_FORMAT = ::std::os::raw::c_int; +#[doc = "! Color formats- used in NvAPI_SetViewEx().\n! \\ingroup dispcontrol"] +pub use self::_NV_FORMAT as NV_FORMAT; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_VIEWPORTF { + #[doc = "!< x-coordinate of the viewport top-left point"] + pub x: f32, + #[doc = "!< y-coordinate of the viewport top-left point"] + pub y: f32, + #[doc = "!< Width of the viewport"] + pub w: f32, + #[doc = "!< Height of the viewport"] + pub h: f32, +} +#[doc = "!< get the current timing"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_CURRENT: _NV_TIMING_OVERRIDE = 0; +#[doc = "!< the timing the driver will use based the current policy"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_AUTO: _NV_TIMING_OVERRIDE = 1; +#[doc = "!< EDID timing"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_EDID: _NV_TIMING_OVERRIDE = 2; +#[doc = "!< VESA DMT timing"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_DMT: _NV_TIMING_OVERRIDE = 3; +#[doc = "!< VESA DMT timing with reduced blanking"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_DMT_RB: _NV_TIMING_OVERRIDE = 4; +#[doc = "!< VESA CVT timing"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_CVT: _NV_TIMING_OVERRIDE = 5; +#[doc = "!< VESA CVT timing with reduced blanking"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_CVT_RB: _NV_TIMING_OVERRIDE = 6; +#[doc = "!< VESA GTF timing"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_GTF: _NV_TIMING_OVERRIDE = 7; +#[doc = "!< EIA 861x pre-defined timing"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_EIA861: _NV_TIMING_OVERRIDE = 8; +#[doc = "!< analog SD/HDTV timing"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_ANALOG_TV: _NV_TIMING_OVERRIDE = 9; +#[doc = "!< NV custom timings"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_CUST: _NV_TIMING_OVERRIDE = 10; +#[doc = "!< NV pre-defined timing (basically the PsF timings)"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_NV_PREDEFINED: _NV_TIMING_OVERRIDE = 11; +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_NV_PSF: _NV_TIMING_OVERRIDE = 11; +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_NV_ASPR: _NV_TIMING_OVERRIDE = 12; +#[doc = "!< Override for SDI timing"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_SDI: _NV_TIMING_OVERRIDE = 13; +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVRRIDE_MAX: _NV_TIMING_OVERRIDE = 14; +#[doc = "! \\ingroup dispcontrol\n! The timing override is not supported yet; must be set to _AUTO. \\n"] +pub type _NV_TIMING_OVERRIDE = ::std::os::raw::c_int; +#[doc = "! \\ingroup dispcontrol\n! The timing override is not supported yet; must be set to _AUTO. \\n"] +pub use self::_NV_TIMING_OVERRIDE as NV_TIMING_OVERRIDE; +#[doc = "! \\ingroup dispcontrol\n! NVIDIA-specific timing extras \\n\n! Used in NV_TIMING."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct tagNV_TIMINGEXT { + #[doc = "!< Reserved for NVIDIA hardware-based enhancement, such as double-scan."] + pub flag: NvU32, + #[doc = "!< Logical refresh rate to present"] + pub rr: NvU16, + #[doc = "!< Physical vertical refresh rate in 0.001Hz"] + pub rrx1k: NvU32, + #[doc = "!< Display aspect ratio Hi(aspect):horizontal-aspect, Low(aspect):vertical-aspect"] + pub aspect: NvU32, + #[doc = "!< Bit-wise pixel repetition factor: 0x1:no pixel repetition; 0x2:each pixel repeats twice horizontally,.."] + pub rep: NvU16, + #[doc = "!< Timing standard"] + pub status: NvU32, + #[doc = "!< Timing name"] + pub name: [NvU8; 40usize], +} +#[doc = "! \\ingroup dispcontrol\n! NVIDIA-specific timing extras \\n\n! Used in NV_TIMING."] +pub type NV_TIMINGEXT = tagNV_TIMINGEXT; +#[doc = "! \\ingroup dispcontrol\n!The very basic timing structure based on the VESA standard:\n! \\code\n! |<----------------------------htotal--------------------------->|\n! ---------\"active\" video-------->|<-------blanking------>|<-----\n! |<-------hvisible-------->|<-hb->|<-hfp->|<-hsw->|<-hbp->|<-hb->|\n! --------- -+-------------------------+ | | | | |\n! A A | | | | | | |\n! : : | | | | | | |\n! : : | | | | | | |\n! :vertical| addressable video | | | | | |\n! : visible| | | | | | |\n! : : | | | | | | |\n! : : | | | | | | |\n! vertical V | | | | | | |\n! total --+-------------------------+ | | | | |\n! : vb border | | | | |\n! : -----------------------------------+ | | | |\n! : vfp front porch | | | |\n! : -------------------------------------------+ | | |\n! : vsw sync width | | |\n! : ---------------------------------------------------+ | |\n! : vbp back porch | |\n! : -----------------------------------------------------------+ |\n! V vb border |\n! ---------------------------------------------------------------------------+\n! \\endcode"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_TIMING { + #[doc = "!< horizontal visible"] + pub HVisible: NvU16, + #[doc = "!< horizontal border"] + pub HBorder: NvU16, + #[doc = "!< horizontal front porch"] + pub HFrontPorch: NvU16, + #[doc = "!< horizontal sync width"] + pub HSyncWidth: NvU16, + #[doc = "!< horizontal total"] + pub HTotal: NvU16, + #[doc = "!< horizontal sync polarity: 1-negative, 0-positive"] + pub HSyncPol: NvU8, + #[doc = "!< vertical visible"] + pub VVisible: NvU16, + #[doc = "!< vertical border"] + pub VBorder: NvU16, + #[doc = "!< vertical front porch"] + pub VFrontPorch: NvU16, + #[doc = "!< vertical sync width"] + pub VSyncWidth: NvU16, + #[doc = "!< vertical total"] + pub VTotal: NvU16, + #[doc = "!< vertical sync polarity: 1-negative, 0-positive"] + pub VSyncPol: NvU8, + #[doc = "!< 1-interlaced, 0-progressive"] + pub interlaced: NvU16, + #[doc = "!< pixel clock in 10 kHz"] + pub pclk: NvU32, + pub etc: NV_TIMINGEXT, +} +#[doc = "! \\ingroup dispcontrol\n!The very basic timing structure based on the VESA standard:\n! \\code\n! |<----------------------------htotal--------------------------->|\n! ---------\"active\" video-------->|<-------blanking------>|<-----\n! |<-------hvisible-------->|<-hb->|<-hfp->|<-hsw->|<-hbp->|<-hb->|\n! --------- -+-------------------------+ | | | | |\n! A A | | | | | | |\n! : : | | | | | | |\n! : : | | | | | | |\n! :vertical| addressable video | | | | | |\n! : visible| | | | | | |\n! : : | | | | | | |\n! : : | | | | | | |\n! vertical V | | | | | | |\n! total --+-------------------------+ | | | | |\n! : vb border | | | | |\n! : -----------------------------------+ | | | |\n! : vfp front porch | | | |\n! : -------------------------------------------+ | | |\n! : vsw sync width | | |\n! : ---------------------------------------------------+ | |\n! : vbp back porch | |\n! : -----------------------------------------------------------+ |\n! V vb border |\n! ---------------------------------------------------------------------------+\n! \\endcode"] +pub type NV_TIMING = _NV_TIMING; +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_SetView() and NvAPI_GetView()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_VIEW_TARGET_INFO { + #[doc = "!< (IN) structure version"] + pub version: NvU32, + #[doc = "!< (IN) target count"] + pub count: NvU32, + pub target: [NV_VIEW_TARGET_INFO__bindgen_ty_1; 2usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_VIEW_TARGET_INFO__bindgen_ty_1 { + #[doc = "!< (IN/OUT) Device mask"] + pub deviceMask: NvU32, + #[doc = "!< (IN/OUT) Source ID - values will be based on the number of heads exposed per GPU."] + pub sourceId: NvU32, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +impl NV_VIEW_TARGET_INFO__bindgen_ty_1 { + #[inline] + pub fn bPrimary(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bPrimary(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bPrimary_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bPrimary_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bInterlaced(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bInterlaced(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bInterlaced_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bInterlaced_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bGDIPrimary(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_bGDIPrimary(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bGDIPrimary_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bGDIPrimary_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bForceModeSet(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_bForceModeSet(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bForceModeSet_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bForceModeSet_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bPrimary: NvU32, + bInterlaced: NvU32, + bGDIPrimary: NvU32, + bForceModeSet: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bPrimary: u32 = unsafe { ::std::mem::transmute(bPrimary) }; + bPrimary as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bInterlaced: u32 = unsafe { ::std::mem::transmute(bInterlaced) }; + bInterlaced as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let bGDIPrimary: u32 = unsafe { ::std::mem::transmute(bGDIPrimary) }; + bGDIPrimary as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let bForceModeSet: u32 = unsafe { ::std::mem::transmute(bForceModeSet) }; + bForceModeSet as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PATH_INFO."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_DISPLAY_PATH { + #[doc = "!< (IN) Device mask"] + pub deviceMask: NvU32, + #[doc = "!< (IN) Values will be based on the number of heads exposed per GPU(0, 1?)"] + pub sourceId: NvU32, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + #[doc = "!< (IN) Specify connector type. For TV only."] + pub connector: NV_GPU_CONNECTOR_TYPE, + #[doc = "!< (IN) Width of the mode"] + pub width: NvU32, + #[doc = "!< (IN) Height of the mode"] + pub height: NvU32, + #[doc = "!< (IN) Depth of the mode"] + pub depth: NvU32, + #[doc = "!< Color format if it needs to be specified. Not used now."] + pub colorFormat: NV_FORMAT, + #[doc = "!< (IN) Rotation setting."] + pub rotation: NV_ROTATE, + #[doc = "!< (IN) Scaling setting"] + pub scaling: NV_SCALING, + #[doc = "!< (IN) Refresh rate of the mode"] + pub refreshRate: NvU32, + pub _bitfield_align_2: [u8; 0], + pub _bitfield_2: __BindgenBitfieldUnit<[u8; 1usize]>, + #[doc = "!< (IN) To choose the last TV format set this value to NV_DISPLAY_TV_FORMAT_NONE"] + pub tvFormat: NV_DISPLAY_TV_FORMAT, + #[doc = "!< (IN/OUT) X-offset of this display on the Windows desktop"] + pub posx: NvU32, + #[doc = "!< (IN/OUT) Y-offset of this display on the Windows desktop"] + pub posy: NvU32, + pub _bitfield_align_3: [u32; 0], + pub _bitfield_3: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl NV_DISPLAY_PATH { + #[inline] + pub fn bPrimary(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bPrimary(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bPrimary_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bPrimary_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1(bPrimary: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bPrimary: u32 = unsafe { ::std::mem::transmute(bPrimary) }; + bPrimary as u64 + }); + __bindgen_bitfield_unit + } + #[inline] + pub fn interlaced(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_interlaced(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_2.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn interlaced_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_2), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_interlaced_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_2(interlaced: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let interlaced: u32 = unsafe { ::std::mem::transmute(interlaced) }; + interlaced as u64 + }); + __bindgen_bitfield_unit + } + #[inline] + pub fn bGDIPrimary(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_3.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bGDIPrimary(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_3.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bGDIPrimary_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_3), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bGDIPrimary_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_3), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bForceModeSet(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_3.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bForceModeSet(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_3.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bForceModeSet_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_3), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bForceModeSet_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_3), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bFocusDisplay(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_3.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_bFocusDisplay(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_3.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bFocusDisplay_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_3), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bFocusDisplay_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_3), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn gpuId(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_3.get(3usize, 24u8) as u32) } + } + #[inline] + pub fn set_gpuId(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_3.set(3usize, 24u8, val as u64) + } + } + #[inline] + pub unsafe fn gpuId_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_3), + 3usize, + 24u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_gpuId_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_3), + 3usize, + 24u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_3( + bGDIPrimary: NvU32, + bForceModeSet: NvU32, + bFocusDisplay: NvU32, + gpuId: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bGDIPrimary: u32 = unsafe { ::std::mem::transmute(bGDIPrimary) }; + bGDIPrimary as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bForceModeSet: u32 = unsafe { ::std::mem::transmute(bForceModeSet) }; + bForceModeSet as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let bFocusDisplay: u32 = unsafe { ::std::mem::transmute(bFocusDisplay) }; + bFocusDisplay as u64 + }); + __bindgen_bitfield_unit.set(3usize, 24u8, { + let gpuId: u32 = unsafe { ::std::mem::transmute(gpuId) }; + gpuId as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_SetViewEx() and NvAPI_GetViewEx()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_DISPLAY_PATH_INFO_V3 { + #[doc = "!< (IN) Structure version"] + pub version: NvU32, + #[doc = "!< (IN) Path count"] + pub count: NvU32, + pub path: [NV_DISPLAY_PATH; 2usize], +} +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_SetViewEx() and NvAPI_GetViewEx()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_DISPLAY_PATH_INFO { + #[doc = "!< (IN) Structure version"] + pub version: NvU32, + #[doc = "!< (IN) Path count"] + pub count: NvU32, + pub path: [NV_DISPLAY_PATH; 4usize], +} +#[doc = "\n! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_POSITION { + pub x: NvS32, + pub y: NvS32, +} +#[doc = "\n! \\ingroup dispcontrol"] +pub type NV_POSITION = _NV_POSITION; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_RESOLUTION { + pub width: NvU32, + pub height: NvU32, + pub colorDepth: NvU32, +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_RESOLUTION = _NV_RESOLUTION; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO_V1 { + pub version: NvU32, + #[doc = "!< (IN) rotation setting."] + pub rotation: NV_ROTATE, + #[doc = "!< (IN) scaling setting."] + pub scaling: NV_SCALING, + #[doc = "!< (IN) Non-interlaced Refresh Rate of the mode, multiplied by 1000, 0 = ignored\n!< This is the value which driver reports to the OS."] + pub refreshRate1K: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Specify connector type. For TV only, ignored if tvFormat == NV_DISPLAY_TV_FORMAT_NONE"] + pub connector: NV_GPU_CONNECTOR_TYPE, + #[doc = "!< (IN) to choose the last TV format set this value to NV_DISPLAY_TV_FORMAT_NONE\n!< In case of NvAPI_DISP_GetDisplayConfig(), this field will indicate the currently applied TV format;\n!< if no TV format is applied, this field will have NV_DISPLAY_TV_FORMAT_NONE value.\n!< In case of NvAPI_DISP_SetDisplayConfig(), this field should only be set in case of TVs;\n!< for other displays this field will be ignored and resolution & refresh rate specified in input will be used to apply the TV format."] + pub tvFormat: NV_DISPLAY_TV_FORMAT, + #[doc = "!< Ignored if timingOverride == NV_TIMING_OVERRIDE_CURRENT"] + pub timingOverride: NV_TIMING_OVERRIDE, + #[doc = "!< Scan out timing, valid only if timingOverride == NV_TIMING_OVERRIDE_CUST\n!< The value NV_TIMING::NV_TIMINGEXT::rrx1k is obtained from the EDID. The driver may\n!< tweak this value for HDTV, stereo, etc., before reporting it to the OS."] + pub timing: NV_TIMING, +} +impl _NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO_V1 { + #[inline] + pub fn interlaced(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_interlaced(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn interlaced_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_interlaced_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn primary(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_primary(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn primary_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_primary_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reservedBit1(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_reservedBit1(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn reservedBit1_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reservedBit1_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn disableVirtualModeSupport(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_disableVirtualModeSupport(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn disableVirtualModeSupport_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_disableVirtualModeSupport_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isPreferredUnscaledTarget(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_isPreferredUnscaledTarget(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isPreferredUnscaledTarget_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isPreferredUnscaledTarget_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 27u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 27u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 27u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + interlaced: NvU32, + primary: NvU32, + reservedBit1: NvU32, + disableVirtualModeSupport: NvU32, + isPreferredUnscaledTarget: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let interlaced: u32 = unsafe { ::std::mem::transmute(interlaced) }; + interlaced as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let primary: u32 = unsafe { ::std::mem::transmute(primary) }; + primary as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let reservedBit1: u32 = unsafe { ::std::mem::transmute(reservedBit1) }; + reservedBit1 as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let disableVirtualModeSupport: u32 = + unsafe { ::std::mem::transmute(disableVirtualModeSupport) }; + disableVirtualModeSupport as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let isPreferredUnscaledTarget: u32 = + unsafe { ::std::mem::transmute(isPreferredUnscaledTarget) }; + isPreferredUnscaledTarget as u64 + }); + __bindgen_bitfield_unit.set(5usize, 27u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO_V1 = + _NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO_V1; +#[doc = "! \\ingroup dispcontrol"] +pub type NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO = NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO_V1; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_DISPLAYCONFIG_PATH_TARGET_INFO_V1 { + #[doc = "!< Display ID"] + pub displayId: NvU32, + #[doc = "!< May be NULL if no advanced settings are required. NULL for Non-NVIDIA Display."] + pub details: *mut NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO, +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_DISPLAYCONFIG_PATH_TARGET_INFO_V1 = _NV_DISPLAYCONFIG_PATH_TARGET_INFO_V1; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_DISPLAYCONFIG_PATH_TARGET_INFO_V2 { + #[doc = "!< Display ID"] + pub displayId: NvU32, + #[doc = "!< May be NULL if no advanced settings are required"] + pub details: *mut NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO, + #[doc = "!< Windows CCD target ID. Must be present only for non-NVIDIA adapter, for NVIDIA adapter this parameter is ignored."] + pub targetId: NvU32, +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_DISPLAYCONFIG_PATH_TARGET_INFO_V2 = _NV_DISPLAYCONFIG_PATH_TARGET_INFO_V2; +#[doc = "! \\ingroup dispcontrol\n! As version is not defined for this structure, we will be using version of NV_DISPLAYCONFIG_PATH_INFO"] +pub type NV_DISPLAYCONFIG_PATH_TARGET_INFO = NV_DISPLAYCONFIG_PATH_TARGET_INFO_V2; +pub const _NV_DISPLAYCONFIG_SPANNING_ORIENTATION_NV_DISPLAYCONFIG_SPAN_NONE: + _NV_DISPLAYCONFIG_SPANNING_ORIENTATION = 0; +pub const _NV_DISPLAYCONFIG_SPANNING_ORIENTATION_NV_DISPLAYCONFIG_SPAN_HORIZONTAL: + _NV_DISPLAYCONFIG_SPANNING_ORIENTATION = 1; +pub const _NV_DISPLAYCONFIG_SPANNING_ORIENTATION_NV_DISPLAYCONFIG_SPAN_VERTICAL: + _NV_DISPLAYCONFIG_SPANNING_ORIENTATION = 2; +#[doc = "! \\ingroup dispcontrol"] +pub type _NV_DISPLAYCONFIG_SPANNING_ORIENTATION = ::std::os::raw::c_int; +#[doc = "! \\ingroup dispcontrol"] +pub use self::_NV_DISPLAYCONFIG_SPANNING_ORIENTATION as NV_DISPLAYCONFIG_SPANNING_ORIENTATION; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1 { + pub resolution: NV_RESOLUTION, + #[doc = "!< Ignored at present, must be NV_FORMAT_UNKNOWN (0)"] + pub colorFormat: NV_FORMAT, + #[doc = "!< Is all positions are 0 or invalid, displays will be automatically\n!< positioned from left to right with GDI Primary at 0,0, and all\n!< other displays in the order of the path array."] + pub position: NV_POSITION, + #[doc = "!< Spanning is only supported on XP"] + pub spanningOrientation: NV_DISPLAYCONFIG_SPANNING_ORIENTATION, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl _NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1 { + #[inline] + pub fn bGDIPrimary(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bGDIPrimary(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bGDIPrimary_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bGDIPrimary_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bSLIFocus(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bSLIFocus(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bSLIFocus_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bSLIFocus_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 30u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 30u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 30u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bGDIPrimary: NvU32, + bSLIFocus: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bGDIPrimary: u32 = unsafe { ::std::mem::transmute(bGDIPrimary) }; + bGDIPrimary as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bSLIFocus: u32 = unsafe { ::std::mem::transmute(bSLIFocus) }; + bSLIFocus as u64 + }); + __bindgen_bitfield_unit.set(2usize, 30u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1 = _NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_DISPLAYCONFIG_PATH_INFO_V1 { + pub version: NvU32, + #[doc = "!< This field is reserved. There is ongoing debate if we need this field.\n!< Identifies sourceIds used by Windows. If all sourceIds are 0,\n!< these will be computed automatically."] + pub reserved_sourceId: NvU32, + #[doc = "!< Number of elements in targetInfo array"] + pub targetInfoCount: NvU32, + pub targetInfo: *mut NV_DISPLAYCONFIG_PATH_TARGET_INFO_V1, + #[doc = "!< May be NULL if mode info is not important"] + pub sourceModeInfo: *mut NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1, +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_DISPLAYCONFIG_PATH_INFO_V1 = _NV_DISPLAYCONFIG_PATH_INFO_V1; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_DISPLAYCONFIG_PATH_INFO { + pub version: NvU32, + pub __bindgen_anon_1: _NV_DISPLAYCONFIG_PATH_INFO__bindgen_ty_1, + #[doc = "!< Number of elements in targetInfo array"] + pub targetInfoCount: NvU32, + pub targetInfo: *mut NV_DISPLAYCONFIG_PATH_TARGET_INFO_V2, + #[doc = "!< May be NULL if mode info is not important"] + pub sourceModeInfo: *mut NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Used by Non-NVIDIA adapter for pointer to OS Adapter of LUID\n!< type, type casted to void *."] + pub pOSAdapterID: *mut ::std::os::raw::c_void, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union _NV_DISPLAYCONFIG_PATH_INFO__bindgen_ty_1 { + #[doc = "!< Identifies sourceId used by Windows CCD. This can be optionally set."] + pub sourceId: NvU32, + #[doc = "!< Only for compatibility"] + pub reserved_sourceId: NvU32, +} +impl _NV_DISPLAYCONFIG_PATH_INFO { + #[inline] + pub fn IsNonNVIDIAAdapter(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_IsNonNVIDIAAdapter(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn IsNonNVIDIAAdapter_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_IsNonNVIDIAAdapter_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + IsNonNVIDIAAdapter: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let IsNonNVIDIAAdapter: u32 = unsafe { ::std::mem::transmute(IsNonNVIDIAAdapter) }; + IsNonNVIDIAAdapter as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_DISPLAYCONFIG_PATH_INFO_V2 = _NV_DISPLAYCONFIG_PATH_INFO; +#[doc = "! \\ingroup dispcontrol"] +pub type NV_DISPLAYCONFIG_PATH_INFO = NV_DISPLAYCONFIG_PATH_INFO_V2; +#[doc = "! \\ingroup dispcontrol"] +pub type NV_DISPLAYCONFIG_SOURCE_MODE_INFO = NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1; +pub const _NV_DISPLAYCONFIG_FLAGS_NV_DISPLAYCONFIG_VALIDATE_ONLY: _NV_DISPLAYCONFIG_FLAGS = 1; +pub const _NV_DISPLAYCONFIG_FLAGS_NV_DISPLAYCONFIG_SAVE_TO_PERSISTENCE: _NV_DISPLAYCONFIG_FLAGS = 2; +#[doc = "!< Driver reload is permitted if necessary"] +pub const _NV_DISPLAYCONFIG_FLAGS_NV_DISPLAYCONFIG_DRIVER_RELOAD_ALLOWED: _NV_DISPLAYCONFIG_FLAGS = + 4; +#[doc = "!< Refresh OS mode list."] +pub const _NV_DISPLAYCONFIG_FLAGS_NV_DISPLAYCONFIG_FORCE_MODE_ENUMERATION: _NV_DISPLAYCONFIG_FLAGS = + 8; +#[doc = "!< Tell OS to avoid optimizing CommitVidPn call during a modeset"] +pub const _NV_DISPLAYCONFIG_FLAGS_NV_FORCE_COMMIT_VIDPN: _NV_DISPLAYCONFIG_FLAGS = 16; +#[doc = "! \\ingroup dispcontrol"] +pub type _NV_DISPLAYCONFIG_FLAGS = ::std::os::raw::c_int; +#[doc = "! \\ingroup dispcontrol"] +pub use self::_NV_DISPLAYCONFIG_FLAGS as NV_DISPLAYCONFIG_FLAGS; +pub type NvAPI_UnicodeString = [NvU16; 2048usize]; +pub type NvAPI_LPCWSTR = *const NvU16; +pub const _NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID_NVAPI_GPU_PERF_VOLTAGE_INFO_DOMAIN_CORE: + _NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID = 0; +pub const _NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID_NVAPI_GPU_PERF_VOLTAGE_INFO_DOMAIN_UNDEFINED: + _NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID = 16; +#[doc = "! \\ingroup gpuclock"] +pub type _NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpuclock"] +pub use self::_NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID as NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID; +pub const _NV_GPU_PUBLIC_CLOCK_ID_NVAPI_GPU_PUBLIC_CLOCK_GRAPHICS: _NV_GPU_PUBLIC_CLOCK_ID = 0; +pub const _NV_GPU_PUBLIC_CLOCK_ID_NVAPI_GPU_PUBLIC_CLOCK_MEMORY: _NV_GPU_PUBLIC_CLOCK_ID = 4; +pub const _NV_GPU_PUBLIC_CLOCK_ID_NVAPI_GPU_PUBLIC_CLOCK_PROCESSOR: _NV_GPU_PUBLIC_CLOCK_ID = 7; +pub const _NV_GPU_PUBLIC_CLOCK_ID_NVAPI_GPU_PUBLIC_CLOCK_VIDEO: _NV_GPU_PUBLIC_CLOCK_ID = 8; +pub const _NV_GPU_PUBLIC_CLOCK_ID_NVAPI_GPU_PUBLIC_CLOCK_UNDEFINED: _NV_GPU_PUBLIC_CLOCK_ID = 32; +#[doc = "! \\ingroup gpuclock"] +pub type _NV_GPU_PUBLIC_CLOCK_ID = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpuclock"] +pub use self::_NV_GPU_PUBLIC_CLOCK_ID as NV_GPU_PUBLIC_CLOCK_ID; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P0: _NV_GPU_PERF_PSTATE_ID = 0; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P1: _NV_GPU_PERF_PSTATE_ID = 1; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P2: _NV_GPU_PERF_PSTATE_ID = 2; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P3: _NV_GPU_PERF_PSTATE_ID = 3; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P4: _NV_GPU_PERF_PSTATE_ID = 4; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P5: _NV_GPU_PERF_PSTATE_ID = 5; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P6: _NV_GPU_PERF_PSTATE_ID = 6; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P7: _NV_GPU_PERF_PSTATE_ID = 7; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P8: _NV_GPU_PERF_PSTATE_ID = 8; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P9: _NV_GPU_PERF_PSTATE_ID = 9; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P10: _NV_GPU_PERF_PSTATE_ID = 10; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P11: _NV_GPU_PERF_PSTATE_ID = 11; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P12: _NV_GPU_PERF_PSTATE_ID = 12; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P13: _NV_GPU_PERF_PSTATE_ID = 13; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P14: _NV_GPU_PERF_PSTATE_ID = 14; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P15: _NV_GPU_PERF_PSTATE_ID = 15; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_UNDEFINED: _NV_GPU_PERF_PSTATE_ID = 16; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_ALL: _NV_GPU_PERF_PSTATE_ID = 17; +#[doc = "! \\addtogroup gpupstate\n! @{"] +pub type _NV_GPU_PERF_PSTATE_ID = ::std::os::raw::c_int; +#[doc = "! \\addtogroup gpupstate\n! @{"] +pub use self::_NV_GPU_PERF_PSTATE_ID as NV_GPU_PERF_PSTATE_ID; +#[doc = "! Clock domains that use single frequency value within given pstate"] +pub const NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID_NVAPI_GPU_PERF_PSTATE20_CLOCK_TYPE_SINGLE: + NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID = 0; +#[doc = "! Clock domains that allow range of frequency values within given pstate"] +pub const NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID_NVAPI_GPU_PERF_PSTATE20_CLOCK_TYPE_RANGE: + NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID = 1; +#[doc = "! Used to identify clock type"] +pub type NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID = ::std::os::raw::c_int; +#[doc = "! Used to describe both voltage and frequency deltas"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PERF_PSTATES20_PARAM_DELTA { + #[doc = "! Value of parameter delta (in respective units [kHz, uV])"] + pub value: NvS32, + pub valueRange: NV_GPU_PERF_PSTATES20_PARAM_DELTA__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PERF_PSTATES20_PARAM_DELTA__bindgen_ty_1 { + #[doc = "! Min value allowed for parameter delta (in respective units [kHz, uV])"] + pub min: NvS32, + #[doc = "! Max value allowed for parameter delta (in respective units [kHz, uV])"] + pub max: NvS32, +} +#[doc = "! Used to describe single clock entry"] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct NV_GPU_PSTATE20_CLOCK_ENTRY_V1 { + #[doc = "! ID of the clock domain"] + pub domainId: NV_GPU_PUBLIC_CLOCK_ID, + #[doc = "! Clock type ID"] + pub typeId: NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "! Current frequency delta from nominal settings in (kHz)"] + pub freqDelta_kHz: NV_GPU_PERF_PSTATES20_PARAM_DELTA, + pub data: NV_GPU_PSTATE20_CLOCK_ENTRY_V1__bindgen_ty_1, +} +#[doc = "! Clock domain type dependant information"] +#[repr(C)] +#[derive(Copy, Clone)] +pub union NV_GPU_PSTATE20_CLOCK_ENTRY_V1__bindgen_ty_1 { + pub single: NV_GPU_PSTATE20_CLOCK_ENTRY_V1__bindgen_ty_1__bindgen_ty_1, + pub range: NV_GPU_PSTATE20_CLOCK_ENTRY_V1__bindgen_ty_1__bindgen_ty_2, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PSTATE20_CLOCK_ENTRY_V1__bindgen_ty_1__bindgen_ty_1 { + #[doc = "! Clock frequency within given pstate in (kHz)"] + pub freq_kHz: NvU32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PSTATE20_CLOCK_ENTRY_V1__bindgen_ty_1__bindgen_ty_2 { + #[doc = "! Min clock frequency within given pstate in (kHz)"] + pub minFreq_kHz: NvU32, + #[doc = "! Max clock frequency within given pstate in (kHz)"] + pub maxFreq_kHz: NvU32, + #[doc = "! Voltage domain ID and value range in (uV) required for this clock"] + pub domainId: NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID, + pub minVoltage_uV: NvU32, + pub maxVoltage_uV: NvU32, +} +impl NV_GPU_PSTATE20_CLOCK_ENTRY_V1 { + #[inline] + pub fn bIsEditable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsEditable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsEditable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsEditable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsEditable: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsEditable: u32 = unsafe { ::std::mem::transmute(bIsEditable) }; + bIsEditable as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! Used to describe single base voltage entry"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY_V1 { + #[doc = "! ID of the voltage domain"] + pub domainId: NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "! Current base voltage settings in [uV]"] + pub volt_uV: NvU32, + pub voltDelta_uV: NV_GPU_PERF_PSTATES20_PARAM_DELTA, +} +impl NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY_V1 { + #[inline] + pub fn bIsEditable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsEditable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsEditable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsEditable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsEditable: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsEditable: u32 = unsafe { ::std::mem::transmute(bIsEditable) }; + bIsEditable as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! Used in NvAPI_GPU_GetPstates20() interface call."] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct NV_GPU_PERF_PSTATES20_INFO_V1 { + #[doc = "! Version info of the structure (NV_GPU_PERF_PSTATES20_INFO_VER)"] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "! Number of populated pstates"] + pub numPstates: NvU32, + #[doc = "! Number of populated clocks (per pstate)"] + pub numClocks: NvU32, + #[doc = "! Number of populated base voltages (per pstate)"] + pub numBaseVoltages: NvU32, + pub pstates: [NV_GPU_PERF_PSTATES20_INFO_V1__bindgen_ty_1; 16usize], +} +#[doc = "! Performance state (P-State) settings\n! Valid index range is 0 to numPstates-1"] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct NV_GPU_PERF_PSTATES20_INFO_V1__bindgen_ty_1 { + #[doc = "! ID of the P-State"] + pub pstateId: NV_GPU_PERF_PSTATE_ID, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "! Array of clock entries\n! Valid index range is 0 to numClocks-1"] + pub clocks: [NV_GPU_PSTATE20_CLOCK_ENTRY_V1; 8usize], + #[doc = "! Array of baseVoltage entries\n! Valid index range is 0 to numBaseVoltages-1"] + pub baseVoltages: [NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY_V1; 4usize], +} +impl NV_GPU_PERF_PSTATES20_INFO_V1__bindgen_ty_1 { + #[inline] + pub fn bIsEditable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsEditable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsEditable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsEditable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsEditable: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsEditable: u32 = unsafe { ::std::mem::transmute(bIsEditable) }; + bIsEditable as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +impl NV_GPU_PERF_PSTATES20_INFO_V1 { + #[inline] + pub fn bIsEditable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsEditable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsEditable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsEditable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsEditable: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsEditable: u32 = unsafe { ::std::mem::transmute(bIsEditable) }; + bIsEditable as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! Used in NvAPI_GPU_GetPstates20() interface call."] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_PERF_PSTATES20_INFO_V2 { + #[doc = "! Version info of the structure (NV_GPU_PERF_PSTATES20_INFO_VER)"] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "! Number of populated pstates"] + pub numPstates: NvU32, + #[doc = "! Number of populated clocks (per pstate)"] + pub numClocks: NvU32, + #[doc = "! Number of populated base voltages (per pstate)"] + pub numBaseVoltages: NvU32, + pub pstates: [_NV_GPU_PERF_PSTATES20_INFO_V2__bindgen_ty_1; 16usize], + pub ov: _NV_GPU_PERF_PSTATES20_INFO_V2__bindgen_ty_2, +} +#[doc = "! Performance state (P-State) settings\n! Valid index range is 0 to numPstates-1"] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_PERF_PSTATES20_INFO_V2__bindgen_ty_1 { + #[doc = "! ID of the P-State"] + pub pstateId: NV_GPU_PERF_PSTATE_ID, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "! Array of clock entries\n! Valid index range is 0 to numClocks-1"] + pub clocks: [NV_GPU_PSTATE20_CLOCK_ENTRY_V1; 8usize], + #[doc = "! Array of baseVoltage entries\n! Valid index range is 0 to numBaseVoltages-1"] + pub baseVoltages: [NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY_V1; 4usize], +} +impl _NV_GPU_PERF_PSTATES20_INFO_V2__bindgen_ty_1 { + #[inline] + pub fn bIsEditable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsEditable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsEditable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsEditable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsEditable: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsEditable: u32 = unsafe { ::std::mem::transmute(bIsEditable) }; + bIsEditable as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! OV settings - Please refer to NVIDIA over-volting recommendation to understand impact of this functionality\n! Valid index range is 0 to numVoltages-1"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_PERF_PSTATES20_INFO_V2__bindgen_ty_2 { + #[doc = "! Number of populated voltages"] + pub numVoltages: NvU32, + #[doc = "! Array of voltage entries\n! Valid index range is 0 to numVoltages-1"] + pub voltages: [NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY_V1; 4usize], +} +impl _NV_GPU_PERF_PSTATES20_INFO_V2 { + #[inline] + pub fn bIsEditable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsEditable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsEditable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsEditable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsEditable: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsEditable: u32 = unsafe { ::std::mem::transmute(bIsEditable) }; + bIsEditable as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! Used in NvAPI_GPU_GetPstates20() interface call."] +pub type NV_GPU_PERF_PSTATES20_INFO_V2 = _NV_GPU_PERF_PSTATES20_INFO_V2; +#[doc = "! Used in NvAPI_GPU_GetPstates20() interface call."] +pub type NV_GPU_PERF_PSTATES20_INFO = NV_GPU_PERF_PSTATES20_INFO_V2; +#[doc = "! \\ingroup driverapi\n! Used in NvAPI_GetDisplayDriverVersion()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_DISPLAY_DRIVER_VERSION { + pub version: NvU32, + pub drvVersion: NvU32, + pub bldChangeListNum: NvU32, + pub szBuildBranchString: NvAPI_ShortString, + pub szAdapterString: NvAPI_ShortString, +} +pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_UNINITIALIZED: NV_MONITOR_CONN_TYPE = 0; +pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_VGA: NV_MONITOR_CONN_TYPE = 1; +pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_COMPONENT: NV_MONITOR_CONN_TYPE = 2; +pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_SVIDEO: NV_MONITOR_CONN_TYPE = 3; +pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_HDMI: NV_MONITOR_CONN_TYPE = 4; +pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_DVI: NV_MONITOR_CONN_TYPE = 5; +pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_LVDS: NV_MONITOR_CONN_TYPE = 6; +pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_DP: NV_MONITOR_CONN_TYPE = 7; +pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_COMPOSITE: NV_MONITOR_CONN_TYPE = 8; +pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_UNKNOWN: NV_MONITOR_CONN_TYPE = -1; +#[doc = "! \\ingroup gpu"] +pub type NV_MONITOR_CONN_TYPE = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_DISPLAYIDS { + pub version: NvU32, + #[doc = "!< out: vga, tv, dvi, hdmi and dp. This is reserved for future use and clients should not rely on this information. Instead get the\n!< GPU connector type from NvAPI_GPU_GetConnectorInfo/NvAPI_GPU_GetConnectorInfoEx"] + pub connectorType: NV_MONITOR_CONN_TYPE, + #[doc = "!< this is a unique identifier for each device"] + pub displayId: NvU32, + pub _bitfield_align_1: [u16; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl _NV_GPU_DISPLAYIDS { + #[inline] + pub fn isDynamic(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isDynamic(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isDynamic_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isDynamic_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMultiStreamRootNode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMultiStreamRootNode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMultiStreamRootNode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMultiStreamRootNode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isActive(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_isActive(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isActive_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isActive_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isCluster(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_isCluster(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isCluster_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isCluster_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isOSVisible(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_isOSVisible(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isOSVisible_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isOSVisible_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isWFD(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_isWFD(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isWFD_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isWFD_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isConnected(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } + } + #[inline] + pub fn set_isConnected(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isConnected_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 6usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isConnected_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reservedInternal(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 10u8) as u32) } + } + #[inline] + pub fn set_reservedInternal(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 10u8, val as u64) + } + } + #[inline] + pub unsafe fn reservedInternal_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 7usize, + 10u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reservedInternal_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 7usize, + 10u8, + val as u64, + ) + } + } + #[inline] + pub fn isPhysicallyConnected(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) } + } + #[inline] + pub fn set_isPhysicallyConnected(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(17usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isPhysicallyConnected_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 17usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isPhysicallyConnected_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 17usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 14u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(18usize, 14u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 18usize, + 14u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 18usize, + 14u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isDynamic: NvU32, + isMultiStreamRootNode: NvU32, + isActive: NvU32, + isCluster: NvU32, + isOSVisible: NvU32, + isWFD: NvU32, + isConnected: NvU32, + reservedInternal: NvU32, + isPhysicallyConnected: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isDynamic: u32 = unsafe { ::std::mem::transmute(isDynamic) }; + isDynamic as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isMultiStreamRootNode: u32 = + unsafe { ::std::mem::transmute(isMultiStreamRootNode) }; + isMultiStreamRootNode as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let isActive: u32 = unsafe { ::std::mem::transmute(isActive) }; + isActive as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let isCluster: u32 = unsafe { ::std::mem::transmute(isCluster) }; + isCluster as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let isOSVisible: u32 = unsafe { ::std::mem::transmute(isOSVisible) }; + isOSVisible as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let isWFD: u32 = unsafe { ::std::mem::transmute(isWFD) }; + isWFD as u64 + }); + __bindgen_bitfield_unit.set(6usize, 1u8, { + let isConnected: u32 = unsafe { ::std::mem::transmute(isConnected) }; + isConnected as u64 + }); + __bindgen_bitfield_unit.set(7usize, 10u8, { + let reservedInternal: u32 = unsafe { ::std::mem::transmute(reservedInternal) }; + reservedInternal as u64 + }); + __bindgen_bitfield_unit.set(17usize, 1u8, { + let isPhysicallyConnected: u32 = + unsafe { ::std::mem::transmute(isPhysicallyConnected) }; + isPhysicallyConnected as u64 + }); + __bindgen_bitfield_unit.set(18usize, 14u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup gpu"] +pub type NV_GPU_DISPLAYIDS = _NV_GPU_DISPLAYIDS; +pub const NV_SYSTEM_TYPE_NV_SYSTEM_TYPE_UNKNOWN: NV_SYSTEM_TYPE = 0; +pub const NV_SYSTEM_TYPE_NV_SYSTEM_TYPE_LAPTOP: NV_SYSTEM_TYPE = 1; +pub const NV_SYSTEM_TYPE_NV_SYSTEM_TYPE_DESKTOP: NV_SYSTEM_TYPE = 2; +#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetSystemType()"] +pub type NV_SYSTEM_TYPE = ::std::os::raw::c_int; +pub const _NV_GPU_OUTPUT_TYPE_NVAPI_GPU_OUTPUT_UNKNOWN: _NV_GPU_OUTPUT_TYPE = 0; +#[doc = "!< CRT display device"] +pub const _NV_GPU_OUTPUT_TYPE_NVAPI_GPU_OUTPUT_CRT: _NV_GPU_OUTPUT_TYPE = 1; +#[doc = "!< Digital Flat Panel display device"] +pub const _NV_GPU_OUTPUT_TYPE_NVAPI_GPU_OUTPUT_DFP: _NV_GPU_OUTPUT_TYPE = 2; +#[doc = "!< TV display device"] +pub const _NV_GPU_OUTPUT_TYPE_NVAPI_GPU_OUTPUT_TV: _NV_GPU_OUTPUT_TYPE = 3; +#[doc = "! \\ingroup gpu\n! used in NvAPI_GPU_GetOutputType()"] +pub type _NV_GPU_OUTPUT_TYPE = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpu\n! used in NvAPI_GPU_GetOutputType()"] +pub use self::_NV_GPU_OUTPUT_TYPE as NV_GPU_OUTPUT_TYPE; +pub const _NV_GPU_TYPE_NV_SYSTEM_TYPE_GPU_UNKNOWN: _NV_GPU_TYPE = 0; +#[doc = "!< Integrated GPU"] +pub const _NV_GPU_TYPE_NV_SYSTEM_TYPE_IGPU: _NV_GPU_TYPE = 1; +#[doc = "!< Discrete GPU"] +pub const _NV_GPU_TYPE_NV_SYSTEM_TYPE_DGPU: _NV_GPU_TYPE = 2; +#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetGPUType()."] +pub type _NV_GPU_TYPE = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetGPUType()."] +pub use self::_NV_GPU_TYPE as NV_GPU_TYPE; +pub const _NV_GPU_BUS_TYPE_NVAPI_GPU_BUS_TYPE_UNDEFINED: _NV_GPU_BUS_TYPE = 0; +pub const _NV_GPU_BUS_TYPE_NVAPI_GPU_BUS_TYPE_PCI: _NV_GPU_BUS_TYPE = 1; +pub const _NV_GPU_BUS_TYPE_NVAPI_GPU_BUS_TYPE_AGP: _NV_GPU_BUS_TYPE = 2; +pub const _NV_GPU_BUS_TYPE_NVAPI_GPU_BUS_TYPE_PCI_EXPRESS: _NV_GPU_BUS_TYPE = 3; +pub const _NV_GPU_BUS_TYPE_NVAPI_GPU_BUS_TYPE_FPCI: _NV_GPU_BUS_TYPE = 4; +pub const _NV_GPU_BUS_TYPE_NVAPI_GPU_BUS_TYPE_AXI: _NV_GPU_BUS_TYPE = 5; +#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetBusType()"] +pub type _NV_GPU_BUS_TYPE = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetBusType()"] +pub use self::_NV_GPU_BUS_TYPE as NV_GPU_BUS_TYPE; +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_BOARD_INFO { + #[doc = "!< structure version"] + pub version: NvU32, + #[doc = "!< Board Serial Number"] + pub BoardNum: [NvU8; 16usize], +} +#[doc = "! \\ingroup gpu"] +pub type NV_BOARD_INFO_V1 = _NV_BOARD_INFO; +#[doc = "! \\ingroup gpu"] +pub type NV_BOARD_INFO = NV_BOARD_INFO_V1; +#[doc = "! Used in NvAPI_GPU_GetArchInfo()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_ARCH_INFO_V1 { + pub version: NvU32, + pub architecture: NvU32, + pub implementation: NvU32, + pub revision: NvU32, +} +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_T2X: _NV_GPU_ARCHITECTURE_ID = -536870880; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_T3X: _NV_GPU_ARCHITECTURE_ID = -536870864; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_T4X: _NV_GPU_ARCHITECTURE_ID = -536870848; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_T12X: _NV_GPU_ARCHITECTURE_ID = -536870848; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_NV40: _NV_GPU_ARCHITECTURE_ID = 64; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_NV50: _NV_GPU_ARCHITECTURE_ID = 80; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_G78: _NV_GPU_ARCHITECTURE_ID = 96; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_G80: _NV_GPU_ARCHITECTURE_ID = 128; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_G90: _NV_GPU_ARCHITECTURE_ID = 144; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GT200: _NV_GPU_ARCHITECTURE_ID = 160; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GF100: _NV_GPU_ARCHITECTURE_ID = 192; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GF110: _NV_GPU_ARCHITECTURE_ID = 208; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GK100: _NV_GPU_ARCHITECTURE_ID = 224; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GK110: _NV_GPU_ARCHITECTURE_ID = 240; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GK200: _NV_GPU_ARCHITECTURE_ID = 256; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GM000: _NV_GPU_ARCHITECTURE_ID = 272; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GM200: _NV_GPU_ARCHITECTURE_ID = 288; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GP100: _NV_GPU_ARCHITECTURE_ID = 304; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GV100: _NV_GPU_ARCHITECTURE_ID = 320; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GV110: _NV_GPU_ARCHITECTURE_ID = 336; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_TU100: _NV_GPU_ARCHITECTURE_ID = 352; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GA100: _NV_GPU_ARCHITECTURE_ID = 368; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_AD100: _NV_GPU_ARCHITECTURE_ID = 400; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GB200: _NV_GPU_ARCHITECTURE_ID = 432; +#[doc = "! NV_GPU_ARCH_INFO() values to identify Architecture level for the GPU."] +pub type _NV_GPU_ARCHITECTURE_ID = ::std::os::raw::c_int; +#[doc = "! NV_GPU_ARCH_INFO() values to identify Architecture level for the GPU."] +pub use self::_NV_GPU_ARCHITECTURE_ID as NV_GPU_ARCHITECTURE_ID; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_T20: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_T30: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_T35: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 5; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_T40: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_T124: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV40: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV41: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 1; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV42: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV43: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 3; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV44: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV44A: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 10; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV46: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV47: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 7; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV49: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 9; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV4B: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 11; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV4C: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 12; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV4E: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 14; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV50: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV63: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 3; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV67: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 7; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_G84: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_G86: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_G92: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_G94: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_G96: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_G98: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 8; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT200: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT212: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT214: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT215: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 3; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT216: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 5; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT218: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 8; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_MCP77: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 10; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT21C: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 11; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_MCP79: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 12; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT21A: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 13; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_MCP89: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 15; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF100: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF104: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF106: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 3; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF108: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 1; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF110: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF116: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF117: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 7; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF118: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 8; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF119: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 9; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GK104: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GK106: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GK107: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 7; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GK20A: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 10; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GK110: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GK208: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 8; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GM204: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GM206: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP100: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP000: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 1; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP102: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP104: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP106: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP107: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 7; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP108: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 8; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GV100: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GV10B: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 11; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU100: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU102: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU104: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU106: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU116: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 8; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU117: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 7; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU000: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 1; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GA100: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GA102: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GA104: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_AD102: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_AD103: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 3; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_AD104: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GB202: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; +#[doc = "! NV_GPU_ARCH_INFO() values to identify GPU Architecture Implementation."] +pub type _NV_GPU_ARCH_IMPLEMENTATION_ID = ::std::os::raw::c_int; +#[doc = "! NV_GPU_ARCH_INFO() values to identify GPU Architecture Implementation."] +pub use self::_NV_GPU_ARCH_IMPLEMENTATION_ID as NV_GPU_ARCH_IMPLEMENTATION_ID; +#[doc = "!< QT chip"] +pub const _NV_GPU_CHIP_REVISION_NV_GPU_CHIP_REV_EMULATION_QT: _NV_GPU_CHIP_REVISION = 0; +#[doc = "!< FPGA implementation of the chipset"] +pub const _NV_GPU_CHIP_REVISION_NV_GPU_CHIP_REV_EMULATION_FPGA: _NV_GPU_CHIP_REVISION = 1; +#[doc = "!< First silicon chipset revision"] +pub const _NV_GPU_CHIP_REVISION_NV_GPU_CHIP_REV_A01: _NV_GPU_CHIP_REVISION = 17; +#[doc = "!< Second Silicon chipset revision"] +pub const _NV_GPU_CHIP_REVISION_NV_GPU_CHIP_REV_A02: _NV_GPU_CHIP_REVISION = 18; +#[doc = "!< Third Silicon chipset revision"] +pub const _NV_GPU_CHIP_REVISION_NV_GPU_CHIP_REV_A03: _NV_GPU_CHIP_REVISION = 19; +#[doc = "!< Unknown chip revision"] +pub const _NV_GPU_CHIP_REVISION_NV_GPU_CHIP_REV_UNKNOWN: _NV_GPU_CHIP_REVISION = -1; +pub type _NV_GPU_CHIP_REVISION = ::std::os::raw::c_int; +pub use self::_NV_GPU_CHIP_REVISION as NV_GPU_CHIP_REVISION; +#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetArchInfo()"] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct NV_GPU_ARCH_INFO_V2 { + pub version: NvU32, + pub __bindgen_anon_1: NV_GPU_ARCH_INFO_V2__bindgen_ty_1, + pub __bindgen_anon_2: NV_GPU_ARCH_INFO_V2__bindgen_ty_2, + pub __bindgen_anon_3: NV_GPU_ARCH_INFO_V2__bindgen_ty_3, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union NV_GPU_ARCH_INFO_V2__bindgen_ty_1 { + #[doc = "!< architecture and architecture_id are the same. The former is NvU32 while the latter is an enum made for readability."] + pub architecture: NvU32, + #[doc = "!< specifies the architecture level for the GPU."] + pub architecture_id: NV_GPU_ARCHITECTURE_ID, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union NV_GPU_ARCH_INFO_V2__bindgen_ty_2 { + #[doc = "!< implementation and implementation_id are the same. The former is NvU32 while the latter is an enum made for readability."] + pub implementation: NvU32, + #[doc = "!< specifies the implementation of the architecture for the GPU."] + pub implementation_id: NV_GPU_ARCH_IMPLEMENTATION_ID, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union NV_GPU_ARCH_INFO_V2__bindgen_ty_3 { + #[doc = "!< revision and revision_id are the same. The former is NvU32 while the latter is an enum made for readability."] + pub revision: NvU32, + #[doc = "!< specifies the architecture revision of the GPU."] + pub revision_id: NV_GPU_CHIP_REVISION, +} +#[doc = "! \\ingroup gpu"] +pub type NV_GPU_ARCH_INFO = NV_GPU_ARCH_INFO_V2; +#[doc = "!< Set i2cSpeedKhz to I2C_SPEED_DEFAULT if default I2C speed is to be chosen, ie.use the current frequency setting."] +pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_DEFAULT: NV_I2C_SPEED = 0; +pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_3KHZ: NV_I2C_SPEED = 1; +pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_10KHZ: NV_I2C_SPEED = 2; +pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_33KHZ: NV_I2C_SPEED = 3; +pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_100KHZ: NV_I2C_SPEED = 4; +pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_200KHZ: NV_I2C_SPEED = 5; +pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_400KHZ: NV_I2C_SPEED = 6; +pub type NV_I2C_SPEED = ::std::os::raw::c_int; +#[doc = "! Used in NvAPI_I2CRead() and NvAPI_I2CWrite()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_I2C_INFO_V1 { + #[doc = "!< The structure version."] + pub version: NvU32, + #[doc = "!< The Display Mask of the concerned display."] + pub displayMask: NvU32, + #[doc = "!< This flag indicates either the DDC port (TRUE) or the communication port\n!< (FALSE) of the concerned display."] + pub bIsDDCPort: NvU8, + #[doc = "!< The address of the I2C slave. The address should be shifted left by one. For\n!< example, the I2C address 0x50, often used for reading EDIDs, would be stored\n!< here as 0xA0. This matches the position within the byte sent by the master, as\n!< the last bit is reserved to specify the read or write direction."] + pub i2cDevAddress: NvU8, + #[doc = "!< The I2C target register address. May be NULL, which indicates no register\n!< address should be sent."] + pub pbI2cRegAddress: *mut NvU8, + #[doc = "!< The size in bytes of target register address. If pbI2cRegAddress is NULL, this\n!< field must be 0."] + pub regAddrSize: NvU32, + #[doc = "!< The buffer of data which is to be read or written (depending on the command)."] + pub pbData: *mut NvU8, + #[doc = "!< The size of the data buffer, pbData, to be read or written."] + pub cbSize: NvU32, + #[doc = "!< The target speed of the transaction (between 28Kbps to 40Kbps; not guaranteed)."] + pub i2cSpeed: NvU32, +} +#[doc = "! Used in NvAPI_I2CRead() and NvAPI_I2CWrite()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_I2C_INFO_V2 { + #[doc = "!< The structure version."] + pub version: NvU32, + #[doc = "!< The Display Mask of the concerned display."] + pub displayMask: NvU32, + #[doc = "!< This flag indicates either the DDC port (TRUE) or the communication port\n!< (FALSE) of the concerned display."] + pub bIsDDCPort: NvU8, + #[doc = "!< The address of the I2C slave. The address should be shifted left by one. For\n!< example, the I2C address 0x50, often used for reading EDIDs, would be stored\n!< here as 0xA0. This matches the position within the byte sent by the master, as\n!< the last bit is reserved to specify the read or write direction."] + pub i2cDevAddress: NvU8, + #[doc = "!< The I2C target register address. May be NULL, which indicates no register\n!< address should be sent."] + pub pbI2cRegAddress: *mut NvU8, + #[doc = "!< The size in bytes of target register address. If pbI2cRegAddress is NULL, this\n!< field must be 0."] + pub regAddrSize: NvU32, + #[doc = "!< The buffer of data which is to be read or written (depending on the command)."] + pub pbData: *mut NvU8, + #[doc = "!< The size of the data buffer, pbData, to be read or written."] + pub cbSize: NvU32, + #[doc = "!< Deprecated, Must be set to NVAPI_I2C_SPEED_DEPRECATED."] + pub i2cSpeed: NvU32, + #[doc = "!< The target speed of the transaction in (kHz) (Chosen from the enum NV_I2C_SPEED)."] + pub i2cSpeedKhz: NV_I2C_SPEED, +} +#[doc = "! Used in NvAPI_I2CRead() and NvAPI_I2CWrite()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_I2C_INFO_V3 { + #[doc = "!< The structure version."] + pub version: NvU32, + #[doc = "!< The Display Mask of the concerned display."] + pub displayMask: NvU32, + #[doc = "!< This flag indicates either the DDC port (TRUE) or the communication port\n!< (FALSE) of the concerned display."] + pub bIsDDCPort: NvU8, + #[doc = "!< The address of the I2C slave. The address should be shifted left by one. For\n!< example, the I2C address 0x50, often used for reading EDIDs, would be stored\n!< here as 0xA0. This matches the position within the byte sent by the master, as\n!< the last bit is reserved to specify the read or write direction."] + pub i2cDevAddress: NvU8, + #[doc = "!< The I2C target register address. May be NULL, which indicates no register\n!< address should be sent."] + pub pbI2cRegAddress: *mut NvU8, + #[doc = "!< The size in bytes of target register address. If pbI2cRegAddress is NULL, this\n!< field must be 0."] + pub regAddrSize: NvU32, + #[doc = "!< The buffer of data which is to be read or written (depending on the command)."] + pub pbData: *mut NvU8, + #[doc = "!< The size of the data buffer, pbData, to be read or written."] + pub cbSize: NvU32, + #[doc = "!< Deprecated, Must be set to NVAPI_I2C_SPEED_DEPRECATED."] + pub i2cSpeed: NvU32, + #[doc = "!< The target speed of the transaction in (kHz) (Chosen from the enum NV_I2C_SPEED)."] + pub i2cSpeedKhz: NV_I2C_SPEED, + #[doc = "!< The portid on which device is connected (remember to set bIsPortIdSet if this value is set)\n!< Optional for pre-Kepler"] + pub portId: NvU8, + #[doc = "!< set this flag on if and only if portid value is set"] + pub bIsPortIdSet: NvU32, +} +#[doc = "! Used in NvAPI_I2CRead() and NvAPI_I2CWrite()"] +pub type NV_I2C_INFO = NV_I2C_INFO_V3; +pub const _NV_GPU_HDCP_FUSE_STATE_NV_GPU_HDCP_FUSE_STATE_UNKNOWN: _NV_GPU_HDCP_FUSE_STATE = 0; +pub const _NV_GPU_HDCP_FUSE_STATE_NV_GPU_HDCP_FUSE_STATE_DISABLED: _NV_GPU_HDCP_FUSE_STATE = 1; +pub const _NV_GPU_HDCP_FUSE_STATE_NV_GPU_HDCP_FUSE_STATE_ENABLED: _NV_GPU_HDCP_FUSE_STATE = 2; +#[doc = "! HDCP fuse states - used in NV_GPU_GET_HDCP_SUPPORT_STATUS"] +pub type _NV_GPU_HDCP_FUSE_STATE = ::std::os::raw::c_int; +#[doc = "! HDCP fuse states - used in NV_GPU_GET_HDCP_SUPPORT_STATUS"] +pub use self::_NV_GPU_HDCP_FUSE_STATE as NV_GPU_HDCP_FUSE_STATE; +pub const _NV_GPU_HDCP_KEY_SOURCE_NV_GPU_HDCP_KEY_SOURCE_UNKNOWN: _NV_GPU_HDCP_KEY_SOURCE = 0; +pub const _NV_GPU_HDCP_KEY_SOURCE_NV_GPU_HDCP_KEY_SOURCE_NONE: _NV_GPU_HDCP_KEY_SOURCE = 1; +pub const _NV_GPU_HDCP_KEY_SOURCE_NV_GPU_HDCP_KEY_SOURCE_CRYPTO_ROM: _NV_GPU_HDCP_KEY_SOURCE = 2; +pub const _NV_GPU_HDCP_KEY_SOURCE_NV_GPU_HDCP_KEY_SOURCE_SBIOS: _NV_GPU_HDCP_KEY_SOURCE = 3; +pub const _NV_GPU_HDCP_KEY_SOURCE_NV_GPU_HDCP_KEY_SOURCE_I2C_ROM: _NV_GPU_HDCP_KEY_SOURCE = 4; +pub const _NV_GPU_HDCP_KEY_SOURCE_NV_GPU_HDCP_KEY_SOURCE_FUSES: _NV_GPU_HDCP_KEY_SOURCE = 5; +#[doc = "! HDCP key sources - used in NV_GPU_GET_HDCP_SUPPORT_STATUS"] +pub type _NV_GPU_HDCP_KEY_SOURCE = ::std::os::raw::c_int; +#[doc = "! HDCP key sources - used in NV_GPU_GET_HDCP_SUPPORT_STATUS"] +pub use self::_NV_GPU_HDCP_KEY_SOURCE as NV_GPU_HDCP_KEY_SOURCE; +pub const _NV_GPU_HDCP_KEY_SOURCE_STATE_NV_GPU_HDCP_KEY_SOURCE_STATE_UNKNOWN: + _NV_GPU_HDCP_KEY_SOURCE_STATE = 0; +pub const _NV_GPU_HDCP_KEY_SOURCE_STATE_NV_GPU_HDCP_KEY_SOURCE_STATE_ABSENT: + _NV_GPU_HDCP_KEY_SOURCE_STATE = 1; +pub const _NV_GPU_HDCP_KEY_SOURCE_STATE_NV_GPU_HDCP_KEY_SOURCE_STATE_PRESENT: + _NV_GPU_HDCP_KEY_SOURCE_STATE = 2; +#[doc = "! HDCP key source states - used in NV_GPU_GET_HDCP_SUPPORT_STATUS"] +pub type _NV_GPU_HDCP_KEY_SOURCE_STATE = ::std::os::raw::c_int; +#[doc = "! HDCP key source states - used in NV_GPU_GET_HDCP_SUPPORT_STATUS"] +pub use self::_NV_GPU_HDCP_KEY_SOURCE_STATE as NV_GPU_HDCP_KEY_SOURCE_STATE; +#[doc = "! HDPC support status - used in NvAPI_GPU_GetHDCPSupportStatus()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_GET_HDCP_SUPPORT_STATUS { + pub version: NvU32, + #[doc = "! Structure version constucted by macro #NV_GPU_GET_HDCP_SUPPORT_STATUS"] + pub hdcpFuseState: NV_GPU_HDCP_FUSE_STATE, + #[doc = "! GPU's HDCP fuse state"] + pub hdcpKeySource: NV_GPU_HDCP_KEY_SOURCE, + #[doc = "! GPU's HDCP key source"] + pub hdcpKeySourceState: NV_GPU_HDCP_KEY_SOURCE_STATE, +} +#[doc = "! @}"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_COMPUTE_GPU_TOPOLOGY_V1 { + #[doc = "!< Structure version"] + pub version: NvU32, + #[doc = "!< Total number of compute-capable GPUs"] + pub gpuCount: NvU32, + #[doc = "!< Array of compute-capable physical GPUs."] + pub computeGpus: [NV_COMPUTE_GPU_TOPOLOGY_V1__bindgen_ty_1; 8usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_COMPUTE_GPU_TOPOLOGY_V1__bindgen_ty_1 { + #[doc = "!< Compute-capable physical GPU handle"] + pub hPhysicalGpu: NvPhysicalGpuHandle, + #[doc = "!< One or more flags from \\ref nvcomp_gpu_top"] + pub flags: NvU32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COMPUTE_GPU { + #[doc = "!< Compute-capable physical GPU handle"] + pub hPhysicalGpu: NvPhysicalGpuHandle, + #[doc = "!< One or more flags from \\ref nvcomp_gpu_top"] + pub flags: NvU32, +} +pub type NV_COMPUTE_GPU = _NV_COMPUTE_GPU; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COMPUTE_GPU_TOPOLOGY_V2 { + #[doc = "!< Structure version"] + pub version: NvU32, + #[doc = "!< Size of array"] + pub gpuCount: NvU32, + #[doc = "!< Array of compute-capable physical GPUs (allocate memory of size of Physical gpuCount of system)."] + pub computeGpus: *mut NV_COMPUTE_GPU, +} +pub type NV_COMPUTE_GPU_TOPOLOGY_V2 = _NV_COMPUTE_GPU_TOPOLOGY_V2; +pub type NV_COMPUTE_GPU_TOPOLOGY = NV_COMPUTE_GPU_TOPOLOGY_V2; +pub const _NV_ECC_CONFIGURATION_NV_ECC_CONFIGURATION_NOT_SUPPORTED: _NV_ECC_CONFIGURATION = 0; +#[doc = "!< Changes require a POST to take effect"] +pub const _NV_ECC_CONFIGURATION_NV_ECC_CONFIGURATION_DEFERRED: _NV_ECC_CONFIGURATION = 1; +#[doc = "!< Changes can optionally be made to take effect immediately"] +pub const _NV_ECC_CONFIGURATION_NV_ECC_CONFIGURATION_IMMEDIATE: _NV_ECC_CONFIGURATION = 2; +#[doc = "! \\addtogroup gpuecc\n! Used in NV_GPU_ECC_STATUS_INFO."] +pub type _NV_ECC_CONFIGURATION = ::std::os::raw::c_int; +#[doc = "! \\addtogroup gpuecc\n! Used in NV_GPU_ECC_STATUS_INFO."] +pub use self::_NV_ECC_CONFIGURATION as NV_ECC_CONFIGURATION; +#[doc = "! \\ingroup gpuecc\n! Used in NvAPI_GPU_GetECCStatusInfo()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_ECC_STATUS_INFO { + #[doc = "!< Structure version"] + pub version: NvU32, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + #[doc = "!< Supported ECC memory feature configuration options"] + pub configurationOptions: NV_ECC_CONFIGURATION, + pub _bitfield_align_2: [u8; 0], + pub _bitfield_2: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +impl NV_GPU_ECC_STATUS_INFO { + #[inline] + pub fn isSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1(isSupported: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isSupported: u32 = unsafe { ::std::mem::transmute(isSupported) }; + isSupported as u64 + }); + __bindgen_bitfield_unit + } + #[inline] + pub fn isEnabled(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isEnabled(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_2.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isEnabled_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_2), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isEnabled_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_2(isEnabled: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isEnabled: u32 = unsafe { ::std::mem::transmute(isEnabled) }; + isEnabled as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup gpuecc\n! Used in NvAPI_GPU_GetECCErrorInfo()/"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_ECC_ERROR_INFO { + #[doc = "!< Structure version"] + pub version: NvU32, + pub current: NV_GPU_ECC_ERROR_INFO__bindgen_ty_1, + pub aggregate: NV_GPU_ECC_ERROR_INFO__bindgen_ty_2, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_ECC_ERROR_INFO__bindgen_ty_1 { + #[doc = "!< Number of single-bit ECC errors detected since last boot"] + pub singleBitErrors: NvU64, + #[doc = "!< Number of double-bit ECC errors detected since last boot"] + pub doubleBitErrors: NvU64, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_ECC_ERROR_INFO__bindgen_ty_2 { + #[doc = "!< Number of single-bit ECC errors detected since last counter reset"] + pub singleBitErrors: NvU64, + #[doc = "!< Number of double-bit ECC errors detected since last counter reset"] + pub doubleBitErrors: NvU64, +} +#[doc = "! \\ingroup gpuecc\n! Used in NvAPI_GPU_GetECCConfigurationInfo()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_ECC_CONFIGURATION_INFO { + pub version: NvU32, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +impl NV_GPU_ECC_CONFIGURATION_INFO { + #[inline] + pub fn isEnabled(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isEnabled(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isEnabled_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isEnabled_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isEnabledByDefault(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isEnabledByDefault(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isEnabledByDefault_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isEnabledByDefault_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isEnabled: NvU32, + isEnabledByDefault: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isEnabled: u32 = unsafe { ::std::mem::transmute(isEnabled) }; + isEnabled as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isEnabledByDefault: u32 = unsafe { ::std::mem::transmute(isEnabledByDefault) }; + isEnabledByDefault as u64 + }); + __bindgen_bitfield_unit + } +} +pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_NONE: NV_QSYNC_EVENT = 0; +pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_SYNC_LOSS: NV_QSYNC_EVENT = 1; +pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_SYNC_GAIN: NV_QSYNC_EVENT = 2; +pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_HOUSESYNC_GAIN: NV_QSYNC_EVENT = 3; +pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_HOUSESYNC_LOSS: NV_QSYNC_EVENT = 4; +pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_RJ45_GAIN: NV_QSYNC_EVENT = 5; +pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_RJ45_LOSS: NV_QSYNC_EVENT = 6; +pub type NV_QSYNC_EVENT = ::std::os::raw::c_int; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_QSYNC_EVENT_DATA { + pub qsyncEvent: NV_QSYNC_EVENT, + pub reserved: [NvU32; 7usize], +} +#[doc = "! Callback for QSYNC event"] +pub type NVAPI_CALLBACK_QSYNCEVENT = ::std::option::Option< + unsafe extern "C" fn( + qyncEventData: NV_QSYNC_EVENT_DATA, + callbackParam: *mut ::std::os::raw::c_void, + ), +>; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_DISPLAY_OUTPUT_MODE_CHANGE_EVENT_DATA { + #[doc = "!< displayId of the display"] + pub displayId: NvU32, + #[doc = "!< display output mode"] + pub outputMode: NvU32, +} +pub type NV_DISPLAY_OUTPUT_MODE_CHANGE_EVENT_DATA = _NV_DISPLAY_OUTPUT_MODE_CHANGE_EVENT_DATA; +#[doc = "! Callback for Display Output Mode change events"] +pub type NVAPI_CALLBACK_DISPLAY_OUTPUT_MODE_CHANGE_EVENT = ::std::option::Option< + unsafe extern "C" fn( + pEventData: *mut NV_DISPLAY_OUTPUT_MODE_CHANGE_EVENT_DATA, + callbackParam: *mut ::std::os::raw::c_void, + ), +>; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_DISPLAY_COLORIMETRY_CHANGE_EVENT_DATA { + #[doc = "!< displayId of the monitor"] + pub displayId: NvU32, + #[doc = "!< min luminance, cd/m^2"] + pub min_luminance: f32, + #[doc = "!< max 100% frame luminance, cd/m^2"] + pub max_full_frame_luminance: f32, + #[doc = "!< max 10% frame luminance, cd/m^2"] + pub max_luminance: f32, + #[doc = "!< HDR brightness luminance scaling factor applied by GPU on output pixels"] + pub hdrBrightnessLuminanceScalingFactor: f32, + #[doc = "!< red primary chromaticity coordinate x"] + pub red_primary_x: f32, + #[doc = "!< red primary chromaticity coordinate y"] + pub red_primary_y: f32, + #[doc = "!< green primary chromaticity coordinate x"] + pub green_primary_x: f32, + #[doc = "!< green primary chromaticity coordinate y"] + pub green_primary_y: f32, + #[doc = "!< blue primary chromaticity coordinate x"] + pub blue_primary_x: f32, + #[doc = "!< blue primary chromaticity coordinate y"] + pub blue_primary_y: f32, + #[doc = "!< white point chromaticity coordinate x"] + pub white_point_x: f32, + #[doc = "!< white point chromaticity coordinate y"] + pub white_point_y: f32, +} +pub type NV_DISPLAY_COLORIMETRY_CHANGE_EVENT_DATA = _NV_DISPLAY_COLORIMETRY_CHANGE_EVENT_DATA; +#[doc = "! Callback for Display Colorimetry change events"] +pub type NVAPI_CALLBACK_DISPLAY_COLORIMETRY_CHANGE_EVENT = ::std::option::Option< + unsafe extern "C" fn( + pEventData: *mut NV_DISPLAY_COLORIMETRY_CHANGE_EVENT_DATA, + callbackParam: *mut ::std::os::raw::c_void, + ), +>; +pub const NV_EVENT_TYPE_NV_EVENT_TYPE_NONE: NV_EVENT_TYPE = 0; +pub const NV_EVENT_TYPE_NV_EVENT_TYPE_QSYNC: NV_EVENT_TYPE = 6; +pub const NV_EVENT_TYPE_NV_EVENT_TYPE_DISPLAY_OUTPUT_MODE_CHANGE: NV_EVENT_TYPE = 103; +pub const NV_EVENT_TYPE_NV_EVENT_TYPE_DISPLAY_COLORIMETRY_CHANGE: NV_EVENT_TYPE = 104; +#[doc = "! Enum for Event IDs"] +pub type NV_EVENT_TYPE = ::std::os::raw::c_int; +#[doc = "! Core NV_EVENT_REGISTER_CALLBACK structure declaration"] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct NV_EVENT_REGISTER_CALLBACK { + #[doc = "!< version field to ensure minimum version compatibility"] + pub version: NvU32, + #[doc = "!< ID of the event being sent"] + pub eventId: NV_EVENT_TYPE, + #[doc = "!< This value will be passed back to the callback function when an event occurs"] + pub callbackParam: *mut ::std::os::raw::c_void, + pub nvCallBackFunc: NV_EVENT_REGISTER_CALLBACK__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union NV_EVENT_REGISTER_CALLBACK__bindgen_ty_1 { + #[doc = "!< Callback function pointer for QSYNC events"] + pub nvQSYNCEventCallback: NVAPI_CALLBACK_QSYNCEVENT, + #[doc = "!< Callback function pointer for Display Output Mode change events"] + pub nvDisplayOutputModeChangeEventCallback: NVAPI_CALLBACK_DISPLAY_OUTPUT_MODE_CHANGE_EVENT, + #[doc = "!< Callback function pointer for Display Colorimetry change events"] + pub nvDisplayColorimetryChangeEventCallback: NVAPI_CALLBACK_DISPLAY_COLORIMETRY_CHANGE_EVENT, +} +#[doc = "!< NVIDIA RTX VR Ready"] +pub const _NV_GPU_WORKSTATION_FEATURE_TYPE_NV_GPU_WORKSTATION_FEATURE_TYPE_NVIDIA_RTX_VR_READY: + _NV_GPU_WORKSTATION_FEATURE_TYPE = 1; +#[doc = "!< DEPRECATED name - do not use"] +pub const _NV_GPU_WORKSTATION_FEATURE_TYPE_NV_GPU_WORKSTATION_FEATURE_TYPE_QUADRO_VR_READY: + _NV_GPU_WORKSTATION_FEATURE_TYPE = 1; +pub const _NV_GPU_WORKSTATION_FEATURE_TYPE_NV_GPU_WORKSTATION_FEATURE_TYPE_PROVIZ: + _NV_GPU_WORKSTATION_FEATURE_TYPE = 2; +#[doc = "! \\ingroup gpu"] +pub type _NV_GPU_WORKSTATION_FEATURE_TYPE = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpu"] +pub use self::_NV_GPU_WORKSTATION_FEATURE_TYPE as NV_GPU_WORKSTATION_FEATURE_TYPE; +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_SCANOUT_INTENSITY_DATA_V1 { + #[doc = "!< version of this structure"] + pub version: NvU32, + #[doc = "!< width of the input texture"] + pub width: NvU32, + #[doc = "!< height of the input texture"] + pub height: NvU32, + #[doc = "!< array of floating values building an intensity RGB texture"] + pub blendingTexture: *mut f32, +} +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_SCANOUT_INTENSITY_DATA_V2 { + #[doc = "!< version of this structure"] + pub version: NvU32, + #[doc = "!< width of the input texture"] + pub width: NvU32, + #[doc = "!< height of the input texture"] + pub height: NvU32, + #[doc = "!< array of floating values building an intensity RGB texture"] + pub blendingTexture: *mut f32, + #[doc = "!< array of floating values building an offset texture"] + pub offsetTexture: *mut f32, + #[doc = "!< number of channels per pixel in the offset texture"] + pub offsetTexChannels: NvU32, +} +#[doc = "! \\ingroup gpu"] +pub type NV_SCANOUT_INTENSITY_DATA = NV_SCANOUT_INTENSITY_DATA_V2; +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_SCANOUT_INTENSITY_STATE_DATA { + #[doc = "!< version of this structure"] + pub version: NvU32, + #[doc = "!< intensity is enabled or not"] + pub bEnabled: NvU32, +} +#[doc = "! \\ingroup gpu"] +pub type NV_SCANOUT_INTENSITY_STATE_DATA = _NV_SCANOUT_INTENSITY_STATE_DATA; +pub const NV_GPU_WARPING_VERTICE_FORMAT_NV_GPU_WARPING_VERTICE_FORMAT_TRIANGLESTRIP_XYUVRQ: + NV_GPU_WARPING_VERTICE_FORMAT = 0; +pub const NV_GPU_WARPING_VERTICE_FORMAT_NV_GPU_WARPING_VERTICE_FORMAT_TRIANGLES_XYUVRQ: + NV_GPU_WARPING_VERTICE_FORMAT = 1; +#[doc = "! \\ingroup gpu"] +pub type NV_GPU_WARPING_VERTICE_FORMAT = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_SCANOUT_WARPING_DATA { + #[doc = "!< version of this structure"] + pub version: NvU32, + #[doc = "!< width of the input texture"] + pub vertices: *mut f32, + #[doc = "!< format of the input vertices"] + pub vertexFormat: NV_GPU_WARPING_VERTICE_FORMAT, + #[doc = "!< number of the input vertices"] + pub numVertices: ::std::os::raw::c_int, + #[doc = "!< rectangle in desktop coordinates describing the source area for the warping"] + pub textureRect: *mut NvSBox, +} +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_SCANOUT_WARPING_STATE_DATA { + #[doc = "!< version of this structure"] + pub version: NvU32, + #[doc = "!< warping is enabled or not"] + pub bEnabled: NvU32, +} +#[doc = "! \\ingroup gpu"] +pub type NV_SCANOUT_WARPING_STATE_DATA = _NV_SCANOUT_WARPING_STATE_DATA; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_WARPING_RESAMPLING_METHOD : NV_GPU_SCANOUT_COMPOSITION_PARAMETER = 0 ; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_SCANOUT_INTENSITY_METHOD : NV_GPU_SCANOUT_COMPOSITION_PARAMETER = 1 ; +pub type NV_GPU_SCANOUT_COMPOSITION_PARAMETER = ::std::os::raw::c_int; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_SET_TO_DEFAULT : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 0 ; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BILINEAR : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 256 ; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_TRIANGULAR : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 257 ; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_BELL_SHAPED : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 258 ; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_BSPLINE : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 259 ; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_ADAPTIVE_TRIANGULAR : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 260 ; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_ADAPTIVE_BELL_SHAPED : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 261 ; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_ADAPTIVE_BSPLINE : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 262 ; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_SCANOUT_INTENSITY_NO_GAMMA : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 512 ; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_SCANOUT_INTENSITY_COLOR_GAMMA : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 513 ; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_SCANOUT_INTENSITY_COLOR_AND_OFFSET_GAMMA : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 514 ; +#[doc = "! This enum defines a collection of scanout composition values that can be used to configure\n! the supported scanout composition settings"] +pub type NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetScanoutConfigurationEx()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_SCANOUT_INFORMATION { + #[doc = "!< Structure version, needs to be initialized with NV_SCANOUT_INFORMATION_VER."] + pub version: NvU32, + #[doc = "!< Operating system display device rect in desktop coordinates displayId is scanning out from."] + pub sourceDesktopRect: NvSBox, + #[doc = "!< Area inside the sourceDesktopRect which is scanned out to the display."] + pub sourceViewportRect: NvSBox, + #[doc = "!< Area inside the rect described by targetDisplayWidth/Height sourceViewportRect is scanned out to."] + pub targetViewportRect: NvSBox, + #[doc = "!< Horizontal size of the active resolution scanned out to the display."] + pub targetDisplayWidth: NvU32, + #[doc = "!< Vertical size of the active resolution scanned out to the display."] + pub targetDisplayHeight: NvU32, + #[doc = "!< If targets are cloned views of the sourceDesktopRect the cloned targets have an importance assigned (0:primary,1 secondary,...)."] + pub cloneImportance: NvU32, + #[doc = "!< Rotation performed between the sourceViewportRect and the targetViewportRect."] + pub sourceToTargetRotation: NV_ROTATE, +} +#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetScanoutConfigurationEx()."] +pub type NV_SCANOUT_INFORMATION = _NV_SCANOUT_INFORMATION; +#[doc = "!< Represents Bare Metal GPU"] +pub const _NV_VIRTUALIZATION_MODE_NV_VIRTUALIZATION_MODE_NONE: _NV_VIRTUALIZATION_MODE = 0; +#[doc = "!< Represents GPU-Passthrough"] +pub const _NV_VIRTUALIZATION_MODE_NV_VIRTUALIZATION_MODE_NMOS: _NV_VIRTUALIZATION_MODE = 1; +#[doc = "!< Represents vGPU inside virtual machine"] +pub const _NV_VIRTUALIZATION_MODE_NV_VIRTUALIZATION_MODE_VGX: _NV_VIRTUALIZATION_MODE = 2; +#[doc = "!< Represents VGX hypervisor in vGPU mode"] +pub const _NV_VIRTUALIZATION_MODE_NV_VIRTUALIZATION_MODE_HOST_VGPU: _NV_VIRTUALIZATION_MODE = 3; +#[doc = "! \\ingroup gpu"] +pub type _NV_VIRTUALIZATION_MODE = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpu"] +pub use self::_NV_VIRTUALIZATION_MODE as NV_VIRTUALIZATION_MODE; +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_VIRTUALIZATION_INFO { + #[doc = "!< Structure version"] + pub version: NvU32, + #[doc = "!< one of NV_VIRTUALIZATION_MODE."] + pub virtualizationMode: NV_VIRTUALIZATION_MODE, + #[doc = "!< reserved for future use. Should be set to ZERO."] + pub reserved: NvU32, +} +#[doc = "! \\ingroup gpu"] +pub type NV_GPU_VIRTUALIZATION_INFO_V1 = _NV_GPU_VIRTUALIZATION_INFO; +#[doc = "! \\ingroup gpu"] +pub type NV_GPU_VIRTUALIZATION_INFO = NV_GPU_VIRTUALIZATION_INFO_V1; +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LOGICAL_GPU_DATA_V1 { + #[doc = "!< [in] Structure version."] + pub version: NvU32, + #[doc = "!< [out] Returns OS-AdapterId. User must send memory buffer of size atleast equal to the size of LUID structure before calling the NVAPI."] + pub pOSAdapterId: *mut ::std::os::raw::c_void, + #[doc = "!< [out] Number of physical GPU handles associated with the specified logical GPU handle."] + pub physicalGpuCount: NvU32, + #[doc = "!< [out] This array will be filled with physical GPU handles associated with the given logical GPU handle.\n!< The array index refers to the Physical Gpu Index (Idx).\n!< Idx value is the same as D3D11 MultiGPUDevice GPU index, D3D12 node index, OpenGL GL_NV_gpu_multicast GPU index.\n!< When converted to a bit mask (1 << Idx), it matches:\n!< 1. Vulkan deviceNodeMask in VkPhysicalDeviceIDProperties\n!< 2. CUDA deviceNodeMask returned by cuDeviceGetLuid"] + pub physicalGpuHandles: [NvPhysicalGpuHandle; 64usize], + #[doc = "!< Reserved for future use. Should be set to ZERO."] + pub reserved: [NvU32; 8usize], +} +#[doc = "! \\ingroup gpu"] +pub type NV_LOGICAL_GPU_DATA_V1 = _NV_LOGICAL_GPU_DATA_V1; +#[doc = "! \\ingroup gpu"] +pub type NV_LOGICAL_GPU_DATA = NV_LOGICAL_GPU_DATA_V1; +#[doc = "! License string"] +pub type NvAPI_LicenseString = [::std::os::raw::c_char; 128usize]; +pub const _NV_LICENSE_FEATURE_TYPE_NV_LICENSE_FEATURE_UNKNOWN: _NV_LICENSE_FEATURE_TYPE = 0; +pub const _NV_LICENSE_FEATURE_TYPE_NV_LICENSE_FEATURE_VGPU: _NV_LICENSE_FEATURE_TYPE = 1; +pub const _NV_LICENSE_FEATURE_TYPE_NV_LICENSE_FEATURE_NVIDIA_RTX: _NV_LICENSE_FEATURE_TYPE = 2; +#[doc = "!< DEPRECATED name - do not use"] +pub const _NV_LICENSE_FEATURE_TYPE_NV_LICENSE_FEATURE_QUADRO: _NV_LICENSE_FEATURE_TYPE = 2; +pub const _NV_LICENSE_FEATURE_TYPE_NV_LICENSE_FEATURE_GAMING: _NV_LICENSE_FEATURE_TYPE = 3; +pub const _NV_LICENSE_FEATURE_TYPE_NV_LICENSE_FEATURE_COMPUTE: _NV_LICENSE_FEATURE_TYPE = 4; +#[doc = "! Used in NV_LICENSE_FEATURE_DETAILS"] +pub type _NV_LICENSE_FEATURE_TYPE = ::std::os::raw::c_int; +#[doc = "! Used in NV_LICENSE_FEATURE_DETAILS"] +pub use self::_NV_LICENSE_FEATURE_TYPE as NV_LICENSE_FEATURE_TYPE; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LICENSE_EXPIRY_DETAILS { + #[doc = "!< Year value of license expiry"] + pub year: NvU32, + #[doc = "!< Month value of license expiry"] + pub month: NvU16, + #[doc = "!< Day value of license expiry"] + pub day: NvU16, + #[doc = "!< Hour value of license expiry"] + pub hour: NvU16, + #[doc = "!< Minutes value of license expiry"] + pub min: NvU16, + #[doc = "!< Seconds value of license expiry"] + pub sec: NvU16, + #[doc = "!< License expiry status"] + pub status: NvU8, +} +pub type NV_LICENSE_EXPIRY_DETAILS = _NV_LICENSE_EXPIRY_DETAILS; +#[doc = "! Used in NV_LICENSABLE_FEATURES"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LICENSE_FEATURE_DETAILS_V1 { + #[doc = "!< IN - Structure version."] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Feature code that corresponds to the licensable feature."] + pub featureCode: NV_LICENSE_FEATURE_TYPE, + #[doc = "!< Deprecated"] + pub licenseInfo: NvAPI_LicenseString, +} +impl _NV_LICENSE_FEATURE_DETAILS_V1 { + #[inline] + pub fn isEnabled(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isEnabled(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isEnabled_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isEnabled_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isEnabled: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isEnabled: u32 = unsafe { ::std::mem::transmute(isEnabled) }; + isEnabled as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! Used in NV_LICENSABLE_FEATURES"] +pub type NV_LICENSE_FEATURE_DETAILS_V1 = _NV_LICENSE_FEATURE_DETAILS_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LICENSE_FEATURE_DETAILS_V2 { + #[doc = "!< Unused."] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Feature code that corresponds to the licensable feature."] + pub featureCode: NV_LICENSE_FEATURE_TYPE, + #[doc = "!< Deprecated"] + pub licenseInfo: NvAPI_LicenseString, + #[doc = "!< Nvidia Grid licensable product name."] + pub productName: NvAPI_LicenseString, +} +impl _NV_LICENSE_FEATURE_DETAILS_V2 { + #[inline] + pub fn isEnabled(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isEnabled(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isEnabled_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isEnabled_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isEnabled: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isEnabled: u32 = unsafe { ::std::mem::transmute(isEnabled) }; + isEnabled as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_LICENSE_FEATURE_DETAILS_V2 = _NV_LICENSE_FEATURE_DETAILS_V2; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LICENSE_FEATURE_DETAILS_V3 { + #[doc = "!< Unused."] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Feature code that corresponds to the licensable feature."] + pub featureCode: NV_LICENSE_FEATURE_TYPE, + #[doc = "!< Deprecated"] + pub licenseInfo: NvAPI_LicenseString, + #[doc = "!< Nvidia Grid licensable product name."] + pub productName: NvAPI_LicenseString, +} +impl _NV_LICENSE_FEATURE_DETAILS_V3 { + #[inline] + pub fn isEnabled(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isEnabled(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isEnabled_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isEnabled_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isFeatureEnabled(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isFeatureEnabled(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isFeatureEnabled_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isFeatureEnabled_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 30u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 30u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 30u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isEnabled: NvU32, + isFeatureEnabled: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isEnabled: u32 = unsafe { ::std::mem::transmute(isEnabled) }; + isEnabled as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isFeatureEnabled: u32 = unsafe { ::std::mem::transmute(isFeatureEnabled) }; + isFeatureEnabled as u64 + }); + __bindgen_bitfield_unit.set(2usize, 30u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_LICENSE_FEATURE_DETAILS_V3 = _NV_LICENSE_FEATURE_DETAILS_V3; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LICENSE_FEATURE_DETAILS_V4 { + #[doc = "!< Unused."] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Feature code that corresponds to the licensable feature."] + pub featureCode: NV_LICENSE_FEATURE_TYPE, + #[doc = "!< Deprecated"] + pub licenseInfo: NvAPI_LicenseString, + #[doc = "!< Nvidia Grid licensable product name."] + pub productName: NvAPI_LicenseString, + #[doc = "!< License expiry information."] + pub licenseExpiry: NV_LICENSE_EXPIRY_DETAILS, +} +impl _NV_LICENSE_FEATURE_DETAILS_V4 { + #[inline] + pub fn isEnabled(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isEnabled(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isEnabled_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isEnabled_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isFeatureEnabled(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isFeatureEnabled(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isFeatureEnabled_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isFeatureEnabled_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 30u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 30u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 30u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isEnabled: NvU32, + isFeatureEnabled: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isEnabled: u32 = unsafe { ::std::mem::transmute(isEnabled) }; + isEnabled as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isFeatureEnabled: u32 = unsafe { ::std::mem::transmute(isFeatureEnabled) }; + isFeatureEnabled as u64 + }); + __bindgen_bitfield_unit.set(2usize, 30u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_LICENSE_FEATURE_DETAILS_V4 = _NV_LICENSE_FEATURE_DETAILS_V4; +#[doc = "! Used in NV_LICENSABLE_FEATURES"] +pub type NV_LICENSE_FEATURE_DETAILS = NV_LICENSE_FEATURE_DETAILS_V1; +#[doc = "! Licensable features"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LICENSABLE_FEATURES_V1 { + #[doc = "!< IN - Structure version."] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< The number of licensable features."] + pub licensableFeatureCount: NvU32, + #[doc = "!< Dynamic signature required for Authentication of the components,\n!< signature length limited to NV_LICENSE_SIGNATURE_SIZE"] + pub signature: [NvU8; 128usize], + #[doc = "!< Array of licensable features"] + pub licenseDetails: [NV_LICENSE_FEATURE_DETAILS_V1; 3usize], +} +impl _NV_LICENSABLE_FEATURES_V1 { + #[inline] + pub fn isLicenseSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isLicenseSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isLicenseSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isLicenseSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isLicenseSupported: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isLicenseSupported: u32 = unsafe { ::std::mem::transmute(isLicenseSupported) }; + isLicenseSupported as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! Licensable features"] +pub type NV_LICENSABLE_FEATURES_V1 = _NV_LICENSABLE_FEATURES_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LICENSABLE_FEATURES_V2 { + #[doc = "!< IN - Structure version."] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< The number of licensable features."] + pub licensableFeatureCount: NvU32, + #[doc = "!< Dynamic signature required for Authentication of the components,\n!< signature length limited to NV_LICENSE_SIGNATURE_SIZE"] + pub signature: [NvU8; 128usize], + #[doc = "!< Array of licensable features"] + pub licenseDetails: [NV_LICENSE_FEATURE_DETAILS_V2; 3usize], +} +impl _NV_LICENSABLE_FEATURES_V2 { + #[inline] + pub fn isLicenseSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isLicenseSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isLicenseSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isLicenseSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isLicenseSupported: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isLicenseSupported: u32 = unsafe { ::std::mem::transmute(isLicenseSupported) }; + isLicenseSupported as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_LICENSABLE_FEATURES_V2 = _NV_LICENSABLE_FEATURES_V2; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LICENSABLE_FEATURES_V3 { + #[doc = "!< IN - Structure version."] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< The number of licensable features."] + pub licensableFeatureCount: NvU32, + #[doc = "!< Dynamic signature required for Authentication of the components,\n!< signature length limited to NV_LICENSE_SIGNATURE_SIZE"] + pub signature: [NvU8; 128usize], + #[doc = "!< Array of licensable features"] + pub licenseDetails: [NV_LICENSE_FEATURE_DETAILS_V3; 3usize], +} +impl _NV_LICENSABLE_FEATURES_V3 { + #[inline] + pub fn isLicenseSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isLicenseSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isLicenseSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isLicenseSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isLicenseSupported: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isLicenseSupported: u32 = unsafe { ::std::mem::transmute(isLicenseSupported) }; + isLicenseSupported as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_LICENSABLE_FEATURES_V3 = _NV_LICENSABLE_FEATURES_V3; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LICENSABLE_FEATURES_V4 { + #[doc = "!< IN - Structure version."] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< The number of licensable features."] + pub licensableFeatureCount: NvU32, + #[doc = "!< Dynamic signature required for Authentication of the components,\n!< signature length limited to NV_LICENSE_SIGNATURE_SIZE"] + pub signature: [NvU8; 128usize], + #[doc = "!< Array of licensable features"] + pub licenseDetails: [NV_LICENSE_FEATURE_DETAILS_V4; 3usize], +} +impl _NV_LICENSABLE_FEATURES_V4 { + #[inline] + pub fn isLicenseSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isLicenseSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isLicenseSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isLicenseSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isLicenseSupported: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isLicenseSupported: u32 = unsafe { ::std::mem::transmute(isLicenseSupported) }; + isLicenseSupported as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_LICENSABLE_FEATURES_V4 = _NV_LICENSABLE_FEATURES_V4; +pub type NV_LICENSABLE_FEATURES = NV_LICENSABLE_FEATURES_V4; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_ENCODER_STATISTICS_V1 { + #[doc = "!< [in] Structure version value."] + pub version: NvU32, + #[doc = "!< [out] Count of active encoder sessions."] + pub sessionsCount: NvU32, + #[doc = "!< [out] Trailing average FPS of all active sessions."] + pub averageFps: NvU32, + #[doc = "!< [out] Encode latency in microseconds."] + pub averageLatency: NvU32, +} +pub type NV_ENCODER_STATISTICS_V1 = _NV_ENCODER_STATISTICS_V1; +pub type NV_ENCODER_STATISTICS = NV_ENCODER_STATISTICS_V1; +pub const _NV_ENCODER_TYPE_NV_ENCODER_H264: _NV_ENCODER_TYPE = 0; +pub const _NV_ENCODER_TYPE_NV_ENCODER_HEVC: _NV_ENCODER_TYPE = 1; +pub const _NV_ENCODER_TYPE_NV_ENCODER_UNKNOWN: _NV_ENCODER_TYPE = -1; +pub type _NV_ENCODER_TYPE = ::std::os::raw::c_int; +pub use self::_NV_ENCODER_TYPE as NV_ENCODER_TYPE; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_ENCODER_PER_SESSION_INFO_V1 { + #[doc = "!< Unique session ID."] + pub sessionId: NvU32, + #[doc = "!< Owning process ID."] + pub processId: NvU32, + #[doc = "!< Owning vGPU instance ID (only valid on vGPU hosts, otherwise zero)."] + pub vgpuInstance: NvU32, + #[doc = "!< Video encoder type."] + pub codecType: NV_ENCODER_TYPE, + #[doc = "!< Current encode horizontal resolution."] + pub hResolution: NvU32, + #[doc = "!< Current encode vertical resolution."] + pub vResolution: NvU32, + #[doc = "!< Moving average encode frames per second."] + pub averageEncodeFps: NvU32, + #[doc = "!< Moving average encode latency in microseconds."] + pub averageEncodeLatency: NvU32, +} +pub type NV_ENCODER_PER_SESSION_INFO_V1 = _NV_ENCODER_PER_SESSION_INFO_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_ENCODER_SESSIONS_INFO_V1 { + #[doc = "!< [in] Structure version value."] + pub version: NvU32, + #[doc = "!< [out] Count of active encoder sessions."] + pub sessionsCount: NvU32, + #[doc = "!< [out] Array of session info. Caller should allocate memory for this field before making\n!< the NvAPI_GPU_GetEncoderSessionsInfo() call, memory allocated should be of\n!< size = sizeof(NV_ENCODER_PER_SESSION_INFO_V1) * NV_ENCODER_SESSION_INFO_MAX_ENTRIES_V1."] + pub pSessionInfo: *mut NV_ENCODER_PER_SESSION_INFO_V1, +} +pub type NV_ENCODER_SESSIONS_INFO_V1 = _NV_ENCODER_SESSIONS_INFO_V1; +pub type NV_ENCODER_SESSIONS_INFO = NV_ENCODER_SESSIONS_INFO_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_INFO_V1 { + #[doc = "!< Structure Version."] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl _NV_GPU_INFO_V1 { + #[inline] + pub fn bIsExternalGpu(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsExternalGpu(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsExternalGpu_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsExternalGpu_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsExternalGpu: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsExternalGpu: u32 = unsafe { ::std::mem::transmute(bIsExternalGpu) }; + bIsExternalGpu as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_GPU_INFO_V1 = _NV_GPU_INFO_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_INFO_V2 { + #[doc = "!< Structure Version."] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Reserved for future use"] + pub reserved1: NvU64, + #[doc = "!< Number of \"Ray Tracing Cores\" supported by the GPU."] + pub rayTracingCores: NvU32, + #[doc = "!< Number of \"Tensor Cores\" supported by the GPU."] + pub tensorCores: NvU32, + #[doc = "!< Reserved for future use."] + pub reserved2: [NvU32; 14usize], +} +impl _NV_GPU_INFO_V2 { + #[inline] + pub fn bIsExternalGpu(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsExternalGpu(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsExternalGpu_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsExternalGpu_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved0(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved0(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved0_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved0_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsExternalGpu: NvU32, + reserved0: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsExternalGpu: u32 = unsafe { ::std::mem::transmute(bIsExternalGpu) }; + bIsExternalGpu as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved0: u32 = unsafe { ::std::mem::transmute(reserved0) }; + reserved0 as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_GPU_INFO_V2 = _NV_GPU_INFO_V2; +pub type NV_GPU_INFO = NV_GPU_INFO_V2; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_VR_READY_V1 { + #[doc = "!< Structure Version."] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl _NV_GPU_VR_READY_V1 { + #[inline] + pub fn isVRReady(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isVRReady(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isVRReady_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isVRReady_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isVRReady: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isVRReady: u32 = unsafe { ::std::mem::transmute(isVRReady) }; + isVRReady as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_GPU_VR_READY_V1 = _NV_GPU_VR_READY_V1; +pub type NV_GPU_VR_READY = NV_GPU_VR_READY_V1; +pub const _NV_ADAPTER_TYPE_NV_ADAPTER_TYPE_UNKNOWN: _NV_ADAPTER_TYPE = 0; +pub const _NV_ADAPTER_TYPE_NV_ADAPTER_TYPE_WDDM: _NV_ADAPTER_TYPE = 1; +pub const _NV_ADAPTER_TYPE_NV_ADAPTER_TYPE_MCDM: _NV_ADAPTER_TYPE = 2; +pub const _NV_ADAPTER_TYPE_NV_ADAPTER_TYPE_TCC: _NV_ADAPTER_TYPE = 4; +pub const _NV_ADAPTER_TYPE_NV_ADAPTER_TYPE_LAST: _NV_ADAPTER_TYPE = -1; +pub type _NV_ADAPTER_TYPE = ::std::os::raw::c_int; +pub use self::_NV_ADAPTER_TYPE as NV_ADAPTER_TYPE; +#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetGspFeatures()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_GSP_INFO_V1 { + #[doc = "!< [in] Structure version"] + pub version: NvU32, + #[doc = "!< [out] Contains GSP firmware version"] + pub firmwareVersion: [NvU8; 64usize], + #[doc = "!< Reserved for future use"] + pub reserved: NvU32, +} +#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetGspFeatures()."] +pub type NV_GPU_GSP_INFO_V1 = _NV_GPU_GSP_INFO_V1; +#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetGspFeatures()."] +pub type NV_GPU_GSP_INFO = NV_GPU_GSP_INFO_V1; +#[doc = "! \\fn NvAPI_GPU_GetUUID(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_UUID *pGpuUuid)\n! DESCRIPTION: This function returns the GPU UUID for the specified physical GPU handle.\n! The UUID is returned in GUID format (16 bytes).\n!\n! SUPPORTED OS: Windows 10 and higher\n!\n!\n! TCC_SUPPORTED\n!\n! MCDM_SUPPORTED\n!\n! \\since Release: 595\n!\n! \\param [in] hPhysicalGpu Physical GPU handle to get UUID for\n! \\param [in,out] pGpuUuid Pointer to structure that will receive the GPU UUID\n!\n! \\retval NVAPI_OK Request completed successfully\n! \\return This API can return any of the error codes enumerated in #NvAPI_Status.\n!\n! \\ingroup gpu\n\n! Used in NvAPI_GPU_GetUUID()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_UUID_V1 { + pub version: NvU32, + pub uuid: [NvU8; 16usize], +} +#[doc = "! \\fn NvAPI_GPU_GetUUID(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_UUID *pGpuUuid)\n! DESCRIPTION: This function returns the GPU UUID for the specified physical GPU handle.\n! The UUID is returned in GUID format (16 bytes).\n!\n! SUPPORTED OS: Windows 10 and higher\n!\n!\n! TCC_SUPPORTED\n!\n! MCDM_SUPPORTED\n!\n! \\since Release: 595\n!\n! \\param [in] hPhysicalGpu Physical GPU handle to get UUID for\n! \\param [in,out] pGpuUuid Pointer to structure that will receive the GPU UUID\n!\n! \\retval NVAPI_OK Request completed successfully\n! \\return This API can return any of the error codes enumerated in #NvAPI_Status.\n!\n! \\ingroup gpu\n\n! Used in NvAPI_GPU_GetUUID()"] +pub type NV_GPU_UUID_V1 = _NV_GPU_UUID_V1; +#[doc = "! \\fn NvAPI_GPU_GetUUID(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_UUID *pGpuUuid)\n! DESCRIPTION: This function returns the GPU UUID for the specified physical GPU handle.\n! The UUID is returned in GUID format (16 bytes).\n!\n! SUPPORTED OS: Windows 10 and higher\n!\n!\n! TCC_SUPPORTED\n!\n! MCDM_SUPPORTED\n!\n! \\since Release: 595\n!\n! \\param [in] hPhysicalGpu Physical GPU handle to get UUID for\n! \\param [in,out] pGpuUuid Pointer to structure that will receive the GPU UUID\n!\n! \\retval NVAPI_OK Request completed successfully\n! \\return This API can return any of the error codes enumerated in #NvAPI_Status.\n!\n! \\ingroup gpu\n\n! Used in NvAPI_GPU_GetUUID()"] +pub type NV_GPU_UUID = NV_GPU_UUID_V1; +#[doc = "! \\ingroup gpupstate\n! Used in NvAPI_GPU_GetPstatesInfoEx()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PERF_PSTATES_INFO_V1 { + pub version: NvU32, + #[doc = "!< - bit 0 indicates if perfmon is enabled or not\n!< - bit 1 indicates if dynamic Pstate is capable or not\n!< - bit 2 indicates if dynamic Pstate is enable or not\n!< - all other bits must be set to 0"] + pub flags: NvU32, + #[doc = "!< The number of available p-states"] + pub numPstates: NvU32, + #[doc = "!< The number of clock domains supported by each P-State"] + pub numClocks: NvU32, + pub pstates: [NV_GPU_PERF_PSTATES_INFO_V1__bindgen_ty_1; 16usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PERF_PSTATES_INFO_V1__bindgen_ty_1 { + #[doc = "!< ID of the p-state."] + pub pstateId: NV_GPU_PERF_PSTATE_ID, + #[doc = "!< - bit 0 indicates if the PCIE limit is GEN1 or GEN2\n!< - bit 1 indicates if the Pstate is overclocked or not\n!< - bit 2 indicates if the Pstate is overclockable or not\n!< - all other bits must be set to 0"] + pub flags: NvU32, + pub clocks: [NV_GPU_PERF_PSTATES_INFO_V1__bindgen_ty_1__bindgen_ty_1; 32usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PERF_PSTATES_INFO_V1__bindgen_ty_1__bindgen_ty_1 { + #[doc = "!< ID of the clock domain"] + pub domainId: NV_GPU_PUBLIC_CLOCK_ID, + #[doc = "!< Reserved. Must be set to 0"] + pub flags: NvU32, + #[doc = "!< Clock frequency in kHz"] + pub freq: NvU32, +} +#[doc = "! \\ingroup gpupstate"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PERF_PSTATES_INFO_V2 { + pub version: NvU32, + #[doc = "!< - bit 0 indicates if perfmon is enabled or not\n!< - bit 1 indicates if dynamic Pstate is capable or not\n!< - bit 2 indicates if dynamic Pstate is enable or not\n!< - all other bits must be set to 0"] + pub flags: NvU32, + #[doc = "!< The number of available p-states"] + pub numPstates: NvU32, + #[doc = "!< The number of clock domains supported by each P-State"] + pub numClocks: NvU32, + pub numVoltages: NvU32, + #[doc = "!< Valid index range is 0 to numVoltages-1"] + pub pstates: [NV_GPU_PERF_PSTATES_INFO_V2__bindgen_ty_1; 16usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PERF_PSTATES_INFO_V2__bindgen_ty_1 { + #[doc = "!< ID of the p-state."] + pub pstateId: NV_GPU_PERF_PSTATE_ID, + #[doc = "!< - bit 0 indicates if the PCIE limit is GEN1 or GEN2\n!< - bit 1 indicates if the Pstate is overclocked or not\n!< - bit 2 indicates if the Pstate is overclockable or not\n!< - all other bits must be set to 0"] + pub flags: NvU32, + pub clocks: [NV_GPU_PERF_PSTATES_INFO_V2__bindgen_ty_1__bindgen_ty_1; 32usize], + pub voltages: [NV_GPU_PERF_PSTATES_INFO_V2__bindgen_ty_1__bindgen_ty_2; 16usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PERF_PSTATES_INFO_V2__bindgen_ty_1__bindgen_ty_1 { + pub domainId: NV_GPU_PUBLIC_CLOCK_ID, + #[doc = "!< bit 0 indicates if this clock is overclockable\n!< all other bits must be set to 0"] + pub flags: NvU32, + pub freq: NvU32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PERF_PSTATES_INFO_V2__bindgen_ty_1__bindgen_ty_2 { + #[doc = "!< ID of the voltage domain, containing flags and mvolt info"] + pub domainId: NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID, + #[doc = "!< Reserved for future use. Must be set to 0"] + pub flags: NvU32, + #[doc = "!< Voltage in mV"] + pub mvolt: NvU32, +} +#[doc = "! \\ingroup gpupstate"] +pub type NV_GPU_PERF_PSTATES_INFO = NV_GPU_PERF_PSTATES_INFO_V2; +#[doc = "! \\ingroup gpupstate\n! Used in NvAPI_GPU_GetDynamicPstatesInfoEx()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_DYNAMIC_PSTATES_INFO_EX { + #[doc = "!< Structure version"] + pub version: NvU32, + #[doc = "!< bit 0 indicates if the dynamic Pstate is enabled or not"] + pub flags: NvU32, + pub utilization: [NV_GPU_DYNAMIC_PSTATES_INFO_EX__bindgen_ty_1; 8usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_DYNAMIC_PSTATES_INFO_EX__bindgen_ty_1 { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + #[doc = "!< Percentage of time where the domain is considered busy in the last 1 second interval"] + pub percentage: NvU32, +} +impl NV_GPU_DYNAMIC_PSTATES_INFO_EX__bindgen_ty_1 { + #[inline] + pub fn bIsPresent(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsPresent(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsPresent_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsPresent_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1(bIsPresent: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsPresent: u32 = unsafe { ::std::mem::transmute(bIsPresent) }; + bIsPresent as u64 + }); + __bindgen_bitfield_unit + } +} +pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_NONE: NV_THERMAL_TARGET = 0; +#[doc = "!< GPU core temperature requires NvPhysicalGpuHandle"] +pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_GPU: NV_THERMAL_TARGET = 1; +#[doc = "!< GPU memory temperature requires NvPhysicalGpuHandle"] +pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_MEMORY: NV_THERMAL_TARGET = 2; +#[doc = "!< GPU power supply temperature requires NvPhysicalGpuHandle"] +pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_POWER_SUPPLY: NV_THERMAL_TARGET = 4; +#[doc = "!< GPU board ambient temperature requires NvPhysicalGpuHandle"] +pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_BOARD: NV_THERMAL_TARGET = 8; +#[doc = "!< Visual Computing Device Board temperature requires NvVisualComputingDeviceHandle"] +pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_VCD_BOARD: NV_THERMAL_TARGET = 9; +#[doc = "!< Visual Computing Device Inlet temperature requires NvVisualComputingDeviceHandle"] +pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_VCD_INLET: NV_THERMAL_TARGET = 10; +#[doc = "!< Visual Computing Device Outlet temperature requires NvVisualComputingDeviceHandle"] +pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_VCD_OUTLET: NV_THERMAL_TARGET = 11; +pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_ALL: NV_THERMAL_TARGET = 15; +pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_UNKNOWN: NV_THERMAL_TARGET = -1; +#[doc = "! \\ingroup gputhermal\n! Used in NV_GPU_THERMAL_SETTINGS"] +pub type NV_THERMAL_TARGET = ::std::os::raw::c_int; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_NONE: NV_THERMAL_CONTROLLER = 0; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_GPU_INTERNAL: NV_THERMAL_CONTROLLER = 1; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_ADM1032: NV_THERMAL_CONTROLLER = 2; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_MAX6649: NV_THERMAL_CONTROLLER = 3; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_MAX1617: NV_THERMAL_CONTROLLER = 4; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_LM99: NV_THERMAL_CONTROLLER = 5; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_LM89: NV_THERMAL_CONTROLLER = 6; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_LM64: NV_THERMAL_CONTROLLER = 7; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_ADT7473: NV_THERMAL_CONTROLLER = 8; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_SBMAX6649: NV_THERMAL_CONTROLLER = 9; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_VBIOSEVT: NV_THERMAL_CONTROLLER = 10; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_OS: NV_THERMAL_CONTROLLER = 11; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_UNKNOWN: NV_THERMAL_CONTROLLER = -1; +#[doc = "! \\ingroup gputhermal\n! Used in NV_GPU_THERMAL_SETTINGS"] +pub type NV_THERMAL_CONTROLLER = ::std::os::raw::c_int; +#[doc = "! \\ingroup gputhermal\n! Used in NvAPI_GPU_GetThermalSettings()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_THERMAL_SETTINGS_V1 { + #[doc = "!< structure version"] + pub version: NvU32, + #[doc = "!< number of associated thermal sensors"] + pub count: NvU32, + pub sensor: [NV_GPU_THERMAL_SETTINGS_V1__bindgen_ty_1; 3usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_THERMAL_SETTINGS_V1__bindgen_ty_1 { + #[doc = "!< internal, ADM1032, MAX6649..."] + pub controller: NV_THERMAL_CONTROLLER, + #[doc = "!< The min default temperature value of the thermal sensor in degree Celsius"] + pub defaultMinTemp: NvU32, + #[doc = "!< The max default temperature value of the thermal sensor in degree Celsius"] + pub defaultMaxTemp: NvU32, + #[doc = "!< The current temperature value of the thermal sensor in degree Celsius"] + pub currentTemp: NvU32, + #[doc = "!< Thermal sensor targeted @ GPU, memory, chipset, powersupply, Visual Computing Device, etc."] + pub target: NV_THERMAL_TARGET, +} +#[doc = "! \\ingroup gputhermal"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_THERMAL_SETTINGS_V2 { + #[doc = "!< structure version"] + pub version: NvU32, + #[doc = "!< number of associated thermal sensors"] + pub count: NvU32, + pub sensor: [NV_GPU_THERMAL_SETTINGS_V2__bindgen_ty_1; 3usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_THERMAL_SETTINGS_V2__bindgen_ty_1 { + #[doc = "!< internal, ADM1032, MAX6649..."] + pub controller: NV_THERMAL_CONTROLLER, + #[doc = "!< Minimum default temperature value of the thermal sensor in degree Celsius"] + pub defaultMinTemp: NvS32, + #[doc = "!< Maximum default temperature value of the thermal sensor in degree Celsius"] + pub defaultMaxTemp: NvS32, + #[doc = "!< Current temperature value of the thermal sensor in degree Celsius"] + pub currentTemp: NvS32, + #[doc = "!< Thermal sensor targeted - GPU, memory, chipset, powersupply, Visual Computing Device, etc"] + pub target: NV_THERMAL_TARGET, +} +#[doc = "! \\ingroup gputhermal"] +pub type NV_GPU_THERMAL_SETTINGS = NV_GPU_THERMAL_SETTINGS_V2; +#[doc = "! \\ingroup gpuclock\n! Used in NvAPI_GPU_GetAllClockFrequencies()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_CLOCK_FREQUENCIES_V1 { + #[doc = "!< Structure version"] + pub version: NvU32, + #[doc = "!< These bits are reserved for future use."] + pub reserved: NvU32, + pub domain: [NV_GPU_CLOCK_FREQUENCIES_V1__bindgen_ty_1; 32usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_CLOCK_FREQUENCIES_V1__bindgen_ty_1 { + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Clock frequency (kHz)"] + pub frequency: NvU32, +} +impl NV_GPU_CLOCK_FREQUENCIES_V1__bindgen_ty_1 { + #[inline] + pub fn bIsPresent(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsPresent(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsPresent_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsPresent_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsPresent: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsPresent: u32 = unsafe { ::std::mem::transmute(bIsPresent) }; + bIsPresent as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub const NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE_NV_GPU_CLOCK_FREQUENCIES_CURRENT_FREQ: + NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE = 0; +pub const NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE_NV_GPU_CLOCK_FREQUENCIES_BASE_CLOCK: + NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE = 1; +pub const NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE_NV_GPU_CLOCK_FREQUENCIES_BOOST_CLOCK: + NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE = 2; +pub const NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE_NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE_NUM: + NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE = 3; +#[doc = "! \\ingroup gpuclock\n! Used in NvAPI_GPU_GetAllClockFrequencies()"] +pub type NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpuclock\n! Used in NvAPI_GPU_GetAllClockFrequencies()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_CLOCK_FREQUENCIES_V2 { + #[doc = "!< Structure version"] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + pub domain: [NV_GPU_CLOCK_FREQUENCIES_V2__bindgen_ty_1; 32usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_CLOCK_FREQUENCIES_V2__bindgen_ty_1 { + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Clock frequency (kHz)"] + pub frequency: NvU32, +} +impl NV_GPU_CLOCK_FREQUENCIES_V2__bindgen_ty_1 { + #[inline] + pub fn bIsPresent(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsPresent(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsPresent_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsPresent_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsPresent: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsPresent: u32 = unsafe { ::std::mem::transmute(bIsPresent) }; + bIsPresent as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +impl NV_GPU_CLOCK_FREQUENCIES_V2 { + #[inline] + pub fn ClockType(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32) } + } + #[inline] + pub fn set_ClockType(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn ClockType_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 4u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_ClockType_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 20u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 20u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 20u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 20u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved1(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u32) } + } + #[inline] + pub fn set_reserved1(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(24usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved1_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 24usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved1_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 24usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + ClockType: NvU32, + reserved: NvU32, + reserved1: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 4u8, { + let ClockType: u32 = unsafe { ::std::mem::transmute(ClockType) }; + ClockType as u64 + }); + __bindgen_bitfield_unit.set(4usize, 20u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit.set(24usize, 8u8, { + let reserved1: u32 = unsafe { ::std::mem::transmute(reserved1) }; + reserved1 as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup gpuclock\n! Used in NvAPI_GPU_GetAllClockFrequencies()"] +pub type NV_GPU_CLOCK_FREQUENCIES = NV_GPU_CLOCK_FREQUENCIES_V2; +pub const _NV_GPU_ILLUMINATION_ATTRIB_NV_GPU_IA_LOGO_BRIGHTNESS: _NV_GPU_ILLUMINATION_ATTRIB = 0; +pub const _NV_GPU_ILLUMINATION_ATTRIB_NV_GPU_IA_SLI_BRIGHTNESS: _NV_GPU_ILLUMINATION_ATTRIB = 1; +#[doc = "! \\ingroup gpu"] +pub type _NV_GPU_ILLUMINATION_ATTRIB = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpu"] +pub use self::_NV_GPU_ILLUMINATION_ATTRIB as NV_GPU_ILLUMINATION_ATTRIB; +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_QUERY_ILLUMINATION_SUPPORT_PARM_V1 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< The handle of the GPU that you are checking for the specified attribute.\n!< note that this is the GPU that is managing the attribute.\n!< Only a single GPU can manage an given attribute on a given HW element,\n!< regardless of how many are attatched.\n!< I.E. only one GPU will be used to control the brightness of the LED on an SLI bridge,\n!< regardless of how many are physicaly attached.\n!< You enumerate thru the GPUs with this call to determine which GPU is managing the attribute."] + pub hPhysicalGpu: NvPhysicalGpuHandle, + #[doc = "!< An enumeration value specifying the Illumination attribute to be querried.\n!< refer to enum \\ref NV_GPU_ILLUMINATION_ATTRIB."] + pub Attribute: NV_GPU_ILLUMINATION_ATTRIB, + #[doc = "!< A boolean indicating if the attribute is supported."] + pub bSupported: NvU32, +} +#[doc = "! \\ingroup gpu"] +pub type NV_GPU_QUERY_ILLUMINATION_SUPPORT_PARM_V1 = _NV_GPU_QUERY_ILLUMINATION_SUPPORT_PARM_V1; +#[doc = "! \\ingroup gpu"] +pub type NV_GPU_QUERY_ILLUMINATION_SUPPORT_PARM = NV_GPU_QUERY_ILLUMINATION_SUPPORT_PARM_V1; +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_GET_ILLUMINATION_PARM_V1 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< The handle of the GPU that you are checking for the specified attribute.\n!< Note that this is the GPU that is managing the attribute.\n!< Only a single GPU can manage an given attribute on a given HW element,\n!< regardless of how many are attatched.\n!< I.E. only one GPU will be used to control the brightness of the LED on an SLI bridge,\n!< regardless of how many are physicaly attached.\n!< You enumerate thru the GPUs with this call to determine which GPU is managing the attribute."] + pub hPhysicalGpu: NvPhysicalGpuHandle, + #[doc = "!< An enumeration value specifying the Illumination attribute to be querried.\n!< refer to enum \\ref NV_GPU_ILLUMINATION_ATTRIB."] + pub Attribute: NV_GPU_ILLUMINATION_ATTRIB, + #[doc = "!< A DWORD that will contain the current value of the specified attribute."] + pub Value: NvU32, +} +#[doc = "! \\ingroup gpu"] +pub type NV_GPU_GET_ILLUMINATION_PARM_V1 = _NV_GPU_GET_ILLUMINATION_PARM_V1; +#[doc = "! \\ingroup gpu"] +pub type NV_GPU_GET_ILLUMINATION_PARM = NV_GPU_GET_ILLUMINATION_PARM_V1; +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_SET_ILLUMINATION_PARM_V1 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< The handle of the GPU that you are checking for the specified attribute.\n!< Note that this is the GPU that is managing the attribute.\n!< Only a single GPU can manage an given attribute on a given HW element,\n!< regardless of how many are attatched.\n!< I.E. only one GPU will be used to control the brightness of the LED on an SLI bridge,\n!< regardless of how many are physicaly attached.\n!< You enumerate thru the GPUs with this call to determine which GPU is managing the attribute."] + pub hPhysicalGpu: NvPhysicalGpuHandle, + #[doc = "!< An enumeration value specifying the Illumination attribute to be querried.\n!< refer to enum \\ref NV_GPU_ILLUMINATION_ATTRIB."] + pub Attribute: NV_GPU_ILLUMINATION_ATTRIB, + #[doc = "!< A DWORD containing the new value for the specified attribute.\n!< This should be specified as a percentage of the full range of the attribute\n!< (0-100; 0 = off, 100 = full brightness)\n!< If a value is specified outside this range, NVAPI_INVALID_ARGUMENT will be returned."] + pub Value: NvU32, +} +#[doc = "! \\ingroup gpu"] +pub type NV_GPU_SET_ILLUMINATION_PARM_V1 = _NV_GPU_SET_ILLUMINATION_PARM_V1; +#[doc = "! \\ingroup gpu"] +pub type NV_GPU_SET_ILLUMINATION_PARM = NV_GPU_SET_ILLUMINATION_PARM_V1; +pub const NV_GPU_CLIENT_ILLUM_CTRL_MODE_NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB: + NV_GPU_CLIENT_ILLUM_CTRL_MODE = 0; +pub const NV_GPU_CLIENT_ILLUM_CTRL_MODE_NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB: + NV_GPU_CLIENT_ILLUM_CTRL_MODE = 1; +pub const NV_GPU_CLIENT_ILLUM_CTRL_MODE_NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL: + NV_GPU_CLIENT_ILLUM_CTRL_MODE = 0; +pub const NV_GPU_CLIENT_ILLUM_CTRL_MODE_NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR: + NV_GPU_CLIENT_ILLUM_CTRL_MODE = 1; +pub const NV_GPU_CLIENT_ILLUM_CTRL_MODE_NV_GPU_CLIENT_ILLUM_CTRL_MODE_INVALID: + NV_GPU_CLIENT_ILLUM_CTRL_MODE = 255; +#[doc = " Enumeration of control modes that can be applied to Illumination Zones."] +pub type NV_GPU_CLIENT_ILLUM_CTRL_MODE = ::std::os::raw::c_int; +pub const NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_GPU_TOP_0: + NV_GPU_CLIENT_ILLUM_ZONE_LOCATION = 0; +pub const NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_GPU_FRONT_0: + NV_GPU_CLIENT_ILLUM_ZONE_LOCATION = 8; +pub const NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_GPU_BACK_0: + NV_GPU_CLIENT_ILLUM_ZONE_LOCATION = 12; +pub const NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_SLI_TOP_0: + NV_GPU_CLIENT_ILLUM_ZONE_LOCATION = 32; +pub const NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_INVALID: + NV_GPU_CLIENT_ILLUM_ZONE_LOCATION = -1; +#[doc = " Enumeration of locations where an Illumination Zone might be present.\n Encoding used -\n 1:0 - Number specifier (0)\n 4:2 - Location (TOP)\n 7:5 - Type (GPU/SLI)"] +pub type NV_GPU_CLIENT_ILLUM_ZONE_LOCATION = ::std::os::raw::c_int; +pub const NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_INVALID: + NV_GPU_CLIENT_ILLUM_DEVICE_TYPE = 0; +pub const NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_MCUV10: + NV_GPU_CLIENT_ILLUM_DEVICE_TYPE = 1; +pub const NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_GPIO_PWM_RGBW_V10: + NV_GPU_CLIENT_ILLUM_DEVICE_TYPE = 2; +pub const NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_GPIO_PWM_SINGLE_COLOR_V10 : NV_GPU_CLIENT_ILLUM_DEVICE_TYPE = 3 ; +#[doc = " Enumeration of ILLUM_DEVICEs."] +pub type NV_GPU_CLIENT_ILLUM_DEVICE_TYPE = ::std::os::raw::c_int; +pub const NV_GPU_CLIENT_ILLUM_ZONE_TYPE_NV_GPU_CLIENT_ILLUM_ZONE_TYPE_INVALID: + NV_GPU_CLIENT_ILLUM_ZONE_TYPE = 0; +pub const NV_GPU_CLIENT_ILLUM_ZONE_TYPE_NV_GPU_CLIENT_ILLUM_ZONE_TYPE_RGB: + NV_GPU_CLIENT_ILLUM_ZONE_TYPE = 1; +pub const NV_GPU_CLIENT_ILLUM_ZONE_TYPE_NV_GPU_CLIENT_ILLUM_ZONE_TYPE_COLOR_FIXED: + NV_GPU_CLIENT_ILLUM_ZONE_TYPE = 2; +pub const NV_GPU_CLIENT_ILLUM_ZONE_TYPE_NV_GPU_CLIENT_ILLUM_ZONE_TYPE_RGBW: + NV_GPU_CLIENT_ILLUM_ZONE_TYPE = 3; +pub const NV_GPU_CLIENT_ILLUM_ZONE_TYPE_NV_GPU_CLIENT_ILLUM_ZONE_TYPE_SINGLE_COLOR: + NV_GPU_CLIENT_ILLUM_ZONE_TYPE = 4; +#[doc = " Enumeration of ILLUM_ZONEs."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_TYPE = ::std::os::raw::c_int; +pub const NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE_NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_HALF_HALT : NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE = 0 ; +pub const NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE_NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_FULL_HALT : NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE = 1 ; +pub const NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE_NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_FULL_REPEAT : NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE = 2 ; +pub const NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE_NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_INVALID : NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE = 255 ; +#[doc = " Enumeration of Cycle types for piecewise linear control mode."] +pub type NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE = ::std::os::raw::c_int; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1\n Describes the static information of illumination device type MCUV10."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_MCUV10 { + #[doc = " I2C Device Index: Pointing to the illumination device in I2C Devices Table."] + pub i2cDevIdx: NvU8, +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1\n Describes the static information of illumination device type MCUV10."] +pub type NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_MCUV10 = _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_MCUV10; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1\n Describes the static information of illum device type GPIO_PWM_RGBW."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_RGBW { + #[doc = " Red drive GPIO pin."] + pub gpioPinRed: NvU8, + #[doc = " Green drive GPIO pin."] + pub gpioPinGreen: NvU8, + #[doc = " Blue drive GPIO pin."] + pub gpioPinBlue: NvU8, + #[doc = " White drive GPIO pin."] + pub gpioPinWhite: NvU8, +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1\n Describes the static information of illum device type GPIO_PWM_RGBW."] +pub type NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_RGBW = + _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_RGBW; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1\n Describes the static information of illum device type GPIO_PWM_SINGLE_COLOR."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_SINGLE_COLOR { + #[doc = " Single Color GPIO pin."] + pub gpioPinSingleColor: NvU8, +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1\n Describes the static information of illum device type GPIO_PWM_SINGLE_COLOR."] +pub type NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_SINGLE_COLOR = + _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_SINGLE_COLOR; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1 { + #[doc = " Type of the illumination device."] + pub type_: NV_GPU_CLIENT_ILLUM_DEVICE_TYPE, + #[doc = " Supported control modes for this illumination device."] + pub ctrlModeMask: NvU32, + pub data: _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1__bindgen_ty_1, + #[doc = " Reserved for future."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Union of illumination device info data. Interpreted as per\n @ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1::type"] +#[repr(C)] +#[derive(Copy, Clone)] +pub union _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1__bindgen_ty_1 { + pub mcuv10: NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_MCUV10, + pub gpioPwmRgbwv10: NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_RGBW, + pub gpioPwmSingleColorv10: NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_SINGLE_COLOR, + #[doc = " Reserved bytes for possible future extension of this struct."] + pub rsvd: [NvU8; 64usize], +} +pub type NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1 = _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_PARAMS_V1 { + #[doc = " Version of structure. Must always be first member."] + pub version: NvU32, + #[doc = " Number of illumination devices present."] + pub numIllumDevices: NvU32, + #[doc = " Reserved bytes for possible future extension of this struct."] + pub rsvd: [NvU8; 64usize], + pub devices: [NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1; 32usize], +} +pub type NV_GPU_CLIENT_ILLUM_DEVICE_INFO_PARAMS_V1 = _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_PARAMS_V1; +pub type NV_GPU_CLIENT_ILLUM_DEVICE_INFO_PARAMS = NV_GPU_CLIENT_ILLUM_DEVICE_INFO_PARAMS_V1; +#[doc = " Structure representing the data required for synchronization."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_CLIENT_ILLUM_DEVICE_SYNC_V1 { + #[doc = " Boolean representing the need for synchronization."] + pub bSync: NvBool, + #[doc = " Time stamp value required for synchronization."] + pub timeStampms: NvU64, + #[doc = " Reserved for future."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Structure representing the device control parameters of each ILLUM_DEVICE."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_V1 { + #[doc = " Type of the illum device."] + pub type_: NV_GPU_CLIENT_ILLUM_DEVICE_TYPE, + #[doc = " Structure containing the synchronization data for the illumination device."] + pub syncData: NV_GPU_CLIENT_ILLUM_DEVICE_SYNC_V1, + #[doc = " Reserved for future."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Structure representing the device control parameters of each ILLUM_DEVICE."] +pub type NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL = NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_V1; +#[doc = " Structure representing the control parameters of ILLUM_DEVICE-s."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_PARAMS_V1 { + #[doc = " Version of structure. Must always be first member."] + pub version: NvU32, + #[doc = " Number of illumination devices present."] + pub numIllumDevices: NvU32, + #[doc = " Reserved bytes for possible future extension of this struct."] + pub rsvd: [NvU8; 64usize], + pub devices: [NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_V1; 32usize], +} +#[doc = " Structure representing the control parameters of ILLUM_DEVICE-s."] +pub type NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_PARAMS = NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_PARAMS_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGB { + pub rsvd: NvU8, +} +pub type NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGB = _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGB; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1\n Describes the static information of illum zone type RGBW."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGBW { + pub rsvd: NvU8, +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1\n Describes the static information of illum zone type RGBW."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGBW = _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGBW; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1\n Describes the static information of illum zone type SINGLE_COLOR."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_SINGLE_COLOR { + pub rsvd: NvU8, +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1\n Describes the static information of illum zone type SINGLE_COLOR."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_SINGLE_COLOR = + _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_SINGLE_COLOR; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1 { + pub type_: NV_GPU_CLIENT_ILLUM_ZONE_TYPE, + #[doc = " Index pointing to an Illumination Device that controls this zone."] + pub illumDeviceIdx: NvU8, + #[doc = " Provider index for representing logical to physical zone mapping."] + pub provIdx: NvU8, + #[doc = " Location of the zone on the board."] + pub zoneLocation: NV_GPU_CLIENT_ILLUM_ZONE_LOCATION, + pub data: _NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1__bindgen_ty_1, + pub rsvd: [NvU8; 64usize], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union _NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1__bindgen_ty_1 { + pub rgb: NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGB, + pub rgbw: NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGBW, + pub singleColor: NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_SINGLE_COLOR, + #[doc = " Reserved bytes for possible future extension of this struct."] + pub rsvd: [NvU8; 64usize], +} +pub type NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1 = _NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_INFO_PARAMS_V1 { + #[doc = " Version of structure. Must always be first member."] + pub version: NvU32, + #[doc = " Number of illumination zones present."] + pub numIllumZones: NvU32, + #[doc = " Reserved bytes for possible future extension of this struct."] + pub rsvd: [NvU8; 64usize], + pub zones: [NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1; 32usize], +} +pub type NV_GPU_CLIENT_ILLUM_ZONE_INFO_PARAMS_V1 = _NV_GPU_CLIENT_ILLUM_ZONE_INFO_PARAMS_V1; +pub type NV_GPU_CLIENT_ILLUM_ZONE_INFO_PARAMS = NV_GPU_CLIENT_ILLUM_ZONE_INFO_PARAMS_V1; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB\n Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB_PARAMS { + #[doc = " Red compenent of color applied to the zone."] + pub colorR: NvU8, + #[doc = " Green compenent of color applied to the zone."] + pub colorG: NvU8, + #[doc = " Blue compenent of color applied to the zone."] + pub colorB: NvU8, + #[doc = " Brightness perecentage value of the zone."] + pub brightnessPct: NvU8, +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB\n Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB_PARAMS = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB_PARAMS; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB { + #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] + pub rgbParams: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB_PARAMS, +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB; +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR { + #[doc = " Type of cycle effect to apply."] + pub cycleType: NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE, + #[doc = " Number of times to repeat function within group period."] + pub grpCount: NvU8, + #[doc = " Time in ms to transition from color A to color B."] + pub riseTimems: NvU16, + #[doc = " Time in ms to transition from color B to color A."] + pub fallTimems: NvU16, + #[doc = " Time in ms to remain at color A before color A to color B transition."] + pub ATimems: NvU16, + #[doc = " Time in ms to remain at color B before color B to color A transition."] + pub BTimems: NvU16, + #[doc = " Time in ms to remain idle before next group of repeated function cycles."] + pub grpIdleTimems: NvU16, + #[doc = " Time in ms to offset the cycle relative to other zones."] + pub phaseOffsetms: NvU16, +} +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB { + #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] + pub rgbParams: [NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB_PARAMS; 2usize], + pub piecewiseLinearData: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR, +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illumination zone of type\n \\ref NV_GPU_CLIENT_ILLUM_ZONE_TYPE_RGB."] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB { + pub data: _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB__bindgen_ty_1, + #[doc = " Reserved for future."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Union of illumination zone control data for zone of type NV_GPU_CLIENT_ILLUM_ZONE_TYPE_RGB.\n Interpreted as per ctrlMode."] +#[repr(C)] +#[derive(Copy, Clone)] +pub union _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB__bindgen_ty_1 { + pub manualRGB: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB, + pub piecewiseLinearRGB: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB, + #[doc = " Reserved bytes for possible future extension of this struct."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illumination zone of type\n \\ref NV_GPU_CLIENT_ILLUM_ZONE_TYPE_RGB."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB = _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB; +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED\n Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_RGB."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED_PARAMS { + #[doc = " Brightness percentage value of the zone."] + pub brightnessPct: NvU8, +} +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED\n Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_RGB."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED_PARAMS = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED_PARAMS; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED { + #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] + pub colorFixedParams: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED_PARAMS, +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_COLOR_FIXED { + #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] + pub colorFixedParams: [NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED_PARAMS; 2usize], + pub piecewiseLinearData: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR, +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_COLOR_FIXED = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_COLOR_FIXED; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illum zone of type\n \\ref NV_GPU_CLIENT_ILLUM_ZONE_TYPE_COLOR_FIXED."] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED { + pub data: _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED__bindgen_ty_1, + #[doc = " Reserved for future."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Union of illum zone control data for zone of type NV_GPU_CLIENT_ILLUM_ZONE_TYPE_COLOR_FIXED.\n Interpreted as per ctrlMode."] +#[repr(C)] +#[derive(Copy, Clone)] +pub union _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED__bindgen_ty_1 { + pub manualColorFixed: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED, + pub piecewiseLinearColorFixed: + NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_COLOR_FIXED, + #[doc = " Reserved bytes for possible future extension of this struct."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illum zone of type\n \\ref NV_GPU_CLIENT_ILLUM_ZONE_TYPE_COLOR_FIXED."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW\n Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGBW."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW_PARAMS { + #[doc = " Red component of color applied to the zone."] + pub colorR: NvU8, + #[doc = " Green component of color applied to the zone."] + pub colorG: NvU8, + #[doc = " Blue component of color applied to the zone."] + pub colorB: NvU8, + #[doc = " White component of color applied to the zone."] + pub colorW: NvU8, + #[doc = " Brightness percentage value of the zone."] + pub brightnessPct: NvU8, +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW\n Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGBW."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW_PARAMS = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW_PARAMS; +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_RGBW\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_RGBW."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW { + #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_RGBW."] + pub rgbwParams: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW_PARAMS, +} +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_RGBW\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_RGBW."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW; +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_RGBW\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGBW."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGBW { + #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGBW."] + pub rgbwParams: [NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW_PARAMS; 2usize], + pub piecewiseLinearData: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR, +} +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_RGBW\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGBW."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGBW = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGBW; +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illum zone of type\n \\ref NV_GPU_ILLUM_ZONE_TYPE_RGBW."] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW { + pub data: _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW__bindgen_ty_1, + #[doc = " Reserved for future."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Union of illum zone control data for zone of type NV_GPU_ILLUM_ZONE_TYPE_RGBW.\n Interpreted as per ctrlMode."] +#[repr(C)] +#[derive(Copy, Clone)] +pub union _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW__bindgen_ty_1 { + pub manualRGBW: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW, + pub piecewiseLinearRGBW: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGBW, + #[doc = " Reserved bytes for possible future extension of this struct."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illum zone of type\n \\ref NV_GPU_ILLUM_ZONE_TYPE_RGBW."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW = _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW; +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR\n Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_SINGLE_COLOR."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR_PARAMS { + #[doc = " Brightness percentage value of the zone."] + pub brightnessPct: NvU8, +} +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR\n Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_SINGLE_COLOR."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR_PARAMS = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR_PARAMS; +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_SINGLE_COLOR."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR { + #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_SINGLE_COLOR."] + pub singleColorParams: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR_PARAMS, +} +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_SINGLE_COLOR."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR; +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_SINGLE_COLOR."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_SINGLE_COLOR { + #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_SINGLE_COLOR."] + pub singleColorParams: + [NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR_PARAMS; 2usize], + pub piecewiseLinearData: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR, +} +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_SINGLE_COLOR."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_SINGLE_COLOR = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_SINGLE_COLOR; +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illum zone of type\n \\ref NV_GPU_ILLUM_ZONE_TYPE_SINGLE_COLOR."] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR { + pub data: _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR__bindgen_ty_1, + #[doc = " Reserved for future."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Union of illum zone control data for zone of type NV_GPU_ILLUM_ZONE_TYPE_SINGLE_COLOR.\n Interpreted as per ctrlMode."] +#[repr(C)] +#[derive(Copy, Clone)] +pub union _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR__bindgen_ty_1 { + pub manualSingleColor: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR, + pub piecewiseLinearSingleColor: + NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_SINGLE_COLOR, + #[doc = " Reserved bytes for possible future extension of this struct."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illum zone of type\n \\ref NV_GPU_ILLUM_ZONE_TYPE_SINGLE_COLOR."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1 { + pub type_: NV_GPU_CLIENT_ILLUM_ZONE_TYPE, + pub ctrlMode: NV_GPU_CLIENT_ILLUM_CTRL_MODE, + pub data: _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1__bindgen_ty_1, + pub rsvd: [NvU8; 64usize], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1__bindgen_ty_1 { + pub rgb: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB, + pub colorFixed: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED, + pub rgbw: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW, + pub singleColor: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR, + pub rsvd: [NvU8; 64usize], +} +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1 = _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS_V1 { + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = " Number of illumination zones present."] + pub numIllumZonesControl: NvU32, + #[doc = " Reserved bytes for possible future extension of this struct."] + pub rsvd: [NvU8; 64usize], + pub zones: [NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1; 32usize], +} +impl _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS_V1 { + #[inline] + pub fn bDefault(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bDefault(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bDefault_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bDefault_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn rsvdField(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_rsvdField(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn rsvdField_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_rsvdField_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bDefault: NvU32, + rsvdField: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bDefault: u32 = unsafe { ::std::mem::transmute(bDefault) }; + bDefault as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let rsvdField: u32 = unsafe { ::std::mem::transmute(rsvdField) }; + rsvdField as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS_V1 = _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS_V1; +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS = NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS_V1; +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_GetDisplayPortInfo()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_DISPLAY_PORT_INFO_V1 { + #[doc = "!< Structure version"] + pub version: NvU32, + #[doc = "!< DPCD version of the monitor"] + pub dpcd_ver: NvU32, + #[doc = "!< Maximum supported link rate"] + pub maxLinkRate: NV_DP_LINK_RATE, + #[doc = "!< Maximum supported lane count"] + pub maxLaneCount: NV_DP_LANE_COUNT, + #[doc = "!< Current link rate"] + pub curLinkRate: NV_DP_LINK_RATE, + #[doc = "!< Current lane count"] + pub curLaneCount: NV_DP_LANE_COUNT, + #[doc = "!< Current color format"] + pub colorFormat: NV_DP_COLOR_FORMAT, + #[doc = "!< Dynamic range"] + pub dynamicRange: NV_DP_DYNAMIC_RANGE, + #[doc = "!< Ignored in RGB space"] + pub colorimetry: NV_DP_COLORIMETRY, + #[doc = "!< Current bit-per-component"] + pub bpc: NV_DP_BPC, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl _NV_DISPLAY_PORT_INFO_V1 { + #[inline] + pub fn isDp(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isDp(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isDp_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isDp_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isInternalDp(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isInternalDp(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isInternalDp_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isInternalDp_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isColorCtrlSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_isColorCtrlSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isColorCtrlSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isColorCtrlSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is6BPCSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_is6BPCSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is6BPCSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is6BPCSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is8BPCSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_is8BPCSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is8BPCSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is8BPCSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is10BPCSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_is10BPCSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is10BPCSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is10BPCSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is12BPCSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } + } + #[inline] + pub fn set_is12BPCSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is12BPCSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 6usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is12BPCSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is16BPCSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } + } + #[inline] + pub fn set_is16BPCSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is16BPCSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 7usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is16BPCSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 7usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isYCrCb420Supported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) } + } + #[inline] + pub fn set_isYCrCb420Supported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isYCrCb420Supported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 8usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isYCrCb420Supported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 8usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isYCrCb422Supported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) } + } + #[inline] + pub fn set_isYCrCb422Supported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(9usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isYCrCb422Supported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 9usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isYCrCb422Supported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 9usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isYCrCb444Supported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) } + } + #[inline] + pub fn set_isYCrCb444Supported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(10usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isYCrCb444Supported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 10usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isYCrCb444Supported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 10usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isRgb444SupportedOnCurrentMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) } + } + #[inline] + pub fn set_isRgb444SupportedOnCurrentMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(11usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isRgb444SupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 11usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isRgb444SupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 11usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isYCbCr444SupportedOnCurrentMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) } + } + #[inline] + pub fn set_isYCbCr444SupportedOnCurrentMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(12usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isYCbCr444SupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 12usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isYCbCr444SupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 12usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isYCbCr422SupportedOnCurrentMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) } + } + #[inline] + pub fn set_isYCbCr422SupportedOnCurrentMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(13usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isYCbCr422SupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 13usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isYCbCr422SupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 13usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isYCbCr420SupportedOnCurrentMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) } + } + #[inline] + pub fn set_isYCbCr420SupportedOnCurrentMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(14usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isYCbCr420SupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 14usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isYCbCr420SupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 14usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is6BPCSupportedOnCurrentMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) } + } + #[inline] + pub fn set_is6BPCSupportedOnCurrentMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(15usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is6BPCSupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 15usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is6BPCSupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 15usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is8BPCSupportedOnCurrentMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) } + } + #[inline] + pub fn set_is8BPCSupportedOnCurrentMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(16usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is8BPCSupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 16usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is8BPCSupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 16usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is10BPCSupportedOnCurrentMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) } + } + #[inline] + pub fn set_is10BPCSupportedOnCurrentMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(17usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is10BPCSupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 17usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is10BPCSupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 17usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is12BPCSupportedOnCurrentMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) } + } + #[inline] + pub fn set_is12BPCSupportedOnCurrentMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(18usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is12BPCSupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 18usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is12BPCSupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 18usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is16BPCSupportedOnCurrentMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u32) } + } + #[inline] + pub fn set_is16BPCSupportedOnCurrentMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(19usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is16BPCSupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 19usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is16BPCSupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 19usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonxvYCC601Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonxvYCC601Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(20usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonxvYCC601Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 20usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonxvYCC601Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 20usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonxvYCC709Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonxvYCC709Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(21usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonxvYCC709Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 21usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonxvYCC709Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 21usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonsYCC601Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonsYCC601Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(22usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonsYCC601Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 22usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonsYCC601Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 22usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonAdobeYCC601Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonAdobeYCC601Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(23usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonAdobeYCC601Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 23usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonAdobeYCC601Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 23usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonAdobeRGBCapable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonAdobeRGBCapable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(24usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonAdobeRGBCapable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 24usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonAdobeRGBCapable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 24usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonBT2020RGBCapable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonBT2020RGBCapable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(25usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonBT2020RGBCapable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 25usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonBT2020RGBCapable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 25usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonBT2020YCCCapable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonBT2020YCCCapable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(26usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonBT2020YCCCapable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 26usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonBT2020YCCCapable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 26usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonBT2020cYCCCapable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonBT2020cYCCCapable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(27usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonBT2020cYCCCapable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 27usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonBT2020cYCCCapable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 27usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 4u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(28usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 28usize, + 4u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 28usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isDp: NvU32, + isInternalDp: NvU32, + isColorCtrlSupported: NvU32, + is6BPCSupported: NvU32, + is8BPCSupported: NvU32, + is10BPCSupported: NvU32, + is12BPCSupported: NvU32, + is16BPCSupported: NvU32, + isYCrCb420Supported: NvU32, + isYCrCb422Supported: NvU32, + isYCrCb444Supported: NvU32, + isRgb444SupportedOnCurrentMode: NvU32, + isYCbCr444SupportedOnCurrentMode: NvU32, + isYCbCr422SupportedOnCurrentMode: NvU32, + isYCbCr420SupportedOnCurrentMode: NvU32, + is6BPCSupportedOnCurrentMode: NvU32, + is8BPCSupportedOnCurrentMode: NvU32, + is10BPCSupportedOnCurrentMode: NvU32, + is12BPCSupportedOnCurrentMode: NvU32, + is16BPCSupportedOnCurrentMode: NvU32, + isMonxvYCC601Capable: NvU32, + isMonxvYCC709Capable: NvU32, + isMonsYCC601Capable: NvU32, + isMonAdobeYCC601Capable: NvU32, + isMonAdobeRGBCapable: NvU32, + isMonBT2020RGBCapable: NvU32, + isMonBT2020YCCCapable: NvU32, + isMonBT2020cYCCCapable: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isDp: u32 = unsafe { ::std::mem::transmute(isDp) }; + isDp as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isInternalDp: u32 = unsafe { ::std::mem::transmute(isInternalDp) }; + isInternalDp as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let isColorCtrlSupported: u32 = unsafe { ::std::mem::transmute(isColorCtrlSupported) }; + isColorCtrlSupported as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let is6BPCSupported: u32 = unsafe { ::std::mem::transmute(is6BPCSupported) }; + is6BPCSupported as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let is8BPCSupported: u32 = unsafe { ::std::mem::transmute(is8BPCSupported) }; + is8BPCSupported as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let is10BPCSupported: u32 = unsafe { ::std::mem::transmute(is10BPCSupported) }; + is10BPCSupported as u64 + }); + __bindgen_bitfield_unit.set(6usize, 1u8, { + let is12BPCSupported: u32 = unsafe { ::std::mem::transmute(is12BPCSupported) }; + is12BPCSupported as u64 + }); + __bindgen_bitfield_unit.set(7usize, 1u8, { + let is16BPCSupported: u32 = unsafe { ::std::mem::transmute(is16BPCSupported) }; + is16BPCSupported as u64 + }); + __bindgen_bitfield_unit.set(8usize, 1u8, { + let isYCrCb420Supported: u32 = unsafe { ::std::mem::transmute(isYCrCb420Supported) }; + isYCrCb420Supported as u64 + }); + __bindgen_bitfield_unit.set(9usize, 1u8, { + let isYCrCb422Supported: u32 = unsafe { ::std::mem::transmute(isYCrCb422Supported) }; + isYCrCb422Supported as u64 + }); + __bindgen_bitfield_unit.set(10usize, 1u8, { + let isYCrCb444Supported: u32 = unsafe { ::std::mem::transmute(isYCrCb444Supported) }; + isYCrCb444Supported as u64 + }); + __bindgen_bitfield_unit.set(11usize, 1u8, { + let isRgb444SupportedOnCurrentMode: u32 = + unsafe { ::std::mem::transmute(isRgb444SupportedOnCurrentMode) }; + isRgb444SupportedOnCurrentMode as u64 + }); + __bindgen_bitfield_unit.set(12usize, 1u8, { + let isYCbCr444SupportedOnCurrentMode: u32 = + unsafe { ::std::mem::transmute(isYCbCr444SupportedOnCurrentMode) }; + isYCbCr444SupportedOnCurrentMode as u64 + }); + __bindgen_bitfield_unit.set(13usize, 1u8, { + let isYCbCr422SupportedOnCurrentMode: u32 = + unsafe { ::std::mem::transmute(isYCbCr422SupportedOnCurrentMode) }; + isYCbCr422SupportedOnCurrentMode as u64 + }); + __bindgen_bitfield_unit.set(14usize, 1u8, { + let isYCbCr420SupportedOnCurrentMode: u32 = + unsafe { ::std::mem::transmute(isYCbCr420SupportedOnCurrentMode) }; + isYCbCr420SupportedOnCurrentMode as u64 + }); + __bindgen_bitfield_unit.set(15usize, 1u8, { + let is6BPCSupportedOnCurrentMode: u32 = + unsafe { ::std::mem::transmute(is6BPCSupportedOnCurrentMode) }; + is6BPCSupportedOnCurrentMode as u64 + }); + __bindgen_bitfield_unit.set(16usize, 1u8, { + let is8BPCSupportedOnCurrentMode: u32 = + unsafe { ::std::mem::transmute(is8BPCSupportedOnCurrentMode) }; + is8BPCSupportedOnCurrentMode as u64 + }); + __bindgen_bitfield_unit.set(17usize, 1u8, { + let is10BPCSupportedOnCurrentMode: u32 = + unsafe { ::std::mem::transmute(is10BPCSupportedOnCurrentMode) }; + is10BPCSupportedOnCurrentMode as u64 + }); + __bindgen_bitfield_unit.set(18usize, 1u8, { + let is12BPCSupportedOnCurrentMode: u32 = + unsafe { ::std::mem::transmute(is12BPCSupportedOnCurrentMode) }; + is12BPCSupportedOnCurrentMode as u64 + }); + __bindgen_bitfield_unit.set(19usize, 1u8, { + let is16BPCSupportedOnCurrentMode: u32 = + unsafe { ::std::mem::transmute(is16BPCSupportedOnCurrentMode) }; + is16BPCSupportedOnCurrentMode as u64 + }); + __bindgen_bitfield_unit.set(20usize, 1u8, { + let isMonxvYCC601Capable: u32 = unsafe { ::std::mem::transmute(isMonxvYCC601Capable) }; + isMonxvYCC601Capable as u64 + }); + __bindgen_bitfield_unit.set(21usize, 1u8, { + let isMonxvYCC709Capable: u32 = unsafe { ::std::mem::transmute(isMonxvYCC709Capable) }; + isMonxvYCC709Capable as u64 + }); + __bindgen_bitfield_unit.set(22usize, 1u8, { + let isMonsYCC601Capable: u32 = unsafe { ::std::mem::transmute(isMonsYCC601Capable) }; + isMonsYCC601Capable as u64 + }); + __bindgen_bitfield_unit.set(23usize, 1u8, { + let isMonAdobeYCC601Capable: u32 = + unsafe { ::std::mem::transmute(isMonAdobeYCC601Capable) }; + isMonAdobeYCC601Capable as u64 + }); + __bindgen_bitfield_unit.set(24usize, 1u8, { + let isMonAdobeRGBCapable: u32 = unsafe { ::std::mem::transmute(isMonAdobeRGBCapable) }; + isMonAdobeRGBCapable as u64 + }); + __bindgen_bitfield_unit.set(25usize, 1u8, { + let isMonBT2020RGBCapable: u32 = + unsafe { ::std::mem::transmute(isMonBT2020RGBCapable) }; + isMonBT2020RGBCapable as u64 + }); + __bindgen_bitfield_unit.set(26usize, 1u8, { + let isMonBT2020YCCCapable: u32 = + unsafe { ::std::mem::transmute(isMonBT2020YCCCapable) }; + isMonBT2020YCCCapable as u64 + }); + __bindgen_bitfield_unit.set(27usize, 1u8, { + let isMonBT2020cYCCCapable: u32 = + unsafe { ::std::mem::transmute(isMonBT2020cYCCCapable) }; + isMonBT2020cYCCCapable as u64 + }); + __bindgen_bitfield_unit.set(28usize, 4u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_GetDisplayPortInfo()."] +pub type NV_DISPLAY_PORT_INFO_V1 = _NV_DISPLAY_PORT_INFO_V1; +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_GetDisplayPortInfo()."] +pub type NV_DISPLAY_PORT_INFO = NV_DISPLAY_PORT_INFO_V1; +#[doc = "! \\ingroup dispcontrol\n! DisplayPort configuration settings - used in NvAPI_SetDisplayPort()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_DISPLAY_PORT_CONFIG { + #[doc = "!< Structure version - 2 is the latest"] + pub version: NvU32, + #[doc = "!< Link rate"] + pub linkRate: NV_DP_LINK_RATE, + #[doc = "!< Lane count"] + pub laneCount: NV_DP_LANE_COUNT, + #[doc = "!< Color format to set"] + pub colorFormat: NV_DP_COLOR_FORMAT, + #[doc = "!< Dynamic range"] + pub dynamicRange: NV_DP_DYNAMIC_RANGE, + #[doc = "!< Ignored in RGB space"] + pub colorimetry: NV_DP_COLORIMETRY, + #[doc = "!< Bit-per-component"] + pub bpc: NV_DP_BPC, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +impl NV_DISPLAY_PORT_CONFIG { + #[inline] + pub fn isHPD(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isHPD(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isHPD_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isHPD_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isSetDeferred(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isSetDeferred(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isSetDeferred_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isSetDeferred_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isChromaLpfOff(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_isChromaLpfOff(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isChromaLpfOff_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isChromaLpfOff_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isDitherOff(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_isDitherOff(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isDitherOff_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isDitherOff_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn testLinkTrain(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_testLinkTrain(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn testLinkTrain_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_testLinkTrain_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn testColorChange(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_testColorChange(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn testColorChange_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_testColorChange_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isHPD: NvU32, + isSetDeferred: NvU32, + isChromaLpfOff: NvU32, + isDitherOff: NvU32, + testLinkTrain: NvU32, + testColorChange: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isHPD: u32 = unsafe { ::std::mem::transmute(isHPD) }; + isHPD as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isSetDeferred: u32 = unsafe { ::std::mem::transmute(isSetDeferred) }; + isSetDeferred as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let isChromaLpfOff: u32 = unsafe { ::std::mem::transmute(isChromaLpfOff) }; + isChromaLpfOff as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let isDitherOff: u32 = unsafe { ::std::mem::transmute(isDitherOff) }; + isDitherOff as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let testLinkTrain: u32 = unsafe { ::std::mem::transmute(testLinkTrain) }; + testLinkTrain as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let testColorChange: u32 = unsafe { ::std::mem::transmute(testColorChange) }; + testColorChange as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_GetHDMISupportInfo()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDMI_SUPPORT_INFO_V1 { + #[doc = "!< Structure version"] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Revision number of the EDID 861 extension"] + pub EDID861ExtRev: NvU32, +} +impl _NV_HDMI_SUPPORT_INFO_V1 { + #[inline] + pub fn isGpuHDMICapable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isGpuHDMICapable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isGpuHDMICapable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isGpuHDMICapable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonUnderscanCapable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonUnderscanCapable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonUnderscanCapable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonUnderscanCapable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonBasicAudioCapable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonBasicAudioCapable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonBasicAudioCapable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonBasicAudioCapable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonYCbCr444Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonYCbCr444Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonYCbCr444Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonYCbCr444Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonYCbCr422Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonYCbCr422Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonYCbCr422Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonYCbCr422Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonxvYCC601Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonxvYCC601Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonxvYCC601Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonxvYCC601Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonxvYCC709Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonxvYCC709Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonxvYCC709Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 6usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonxvYCC709Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonHDMI(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonHDMI(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonHDMI_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 7usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonHDMI_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 7usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 24u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 24u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 8usize, + 24u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 8usize, + 24u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isGpuHDMICapable: NvU32, + isMonUnderscanCapable: NvU32, + isMonBasicAudioCapable: NvU32, + isMonYCbCr444Capable: NvU32, + isMonYCbCr422Capable: NvU32, + isMonxvYCC601Capable: NvU32, + isMonxvYCC709Capable: NvU32, + isMonHDMI: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isGpuHDMICapable: u32 = unsafe { ::std::mem::transmute(isGpuHDMICapable) }; + isGpuHDMICapable as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isMonUnderscanCapable: u32 = + unsafe { ::std::mem::transmute(isMonUnderscanCapable) }; + isMonUnderscanCapable as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let isMonBasicAudioCapable: u32 = + unsafe { ::std::mem::transmute(isMonBasicAudioCapable) }; + isMonBasicAudioCapable as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let isMonYCbCr444Capable: u32 = unsafe { ::std::mem::transmute(isMonYCbCr444Capable) }; + isMonYCbCr444Capable as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let isMonYCbCr422Capable: u32 = unsafe { ::std::mem::transmute(isMonYCbCr422Capable) }; + isMonYCbCr422Capable as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let isMonxvYCC601Capable: u32 = unsafe { ::std::mem::transmute(isMonxvYCC601Capable) }; + isMonxvYCC601Capable as u64 + }); + __bindgen_bitfield_unit.set(6usize, 1u8, { + let isMonxvYCC709Capable: u32 = unsafe { ::std::mem::transmute(isMonxvYCC709Capable) }; + isMonxvYCC709Capable as u64 + }); + __bindgen_bitfield_unit.set(7usize, 1u8, { + let isMonHDMI: u32 = unsafe { ::std::mem::transmute(isMonHDMI) }; + isMonHDMI as u64 + }); + __bindgen_bitfield_unit.set(8usize, 24u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_GetHDMISupportInfo()."] +pub type NV_HDMI_SUPPORT_INFO_V1 = _NV_HDMI_SUPPORT_INFO_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDMI_SUPPORT_INFO_V2 { + #[doc = "!< Structure version"] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Revision number of the EDID 861 extension"] + pub EDID861ExtRev: NvU32, +} +impl _NV_HDMI_SUPPORT_INFO_V2 { + #[inline] + pub fn isGpuHDMICapable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isGpuHDMICapable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isGpuHDMICapable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isGpuHDMICapable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonUnderscanCapable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonUnderscanCapable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonUnderscanCapable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonUnderscanCapable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonBasicAudioCapable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonBasicAudioCapable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonBasicAudioCapable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonBasicAudioCapable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonYCbCr444Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonYCbCr444Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonYCbCr444Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonYCbCr444Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonYCbCr422Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonYCbCr422Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonYCbCr422Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonYCbCr422Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonxvYCC601Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonxvYCC601Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonxvYCC601Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonxvYCC601Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonxvYCC709Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonxvYCC709Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonxvYCC709Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 6usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonxvYCC709Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonHDMI(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonHDMI(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonHDMI_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 7usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonHDMI_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 7usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonsYCC601Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonsYCC601Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonsYCC601Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 8usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonsYCC601Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 8usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonAdobeYCC601Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonAdobeYCC601Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(9usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonAdobeYCC601Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 9usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonAdobeYCC601Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 9usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonAdobeRGBCapable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonAdobeRGBCapable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(10usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonAdobeRGBCapable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 10usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonAdobeRGBCapable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 10usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 21u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(11usize, 21u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 11usize, + 21u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 11usize, + 21u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isGpuHDMICapable: NvU32, + isMonUnderscanCapable: NvU32, + isMonBasicAudioCapable: NvU32, + isMonYCbCr444Capable: NvU32, + isMonYCbCr422Capable: NvU32, + isMonxvYCC601Capable: NvU32, + isMonxvYCC709Capable: NvU32, + isMonHDMI: NvU32, + isMonsYCC601Capable: NvU32, + isMonAdobeYCC601Capable: NvU32, + isMonAdobeRGBCapable: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isGpuHDMICapable: u32 = unsafe { ::std::mem::transmute(isGpuHDMICapable) }; + isGpuHDMICapable as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isMonUnderscanCapable: u32 = + unsafe { ::std::mem::transmute(isMonUnderscanCapable) }; + isMonUnderscanCapable as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let isMonBasicAudioCapable: u32 = + unsafe { ::std::mem::transmute(isMonBasicAudioCapable) }; + isMonBasicAudioCapable as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let isMonYCbCr444Capable: u32 = unsafe { ::std::mem::transmute(isMonYCbCr444Capable) }; + isMonYCbCr444Capable as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let isMonYCbCr422Capable: u32 = unsafe { ::std::mem::transmute(isMonYCbCr422Capable) }; + isMonYCbCr422Capable as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let isMonxvYCC601Capable: u32 = unsafe { ::std::mem::transmute(isMonxvYCC601Capable) }; + isMonxvYCC601Capable as u64 + }); + __bindgen_bitfield_unit.set(6usize, 1u8, { + let isMonxvYCC709Capable: u32 = unsafe { ::std::mem::transmute(isMonxvYCC709Capable) }; + isMonxvYCC709Capable as u64 + }); + __bindgen_bitfield_unit.set(7usize, 1u8, { + let isMonHDMI: u32 = unsafe { ::std::mem::transmute(isMonHDMI) }; + isMonHDMI as u64 + }); + __bindgen_bitfield_unit.set(8usize, 1u8, { + let isMonsYCC601Capable: u32 = unsafe { ::std::mem::transmute(isMonsYCC601Capable) }; + isMonsYCC601Capable as u64 + }); + __bindgen_bitfield_unit.set(9usize, 1u8, { + let isMonAdobeYCC601Capable: u32 = + unsafe { ::std::mem::transmute(isMonAdobeYCC601Capable) }; + isMonAdobeYCC601Capable as u64 + }); + __bindgen_bitfield_unit.set(10usize, 1u8, { + let isMonAdobeRGBCapable: u32 = unsafe { ::std::mem::transmute(isMonAdobeRGBCapable) }; + isMonAdobeRGBCapable as u64 + }); + __bindgen_bitfield_unit.set(11usize, 21u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_HDMI_SUPPORT_INFO_V2 = _NV_HDMI_SUPPORT_INFO_V2; +pub type NV_HDMI_SUPPORT_INFO = NV_HDMI_SUPPORT_INFO_V2; +#[doc = "!< Returns the fields in the infoframe with values set by the manufacturer - NVIDIA/OEM."] +pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_GET_DEFAULT: NV_INFOFRAME_CMD = 0; +#[doc = "!< Sets the fields in the infoframe to auto, and infoframe to the default infoframe for use in a set."] +pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_RESET: NV_INFOFRAME_CMD = 1; +#[doc = "!< Get the current infoframe state."] +pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_GET: NV_INFOFRAME_CMD = 2; +#[doc = "!< Set the current infoframe state (flushed to the monitor), the values are one time and do not persist."] +pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_SET: NV_INFOFRAME_CMD = 3; +#[doc = "!< Get the override infoframe state, non-override fields will be set to value = AUTO, overridden fields will have the current override values."] +pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_GET_OVERRIDE: NV_INFOFRAME_CMD = 4; +#[doc = "!< Set the override infoframe state, non-override fields will be set to value = AUTO, other values indicate override; persist across modeset/reboot"] +pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_SET_OVERRIDE: NV_INFOFRAME_CMD = 5; +#[doc = "!< get properties associated with infoframe (each of the infoframe type will have properties)"] +pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_GET_PROPERTY: NV_INFOFRAME_CMD = 6; +#[doc = "!< set properties associated with infoframe"] +pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_SET_PROPERTY: NV_INFOFRAME_CMD = 7; +#[doc = "! \\ingroup dispcontrol"] +pub type NV_INFOFRAME_CMD = ::std::os::raw::c_int; +#[doc = "!< Driver determines whether to send infoframes."] +pub const NV_INFOFRAME_PROPERTY_MODE_NV_INFOFRAME_PROPERTY_MODE_AUTO: NV_INFOFRAME_PROPERTY_MODE = + 0; +#[doc = "!< Driver always sends infoframe."] +pub const NV_INFOFRAME_PROPERTY_MODE_NV_INFOFRAME_PROPERTY_MODE_ENABLE: NV_INFOFRAME_PROPERTY_MODE = + 1; +#[doc = "!< Driver never sends infoframe."] +pub const NV_INFOFRAME_PROPERTY_MODE_NV_INFOFRAME_PROPERTY_MODE_DISABLE: + NV_INFOFRAME_PROPERTY_MODE = 2; +#[doc = "!< Driver only sends infoframe when client requests it via infoframe escape call."] +pub const NV_INFOFRAME_PROPERTY_MODE_NV_INFOFRAME_PROPERTY_MODE_ALLOW_OVERRIDE: + NV_INFOFRAME_PROPERTY_MODE = 3; +pub type NV_INFOFRAME_PROPERTY_MODE = ::std::os::raw::c_int; +pub const NV_INFOFRAME_PROPERTY_BLACKLIST_NV_INFOFRAME_PROPERTY_BLACKLIST_FALSE: + NV_INFOFRAME_PROPERTY_BLACKLIST = 0; +pub const NV_INFOFRAME_PROPERTY_BLACKLIST_NV_INFOFRAME_PROPERTY_BLACKLIST_TRUE: + NV_INFOFRAME_PROPERTY_BLACKLIST = 1; +#[doc = "! Returns whether the current monitor is in blacklist or force this monitor to be in blacklist."] +pub type NV_INFOFRAME_PROPERTY_BLACKLIST = ::std::os::raw::c_int; +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct NV_INFOFRAME_PROPERTY { + pub _bitfield_align_1: [u16; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl NV_INFOFRAME_PROPERTY { + #[inline] + pub fn mode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32) } + } + #[inline] + pub fn set_mode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn mode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 4u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_mode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn blackList(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 2u8) as u32) } + } + #[inline] + pub fn set_blackList(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn blackList_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_blackList_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 10u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 10u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 6usize, + 10u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 10u8, + val as u64, + ) + } + } + #[inline] + pub fn version(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 8u8) as u32) } + } + #[inline] + pub fn set_version(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(16usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn version_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 16usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_version_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 16usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn length(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u32) } + } + #[inline] + pub fn set_length(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(24usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn length_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 24usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_length_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 24usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + mode: NvU32, + blackList: NvU32, + reserved: NvU32, + version: NvU32, + length: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 4u8, { + let mode: u32 = unsafe { ::std::mem::transmute(mode) }; + mode as u64 + }); + __bindgen_bitfield_unit.set(4usize, 2u8, { + let blackList: u32 = unsafe { ::std::mem::transmute(blackList) }; + blackList as u64 + }); + __bindgen_bitfield_unit.set(6usize, 10u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit.set(16usize, 8u8, { + let version: u32 = unsafe { ::std::mem::transmute(version) }; + version as u64 + }); + __bindgen_bitfield_unit.set(24usize, 8u8, { + let length: u32 = unsafe { ::std::mem::transmute(length) }; + length as u64 + }); + __bindgen_bitfield_unit + } +} +pub const NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_NODATA: + NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO = 0; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_OVERSCAN: + NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO = 1; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_UNDERSCAN: + NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO = 2; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_FUTURE: + NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO = 3; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_AUTO: + NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO = 7; +#[doc = "! Byte1 related"] +pub type NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_NOT_PRESENT: + NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA = 0; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_VERTICAL_PRESENT : NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_HORIZONTAL_PRESENT : NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_BOTH_PRESENT: + NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA = 3; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_AUTO: + NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA = 7; +pub type NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO_NV_INFOFRAME_FIELD_VALUE_AVI_AFI_ABSENT: + NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO = 0; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO_NV_INFOFRAME_FIELD_VALUE_AVI_AFI_PRESENT: + NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO = 1; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO_NV_INFOFRAME_FIELD_VALUE_AVI_AFI_AUTO: + NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO = 3; +pub type NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_RGB: + NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT = 0; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_YCbCr422 : NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_YCbCr444 : NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_FUTURE : NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_AUTO: + NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT = 7; +pub type NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_F17_NV_INFOFRAME_FIELD_VALUE_AVI_F17_FALSE: + NV_INFOFRAME_FIELD_VALUE_AVI_F17 = 0; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_F17_NV_INFOFRAME_FIELD_VALUE_AVI_F17_TRUE: + NV_INFOFRAME_FIELD_VALUE_AVI_F17 = 1; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_F17_NV_INFOFRAME_FIELD_VALUE_AVI_F17_AUTO: + NV_INFOFRAME_FIELD_VALUE_AVI_F17 = 3; +pub type NV_INFOFRAME_FIELD_VALUE_AVI_F17 = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NO_AFD : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE01 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE02 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE03 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_LETTERBOX_GT16x9 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 4 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE05 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 5 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE06 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 6 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE07 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 7 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_EQUAL_CODEDFRAME : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 8 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_CENTER_4x3 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 9 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_CENTER_16x9 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 10 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_CENTER_14x9 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 11 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE12 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 12 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_4x3_ON_14x9 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 13 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_16x9_ON_14x9 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 14 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_16x9_ON_4x3 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 15 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 31 ; +#[doc = "! Byte2 related"] +pub type NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_NO_DATA : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_4x3 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_16x9 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_FUTURE : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME = 7 ; +pub type NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_NO_DATA : NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_SMPTE_170M : NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_ITUR_BT709 : NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_USE_EXTENDED_COLORIMETRY : NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_AUTO: + NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY = 7; +pub type NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_NO_DATA : NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_HORIZONTAL : NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_VERTICAL : NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_BOTH : NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING = 7 ; +#[doc = "! Byte 3 related"] +pub type NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_DEFAULT : NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_LIMITED_RANGE : NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_FULL_RANGE : NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_RESERVED : NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION = 7 ; +pub type NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_XVYCC601 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_XVYCC709 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_SYCC601 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_ADOBEYCC601 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_ADOBERGB : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 4 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_RESERVED05 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 5 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_RESERVED06 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 6 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_RESERVED07 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 7 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 15 ; +pub type NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ITC_NV_INFOFRAME_FIELD_VALUE_AVI_ITC_VIDEO_CONTENT: + NV_INFOFRAME_FIELD_VALUE_AVI_ITC = 0; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ITC_NV_INFOFRAME_FIELD_VALUE_AVI_ITC_ITCONTENT: + NV_INFOFRAME_FIELD_VALUE_AVI_ITC = 1; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ITC_NV_INFOFRAME_FIELD_VALUE_AVI_ITC_AUTO: + NV_INFOFRAME_FIELD_VALUE_AVI_ITC = 3; +pub type NV_INFOFRAME_FIELD_VALUE_AVI_ITC = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NONE : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X02 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X03 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X04 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X05 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 4 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X06 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 5 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X07 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 6 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X08 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 7 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X09 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 8 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X10 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 9 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED10 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 10 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED11 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 11 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED12 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 12 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED13 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 13 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED14 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 14 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED15 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 15 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 31 ; +#[doc = "! Byte 4 related"] +pub type NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_GRAPHICS : NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_PHOTO : NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_CINEMA : NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_GAME: + NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE = 3; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_AUTO: + NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE = 7; +pub type NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_LIMITED_RANGE : NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_FULL_RANGE : NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_RESERVED02 : NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_RESERVED03 : NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION = 7 ; +pub type NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION = ::std::os::raw::c_int; +#[doc = "! Adding an Auto bit to each field"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_INFOFRAME_VIDEO { + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 23usize]>, +} +impl NV_INFOFRAME_VIDEO { + #[inline] + pub fn vic(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) } + } + #[inline] + pub fn set_vic(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn vic_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_vic_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn pixelRepeat(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 5u8) as u32) } + } + #[inline] + pub fn set_pixelRepeat(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 5u8, val as u64) + } + } + #[inline] + pub unsafe fn pixelRepeat_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 8usize, + 5u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_pixelRepeat_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 8usize, + 5u8, + val as u64, + ) + } + } + #[inline] + pub fn colorSpace(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 3u8) as u32) } + } + #[inline] + pub fn set_colorSpace(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(13usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn colorSpace_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 13usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_colorSpace_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 13usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn colorimetry(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 3u8) as u32) } + } + #[inline] + pub fn set_colorimetry(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(16usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn colorimetry_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 16usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_colorimetry_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 16usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn extendedColorimetry(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 4u8) as u32) } + } + #[inline] + pub fn set_extendedColorimetry(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(19usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn extendedColorimetry_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 19usize, + 4u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_extendedColorimetry_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 19usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn rgbQuantizationRange(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 3u8) as u32) } + } + #[inline] + pub fn set_rgbQuantizationRange(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(23usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn rgbQuantizationRange_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 23usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_rgbQuantizationRange_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 23usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn yccQuantizationRange(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 3u8) as u32) } + } + #[inline] + pub fn set_yccQuantizationRange(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(26usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn yccQuantizationRange_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 26usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_yccQuantizationRange_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 26usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn itContent(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 2u8) as u32) } + } + #[inline] + pub fn set_itContent(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(29usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn itContent_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 29usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_itContent_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 29usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn contentTypes(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 3u8) as u32) } + } + #[inline] + pub fn set_contentTypes(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(32usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn contentTypes_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 32usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_contentTypes_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 32usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn scanInfo(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(35usize, 3u8) as u32) } + } + #[inline] + pub fn set_scanInfo(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(35usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn scanInfo_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 35usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_scanInfo_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 35usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn activeFormatInfoPresent(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(38usize, 2u8) as u32) } + } + #[inline] + pub fn set_activeFormatInfoPresent(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(38usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn activeFormatInfoPresent_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 38usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_activeFormatInfoPresent_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 38usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn activeFormatAspectRatio(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(40usize, 5u8) as u32) } + } + #[inline] + pub fn set_activeFormatAspectRatio(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(40usize, 5u8, val as u64) + } + } + #[inline] + pub unsafe fn activeFormatAspectRatio_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 40usize, + 5u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_activeFormatAspectRatio_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 40usize, + 5u8, + val as u64, + ) + } + } + #[inline] + pub fn picAspectRatio(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(45usize, 3u8) as u32) } + } + #[inline] + pub fn set_picAspectRatio(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(45usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn picAspectRatio_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 45usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_picAspectRatio_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 45usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn nonuniformScaling(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 3u8) as u32) } + } + #[inline] + pub fn set_nonuniformScaling(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(48usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn nonuniformScaling_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 48usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_nonuniformScaling_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 48usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn barInfo(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(51usize, 3u8) as u32) } + } + #[inline] + pub fn set_barInfo(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(51usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn barInfo_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 51usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_barInfo_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 51usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn top_bar(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(64usize, 17u8) as u32) } + } + #[inline] + pub fn set_top_bar(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(64usize, 17u8, val as u64) + } + } + #[inline] + pub unsafe fn top_bar_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 64usize, + 17u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_top_bar_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 64usize, + 17u8, + val as u64, + ) + } + } + #[inline] + pub fn bottom_bar(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(96usize, 17u8) as u32) } + } + #[inline] + pub fn set_bottom_bar(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(96usize, 17u8, val as u64) + } + } + #[inline] + pub unsafe fn bottom_bar_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 96usize, + 17u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bottom_bar_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 96usize, + 17u8, + val as u64, + ) + } + } + #[inline] + pub fn left_bar(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(128usize, 17u8) as u32) } + } + #[inline] + pub fn set_left_bar(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(128usize, 17u8, val as u64) + } + } + #[inline] + pub unsafe fn left_bar_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 128usize, + 17u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_left_bar_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 128usize, + 17u8, + val as u64, + ) + } + } + #[inline] + pub fn right_bar(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(160usize, 17u8) as u32) } + } + #[inline] + pub fn set_right_bar(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(160usize, 17u8, val as u64) + } + } + #[inline] + pub unsafe fn right_bar_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 160usize, + 17u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_right_bar_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 160usize, + 17u8, + val as u64, + ) + } + } + #[inline] + pub fn Future17(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(177usize, 2u8) as u32) } + } + #[inline] + pub fn set_Future17(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(177usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn Future17_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 177usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_Future17_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 177usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn Future47(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(179usize, 2u8) as u32) } + } + #[inline] + pub fn set_Future47(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(179usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn Future47_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 179usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_Future47_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 179usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + vic: NvU32, + pixelRepeat: NvU32, + colorSpace: NvU32, + colorimetry: NvU32, + extendedColorimetry: NvU32, + rgbQuantizationRange: NvU32, + yccQuantizationRange: NvU32, + itContent: NvU32, + contentTypes: NvU32, + scanInfo: NvU32, + activeFormatInfoPresent: NvU32, + activeFormatAspectRatio: NvU32, + picAspectRatio: NvU32, + nonuniformScaling: NvU32, + barInfo: NvU32, + top_bar: NvU32, + bottom_bar: NvU32, + left_bar: NvU32, + right_bar: NvU32, + Future17: NvU32, + Future47: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 23usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 23usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 8u8, { + let vic: u32 = unsafe { ::std::mem::transmute(vic) }; + vic as u64 + }); + __bindgen_bitfield_unit.set(8usize, 5u8, { + let pixelRepeat: u32 = unsafe { ::std::mem::transmute(pixelRepeat) }; + pixelRepeat as u64 + }); + __bindgen_bitfield_unit.set(13usize, 3u8, { + let colorSpace: u32 = unsafe { ::std::mem::transmute(colorSpace) }; + colorSpace as u64 + }); + __bindgen_bitfield_unit.set(16usize, 3u8, { + let colorimetry: u32 = unsafe { ::std::mem::transmute(colorimetry) }; + colorimetry as u64 + }); + __bindgen_bitfield_unit.set(19usize, 4u8, { + let extendedColorimetry: u32 = unsafe { ::std::mem::transmute(extendedColorimetry) }; + extendedColorimetry as u64 + }); + __bindgen_bitfield_unit.set(23usize, 3u8, { + let rgbQuantizationRange: u32 = unsafe { ::std::mem::transmute(rgbQuantizationRange) }; + rgbQuantizationRange as u64 + }); + __bindgen_bitfield_unit.set(26usize, 3u8, { + let yccQuantizationRange: u32 = unsafe { ::std::mem::transmute(yccQuantizationRange) }; + yccQuantizationRange as u64 + }); + __bindgen_bitfield_unit.set(29usize, 2u8, { + let itContent: u32 = unsafe { ::std::mem::transmute(itContent) }; + itContent as u64 + }); + __bindgen_bitfield_unit.set(32usize, 3u8, { + let contentTypes: u32 = unsafe { ::std::mem::transmute(contentTypes) }; + contentTypes as u64 + }); + __bindgen_bitfield_unit.set(35usize, 3u8, { + let scanInfo: u32 = unsafe { ::std::mem::transmute(scanInfo) }; + scanInfo as u64 + }); + __bindgen_bitfield_unit.set(38usize, 2u8, { + let activeFormatInfoPresent: u32 = + unsafe { ::std::mem::transmute(activeFormatInfoPresent) }; + activeFormatInfoPresent as u64 + }); + __bindgen_bitfield_unit.set(40usize, 5u8, { + let activeFormatAspectRatio: u32 = + unsafe { ::std::mem::transmute(activeFormatAspectRatio) }; + activeFormatAspectRatio as u64 + }); + __bindgen_bitfield_unit.set(45usize, 3u8, { + let picAspectRatio: u32 = unsafe { ::std::mem::transmute(picAspectRatio) }; + picAspectRatio as u64 + }); + __bindgen_bitfield_unit.set(48usize, 3u8, { + let nonuniformScaling: u32 = unsafe { ::std::mem::transmute(nonuniformScaling) }; + nonuniformScaling as u64 + }); + __bindgen_bitfield_unit.set(51usize, 3u8, { + let barInfo: u32 = unsafe { ::std::mem::transmute(barInfo) }; + barInfo as u64 + }); + __bindgen_bitfield_unit.set(64usize, 17u8, { + let top_bar: u32 = unsafe { ::std::mem::transmute(top_bar) }; + top_bar as u64 + }); + __bindgen_bitfield_unit.set(96usize, 17u8, { + let bottom_bar: u32 = unsafe { ::std::mem::transmute(bottom_bar) }; + bottom_bar as u64 + }); + __bindgen_bitfield_unit.set(128usize, 17u8, { + let left_bar: u32 = unsafe { ::std::mem::transmute(left_bar) }; + left_bar as u64 + }); + __bindgen_bitfield_unit.set(160usize, 17u8, { + let right_bar: u32 = unsafe { ::std::mem::transmute(right_bar) }; + right_bar as u64 + }); + __bindgen_bitfield_unit.set(177usize, 2u8, { + let Future17: u32 = unsafe { ::std::mem::transmute(Future17) }; + Future17 as u64 + }); + __bindgen_bitfield_unit.set(179usize, 2u8, { + let Future47: u32 = unsafe { ::std::mem::transmute(Future47) }; + Future47 as u64 + }); + __bindgen_bitfield_unit + } +} +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_IN_HEADER : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_2 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_3 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_4 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_5 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 4 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_6 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 5 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_7 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 6 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_8 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 7 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 15 ; +#[doc = "! Byte 1 related"] +pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_IN_HEADER : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_PCM : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_AC3 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_MPEG1 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_MP3 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 4 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_MPEG2 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 5 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_AACLC : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 6 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_DTS : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 7 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_ATRAC : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 8 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_DSD : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 9 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_EAC3 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 10 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_DTSHD : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 11 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_MLP : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 12 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_DST : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 13 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_WMAPRO : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 14 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_USE_CODING_EXTENSION_TYPE : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 15 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 31 ; +pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_IN_HEADER : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_16BITS : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_20BITS : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_24BITS : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE = 7 ; +#[doc = "! Byte 2 related"] +pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_IN_HEADER : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_32000HZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_44100HZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_48000HZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_88200KHZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 4 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_96000KHZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 5 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_176400KHZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 6 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_192000KHZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 7 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 15 ; +pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_USE_CODING_TYPE : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_HEAAC : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_HEAACV2 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_MPEGSURROUND : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE04 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 4 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE05 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 5 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE06 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 6 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE07 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 7 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE08 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 8 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE09 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 9 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE10 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 10 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE11 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 11 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE12 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 12 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE13 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 13 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE14 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 14 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE15 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 15 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE16 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 16 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE17 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 17 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE18 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 18 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE19 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 19 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE20 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 20 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE21 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 21 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE22 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 22 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE23 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 23 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE24 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 24 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE25 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 25 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE26 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 26 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE27 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 27 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE28 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 28 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE29 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 29 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE30 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 30 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE31 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 31 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 63 ; +#[doc = "! Byte 3 related"] +pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_X_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_X_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_X_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_X_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_RC_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 4 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_RC_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 5 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_RC_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 6 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_RC_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 7 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_RR_RL_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 8 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_RR_RL_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 9 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 10 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 11 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_RC_RR_RL_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 12 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_RC_RR_RL_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 13 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_RC_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 14 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_RC_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 15 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_RRC_RLC_RR_RL_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 16 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_RRC_RLC_RR_RL_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 17 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_RRC_RLC_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 18 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_RRC_RLC_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 19 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_X_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 20 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_X_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 21 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_X_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 22 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_X_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 23 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_RC_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 24 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_RC_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 25 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_RC_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 26 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_RC_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 27 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_RR_RL_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 28 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_RR_RL_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 29 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 30 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 31 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_FCH_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 32 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_FCH_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 33 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_X_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 34 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_X_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 35 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRH_FLH_RR_RL_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 36 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRH_FLH_RR_RL_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 37 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRW_FLW_RR_RL_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 38 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRW_FLW_RR_RL_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 39 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_RC_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 40 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_RC_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 41 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FCH_RC_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 42 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FCH_RC_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 43 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_FCH_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 44 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_FCH_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 45 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRH_FLH_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 46 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRH_FLH_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 47 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRW_FLW_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 48 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRW_FLW_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 49 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 511 ; +#[doc = "! Byte 4 related"] +pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_NO_DATA : NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_0DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_PLUS10DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_RESERVED03 : NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL = 7 ; +#[doc = "! Byte 5 related"] +pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_0DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_1DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_2DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_3DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_4DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 4 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_5DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 5 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_6DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 6 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_7DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 7 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_8DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 8 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_9DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 9 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_10DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 10 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_11DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 11 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_12DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 12 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_13DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 13 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_14DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 14 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_15DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 15 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 31 ; +pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_PERMITTED : NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_PROHIBITED : NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_AUTO: + NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX = 3; +pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX = ::std::os::raw::c_int; +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct NV_INFOFRAME_AUDIO { + pub _bitfield_align_1: [u16; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 14usize]>, + pub __bindgen_padding_0: u16, +} +impl NV_INFOFRAME_AUDIO { + #[inline] + pub fn codingType(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 5u8) as u32) } + } + #[inline] + pub fn set_codingType(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 5u8, val as u64) + } + } + #[inline] + pub unsafe fn codingType_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 5u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_codingType_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 5u8, + val as u64, + ) + } + } + #[inline] + pub fn codingExtensionType(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 6u8) as u32) } + } + #[inline] + pub fn set_codingExtensionType(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 6u8, val as u64) + } + } + #[inline] + pub unsafe fn codingExtensionType_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 6u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_codingExtensionType_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 6u8, + val as u64, + ) + } + } + #[inline] + pub fn sampleSize(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 3u8) as u32) } + } + #[inline] + pub fn set_sampleSize(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(11usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn sampleSize_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 11usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_sampleSize_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 11usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn sampleRate(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 4u8) as u32) } + } + #[inline] + pub fn set_sampleRate(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(14usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn sampleRate_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 14usize, + 4u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_sampleRate_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 14usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn channelCount(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 4u8) as u32) } + } + #[inline] + pub fn set_channelCount(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(18usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn channelCount_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 18usize, + 4u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_channelCount_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 18usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn speakerPlacement(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 9u8) as u32) } + } + #[inline] + pub fn set_speakerPlacement(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(22usize, 9u8, val as u64) + } + } + #[inline] + pub unsafe fn speakerPlacement_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 22usize, + 9u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_speakerPlacement_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 22usize, + 9u8, + val as u64, + ) + } + } + #[inline] + pub fn downmixInhibit(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 2u8) as u32) } + } + #[inline] + pub fn set_downmixInhibit(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(32usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn downmixInhibit_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 32usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_downmixInhibit_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 32usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn lfePlaybackLevel(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(34usize, 3u8) as u32) } + } + #[inline] + pub fn set_lfePlaybackLevel(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(34usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn lfePlaybackLevel_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 34usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_lfePlaybackLevel_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 34usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn levelShift(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(37usize, 5u8) as u32) } + } + #[inline] + pub fn set_levelShift(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(37usize, 5u8, val as u64) + } + } + #[inline] + pub unsafe fn levelShift_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 37usize, + 5u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_levelShift_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 37usize, + 5u8, + val as u64, + ) + } + } + #[inline] + pub fn Future12(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(42usize, 2u8) as u32) } + } + #[inline] + pub fn set_Future12(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(42usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn Future12_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 42usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_Future12_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 42usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn Future2x(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(44usize, 4u8) as u32) } + } + #[inline] + pub fn set_Future2x(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(44usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn Future2x_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 44usize, + 4u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_Future2x_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 44usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn Future3x(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 4u8) as u32) } + } + #[inline] + pub fn set_Future3x(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(48usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn Future3x_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 48usize, + 4u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_Future3x_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 48usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn Future52(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(52usize, 2u8) as u32) } + } + #[inline] + pub fn set_Future52(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(52usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn Future52_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 52usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_Future52_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 52usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn Future6(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(54usize, 9u8) as u32) } + } + #[inline] + pub fn set_Future6(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(54usize, 9u8, val as u64) + } + } + #[inline] + pub unsafe fn Future6_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 54usize, + 9u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_Future6_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 54usize, + 9u8, + val as u64, + ) + } + } + #[inline] + pub fn Future7(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(64usize, 9u8) as u32) } + } + #[inline] + pub fn set_Future7(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(64usize, 9u8, val as u64) + } + } + #[inline] + pub unsafe fn Future7_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 64usize, + 9u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_Future7_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 64usize, + 9u8, + val as u64, + ) + } + } + #[inline] + pub fn Future8(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(73usize, 9u8) as u32) } + } + #[inline] + pub fn set_Future8(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(73usize, 9u8, val as u64) + } + } + #[inline] + pub unsafe fn Future8_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 73usize, + 9u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_Future8_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 73usize, + 9u8, + val as u64, + ) + } + } + #[inline] + pub fn Future9(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(82usize, 9u8) as u32) } + } + #[inline] + pub fn set_Future9(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(82usize, 9u8, val as u64) + } + } + #[inline] + pub unsafe fn Future9_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 82usize, + 9u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_Future9_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 82usize, + 9u8, + val as u64, + ) + } + } + #[inline] + pub fn Future10(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(96usize, 9u8) as u32) } + } + #[inline] + pub fn set_Future10(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(96usize, 9u8, val as u64) + } + } + #[inline] + pub unsafe fn Future10_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 96usize, + 9u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_Future10_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 96usize, + 9u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + codingType: NvU32, + codingExtensionType: NvU32, + sampleSize: NvU32, + sampleRate: NvU32, + channelCount: NvU32, + speakerPlacement: NvU32, + downmixInhibit: NvU32, + lfePlaybackLevel: NvU32, + levelShift: NvU32, + Future12: NvU32, + Future2x: NvU32, + Future3x: NvU32, + Future52: NvU32, + Future6: NvU32, + Future7: NvU32, + Future8: NvU32, + Future9: NvU32, + Future10: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 14usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 14usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 5u8, { + let codingType: u32 = unsafe { ::std::mem::transmute(codingType) }; + codingType as u64 + }); + __bindgen_bitfield_unit.set(5usize, 6u8, { + let codingExtensionType: u32 = unsafe { ::std::mem::transmute(codingExtensionType) }; + codingExtensionType as u64 + }); + __bindgen_bitfield_unit.set(11usize, 3u8, { + let sampleSize: u32 = unsafe { ::std::mem::transmute(sampleSize) }; + sampleSize as u64 + }); + __bindgen_bitfield_unit.set(14usize, 4u8, { + let sampleRate: u32 = unsafe { ::std::mem::transmute(sampleRate) }; + sampleRate as u64 + }); + __bindgen_bitfield_unit.set(18usize, 4u8, { + let channelCount: u32 = unsafe { ::std::mem::transmute(channelCount) }; + channelCount as u64 + }); + __bindgen_bitfield_unit.set(22usize, 9u8, { + let speakerPlacement: u32 = unsafe { ::std::mem::transmute(speakerPlacement) }; + speakerPlacement as u64 + }); + __bindgen_bitfield_unit.set(32usize, 2u8, { + let downmixInhibit: u32 = unsafe { ::std::mem::transmute(downmixInhibit) }; + downmixInhibit as u64 + }); + __bindgen_bitfield_unit.set(34usize, 3u8, { + let lfePlaybackLevel: u32 = unsafe { ::std::mem::transmute(lfePlaybackLevel) }; + lfePlaybackLevel as u64 + }); + __bindgen_bitfield_unit.set(37usize, 5u8, { + let levelShift: u32 = unsafe { ::std::mem::transmute(levelShift) }; + levelShift as u64 + }); + __bindgen_bitfield_unit.set(42usize, 2u8, { + let Future12: u32 = unsafe { ::std::mem::transmute(Future12) }; + Future12 as u64 + }); + __bindgen_bitfield_unit.set(44usize, 4u8, { + let Future2x: u32 = unsafe { ::std::mem::transmute(Future2x) }; + Future2x as u64 + }); + __bindgen_bitfield_unit.set(48usize, 4u8, { + let Future3x: u32 = unsafe { ::std::mem::transmute(Future3x) }; + Future3x as u64 + }); + __bindgen_bitfield_unit.set(52usize, 2u8, { + let Future52: u32 = unsafe { ::std::mem::transmute(Future52) }; + Future52 as u64 + }); + __bindgen_bitfield_unit.set(54usize, 9u8, { + let Future6: u32 = unsafe { ::std::mem::transmute(Future6) }; + Future6 as u64 + }); + __bindgen_bitfield_unit.set(64usize, 9u8, { + let Future7: u32 = unsafe { ::std::mem::transmute(Future7) }; + Future7 as u64 + }); + __bindgen_bitfield_unit.set(73usize, 9u8, { + let Future8: u32 = unsafe { ::std::mem::transmute(Future8) }; + Future8 as u64 + }); + __bindgen_bitfield_unit.set(82usize, 9u8, { + let Future9: u32 = unsafe { ::std::mem::transmute(Future9) }; + Future9 as u64 + }); + __bindgen_bitfield_unit.set(96usize, 9u8, { + let Future10: u32 = unsafe { ::std::mem::transmute(Future10) }; + Future10 as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct NV_INFOFRAME_DATA { + #[doc = "!< version of this structure"] + pub version: NvU32, + #[doc = "!< size of this structure"] + pub size: NvU16, + #[doc = "!< The actions to perform from NV_INFOFRAME_CMD"] + pub cmd: NvU8, + #[doc = "!< type of infoframe"] + pub type_: NvU8, + pub infoframe: NV_INFOFRAME_DATA__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union NV_INFOFRAME_DATA__bindgen_ty_1 { + #[doc = "!< This is NVIDIA-specific and corresponds to the property cmds and associated infoframe."] + pub property: NV_INFOFRAME_PROPERTY, + pub audio: NV_INFOFRAME_AUDIO, + pub video: NV_INFOFRAME_VIDEO, +} +pub const NV_COLOR_CMD_NV_COLOR_CMD_GET: NV_COLOR_CMD = 1; +pub const NV_COLOR_CMD_NV_COLOR_CMD_SET: NV_COLOR_CMD = 2; +pub const NV_COLOR_CMD_NV_COLOR_CMD_IS_SUPPORTED_COLOR: NV_COLOR_CMD = 3; +pub const NV_COLOR_CMD_NV_COLOR_CMD_GET_DEFAULT: NV_COLOR_CMD = 4; +pub type NV_COLOR_CMD = ::std::os::raw::c_int; +pub const NV_COLOR_FORMAT_NV_COLOR_FORMAT_RGB: NV_COLOR_FORMAT = 0; +pub const NV_COLOR_FORMAT_NV_COLOR_FORMAT_YUV422: NV_COLOR_FORMAT = 1; +pub const NV_COLOR_FORMAT_NV_COLOR_FORMAT_YUV444: NV_COLOR_FORMAT = 2; +pub const NV_COLOR_FORMAT_NV_COLOR_FORMAT_YUV420: NV_COLOR_FORMAT = 3; +pub const NV_COLOR_FORMAT_NV_COLOR_FORMAT_DEFAULT: NV_COLOR_FORMAT = 254; +pub const NV_COLOR_FORMAT_NV_COLOR_FORMAT_AUTO: NV_COLOR_FORMAT = 255; +#[doc = "! See Table 14 of CEA-861E. Not all of this is supported by the GPU."] +pub type NV_COLOR_FORMAT = ::std::os::raw::c_int; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_RGB: NV_COLOR_COLORIMETRY = 0; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_YCC601: NV_COLOR_COLORIMETRY = 1; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_YCC709: NV_COLOR_COLORIMETRY = 2; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_XVYCC601: NV_COLOR_COLORIMETRY = 3; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_XVYCC709: NV_COLOR_COLORIMETRY = 4; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_SYCC601: NV_COLOR_COLORIMETRY = 5; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_ADOBEYCC601: NV_COLOR_COLORIMETRY = 6; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_ADOBERGB: NV_COLOR_COLORIMETRY = 7; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_BT2020RGB: NV_COLOR_COLORIMETRY = 8; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_BT2020YCC: NV_COLOR_COLORIMETRY = 9; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_BT2020cYCC: NV_COLOR_COLORIMETRY = 10; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_DEFAULT: NV_COLOR_COLORIMETRY = 254; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_AUTO: NV_COLOR_COLORIMETRY = 255; +pub type NV_COLOR_COLORIMETRY = ::std::os::raw::c_int; +pub const _NV_DYNAMIC_RANGE_NV_DYNAMIC_RANGE_VESA: _NV_DYNAMIC_RANGE = 0; +pub const _NV_DYNAMIC_RANGE_NV_DYNAMIC_RANGE_CEA: _NV_DYNAMIC_RANGE = 1; +pub const _NV_DYNAMIC_RANGE_NV_DYNAMIC_RANGE_AUTO: _NV_DYNAMIC_RANGE = 255; +pub type _NV_DYNAMIC_RANGE = ::std::os::raw::c_int; +pub use self::_NV_DYNAMIC_RANGE as NV_DYNAMIC_RANGE; +pub const _NV_BPC_NV_BPC_DEFAULT: _NV_BPC = 0; +pub const _NV_BPC_NV_BPC_6: _NV_BPC = 1; +pub const _NV_BPC_NV_BPC_8: _NV_BPC = 2; +pub const _NV_BPC_NV_BPC_10: _NV_BPC = 3; +pub const _NV_BPC_NV_BPC_12: _NV_BPC = 4; +pub const _NV_BPC_NV_BPC_16: _NV_BPC = 5; +pub type _NV_BPC = ::std::os::raw::c_int; +pub use self::_NV_BPC as NV_BPC; +#[doc = "!< app/nvcpl make decision to select the desire color format"] +pub const _NV_COLOR_SELECTION_POLICY_NV_COLOR_SELECTION_POLICY_USER: _NV_COLOR_SELECTION_POLICY = 0; +#[doc = "!< driver/ OS make decision to select the best color format"] +pub const _NV_COLOR_SELECTION_POLICY_NV_COLOR_SELECTION_POLICY_BEST_QUALITY: + _NV_COLOR_SELECTION_POLICY = 1; +pub const _NV_COLOR_SELECTION_POLICY_NV_COLOR_SELECTION_POLICY_DEFAULT: _NV_COLOR_SELECTION_POLICY = + 1; +pub const _NV_COLOR_SELECTION_POLICY_NV_COLOR_SELECTION_POLICY_UNKNOWN: _NV_COLOR_SELECTION_POLICY = + 255; +pub type _NV_COLOR_SELECTION_POLICY = ::std::os::raw::c_int; +pub use self::_NV_COLOR_SELECTION_POLICY as NV_COLOR_SELECTION_POLICY; +pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_DEFAULT: _NV_DESKTOP_COLOR_DEPTH = 0; +pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_8BPC: _NV_DESKTOP_COLOR_DEPTH = 1; +pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_10BPC: _NV_DESKTOP_COLOR_DEPTH = 2; +pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_16BPC_FLOAT: _NV_DESKTOP_COLOR_DEPTH = 3; +pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_16BPC_FLOAT_WCG: _NV_DESKTOP_COLOR_DEPTH = + 4; +pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_16BPC_FLOAT_HDR: _NV_DESKTOP_COLOR_DEPTH = + 5; +pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_MAX_VALUE: _NV_DESKTOP_COLOR_DEPTH = 5; +pub type _NV_DESKTOP_COLOR_DEPTH = ::std::os::raw::c_int; +pub use self::_NV_DESKTOP_COLOR_DEPTH as NV_DESKTOP_COLOR_DEPTH; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COLOR_DATA_V1 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Size of this structure"] + pub size: NvU16, + pub cmd: NvU8, + pub data: _NV_COLOR_DATA_V1__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COLOR_DATA_V1__bindgen_ty_1 { + #[doc = "!< One of NV_COLOR_FORMAT enum values."] + pub colorFormat: NvU8, + #[doc = "!< One of NV_COLOR_COLORIMETRY enum values."] + pub colorimetry: NvU8, +} +pub type NV_COLOR_DATA_V1 = _NV_COLOR_DATA_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COLOR_DATA_V2 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Size of this structure"] + pub size: NvU16, + pub cmd: NvU8, + pub data: _NV_COLOR_DATA_V2__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COLOR_DATA_V2__bindgen_ty_1 { + #[doc = "!< One of NV_COLOR_FORMAT enum values."] + pub colorFormat: NvU8, + #[doc = "!< One of NV_COLOR_COLORIMETRY enum values."] + pub colorimetry: NvU8, + #[doc = "!< One of NV_DYNAMIC_RANGE enum values."] + pub dynamicRange: NvU8, +} +pub type NV_COLOR_DATA_V2 = _NV_COLOR_DATA_V2; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COLOR_DATA_V3 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Size of this structure"] + pub size: NvU16, + pub cmd: NvU8, + pub data: _NV_COLOR_DATA_V3__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COLOR_DATA_V3__bindgen_ty_1 { + #[doc = "!< One of NV_COLOR_FORMAT enum values."] + pub colorFormat: NvU8, + #[doc = "!< One of NV_COLOR_COLORIMETRY enum values."] + pub colorimetry: NvU8, + #[doc = "!< One of NV_DYNAMIC_RANGE enum values."] + pub dynamicRange: NvU8, + #[doc = "!< One of NV_BPC enum values."] + pub bpc: NV_BPC, +} +pub type NV_COLOR_DATA_V3 = _NV_COLOR_DATA_V3; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COLOR_DATA_V4 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Size of this structure"] + pub size: NvU16, + pub cmd: NvU8, + pub data: _NV_COLOR_DATA_V4__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COLOR_DATA_V4__bindgen_ty_1 { + #[doc = "!< One of NV_COLOR_FORMAT enum values."] + pub colorFormat: NvU8, + #[doc = "!< One of NV_COLOR_COLORIMETRY enum values."] + pub colorimetry: NvU8, + #[doc = "!< One of NV_DYNAMIC_RANGE enum values."] + pub dynamicRange: NvU8, + #[doc = "!< One of NV_BPC enum values."] + pub bpc: NV_BPC, + #[doc = "!< One of the color selection policy"] + pub colorSelectionPolicy: NV_COLOR_SELECTION_POLICY, +} +pub type NV_COLOR_DATA_V4 = _NV_COLOR_DATA_V4; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COLOR_DATA_V5 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Size of this structure"] + pub size: NvU16, + pub cmd: NvU8, + pub data: _NV_COLOR_DATA_V5__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COLOR_DATA_V5__bindgen_ty_1 { + #[doc = "!< One of NV_COLOR_FORMAT enum values."] + pub colorFormat: NvU8, + #[doc = "!< One of NV_COLOR_COLORIMETRY enum values."] + pub colorimetry: NvU8, + #[doc = "!< One of NV_DYNAMIC_RANGE enum values."] + pub dynamicRange: NvU8, + #[doc = "!< One of NV_BPC enum values."] + pub bpc: NV_BPC, + #[doc = "!< One of the color selection policy"] + pub colorSelectionPolicy: NV_COLOR_SELECTION_POLICY, + #[doc = "!< One of NV_DESKTOP_COLOR_DEPTH enum values."] + pub depth: NV_DESKTOP_COLOR_DEPTH, +} +pub type NV_COLOR_DATA_V5 = _NV_COLOR_DATA_V5; +pub type NV_COLOR_DATA = NV_COLOR_DATA_V5; +#[doc = "!< Tells the type of structure used to define the Static Metadata Descriptor block."] +pub const NV_STATIC_METADATA_DESCRIPTOR_ID_NV_STATIC_METADATA_TYPE_1: + NV_STATIC_METADATA_DESCRIPTOR_ID = 0; +#[doc = "! @}"] +pub type NV_STATIC_METADATA_DESCRIPTOR_ID = ::std::os::raw::c_int; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_CAPABILITIES_V1 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Static Metadata Descriptor Id (0 for static metadata type 1)"] + pub static_metadata_descriptor_id: NV_STATIC_METADATA_DESCRIPTOR_ID, + pub display_data: _NV_HDR_CAPABILITIES_V1__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_CAPABILITIES_V1__bindgen_ty_1 { + #[doc = "!< x coordinate of color primary 0 (e.g. Red) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x0: NvU16, + #[doc = "!< y coordinate of color primary 0 (e.g. Red) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y0: NvU16, + #[doc = "!< x coordinate of color primary 1 (e.g. Green) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x1: NvU16, + #[doc = "!< y coordinate of color primary 1 (e.g. Green) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y1: NvU16, + #[doc = "!< x coordinate of color primary 2 (e.g. Blue) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x2: NvU16, + #[doc = "!< y coordinate of color primary 2 (e.g. Blue) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y2: NvU16, + #[doc = "!< x coordinate of white point of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_x: NvU16, + #[doc = "!< y coordinate of white point of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_y: NvU16, + #[doc = "!< Maximum display luminance = desired max luminance of HDR content ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] + pub desired_content_max_luminance: NvU16, + #[doc = "!< Minimum display luminance = desired min luminance of HDR content ([0x0001-0xFFFF] = [1.0 - 6.55350] cd/m^2)"] + pub desired_content_min_luminance: NvU16, + #[doc = "!< Desired maximum Frame-Average Light Level (MaxFALL) of HDR content ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] + pub desired_content_max_frame_average_luminance: NvU16, +} +impl _NV_HDR_CAPABILITIES_V1 { + #[inline] + pub fn isST2084EotfSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isST2084EotfSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isST2084EotfSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isST2084EotfSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isTraditionalHdrGammaSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isTraditionalHdrGammaSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isTraditionalHdrGammaSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isTraditionalHdrGammaSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isEdrSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_isEdrSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isEdrSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isEdrSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn driverExpandDefaultHdrParameters(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_driverExpandDefaultHdrParameters(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn driverExpandDefaultHdrParameters_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_driverExpandDefaultHdrParameters_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isTraditionalSdrGammaSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_isTraditionalSdrGammaSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isTraditionalSdrGammaSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isTraditionalSdrGammaSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 27u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 27u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 27u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isST2084EotfSupported: NvU32, + isTraditionalHdrGammaSupported: NvU32, + isEdrSupported: NvU32, + driverExpandDefaultHdrParameters: NvU32, + isTraditionalSdrGammaSupported: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isST2084EotfSupported: u32 = + unsafe { ::std::mem::transmute(isST2084EotfSupported) }; + isST2084EotfSupported as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isTraditionalHdrGammaSupported: u32 = + unsafe { ::std::mem::transmute(isTraditionalHdrGammaSupported) }; + isTraditionalHdrGammaSupported as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let isEdrSupported: u32 = unsafe { ::std::mem::transmute(isEdrSupported) }; + isEdrSupported as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let driverExpandDefaultHdrParameters: u32 = + unsafe { ::std::mem::transmute(driverExpandDefaultHdrParameters) }; + driverExpandDefaultHdrParameters as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let isTraditionalSdrGammaSupported: u32 = + unsafe { ::std::mem::transmute(isTraditionalSdrGammaSupported) }; + isTraditionalSdrGammaSupported as u64 + }); + __bindgen_bitfield_unit.set(5usize, 27u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_HDR_CAPABILITIES_V1 = _NV_HDR_CAPABILITIES_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_CAPABILITIES_V2 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Static Metadata Descriptor Id (0 for static metadata type 1)"] + pub static_metadata_descriptor_id: NV_STATIC_METADATA_DESCRIPTOR_ID, + pub display_data: _NV_HDR_CAPABILITIES_V2__bindgen_ty_1, + pub dv_static_metadata: _NV_HDR_CAPABILITIES_V2__bindgen_ty_2, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_CAPABILITIES_V2__bindgen_ty_1 { + #[doc = "!< x coordinate of color primary 0 (e.g. Red) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x0: NvU16, + #[doc = "!< y coordinate of color primary 0 (e.g. Red) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y0: NvU16, + #[doc = "!< x coordinate of color primary 1 (e.g. Green) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x1: NvU16, + #[doc = "!< y coordinate of color primary 1 (e.g. Green) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y1: NvU16, + #[doc = "!< x coordinate of color primary 2 (e.g. Blue) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x2: NvU16, + #[doc = "!< y coordinate of color primary 2 (e.g. Blue) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y2: NvU16, + #[doc = "!< x coordinate of white point of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_x: NvU16, + #[doc = "!< y coordinate of white point of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_y: NvU16, + #[doc = "!< Maximum display luminance = desired max luminance of HDR content ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] + pub desired_content_max_luminance: NvU16, + #[doc = "!< Minimum display luminance = desired min luminance of HDR content ([0x0001-0xFFFF] = [1.0 - 6.55350] cd/m^2)"] + pub desired_content_min_luminance: NvU16, + #[doc = "!< Desired maximum Frame-Average Light Level (MaxFALL) of HDR content ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] + pub desired_content_max_frame_average_luminance: NvU16, +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_CAPABILITIES_V2__bindgen_ty_2 { + pub _bitfield_align_1: [u16; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Represents min luminance level of Sink"] + pub target_min_luminance: NvU16, + #[doc = "!< Represents max luminance level of sink"] + pub target_max_luminance: NvU16, + #[doc = "!< Red primary chromaticity coordinate x"] + pub cc_red_x: NvU16, + #[doc = "!< Red primary chromaticity coordinate y"] + pub cc_red_y: NvU16, + #[doc = "!< Green primary chromaticity coordinate x"] + pub cc_green_x: NvU16, + #[doc = "!< Green primary chromaticity coordinate Y"] + pub cc_green_y: NvU16, + #[doc = "!< Blue primary chromaticity coordinate x"] + pub cc_blue_x: NvU16, + #[doc = "!< Blue primary chromaticity coordinate y"] + pub cc_blue_y: NvU16, + #[doc = "!< White primary chromaticity coordinate x"] + pub cc_white_x: NvU16, + #[doc = "!< White primary chromaticity coordinate y"] + pub cc_white_y: NvU16, +} +impl _NV_HDR_CAPABILITIES_V2__bindgen_ty_2 { + #[inline] + pub fn VSVDB_version(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 3u8) as u32) } + } + #[inline] + pub fn set_VSVDB_version(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn VSVDB_version_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_VSVDB_version_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn dm_version(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 8u8) as u32) } + } + #[inline] + pub fn set_dm_version(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn dm_version_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_dm_version_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn supports_2160p60hz(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) } + } + #[inline] + pub fn set_supports_2160p60hz(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(11usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supports_2160p60hz_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 11usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_supports_2160p60hz_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 11usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn supports_YUV422_12bit(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) } + } + #[inline] + pub fn set_supports_YUV422_12bit(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(12usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supports_YUV422_12bit_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 12usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_supports_YUV422_12bit_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 12usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn supports_global_dimming(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) } + } + #[inline] + pub fn set_supports_global_dimming(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(13usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supports_global_dimming_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 13usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_supports_global_dimming_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 13usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn colorimetry(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) } + } + #[inline] + pub fn set_colorimetry(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(14usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn colorimetry_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 14usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_colorimetry_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 14usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn supports_backlight_control(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 2u8) as u32) } + } + #[inline] + pub fn set_supports_backlight_control(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(15usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn supports_backlight_control_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 15usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_supports_backlight_control_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 15usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn backlt_min_luma(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 2u8) as u32) } + } + #[inline] + pub fn set_backlt_min_luma(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(17usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn backlt_min_luma_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 17usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_backlt_min_luma_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 17usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn interface_supported_by_sink(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 2u8) as u32) } + } + #[inline] + pub fn set_interface_supported_by_sink(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(19usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn interface_supported_by_sink_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 19usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_interface_supported_by_sink_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 19usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn supports_10b_12b_444(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 2u8) as u32) } + } + #[inline] + pub fn set_supports_10b_12b_444(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(21usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn supports_10b_12b_444_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 21usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_supports_10b_12b_444_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 21usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 9u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(23usize, 9u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 23usize, + 9u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 23usize, + 9u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + VSVDB_version: NvU32, + dm_version: NvU32, + supports_2160p60hz: NvU32, + supports_YUV422_12bit: NvU32, + supports_global_dimming: NvU32, + colorimetry: NvU32, + supports_backlight_control: NvU32, + backlt_min_luma: NvU32, + interface_supported_by_sink: NvU32, + supports_10b_12b_444: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 3u8, { + let VSVDB_version: u32 = unsafe { ::std::mem::transmute(VSVDB_version) }; + VSVDB_version as u64 + }); + __bindgen_bitfield_unit.set(3usize, 8u8, { + let dm_version: u32 = unsafe { ::std::mem::transmute(dm_version) }; + dm_version as u64 + }); + __bindgen_bitfield_unit.set(11usize, 1u8, { + let supports_2160p60hz: u32 = unsafe { ::std::mem::transmute(supports_2160p60hz) }; + supports_2160p60hz as u64 + }); + __bindgen_bitfield_unit.set(12usize, 1u8, { + let supports_YUV422_12bit: u32 = + unsafe { ::std::mem::transmute(supports_YUV422_12bit) }; + supports_YUV422_12bit as u64 + }); + __bindgen_bitfield_unit.set(13usize, 1u8, { + let supports_global_dimming: u32 = + unsafe { ::std::mem::transmute(supports_global_dimming) }; + supports_global_dimming as u64 + }); + __bindgen_bitfield_unit.set(14usize, 1u8, { + let colorimetry: u32 = unsafe { ::std::mem::transmute(colorimetry) }; + colorimetry as u64 + }); + __bindgen_bitfield_unit.set(15usize, 2u8, { + let supports_backlight_control: u32 = + unsafe { ::std::mem::transmute(supports_backlight_control) }; + supports_backlight_control as u64 + }); + __bindgen_bitfield_unit.set(17usize, 2u8, { + let backlt_min_luma: u32 = unsafe { ::std::mem::transmute(backlt_min_luma) }; + backlt_min_luma as u64 + }); + __bindgen_bitfield_unit.set(19usize, 2u8, { + let interface_supported_by_sink: u32 = + unsafe { ::std::mem::transmute(interface_supported_by_sink) }; + interface_supported_by_sink as u64 + }); + __bindgen_bitfield_unit.set(21usize, 2u8, { + let supports_10b_12b_444: u32 = unsafe { ::std::mem::transmute(supports_10b_12b_444) }; + supports_10b_12b_444 as u64 + }); + __bindgen_bitfield_unit.set(23usize, 9u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +impl _NV_HDR_CAPABILITIES_V2 { + #[inline] + pub fn isST2084EotfSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isST2084EotfSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isST2084EotfSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isST2084EotfSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isTraditionalHdrGammaSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isTraditionalHdrGammaSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isTraditionalHdrGammaSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isTraditionalHdrGammaSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isEdrSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_isEdrSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isEdrSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isEdrSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn driverExpandDefaultHdrParameters(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_driverExpandDefaultHdrParameters(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn driverExpandDefaultHdrParameters_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_driverExpandDefaultHdrParameters_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isTraditionalSdrGammaSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_isTraditionalSdrGammaSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isTraditionalSdrGammaSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isTraditionalSdrGammaSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isDolbyVisionSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_isDolbyVisionSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isDolbyVisionSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isDolbyVisionSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 26u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 26u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 6usize, + 26u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 26u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isST2084EotfSupported: NvU32, + isTraditionalHdrGammaSupported: NvU32, + isEdrSupported: NvU32, + driverExpandDefaultHdrParameters: NvU32, + isTraditionalSdrGammaSupported: NvU32, + isDolbyVisionSupported: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isST2084EotfSupported: u32 = + unsafe { ::std::mem::transmute(isST2084EotfSupported) }; + isST2084EotfSupported as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isTraditionalHdrGammaSupported: u32 = + unsafe { ::std::mem::transmute(isTraditionalHdrGammaSupported) }; + isTraditionalHdrGammaSupported as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let isEdrSupported: u32 = unsafe { ::std::mem::transmute(isEdrSupported) }; + isEdrSupported as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let driverExpandDefaultHdrParameters: u32 = + unsafe { ::std::mem::transmute(driverExpandDefaultHdrParameters) }; + driverExpandDefaultHdrParameters as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let isTraditionalSdrGammaSupported: u32 = + unsafe { ::std::mem::transmute(isTraditionalSdrGammaSupported) }; + isTraditionalSdrGammaSupported as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let isDolbyVisionSupported: u32 = + unsafe { ::std::mem::transmute(isDolbyVisionSupported) }; + isDolbyVisionSupported as u64 + }); + __bindgen_bitfield_unit.set(6usize, 26u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_HDR_CAPABILITIES_V2 = _NV_HDR_CAPABILITIES_V2; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_CAPABILITIES_V3 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Static Metadata Descriptor Id (0 for static metadata type 1)"] + pub static_metadata_descriptor_id: NV_STATIC_METADATA_DESCRIPTOR_ID, + pub display_data: _NV_HDR_CAPABILITIES_V3__bindgen_ty_1, + pub dv_static_metadata: _NV_HDR_CAPABILITIES_V3__bindgen_ty_2, + pub hdr10plus_vsvdb: _NV_HDR_CAPABILITIES_V3__bindgen_ty_3, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_CAPABILITIES_V3__bindgen_ty_1 { + #[doc = "!< x coordinate of color primary 0 (e.g. Red) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x0: NvU16, + #[doc = "!< y coordinate of color primary 0 (e.g. Red) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y0: NvU16, + #[doc = "!< x coordinate of color primary 1 (e.g. Green) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x1: NvU16, + #[doc = "!< y coordinate of color primary 1 (e.g. Green) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y1: NvU16, + #[doc = "!< x coordinate of color primary 2 (e.g. Blue) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x2: NvU16, + #[doc = "!< y coordinate of color primary 2 (e.g. Blue) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y2: NvU16, + #[doc = "!< x coordinate of white point of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_x: NvU16, + #[doc = "!< y coordinate of white point of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_y: NvU16, + #[doc = "!< Maximum display luminance = desired max luminance of HDR content ([0x0000-0xFFFF] = [0.0 - 65535.0] cd/m^2, in units of 1 cd/m^2)"] + pub desired_content_max_luminance: NvU16, + #[doc = "!< Minimum display luminance = desired min luminance of HDR content ([0x0000-0xFFFF] = [0.0 - 6.55350] cd/m^2, in units of 0.0001 cd/m^2)"] + pub desired_content_min_luminance: NvU16, + #[doc = "!< Desired maximum Frame-Average Light Level (MaxFALL) of HDR content ([0x0000-0xFFFF] = [0.0 - 65535.0] cd/m^2, in units of 1 cd/m^2)"] + pub desired_content_max_frame_average_luminance: NvU16, +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_CAPABILITIES_V3__bindgen_ty_2 { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Represents min luminance level of Sink"] + pub target_min_luminance: NvU16, + #[doc = "!< Represents max luminance level of sink"] + pub target_max_luminance: NvU16, + #[doc = "!< Red primary chromaticity coordinate x"] + pub cc_red_x: NvU16, + #[doc = "!< Red primary chromaticity coordinate y"] + pub cc_red_y: NvU16, + #[doc = "!< Green primary chromaticity coordinate x"] + pub cc_green_x: NvU16, + #[doc = "!< Green primary chromaticity coordinate Y"] + pub cc_green_y: NvU16, + #[doc = "!< Blue primary chromaticity coordinate x"] + pub cc_blue_x: NvU16, + #[doc = "!< Blue primary chromaticity coordinate y"] + pub cc_blue_y: NvU16, + #[doc = "!< White primary chromaticity coordinate x"] + pub cc_white_x: NvU16, + #[doc = "!< White primary chromaticity coordinate y"] + pub cc_white_y: NvU16, +} +impl _NV_HDR_CAPABILITIES_V3__bindgen_ty_2 { + #[inline] + pub fn VSVDB_version(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 3u8) as u32) } + } + #[inline] + pub fn set_VSVDB_version(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn VSVDB_version_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_VSVDB_version_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn dm_version(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 8u8) as u32) } + } + #[inline] + pub fn set_dm_version(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn dm_version_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_dm_version_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn supports_2160p60hz(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) } + } + #[inline] + pub fn set_supports_2160p60hz(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(11usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supports_2160p60hz_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 11usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_supports_2160p60hz_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 11usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn supports_YUV422_12bit(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) } + } + #[inline] + pub fn set_supports_YUV422_12bit(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(12usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supports_YUV422_12bit_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 12usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_supports_YUV422_12bit_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 12usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn supports_global_dimming(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) } + } + #[inline] + pub fn set_supports_global_dimming(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(13usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supports_global_dimming_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 13usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_supports_global_dimming_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 13usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn colorimetry(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) } + } + #[inline] + pub fn set_colorimetry(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(14usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn colorimetry_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 14usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_colorimetry_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 14usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn supports_backlight_control(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 2u8) as u32) } + } + #[inline] + pub fn set_supports_backlight_control(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(15usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn supports_backlight_control_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 15usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_supports_backlight_control_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 15usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn backlt_min_luma(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 2u8) as u32) } + } + #[inline] + pub fn set_backlt_min_luma(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(17usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn backlt_min_luma_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 17usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_backlt_min_luma_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 17usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn interface_supported_by_sink(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 2u8) as u32) } + } + #[inline] + pub fn set_interface_supported_by_sink(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(19usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn interface_supported_by_sink_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 19usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_interface_supported_by_sink_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 19usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn supports_10b_12b_444(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 2u8) as u32) } + } + #[inline] + pub fn set_supports_10b_12b_444(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(21usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn supports_10b_12b_444_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 21usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_supports_10b_12b_444_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 21usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn parity(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u32) } + } + #[inline] + pub fn set_parity(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(23usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn parity_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 23usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_parity_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 23usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(24usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 24usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 24usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + VSVDB_version: NvU32, + dm_version: NvU32, + supports_2160p60hz: NvU32, + supports_YUV422_12bit: NvU32, + supports_global_dimming: NvU32, + colorimetry: NvU32, + supports_backlight_control: NvU32, + backlt_min_luma: NvU32, + interface_supported_by_sink: NvU32, + supports_10b_12b_444: NvU32, + parity: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 3u8, { + let VSVDB_version: u32 = unsafe { ::std::mem::transmute(VSVDB_version) }; + VSVDB_version as u64 + }); + __bindgen_bitfield_unit.set(3usize, 8u8, { + let dm_version: u32 = unsafe { ::std::mem::transmute(dm_version) }; + dm_version as u64 + }); + __bindgen_bitfield_unit.set(11usize, 1u8, { + let supports_2160p60hz: u32 = unsafe { ::std::mem::transmute(supports_2160p60hz) }; + supports_2160p60hz as u64 + }); + __bindgen_bitfield_unit.set(12usize, 1u8, { + let supports_YUV422_12bit: u32 = + unsafe { ::std::mem::transmute(supports_YUV422_12bit) }; + supports_YUV422_12bit as u64 + }); + __bindgen_bitfield_unit.set(13usize, 1u8, { + let supports_global_dimming: u32 = + unsafe { ::std::mem::transmute(supports_global_dimming) }; + supports_global_dimming as u64 + }); + __bindgen_bitfield_unit.set(14usize, 1u8, { + let colorimetry: u32 = unsafe { ::std::mem::transmute(colorimetry) }; + colorimetry as u64 + }); + __bindgen_bitfield_unit.set(15usize, 2u8, { + let supports_backlight_control: u32 = + unsafe { ::std::mem::transmute(supports_backlight_control) }; + supports_backlight_control as u64 + }); + __bindgen_bitfield_unit.set(17usize, 2u8, { + let backlt_min_luma: u32 = unsafe { ::std::mem::transmute(backlt_min_luma) }; + backlt_min_luma as u64 + }); + __bindgen_bitfield_unit.set(19usize, 2u8, { + let interface_supported_by_sink: u32 = + unsafe { ::std::mem::transmute(interface_supported_by_sink) }; + interface_supported_by_sink as u64 + }); + __bindgen_bitfield_unit.set(21usize, 2u8, { + let supports_10b_12b_444: u32 = unsafe { ::std::mem::transmute(supports_10b_12b_444) }; + supports_10b_12b_444 as u64 + }); + __bindgen_bitfield_unit.set(23usize, 1u8, { + let parity: u32 = unsafe { ::std::mem::transmute(parity) }; + parity as u64 + }); + __bindgen_bitfield_unit.set(24usize, 8u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[repr(align(2))] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_CAPABILITIES_V3__bindgen_ty_3 { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>, +} +impl _NV_HDR_CAPABILITIES_V3__bindgen_ty_3 { + #[inline] + pub fn application_version(&self) -> NvU16 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u16) } + } + #[inline] + pub fn set_application_version(&mut self, val: NvU16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn application_version_raw(this: *const Self) -> NvU16 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 2u8, + ) as u16) + } + } + #[inline] + pub unsafe fn set_application_version_raw(this: *mut Self, val: NvU16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn full_frame_peak_luminance_index(&self) -> NvU16 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 2u8) as u16) } + } + #[inline] + pub fn set_full_frame_peak_luminance_index(&mut self, val: NvU16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn full_frame_peak_luminance_index_raw(this: *const Self) -> NvU16 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 2u8, + ) as u16) + } + } + #[inline] + pub unsafe fn set_full_frame_peak_luminance_index_raw(this: *mut Self, val: NvU16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn peak_luminance_index(&self) -> NvU16 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u16) } + } + #[inline] + pub fn set_peak_luminance_index(&mut self, val: NvU16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn peak_luminance_index_raw(this: *const Self) -> NvU16 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 4u8, + ) as u16) + } + } + #[inline] + pub unsafe fn set_peak_luminance_index_raw(this: *mut Self, val: NvU16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU16 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 8u8) as u16) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU16 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 8usize, + 8u8, + ) as u16) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 8usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + application_version: NvU16, + full_frame_peak_luminance_index: NvU16, + peak_luminance_index: NvU16, + reserved: NvU16, + ) -> __BindgenBitfieldUnit<[u8; 2usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 2u8, { + let application_version: u16 = unsafe { ::std::mem::transmute(application_version) }; + application_version as u64 + }); + __bindgen_bitfield_unit.set(2usize, 2u8, { + let full_frame_peak_luminance_index: u16 = + unsafe { ::std::mem::transmute(full_frame_peak_luminance_index) }; + full_frame_peak_luminance_index as u64 + }); + __bindgen_bitfield_unit.set(4usize, 4u8, { + let peak_luminance_index: u16 = unsafe { ::std::mem::transmute(peak_luminance_index) }; + peak_luminance_index as u64 + }); + __bindgen_bitfield_unit.set(8usize, 8u8, { + let reserved: u16 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +impl _NV_HDR_CAPABILITIES_V3 { + #[inline] + pub fn isST2084EotfSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isST2084EotfSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isST2084EotfSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isST2084EotfSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isTraditionalHdrGammaSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isTraditionalHdrGammaSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isTraditionalHdrGammaSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isTraditionalHdrGammaSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isEdrSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_isEdrSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isEdrSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isEdrSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn driverExpandDefaultHdrParameters(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_driverExpandDefaultHdrParameters(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn driverExpandDefaultHdrParameters_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_driverExpandDefaultHdrParameters_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isTraditionalSdrGammaSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_isTraditionalSdrGammaSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isTraditionalSdrGammaSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isTraditionalSdrGammaSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isDolbyVisionSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_isDolbyVisionSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isDolbyVisionSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isDolbyVisionSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isHdr10PlusSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } + } + #[inline] + pub fn set_isHdr10PlusSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isHdr10PlusSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 6usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isHdr10PlusSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isHdr10PlusGamingSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } + } + #[inline] + pub fn set_isHdr10PlusGamingSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isHdr10PlusGamingSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 7usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isHdr10PlusGamingSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 7usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isNvidiaCertifiedDisplay(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) } + } + #[inline] + pub fn set_isNvidiaCertifiedDisplay(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isNvidiaCertifiedDisplay_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 8usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isNvidiaCertifiedDisplay_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 8usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 23u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(9usize, 23u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 9usize, + 23u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 9usize, + 23u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isST2084EotfSupported: NvU32, + isTraditionalHdrGammaSupported: NvU32, + isEdrSupported: NvU32, + driverExpandDefaultHdrParameters: NvU32, + isTraditionalSdrGammaSupported: NvU32, + isDolbyVisionSupported: NvU32, + isHdr10PlusSupported: NvU32, + isHdr10PlusGamingSupported: NvU32, + isNvidiaCertifiedDisplay: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isST2084EotfSupported: u32 = + unsafe { ::std::mem::transmute(isST2084EotfSupported) }; + isST2084EotfSupported as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isTraditionalHdrGammaSupported: u32 = + unsafe { ::std::mem::transmute(isTraditionalHdrGammaSupported) }; + isTraditionalHdrGammaSupported as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let isEdrSupported: u32 = unsafe { ::std::mem::transmute(isEdrSupported) }; + isEdrSupported as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let driverExpandDefaultHdrParameters: u32 = + unsafe { ::std::mem::transmute(driverExpandDefaultHdrParameters) }; + driverExpandDefaultHdrParameters as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let isTraditionalSdrGammaSupported: u32 = + unsafe { ::std::mem::transmute(isTraditionalSdrGammaSupported) }; + isTraditionalSdrGammaSupported as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let isDolbyVisionSupported: u32 = + unsafe { ::std::mem::transmute(isDolbyVisionSupported) }; + isDolbyVisionSupported as u64 + }); + __bindgen_bitfield_unit.set(6usize, 1u8, { + let isHdr10PlusSupported: u32 = unsafe { ::std::mem::transmute(isHdr10PlusSupported) }; + isHdr10PlusSupported as u64 + }); + __bindgen_bitfield_unit.set(7usize, 1u8, { + let isHdr10PlusGamingSupported: u32 = + unsafe { ::std::mem::transmute(isHdr10PlusGamingSupported) }; + isHdr10PlusGamingSupported as u64 + }); + __bindgen_bitfield_unit.set(8usize, 1u8, { + let isNvidiaCertifiedDisplay: u32 = + unsafe { ::std::mem::transmute(isNvidiaCertifiedDisplay) }; + isNvidiaCertifiedDisplay as u64 + }); + __bindgen_bitfield_unit.set(9usize, 23u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_HDR_CAPABILITIES_V3 = _NV_HDR_CAPABILITIES_V3; +pub type NV_HDR_CAPABILITIES = NV_HDR_CAPABILITIES_V3; +#[doc = "!< Get current HDR output configuration"] +pub const NV_HDR_CMD_NV_HDR_CMD_GET: NV_HDR_CMD = 0; +#[doc = "!< Set HDR output configuration"] +pub const NV_HDR_CMD_NV_HDR_CMD_SET: NV_HDR_CMD = 1; +#[doc = "! @}"] +pub type NV_HDR_CMD = ::std::os::raw::c_int; +#[doc = "!< Turn off HDR"] +pub const NV_HDR_MODE_NV_HDR_MODE_OFF: NV_HDR_MODE = 0; +#[doc = "!< Source: CCCS [a.k.a FP16 scRGB, linear, sRGB primaries, [-65504,0, 65504] range, RGB(1,1,1) = 80nits] Output : UHDA HDR [a.k.a HDR10, RGB/YCC 10/12bpc ST2084(PQ) EOTF RGB(1,1,1) = 10000 nits, Rec2020 color primaries, ST2086 static HDR metadata]. This is the only supported production HDR mode."] +pub const NV_HDR_MODE_NV_HDR_MODE_UHDA: NV_HDR_MODE = 2; +#[doc = "!< Experimental mode only, not for production! Source: HDR10 RGB 10bpc Output: HDR10 RGB 10 bpc - signal UHDA HDR mode (PQ + Rec2020) to the sink but send source pixel values unmodified (no PQ or Rec2020 conversions) - assumes source is already in HDR10 format."] +pub const NV_HDR_MODE_NV_HDR_MODE_UHDA_PASSTHROUGH: NV_HDR_MODE = 5; +#[doc = "!< Experimental mode only, not for production! Source: RGB8 Dolby Vision encoded (12 bpc YCbCr422 packed into RGB8) Output: Dolby Vision encoded : Application is to encoded frames in DV format and embed DV dynamic metadata as described in Dolby Vision specification."] +pub const NV_HDR_MODE_NV_HDR_MODE_DOLBY_VISION: NV_HDR_MODE = 7; +#[doc = "!< Do not use! Internal test mode only, to be removed. Source: CCCS (a.k.a FP16 scRGB) Output : EDR (Extended Dynamic Range) - HDR content is tonemapped and gamut mapped to output on regular SDR display set to max luminance ( ~300 nits )."] +pub const NV_HDR_MODE_NV_HDR_MODE_EDR: NV_HDR_MODE = 3; +#[doc = "!< Do not use! Internal test mode only, to be removed. Source: any Output: SDR (Standard Dynamic Range), we continuously send SDR EOTF InfoFrame signaling, HDMI compliance testing."] +pub const NV_HDR_MODE_NV_HDR_MODE_SDR: NV_HDR_MODE = 4; +#[doc = "!< Do not use! Internal test mode only, to be removed. Source: CCCS (a.k.a FP16 scRGB) Output : notebook HDR"] +pub const NV_HDR_MODE_NV_HDR_MODE_UHDA_NB: NV_HDR_MODE = 6; +#[doc = "!< Do not use! Obsolete, to be removed. NV_HDR_MODE_UHDBD == NV_HDR_MODE_UHDA, reflects obsolete pre-UHDA naming convention."] +pub const NV_HDR_MODE_NV_HDR_MODE_UHDBD: NV_HDR_MODE = 2; +pub type NV_HDR_MODE = ::std::os::raw::c_int; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_COLOR_DATA_V1 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Command get/set"] + pub cmd: NV_HDR_CMD, + #[doc = "!< HDR mode"] + pub hdrMode: NV_HDR_MODE, + #[doc = "!< Static Metadata Descriptor Id (0 for static metadata type 1)"] + pub static_metadata_descriptor_id: NV_STATIC_METADATA_DESCRIPTOR_ID, + pub mastering_display_data: _NV_HDR_COLOR_DATA_V1__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_COLOR_DATA_V1__bindgen_ty_1 { + #[doc = "!< x coordinate of color primary 0 (e.g. Red) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x0: NvU16, + #[doc = "!< y coordinate of color primary 0 (e.g. Red) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y0: NvU16, + #[doc = "!< x coordinate of color primary 1 (e.g. Green) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x1: NvU16, + #[doc = "!< y coordinate of color primary 1 (e.g. Green) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y1: NvU16, + #[doc = "!< x coordinate of color primary 2 (e.g. Blue) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x2: NvU16, + #[doc = "!< y coordinate of color primary 2 (e.g. Blue) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y2: NvU16, + #[doc = "!< x coordinate of white point of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_x: NvU16, + #[doc = "!< y coordinate of white point of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_y: NvU16, + #[doc = "!< Maximum display mastering luminance ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] + pub max_display_mastering_luminance: NvU16, + #[doc = "!< Minimum display mastering luminance ([0x0001-0xFFFF] = [1.0 - 6.55350] cd/m^2)"] + pub min_display_mastering_luminance: NvU16, + #[doc = "!< Maximum Content Light level (MaxCLL) ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] + pub max_content_light_level: NvU16, + #[doc = "!< Maximum Frame-Average Light Level (MaxFALL) ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] + pub max_frame_average_light_level: NvU16, +} +pub type NV_HDR_COLOR_DATA_V1 = _NV_HDR_COLOR_DATA_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_COLOR_DATA_V2 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Command get/set"] + pub cmd: NV_HDR_CMD, + #[doc = "!< HDR mode"] + pub hdrMode: NV_HDR_MODE, + #[doc = "!< Static Metadata Descriptor Id (0 for static metadata type 1)"] + pub static_metadata_descriptor_id: NV_STATIC_METADATA_DESCRIPTOR_ID, + pub mastering_display_data: _NV_HDR_COLOR_DATA_V2__bindgen_ty_1, + #[doc = "!< Optional, One of NV_COLOR_FORMAT enum values, if set it will apply requested color format for HDR session"] + pub hdrColorFormat: NV_COLOR_FORMAT, + #[doc = "!< Optional, One of NV_DYNAMIC_RANGE enum values, if set it will apply requested dynamic range for HDR session"] + pub hdrDynamicRange: NV_DYNAMIC_RANGE, + #[doc = "!< Optional, One of NV_BPC enum values, if set it will apply requested color depth\n!< Dolby Vision mode: DV supports specific combinations of colorformat, dynamic range and bpc. Please refer Dolby Vision specification.\n!< If invalid or no combination is passed driver will force default combination of RGB format + full range + 8bpc.\n!< HDR mode: These fields are ignored in hdr mode"] + pub hdrBpc: NV_BPC, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_COLOR_DATA_V2__bindgen_ty_1 { + #[doc = "!< x coordinate of color primary 0 (e.g. Red) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x0: NvU16, + #[doc = "!< y coordinate of color primary 0 (e.g. Red) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y0: NvU16, + #[doc = "!< x coordinate of color primary 1 (e.g. Green) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x1: NvU16, + #[doc = "!< y coordinate of color primary 1 (e.g. Green) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y1: NvU16, + #[doc = "!< x coordinate of color primary 2 (e.g. Blue) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x2: NvU16, + #[doc = "!< y coordinate of color primary 2 (e.g. Blue) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y2: NvU16, + #[doc = "!< x coordinate of white point of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_x: NvU16, + #[doc = "!< y coordinate of white point of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_y: NvU16, + #[doc = "!< Maximum display mastering luminance ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] + pub max_display_mastering_luminance: NvU16, + #[doc = "!< Minimum display mastering luminance ([0x0001-0xFFFF] = [1.0 - 6.55350] cd/m^2)"] + pub min_display_mastering_luminance: NvU16, + #[doc = "!< Maximum Content Light level (MaxCLL) ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] + pub max_content_light_level: NvU16, + #[doc = "!< Maximum Frame-Average Light Level (MaxFALL) ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] + pub max_frame_average_light_level: NvU16, +} +pub type NV_HDR_COLOR_DATA_V2 = _NV_HDR_COLOR_DATA_V2; +pub type NV_HDR_COLOR_DATA = NV_HDR_COLOR_DATA_V2; +#[doc = "!< sRGB IEC 61966-2-1:1999 == DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709"] +pub const _NV_COLORSPACE_TYPE_NV_COLORSPACE_sRGB: _NV_COLORSPACE_TYPE = 0; +#[doc = "!< FP16 linear with sRGB color primaries == DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709"] +pub const _NV_COLORSPACE_TYPE_NV_COLORSPACE_xRGB: _NV_COLORSPACE_TYPE = 1; +#[doc = "!< ITU-R Rec BT.2100 (HDR10) == DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020"] +pub const _NV_COLORSPACE_TYPE_NV_COLORSPACE_REC2100: _NV_COLORSPACE_TYPE = 12; +pub type _NV_COLORSPACE_TYPE = ::std::os::raw::c_int; +pub use self::_NV_COLORSPACE_TYPE as NV_COLORSPACE_TYPE; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_METADATA_V1 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< x coordinate of color primary 0 (e.g. Red) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x0: NvU16, + #[doc = "!< y coordinate of color primary 0 (e.g. Red) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y0: NvU16, + #[doc = "!< x coordinate of color primary 1 (e.g. Green) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x1: NvU16, + #[doc = "!< y coordinate of color primary 1 (e.g. Green) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y1: NvU16, + #[doc = "!< x coordinate of color primary 2 (e.g. Blue) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x2: NvU16, + #[doc = "!< y coordinate of color primary 2 (e.g. Blue) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y2: NvU16, + #[doc = "!< x coordinate of white point of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_x: NvU16, + #[doc = "!< y coordinate of white point of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_y: NvU16, + #[doc = "!< Maximum display mastering luminance ([0x0000-0xFFFF] = [0.0 - 65535.0] cd/m^2, in units of 1 cd/m^2)"] + pub max_display_mastering_luminance: NvU16, + #[doc = "!< Minimum display mastering luminance ([0x0000-0xFFFF] = [0.0 - 6.55350] cd/m^2, in units of 0.0001 cd/m^2)"] + pub min_display_mastering_luminance: NvU16, + #[doc = "!< Maximum Content Light level (MaxCLL) ([0x0000-0xFFFF] = [0.0 - 65535.0] cd/m^2, in units of 1 cd/m^2)"] + pub max_content_light_level: NvU16, + #[doc = "!< Maximum Frame-Average Light Level (MaxFALL) ([0x0000-0xFFFF] = [0.0 - 65535.0] cd/m^2, in units of 1 cd/m^2)"] + pub max_frame_average_light_level: NvU16, +} +pub type NV_HDR_METADATA_V1 = _NV_HDR_METADATA_V1; +pub type NV_HDR_METADATA = NV_HDR_METADATA_V1; +pub const _NV_DISPLAY_OUTPUT_MODE_NV_DISPLAY_OUTPUT_MODE_SDR: _NV_DISPLAY_OUTPUT_MODE = 0; +pub const _NV_DISPLAY_OUTPUT_MODE_NV_DISPLAY_OUTPUT_MODE_HDR10: _NV_DISPLAY_OUTPUT_MODE = 1; +pub const _NV_DISPLAY_OUTPUT_MODE_NV_DISPLAY_OUTPUT_MODE_HDR10PLUS_GAMING: _NV_DISPLAY_OUTPUT_MODE = + 2; +pub type _NV_DISPLAY_OUTPUT_MODE = ::std::os::raw::c_int; +pub use self::_NV_DISPLAY_OUTPUT_MODE as NV_DISPLAY_OUTPUT_MODE; +pub const _NV_HDR_TONEMAPPING_METHOD_NV_HDR_TONEMAPPING_APP: _NV_HDR_TONEMAPPING_METHOD = 0; +pub const _NV_HDR_TONEMAPPING_METHOD_NV_HDR_TONEMAPPING_GPU: _NV_HDR_TONEMAPPING_METHOD = 1; +pub type _NV_HDR_TONEMAPPING_METHOD = ::std::os::raw::c_int; +pub use self::_NV_HDR_TONEMAPPING_METHOD as NV_HDR_TONEMAPPING_METHOD; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_DISPLAY_COLORIMETRY_V1 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< min luminance, cd/m^2"] + pub min_luminance: f32, + #[doc = "!< max 100% frame luminance, cd/m^2"] + pub max_full_frame_luminance: f32, + #[doc = "!< max 10% frame luminance, cd/m^2"] + pub max_luminance: f32, + #[doc = "!< HDR brightness luminance scaling factor applied by GPU on output pixels"] + pub hdrBrightnessLuminanceScalingFactor: f32, + #[doc = "!< red primary chromaticity coordinate x"] + pub red_primary_x: f32, + #[doc = "!< red primary chromaticity coordinate y"] + pub red_primary_y: f32, + #[doc = "!< green primary chromaticity coordinate x"] + pub green_primary_x: f32, + #[doc = "!< green primary chromaticity coordinate y"] + pub green_primary_y: f32, + #[doc = "!< blue primary chromaticity coordinate x"] + pub blue_primary_x: f32, + #[doc = "!< blue primary chromaticity coordinate y"] + pub blue_primary_y: f32, + #[doc = "!< white point chromaticity coordinate x"] + pub white_point_x: f32, + #[doc = "!< white point chromaticity coordinate y"] + pub white_point_y: f32, +} +pub type NV_DISPLAY_COLORIMETRY_V1 = _NV_DISPLAY_COLORIMETRY_V1; +pub type NV_DISPLAY_COLORIMETRY = NV_DISPLAY_COLORIMETRY_V1; +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_DISP_GetTiming()."] +#[repr(C)] +#[repr(align(4))] +#[derive(Copy, Clone)] +pub struct NV_TIMING_FLAG { + pub _bitfield_align_1: [u16; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>, + pub __bindgen_anon_1: NV_TIMING_FLAG__bindgen_ty_1, + pub _bitfield_align_2: [u8; 0], + pub _bitfield_2: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 5usize], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union NV_TIMING_FLAG__bindgen_ty_1 { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>, +} +impl NV_TIMING_FLAG__bindgen_ty_1 { + #[inline] + pub fn tvFormat(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) } + } + #[inline] + pub fn set_tvFormat(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn tvFormat_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_tvFormat_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn ceaId(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 8u8) as u32) } + } + #[inline] + pub fn set_ceaId(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn ceaId_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 8usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_ceaId_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 8usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn nvPsfId(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 8u8) as u32) } + } + #[inline] + pub fn set_nvPsfId(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(16usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn nvPsfId_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 16usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_nvPsfId_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 16usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + tvFormat: NvU32, + ceaId: NvU32, + nvPsfId: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 3usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 8u8, { + let tvFormat: u32 = unsafe { ::std::mem::transmute(tvFormat) }; + tvFormat as u64 + }); + __bindgen_bitfield_unit.set(8usize, 8u8, { + let ceaId: u32 = unsafe { ::std::mem::transmute(ceaId) }; + ceaId as u64 + }); + __bindgen_bitfield_unit.set(16usize, 8u8, { + let nvPsfId: u32 = unsafe { ::std::mem::transmute(nvPsfId) }; + nvPsfId as u64 + }); + __bindgen_bitfield_unit + } +} +impl NV_TIMING_FLAG { + #[inline] + pub fn isInterlaced(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32) } + } + #[inline] + pub fn set_isInterlaced(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn isInterlaced_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 4u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isInterlaced_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved0(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 12u8) as u32) } + } + #[inline] + pub fn set_reserved0(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 12u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved0_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 12u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved0_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 12u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isInterlaced: NvU32, + reserved0: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 2usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 4u8, { + let isInterlaced: u32 = unsafe { ::std::mem::transmute(isInterlaced) }; + isInterlaced as u64 + }); + __bindgen_bitfield_unit.set(4usize, 12u8, { + let reserved0: u32 = unsafe { ::std::mem::transmute(reserved0) }; + reserved0 as u64 + }); + __bindgen_bitfield_unit + } + #[inline] + pub fn scaling(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 8u8) as u32) } + } + #[inline] + pub fn set_scaling(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_2.set(0usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn scaling_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_2), + 0usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_scaling_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 0usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_2(scaling: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 8u8, { + let scaling: u32 = unsafe { ::std::mem::transmute(scaling) }; + scaling as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_DISP_GetTiming()."] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_TIMING_INPUT { + #[doc = "!< (IN) structure version"] + pub version: NvU32, + #[doc = "!< Visible horizontal size"] + pub width: NvU32, + #[doc = "!< Visible vertical size"] + pub height: NvU32, + #[doc = "!< Timing refresh rate"] + pub rr: f32, + #[doc = "!< Flag containing additional info for timing calculation."] + pub flag: NV_TIMING_FLAG, + #[doc = "!< Timing type(formula) to use for calculating the timing"] + pub type_: NV_TIMING_OVERRIDE, +} +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_DISP_GetTiming()."] +pub type NV_TIMING_INPUT = _NV_TIMING_INPUT; +pub const NV_MONITOR_CAPS_TYPE_NV_MONITOR_CAPS_TYPE_HDMI_VSDB: NV_MONITOR_CAPS_TYPE = 4096; +pub const NV_MONITOR_CAPS_TYPE_NV_MONITOR_CAPS_TYPE_HDMI_VCDB: NV_MONITOR_CAPS_TYPE = 4097; +pub const NV_MONITOR_CAPS_TYPE_NV_MONITOR_CAPS_TYPE_GENERIC: NV_MONITOR_CAPS_TYPE = 4098; +#[doc = "! HDMI-related and extended CAPs"] +pub type NV_MONITOR_CAPS_TYPE = ::std::os::raw::c_int; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MONITOR_CAPS_VCDB { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, +} +impl _NV_MONITOR_CAPS_VCDB { + #[inline] + pub fn quantizationRangeYcc(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) } + } + #[inline] + pub fn set_quantizationRangeYcc(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn quantizationRangeYcc_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_quantizationRangeYcc_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn quantizationRangeRgb(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) } + } + #[inline] + pub fn set_quantizationRangeRgb(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn quantizationRangeRgb_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_quantizationRangeRgb_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn scanInfoPreferredVideoFormat(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 2u8) as u8) } + } + #[inline] + pub fn set_scanInfoPreferredVideoFormat(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn scanInfoPreferredVideoFormat_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 2u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_scanInfoPreferredVideoFormat_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn scanInfoITVideoFormats(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 2u8) as u8) } + } + #[inline] + pub fn set_scanInfoITVideoFormats(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn scanInfoITVideoFormats_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 2u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_scanInfoITVideoFormats_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn scanInfoCEVideoFormats(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 2u8) as u8) } + } + #[inline] + pub fn set_scanInfoCEVideoFormats(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn scanInfoCEVideoFormats_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 6usize, + 2u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_scanInfoCEVideoFormats_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + quantizationRangeYcc: NvU8, + quantizationRangeRgb: NvU8, + scanInfoPreferredVideoFormat: NvU8, + scanInfoITVideoFormats: NvU8, + scanInfoCEVideoFormats: NvU8, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let quantizationRangeYcc: u8 = unsafe { ::std::mem::transmute(quantizationRangeYcc) }; + quantizationRangeYcc as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let quantizationRangeRgb: u8 = unsafe { ::std::mem::transmute(quantizationRangeRgb) }; + quantizationRangeRgb as u64 + }); + __bindgen_bitfield_unit.set(2usize, 2u8, { + let scanInfoPreferredVideoFormat: u8 = + unsafe { ::std::mem::transmute(scanInfoPreferredVideoFormat) }; + scanInfoPreferredVideoFormat as u64 + }); + __bindgen_bitfield_unit.set(4usize, 2u8, { + let scanInfoITVideoFormats: u8 = + unsafe { ::std::mem::transmute(scanInfoITVideoFormats) }; + scanInfoITVideoFormats as u64 + }); + __bindgen_bitfield_unit.set(6usize, 2u8, { + let scanInfoCEVideoFormats: u8 = + unsafe { ::std::mem::transmute(scanInfoCEVideoFormats) }; + scanInfoCEVideoFormats as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_MONITOR_CAPS_VCDB = _NV_MONITOR_CAPS_VCDB; +#[doc = "! See NvAPI_DISP_GetMonitorCapabilities()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MONITOR_CAPS_VSDB { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>, + #[doc = "!< Bye 4"] + pub maxTmdsClock: NvU8, + pub _bitfield_align_2: [u8; 0], + pub _bitfield_2: __BindgenBitfieldUnit<[u8; 1usize]>, + #[doc = "!< Byte 6"] + pub videoLatency: NvU8, + #[doc = "!< Byte 7"] + pub audioLatency: NvU8, + #[doc = "!< Byte 8"] + pub interlacedVideoLatency: NvU8, + #[doc = "!< Byte 9"] + pub interlacedAudioLatency: NvU8, + pub _bitfield_align_3: [u8; 0], + pub _bitfield_3: __BindgenBitfieldUnit<[u8; 2usize]>, + #[doc = "!< Keeping maximum length for 3 bits"] + pub hdmi_vic: [NvU8; 7usize], + #[doc = "!< Keeping maximum length for 5 bits"] + pub hdmi_3d: [NvU8; 31usize], +} +impl _NV_MONITOR_CAPS_VSDB { + #[inline] + pub fn sourcePhysicalAddressB(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u8) } + } + #[inline] + pub fn set_sourcePhysicalAddressB(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn sourcePhysicalAddressB_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 4u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_sourcePhysicalAddressB_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn sourcePhysicalAddressA(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u8) } + } + #[inline] + pub fn set_sourcePhysicalAddressA(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn sourcePhysicalAddressA_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 4u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_sourcePhysicalAddressA_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn sourcePhysicalAddressD(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 4u8) as u8) } + } + #[inline] + pub fn set_sourcePhysicalAddressD(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn sourcePhysicalAddressD_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 8usize, + 4u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_sourcePhysicalAddressD_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 8usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn sourcePhysicalAddressC(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 4u8) as u8) } + } + #[inline] + pub fn set_sourcePhysicalAddressC(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(12usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn sourcePhysicalAddressC_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 12usize, + 4u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_sourcePhysicalAddressC_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 12usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn supportDualDviOperation(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u8) } + } + #[inline] + pub fn set_supportDualDviOperation(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(16usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supportDualDviOperation_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 16usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_supportDualDviOperation_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 16usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved6(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 2u8) as u8) } + } + #[inline] + pub fn set_reserved6(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(17usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved6_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 17usize, + 2u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_reserved6_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 17usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn supportDeepColorYCbCr444(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u8) } + } + #[inline] + pub fn set_supportDeepColorYCbCr444(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(19usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supportDeepColorYCbCr444_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 19usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_supportDeepColorYCbCr444_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 19usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn supportDeepColor30bits(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u8) } + } + #[inline] + pub fn set_supportDeepColor30bits(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(20usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supportDeepColor30bits_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 20usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_supportDeepColor30bits_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 20usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn supportDeepColor36bits(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u8) } + } + #[inline] + pub fn set_supportDeepColor36bits(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(21usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supportDeepColor36bits_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 21usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_supportDeepColor36bits_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 21usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn supportDeepColor48bits(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u8) } + } + #[inline] + pub fn set_supportDeepColor48bits(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(22usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supportDeepColor48bits_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 22usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_supportDeepColor48bits_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 22usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn supportAI(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u8) } + } + #[inline] + pub fn set_supportAI(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(23usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supportAI_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 23usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_supportAI_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 23usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + sourcePhysicalAddressB: NvU8, + sourcePhysicalAddressA: NvU8, + sourcePhysicalAddressD: NvU8, + sourcePhysicalAddressC: NvU8, + supportDualDviOperation: NvU8, + reserved6: NvU8, + supportDeepColorYCbCr444: NvU8, + supportDeepColor30bits: NvU8, + supportDeepColor36bits: NvU8, + supportDeepColor48bits: NvU8, + supportAI: NvU8, + ) -> __BindgenBitfieldUnit<[u8; 3usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 4u8, { + let sourcePhysicalAddressB: u8 = + unsafe { ::std::mem::transmute(sourcePhysicalAddressB) }; + sourcePhysicalAddressB as u64 + }); + __bindgen_bitfield_unit.set(4usize, 4u8, { + let sourcePhysicalAddressA: u8 = + unsafe { ::std::mem::transmute(sourcePhysicalAddressA) }; + sourcePhysicalAddressA as u64 + }); + __bindgen_bitfield_unit.set(8usize, 4u8, { + let sourcePhysicalAddressD: u8 = + unsafe { ::std::mem::transmute(sourcePhysicalAddressD) }; + sourcePhysicalAddressD as u64 + }); + __bindgen_bitfield_unit.set(12usize, 4u8, { + let sourcePhysicalAddressC: u8 = + unsafe { ::std::mem::transmute(sourcePhysicalAddressC) }; + sourcePhysicalAddressC as u64 + }); + __bindgen_bitfield_unit.set(16usize, 1u8, { + let supportDualDviOperation: u8 = + unsafe { ::std::mem::transmute(supportDualDviOperation) }; + supportDualDviOperation as u64 + }); + __bindgen_bitfield_unit.set(17usize, 2u8, { + let reserved6: u8 = unsafe { ::std::mem::transmute(reserved6) }; + reserved6 as u64 + }); + __bindgen_bitfield_unit.set(19usize, 1u8, { + let supportDeepColorYCbCr444: u8 = + unsafe { ::std::mem::transmute(supportDeepColorYCbCr444) }; + supportDeepColorYCbCr444 as u64 + }); + __bindgen_bitfield_unit.set(20usize, 1u8, { + let supportDeepColor30bits: u8 = + unsafe { ::std::mem::transmute(supportDeepColor30bits) }; + supportDeepColor30bits as u64 + }); + __bindgen_bitfield_unit.set(21usize, 1u8, { + let supportDeepColor36bits: u8 = + unsafe { ::std::mem::transmute(supportDeepColor36bits) }; + supportDeepColor36bits as u64 + }); + __bindgen_bitfield_unit.set(22usize, 1u8, { + let supportDeepColor48bits: u8 = + unsafe { ::std::mem::transmute(supportDeepColor48bits) }; + supportDeepColor48bits as u64 + }); + __bindgen_bitfield_unit.set(23usize, 1u8, { + let supportAI: u8 = unsafe { ::std::mem::transmute(supportAI) }; + supportAI as u64 + }); + __bindgen_bitfield_unit + } + #[inline] + pub fn cnc0SupportGraphicsTextContent(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 1u8) as u8) } + } + #[inline] + pub fn set_cnc0SupportGraphicsTextContent(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_2.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn cnc0SupportGraphicsTextContent_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_2), + 0usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_cnc0SupportGraphicsTextContent_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn cnc1SupportPhotoContent(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(1usize, 1u8) as u8) } + } + #[inline] + pub fn set_cnc1SupportPhotoContent(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_2.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn cnc1SupportPhotoContent_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_2), + 1usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_cnc1SupportPhotoContent_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn cnc2SupportCinemaContent(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(2usize, 1u8) as u8) } + } + #[inline] + pub fn set_cnc2SupportCinemaContent(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_2.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn cnc2SupportCinemaContent_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_2), + 2usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_cnc2SupportCinemaContent_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn cnc3SupportGameContent(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(3usize, 1u8) as u8) } + } + #[inline] + pub fn set_cnc3SupportGameContent(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_2.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn cnc3SupportGameContent_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_2), + 3usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_cnc3SupportGameContent_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved8(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(4usize, 1u8) as u8) } + } + #[inline] + pub fn set_reserved8(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_2.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved8_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_2), + 4usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_reserved8_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn hasVicEntries(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(5usize, 1u8) as u8) } + } + #[inline] + pub fn set_hasVicEntries(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_2.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn hasVicEntries_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_2), + 5usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_hasVicEntries_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn hasInterlacedLatencyField(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(6usize, 1u8) as u8) } + } + #[inline] + pub fn set_hasInterlacedLatencyField(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_2.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn hasInterlacedLatencyField_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_2), + 6usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_hasInterlacedLatencyField_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 6usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn hasLatencyField(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(7usize, 1u8) as u8) } + } + #[inline] + pub fn set_hasLatencyField(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_2.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn hasLatencyField_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_2), + 7usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_hasLatencyField_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 7usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_2( + cnc0SupportGraphicsTextContent: NvU8, + cnc1SupportPhotoContent: NvU8, + cnc2SupportCinemaContent: NvU8, + cnc3SupportGameContent: NvU8, + reserved8: NvU8, + hasVicEntries: NvU8, + hasInterlacedLatencyField: NvU8, + hasLatencyField: NvU8, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let cnc0SupportGraphicsTextContent: u8 = + unsafe { ::std::mem::transmute(cnc0SupportGraphicsTextContent) }; + cnc0SupportGraphicsTextContent as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let cnc1SupportPhotoContent: u8 = + unsafe { ::std::mem::transmute(cnc1SupportPhotoContent) }; + cnc1SupportPhotoContent as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let cnc2SupportCinemaContent: u8 = + unsafe { ::std::mem::transmute(cnc2SupportCinemaContent) }; + cnc2SupportCinemaContent as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let cnc3SupportGameContent: u8 = + unsafe { ::std::mem::transmute(cnc3SupportGameContent) }; + cnc3SupportGameContent as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let reserved8: u8 = unsafe { ::std::mem::transmute(reserved8) }; + reserved8 as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let hasVicEntries: u8 = unsafe { ::std::mem::transmute(hasVicEntries) }; + hasVicEntries as u64 + }); + __bindgen_bitfield_unit.set(6usize, 1u8, { + let hasInterlacedLatencyField: u8 = + unsafe { ::std::mem::transmute(hasInterlacedLatencyField) }; + hasInterlacedLatencyField as u64 + }); + __bindgen_bitfield_unit.set(7usize, 1u8, { + let hasLatencyField: u8 = unsafe { ::std::mem::transmute(hasLatencyField) }; + hasLatencyField as u64 + }); + __bindgen_bitfield_unit + } + #[inline] + pub fn reserved13(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_3.get(0usize, 7u8) as u8) } + } + #[inline] + pub fn set_reserved13(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_3.set(0usize, 7u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved13_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_3), + 0usize, + 7u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_reserved13_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_3), + 0usize, + 7u8, + val as u64, + ) + } + } + #[inline] + pub fn has3dEntries(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_3.get(7usize, 1u8) as u8) } + } + #[inline] + pub fn set_has3dEntries(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_3.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn has3dEntries_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_3), + 7usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_has3dEntries_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_3), + 7usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn hdmi3dLength(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_3.get(8usize, 5u8) as u8) } + } + #[inline] + pub fn set_hdmi3dLength(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_3.set(8usize, 5u8, val as u64) + } + } + #[inline] + pub unsafe fn hdmi3dLength_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_3), + 8usize, + 5u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_hdmi3dLength_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_3), + 8usize, + 5u8, + val as u64, + ) + } + } + #[inline] + pub fn hdmiVicLength(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_3.get(13usize, 3u8) as u8) } + } + #[inline] + pub fn set_hdmiVicLength(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_3.set(13usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn hdmiVicLength_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_3), + 13usize, + 3u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_hdmiVicLength_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_3), + 13usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_3( + reserved13: NvU8, + has3dEntries: NvU8, + hdmi3dLength: NvU8, + hdmiVicLength: NvU8, + ) -> __BindgenBitfieldUnit<[u8; 2usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 7u8, { + let reserved13: u8 = unsafe { ::std::mem::transmute(reserved13) }; + reserved13 as u64 + }); + __bindgen_bitfield_unit.set(7usize, 1u8, { + let has3dEntries: u8 = unsafe { ::std::mem::transmute(has3dEntries) }; + has3dEntries as u64 + }); + __bindgen_bitfield_unit.set(8usize, 5u8, { + let hdmi3dLength: u8 = unsafe { ::std::mem::transmute(hdmi3dLength) }; + hdmi3dLength as u64 + }); + __bindgen_bitfield_unit.set(13usize, 3u8, { + let hdmiVicLength: u8 = unsafe { ::std::mem::transmute(hdmiVicLength) }; + hdmiVicLength as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! See NvAPI_DISP_GetMonitorCapabilities()."] +pub type NV_MONITOR_CAPS_VSDB = _NV_MONITOR_CAPS_VSDB; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MONITOR_CAPS_GENERIC { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, +} +impl _NV_MONITOR_CAPS_GENERIC { + #[inline] + pub fn supportVRR(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) } + } + #[inline] + pub fn set_supportVRR(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supportVRR_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_supportVRR_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn supportULMB(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) } + } + #[inline] + pub fn set_supportULMB(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supportULMB_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_supportULMB_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isTrueGsync(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) } + } + #[inline] + pub fn set_isTrueGsync(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isTrueGsync_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_isTrueGsync_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isRLACapable(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) } + } + #[inline] + pub fn set_isRLACapable(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isRLACapable_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_isRLACapable_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn currentlyCapableOfVRR(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) } + } + #[inline] + pub fn set_currentlyCapableOfVRR(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn currentlyCapableOfVRR_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_currentlyCapableOfVRR_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isBasicVRR(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) } + } + #[inline] + pub fn set_isBasicVRR(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isBasicVRR_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_isBasicVRR_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 2u8) as u8) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 6usize, + 2u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + supportVRR: NvU8, + supportULMB: NvU8, + isTrueGsync: NvU8, + isRLACapable: NvU8, + currentlyCapableOfVRR: NvU8, + isBasicVRR: NvU8, + reserved: NvU8, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let supportVRR: u8 = unsafe { ::std::mem::transmute(supportVRR) }; + supportVRR as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let supportULMB: u8 = unsafe { ::std::mem::transmute(supportULMB) }; + supportULMB as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let isTrueGsync: u8 = unsafe { ::std::mem::transmute(isTrueGsync) }; + isTrueGsync as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let isRLACapable: u8 = unsafe { ::std::mem::transmute(isRLACapable) }; + isRLACapable as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let currentlyCapableOfVRR: u8 = unsafe { ::std::mem::transmute(currentlyCapableOfVRR) }; + currentlyCapableOfVRR as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let isBasicVRR: u8 = unsafe { ::std::mem::transmute(isBasicVRR) }; + isBasicVRR as u64 + }); + __bindgen_bitfield_unit.set(6usize, 2u8, { + let reserved: u8 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_MONITOR_CAPS_GENERIC = _NV_MONITOR_CAPS_GENERIC; +#[doc = "! See NvAPI_DISP_GetMonitorCapabilities()."] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_MONITOR_CAPABILITIES_V1 { + pub version: NvU32, + pub size: NvU16, + pub infoType: NvU32, + #[doc = "!< Out: VGA, TV, DVI, HDMI, DP"] + pub connectorType: NvU32, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub data: _NV_MONITOR_CAPABILITIES_V1__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union _NV_MONITOR_CAPABILITIES_V1__bindgen_ty_1 { + pub vsdb: NV_MONITOR_CAPS_VSDB, + pub vcdb: NV_MONITOR_CAPS_VCDB, + pub caps: NV_MONITOR_CAPS_GENERIC, +} +impl _NV_MONITOR_CAPABILITIES_V1 { + #[inline] + pub fn bIsValidInfo(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) } + } + #[inline] + pub fn set_bIsValidInfo(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsValidInfo_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_bIsValidInfo_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1(bIsValidInfo: NvU8) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsValidInfo: u8 = unsafe { ::std::mem::transmute(bIsValidInfo) }; + bIsValidInfo as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! See NvAPI_DISP_GetMonitorCapabilities()."] +pub type NV_MONITOR_CAPABILITIES_V1 = _NV_MONITOR_CAPABILITIES_V1; +#[doc = "! See NvAPI_DISP_GetMonitorCapabilities()."] +pub type NV_MONITOR_CAPABILITIES = NV_MONITOR_CAPABILITIES_V1; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MONITOR_COLOR_DATA { + pub version: NvU32, + #[doc = "!< One of the supported color formats"] + pub colorFormat: NV_DP_COLOR_FORMAT, + #[doc = "!< One of the supported bit depths"] + pub backendBitDepths: NV_DP_BPC, +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_MONITOR_COLOR_CAPS_V1 = _NV_MONITOR_COLOR_DATA; +#[doc = "! \\ingroup dispcontrol"] +pub type NV_MONITOR_COLOR_CAPS = NV_MONITOR_COLOR_CAPS_V1; +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_DISP_EnumCustomDisplay() and NvAPI_DISP_TryCustomDisplay()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_CUSTOM_DISPLAY { + pub version: NvU32, + #[doc = "!< Source surface(source mode) width"] + pub width: NvU32, + #[doc = "!< Source surface(source mode) height"] + pub height: NvU32, + #[doc = "!< Source surface color depth.\"0\" means all 8/16/32bpp"] + pub depth: NvU32, + #[doc = "!< Color format (optional)"] + pub colorFormat: NV_FORMAT, + #[doc = "!< For multimon support, should be set to (0,0,1.0,1.0) for now."] + pub srcPartition: NV_VIEWPORTF, + #[doc = "!< Horizontal scaling ratio"] + pub xRatio: f32, + #[doc = "!< Vertical scaling ratio"] + pub yRatio: f32, + #[doc = "!< Timing used to program TMDS/DAC/LVDS/HDMI/TVEncoder, etc."] + pub timing: NV_TIMING, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +impl NV_CUSTOM_DISPLAY { + #[inline] + pub fn hwModeSetOnly(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_hwModeSetOnly(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn hwModeSetOnly_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_hwModeSetOnly_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1(hwModeSetOnly: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let hwModeSetOnly: u32 = unsafe { ::std::mem::transmute(hwModeSetOnly) }; + hwModeSetOnly as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup dispcontrol\n! @{"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_EDID_DATA_V1 { + #[doc = "!< Structure version."] + pub version: NvU32, + #[doc = "!< Pointer to EDID data."] + pub pEDID: *mut NvU8, + #[doc = "!< Size of EDID data."] + pub sizeOfEDID: NvU32, +} +#[doc = "! \\ingroup dispcontrol\n! @{"] +pub type NV_EDID_DATA_V1 = _NV_EDID_DATA_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_EDID_DATA_V2 { + #[doc = "!< Structure version."] + pub version: NvU32, + #[doc = "!< Pointer to EDID data."] + pub pEDID: *mut NvU8, + #[doc = "!< Size of EDID data."] + pub sizeOfEDID: NvU32, + #[doc = "!< Reserved for future use."] + pub reserved: [NvU32; 8usize], +} +pub type NV_EDID_DATA_V2 = _NV_EDID_DATA_V2; +pub type NV_EDID_DATA = NV_EDID_DATA_V2; +#[doc = "! @}"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GET_ADAPTIVE_SYNC_DATA_V1 { + #[doc = "!< [in] structure version"] + pub version: NvU32, + #[doc = "!< [out] maximum frame interval in micro seconds as set previously using NvAPI_DISP_SetAdaptiveSyncData function."] + pub maxFrameInterval: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< [out] Number of times the last flip was shown on the screen"] + pub lastFlipRefreshCount: NvU32, + #[doc = "!< [out] Timestamp for the lastest flip on the screen"] + pub lastFlipTimeStamp: NvU64, + #[doc = "!< reserved for future use."] + pub reservedEx: [NvU32; 4usize], +} +impl _NV_GET_ADAPTIVE_SYNC_DATA_V1 { + #[inline] + pub fn bDisableAdaptiveSync(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bDisableAdaptiveSync(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bDisableAdaptiveSync_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bDisableAdaptiveSync_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bDisableFrameSplitting(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bDisableFrameSplitting(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bDisableFrameSplitting_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bDisableFrameSplitting_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 30u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 30u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 30u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bDisableAdaptiveSync: NvU32, + bDisableFrameSplitting: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bDisableAdaptiveSync: u32 = unsafe { ::std::mem::transmute(bDisableAdaptiveSync) }; + bDisableAdaptiveSync as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bDisableFrameSplitting: u32 = + unsafe { ::std::mem::transmute(bDisableFrameSplitting) }; + bDisableFrameSplitting as u64 + }); + __bindgen_bitfield_unit.set(2usize, 30u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! @}"] +pub type NV_GET_ADAPTIVE_SYNC_DATA_V1 = _NV_GET_ADAPTIVE_SYNC_DATA_V1; +#[doc = "! @}"] +pub type NV_GET_ADAPTIVE_SYNC_DATA = NV_GET_ADAPTIVE_SYNC_DATA_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_SET_ADAPTIVE_SYNC_DATA_V1 { + #[doc = "!< [in] structure version"] + pub version: NvU32, + #[doc = "!< [in] deprecated, please use maxFrameIntervalNs instead\n!< If maxFrameInterval is sent as 0, default values from EDID will be used."] + pub maxFrameInterval: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Ensure the alignment is 8 bytes and reserve it for future use."] + pub reserved1: NvU32, + #[doc = "!< [in] maximum frame interval in nano seconds.\n!< If maxFrameIntervalNs is sent as 0, default values from EDID will be used."] + pub maxFrameIntervalNs: NvU64, + #[doc = "!< reserved for future use."] + pub reservedEx: [NvU32; 4usize], +} +impl _NV_SET_ADAPTIVE_SYNC_DATA_V1 { + #[inline] + pub fn bDisableAdaptiveSync(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bDisableAdaptiveSync(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bDisableAdaptiveSync_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bDisableAdaptiveSync_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bDisableFrameSplitting(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bDisableFrameSplitting(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bDisableFrameSplitting_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bDisableFrameSplitting_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 30u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 30u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 30u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bDisableAdaptiveSync: NvU32, + bDisableFrameSplitting: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bDisableAdaptiveSync: u32 = unsafe { ::std::mem::transmute(bDisableAdaptiveSync) }; + bDisableAdaptiveSync as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bDisableFrameSplitting: u32 = + unsafe { ::std::mem::transmute(bDisableFrameSplitting) }; + bDisableFrameSplitting as u64 + }); + __bindgen_bitfield_unit.set(2usize, 30u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_SET_ADAPTIVE_SYNC_DATA_V1 = _NV_SET_ADAPTIVE_SYNC_DATA_V1; +pub type NV_SET_ADAPTIVE_SYNC_DATA = NV_SET_ADAPTIVE_SYNC_DATA_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GET_VIRTUAL_REFRESH_RATE_DATA_V1 { + #[doc = "!< [in] structure version"] + pub version: NvU32, + #[doc = "!< [out] frame interval in micro seconds if Virtual RR is currently applied"] + pub frameIntervalUs: NvU32, + #[doc = "!< [out] Refresh Rate * 1000"] + pub rrx1k: NvU32, + #[doc = "!< [out] If the content is Gaming"] + pub bIsGamingVrr: NvU32, + #[doc = "!< reserved for future use."] + pub reservedEx: [NvU32; 6usize], +} +pub type NV_GET_VIRTUAL_REFRESH_RATE_DATA_V1 = _NV_GET_VIRTUAL_REFRESH_RATE_DATA_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GET_VIRTUAL_REFRESH_RATE_DATA_V2 { + #[doc = "!< [in] structure version"] + pub version: NvU32, + #[doc = "!< [out] frame interval in micro seconds if Virtual RR is currently applied. This variable is deprecated in V2 and should not be used."] + pub frameIntervalUs: NvU32, + #[doc = "!< [out] Refresh Rate * 1000"] + pub rrx1k: NvU32, + #[doc = "!< [out] If the content is Gaming"] + pub bIsGamingVrr: NvU32, + #[doc = "!< [out] frame interval in nano seconds if Virtual RR is currently applied"] + pub frameIntervalNs: NvU64, + #[doc = "!< reserved for future use."] + pub reservedEx: [NvU32; 4usize], +} +pub type NV_GET_VIRTUAL_REFRESH_RATE_DATA_V2 = _NV_GET_VIRTUAL_REFRESH_RATE_DATA_V2; +pub type NV_GET_VIRTUAL_REFRESH_RATE_DATA = NV_GET_VIRTUAL_REFRESH_RATE_DATA_V2; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_SET_VIRTUAL_REFRESH_RATE_DATA_V1 { + #[doc = "!< [in] structure version"] + pub version: NvU32, + #[doc = "!< [in] frame interval in micro seconds if Virtual RR is currently applied"] + pub frameIntervalUs: NvU32, + #[doc = "!< [in] Refresh Rate * 1000"] + pub rrx1k: NvU32, + #[doc = "!< [in] If the content is Gaming"] + pub bIsGamingVrr: NvU32, + #[doc = "!< reserved for future use."] + pub reservedEx: [NvU32; 6usize], +} +pub type NV_SET_VIRTUAL_REFRESH_RATE_DATA_V1 = _NV_SET_VIRTUAL_REFRESH_RATE_DATA_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_SET_VIRTUAL_REFRESH_RATE_DATA_V2 { + #[doc = "!< [in] structure version"] + pub version: NvU32, + #[doc = "!< [in] frame interval in micro seconds if Virtual RR is currently applied. This variable is deprecated in V2 and should not be used."] + pub frameIntervalUs: NvU32, + #[doc = "!< [in] Refresh Rate * 1000"] + pub rrx1k: NvU32, + #[doc = "!< [in] If the content is Gaming"] + pub bIsGamingVrr: NvU32, + #[doc = "!< [in] frame interval in nano seconds if Virtual RR is currently applied"] + pub frameIntervalNs: NvU64, + #[doc = "!< reserved for future use."] + pub reservedEx: [NvU32; 4usize], +} +pub type NV_SET_VIRTUAL_REFRESH_RATE_DATA_V2 = _NV_SET_VIRTUAL_REFRESH_RATE_DATA_V2; +pub type NV_SET_VIRTUAL_REFRESH_RATE_DATA = NV_SET_VIRTUAL_REFRESH_RATE_DATA_V2; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_SET_PREFERRED_STEREO_DISPLAY_V1 { + #[doc = "!< [in] Structure version"] + pub version: NvU32, + #[doc = "!< [in] Monitor Identifier to be set"] + pub displayId: NvU32, + #[doc = "!< Reserved for future use without adding versioning"] + pub reserved: NvU32, +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_SET_PREFERRED_STEREO_DISPLAY = NV_SET_PREFERRED_STEREO_DISPLAY_V1; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GET_PREFERRED_STEREO_DISPLAY_V1 { + #[doc = "!< [in] Structure version"] + pub version: NvU32, + #[doc = "!< [out] The queried stereo display"] + pub displayId: NvU32, + #[doc = "!< Reserved for future use without adding versioning"] + pub reserved: NvU32, +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_GET_PREFERRED_STEREO_DISPLAY = NV_GET_PREFERRED_STEREO_DISPLAY_V1; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_DISPLAY_ID_INFO_DATA_V1 { + #[doc = "!< [in] Structure version"] + pub version: NvU32, + #[doc = "!< [out] Locally unique ID (LUID) of the display adapter on which the given display is present."] + pub adapterId: LUID, + #[doc = "!< [out] The target identifier of the given display. This is also called AdapterRelativeId."] + pub targetId: NvU32, + #[doc = "!< Reserved for future use."] + pub reserved: [NvU32; 4usize], +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_DISPLAY_ID_INFO_DATA_V1 = _NV_DISPLAY_ID_INFO_DATA_V1; +#[doc = "! \\ingroup dispcontrol"] +pub type NV_DISPLAY_ID_INFO_DATA = NV_DISPLAY_ID_INFO_DATA_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_TARGET_INFO_DATA_V1 { + #[doc = "!< [in] Structure version"] + pub version: NvU32, + #[doc = "!< [in] Locally unique ID (LUID) of the display adapter on which the target is present."] + pub adapterId: LUID, + #[doc = "!< [in] The target identifier. This is also called AdapterRelativeId."] + pub targetId: NvU32, + #[doc = "!< [out] An array of displayIds corresponding to the input adapterId and targetId.\n!< If the input (targetId, adapterId) pair is a display grid (Mosaic/Surround),\n!< then the output contains the displayId of every display that is part of the display grid.\n!< Otherwise, it contains exactly one displayId.\n!< These displayId values are unique to this (targetId, adapterId) pair."] + pub displayId: [NvU32; 128usize], + #[doc = "!< [out] The number of displays returned in displayId array."] + pub displayIdCount: NvU32, + #[doc = "!< Reserved for future use."] + pub reserved: [NvU32; 4usize], +} +pub type NV_TARGET_INFO_DATA_V1 = _NV_TARGET_INFO_DATA_V1; +pub type NV_TARGET_INFO_DATA = NV_TARGET_INFO_DATA_V1; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GET_VRR_INFO_V1 { + #[doc = "!< [in] Structure version"] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Reserved for future use"] + pub reservedEx: [NvU32; 4usize], +} +impl _NV_GET_VRR_INFO_V1 { + #[inline] + pub fn bIsVRREnabled(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsVRREnabled(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsVRREnabled_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsVRREnabled_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsVRRPossible(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsVRRPossible(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsVRRPossible_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsVRRPossible_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsVRRRequested(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsVRRRequested(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsVRRRequested_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsVRRRequested_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsVRRIndicatorEnabled(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsVRRIndicatorEnabled(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsVRRIndicatorEnabled_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsVRRIndicatorEnabled_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsDisplayInVRRMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsDisplayInVRRMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsDisplayInVRRMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsDisplayInVRRMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 27u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 27u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 27u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsVRREnabled: NvU32, + bIsVRRPossible: NvU32, + bIsVRRRequested: NvU32, + bIsVRRIndicatorEnabled: NvU32, + bIsDisplayInVRRMode: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsVRREnabled: u32 = unsafe { ::std::mem::transmute(bIsVRREnabled) }; + bIsVRREnabled as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bIsVRRPossible: u32 = unsafe { ::std::mem::transmute(bIsVRRPossible) }; + bIsVRRPossible as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let bIsVRRRequested: u32 = unsafe { ::std::mem::transmute(bIsVRRRequested) }; + bIsVRRRequested as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let bIsVRRIndicatorEnabled: u32 = + unsafe { ::std::mem::transmute(bIsVRRIndicatorEnabled) }; + bIsVRRIndicatorEnabled as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let bIsDisplayInVRRMode: u32 = unsafe { ::std::mem::transmute(bIsDisplayInVRRMode) }; + bIsDisplayInVRRMode as u64 + }); + __bindgen_bitfield_unit.set(5usize, 27u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_GET_VRR_INFO_V1 = _NV_GET_VRR_INFO_V1; +#[doc = "! \\ingroup dispcontrol"] +pub type NV_GET_VRR_INFO = NV_GET_VRR_INFO_V1; +#[doc = "! This structure defines the topology details."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_MOSAIC_TOPO_DETAILS { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Logical GPU for this topology"] + pub hLogicalGPU: NvLogicalGpuHandle, + #[doc = "!< 0 means topology is valid with the current hardware."] + pub validityMask: NvU32, + #[doc = "!< Number of displays in a row"] + pub rowCount: NvU32, + #[doc = "!< Number of displays in a column"] + pub colCount: NvU32, + pub gpuLayout: [[NV_MOSAIC_TOPO_DETAILS__bindgen_ty_1; 8usize]; 8usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_MOSAIC_TOPO_DETAILS__bindgen_ty_1 { + #[doc = "!< Physical GPU to be used in the topology (0 if GPU missing)"] + pub hPhysicalGPU: NvPhysicalGpuHandle, + #[doc = "!< Connected display target (0 if no display connected)"] + pub displayOutputId: NvU32, + #[doc = "!< Pixels of overlap on left of target: (+overlap, -gap)"] + pub overlapX: NvS32, + #[doc = "!< Pixels of overlap on top of target: (+overlap, -gap)"] + pub overlapY: NvS32, +} +#[doc = "!< All mosaic topologies"] +pub const NV_MOSAIC_TOPO_TYPE_NV_MOSAIC_TOPO_TYPE_ALL: NV_MOSAIC_TOPO_TYPE = 0; +#[doc = "!< Basic Mosaic topologies"] +pub const NV_MOSAIC_TOPO_TYPE_NV_MOSAIC_TOPO_TYPE_BASIC: NV_MOSAIC_TOPO_TYPE = 1; +#[doc = "!< Passive Stereo topologies"] +pub const NV_MOSAIC_TOPO_TYPE_NV_MOSAIC_TOPO_TYPE_PASSIVE_STEREO: NV_MOSAIC_TOPO_TYPE = 2; +#[doc = "!< Not supported at this time"] +pub const NV_MOSAIC_TOPO_TYPE_NV_MOSAIC_TOPO_TYPE_SCALED_CLONE: NV_MOSAIC_TOPO_TYPE = 3; +#[doc = "!< Not supported at this time"] +pub const NV_MOSAIC_TOPO_TYPE_NV_MOSAIC_TOPO_TYPE_PASSIVE_STEREO_SCALED_CLONE: NV_MOSAIC_TOPO_TYPE = + 4; +#[doc = "!< Always leave this at end of the enum"] +pub const NV_MOSAIC_TOPO_TYPE_NV_MOSAIC_TOPO_TYPE_MAX: NV_MOSAIC_TOPO_TYPE = 5; +#[doc = "! These values refer to the different types of Mosaic topologies that are possible. When\n! getting the supported Mosaic topologies, you can specify one of these types to narrow down\n! the returned list to only those that match the given type."] +pub type NV_MOSAIC_TOPO_TYPE = ::std::os::raw::c_int; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_NONE: NV_MOSAIC_TOPO = 0; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_BEGIN_BASIC: NV_MOSAIC_TOPO = 1; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x2_BASIC: NV_MOSAIC_TOPO = 1; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_2x1_BASIC: NV_MOSAIC_TOPO = 2; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x3_BASIC: NV_MOSAIC_TOPO = 3; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_3x1_BASIC: NV_MOSAIC_TOPO = 4; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x4_BASIC: NV_MOSAIC_TOPO = 5; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_4x1_BASIC: NV_MOSAIC_TOPO = 6; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_2x2_BASIC: NV_MOSAIC_TOPO = 7; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_2x3_BASIC: NV_MOSAIC_TOPO = 8; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_2x4_BASIC: NV_MOSAIC_TOPO = 9; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_3x2_BASIC: NV_MOSAIC_TOPO = 10; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_4x2_BASIC: NV_MOSAIC_TOPO = 11; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x5_BASIC: NV_MOSAIC_TOPO = 12; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x6_BASIC: NV_MOSAIC_TOPO = 13; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_7x1_BASIC: NV_MOSAIC_TOPO = 14; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_END_BASIC: NV_MOSAIC_TOPO = 23; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_BEGIN_PASSIVE_STEREO: NV_MOSAIC_TOPO = 24; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x2_PASSIVE_STEREO: NV_MOSAIC_TOPO = 24; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_2x1_PASSIVE_STEREO: NV_MOSAIC_TOPO = 25; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x3_PASSIVE_STEREO: NV_MOSAIC_TOPO = 26; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_3x1_PASSIVE_STEREO: NV_MOSAIC_TOPO = 27; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x4_PASSIVE_STEREO: NV_MOSAIC_TOPO = 28; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_4x1_PASSIVE_STEREO: NV_MOSAIC_TOPO = 29; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_2x2_PASSIVE_STEREO: NV_MOSAIC_TOPO = 30; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_END_PASSIVE_STEREO: NV_MOSAIC_TOPO = 34; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_MAX: NV_MOSAIC_TOPO = 35; +#[doc = "! This is a complete list of supported Mosaic topologies.\n!\n! Using a \"Basic\" topology combines multiple monitors to create a single desktop.\n!\n! Using a \"Passive\" topology combines multiples monitors to create a passive stereo desktop.\n! In passive stereo, two identical topologies combine - one topology is used for the right eye and the other identical //! topology (targeting different displays) is used for the left eye. \\n\n! NOTE: common\\inc\\nvEscDef.h shadows a couple PASSIVE_STEREO enums. If this\n! enum list changes and effects the value of NV_MOSAIC_TOPO_BEGIN_PASSIVE_STEREO\n! please update the corresponding value in nvEscDef.h"] +pub type NV_MOSAIC_TOPO = ::std::os::raw::c_int; +#[doc = "! This is a \"topology brief\" structure. It tells you what you need to know about\n! a topology at a high level. A list of these is returned when you query for the\n! supported Mosaic information.\n!\n! If you need more detailed information about the topology, call\n! NvAPI_Mosaic_GetTopoGroup() with the topology value from this structure."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_MOSAIC_TOPO_BRIEF { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< The topology"] + pub topo: NV_MOSAIC_TOPO, + #[doc = "!< 1 if topo is enabled, else 0"] + pub enabled: NvU32, + #[doc = "!< 1 if topo *can* be enabled, else 0"] + pub isPossible: NvU32, +} +#[doc = "! Basic per-display settings that are used in setting/getting the Mosaic mode"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MOSAIC_DISPLAY_SETTING_V1 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Per-display width"] + pub width: NvU32, + #[doc = "!< Per-display height"] + pub height: NvU32, + #[doc = "!< Bits per pixel"] + pub bpp: NvU32, + #[doc = "!< Display frequency"] + pub freq: NvU32, +} +#[doc = "! Basic per-display settings that are used in setting/getting the Mosaic mode"] +pub type NV_MOSAIC_DISPLAY_SETTING_V1 = _NV_MOSAIC_DISPLAY_SETTING_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_MOSAIC_DISPLAY_SETTING_V2 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Per-display width"] + pub width: NvU32, + #[doc = "!< Per-display height"] + pub height: NvU32, + #[doc = "!< Bits per pixel"] + pub bpp: NvU32, + #[doc = "!< Display frequency"] + pub freq: NvU32, + #[doc = "!< Display frequency in x1k"] + pub rrx1k: NvU32, +} +pub type NV_MOSAIC_DISPLAY_SETTING = NV_MOSAIC_DISPLAY_SETTING_V2; +#[doc = "! This structure is used to contain a list of supported Mosaic topologies\n! along with the display settings that can be used."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MOSAIC_SUPPORTED_TOPO_INFO_V1 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Number of topologies in below array"] + pub topoBriefsCount: NvU32, + #[doc = "!< List of supported topologies with only brief details"] + pub topoBriefs: [NV_MOSAIC_TOPO_BRIEF; 35usize], + #[doc = "!< Number of display settings in below array"] + pub displaySettingsCount: NvU32, + #[doc = "!< List of per display settings possible"] + pub displaySettings: [NV_MOSAIC_DISPLAY_SETTING_V1; 40usize], +} +#[doc = "! This structure is used to contain a list of supported Mosaic topologies\n! along with the display settings that can be used."] +pub type NV_MOSAIC_SUPPORTED_TOPO_INFO_V1 = _NV_MOSAIC_SUPPORTED_TOPO_INFO_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MOSAIC_SUPPORTED_TOPO_INFO_V2 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Number of topologies in below array"] + pub topoBriefsCount: NvU32, + #[doc = "!< List of supported topologies with only brief details"] + pub topoBriefs: [NV_MOSAIC_TOPO_BRIEF; 35usize], + #[doc = "!< Number of display settings in below array"] + pub displaySettingsCount: NvU32, + #[doc = "!< List of per display settings possible"] + pub displaySettings: [NV_MOSAIC_DISPLAY_SETTING_V2; 40usize], +} +pub type NV_MOSAIC_SUPPORTED_TOPO_INFO_V2 = _NV_MOSAIC_SUPPORTED_TOPO_INFO_V2; +pub type NV_MOSAIC_SUPPORTED_TOPO_INFO = NV_MOSAIC_SUPPORTED_TOPO_INFO_V2; +#[doc = "! This structure defines a group of topologies that work together to create one\n! overall layout. All of the supported topologies are represented with this\n! structure.\n!\n! For example, a 'Passive Stereo' topology would be represented with this\n! structure, and would have separate topology details for the left and right eyes.\n! The count would be 2. A 'Basic' topology is also represented by this structure,\n! with a count of 1.\n!\n! The structure is primarily used internally, but is exposed to applications in a\n! read-only fashion because there are some details in it that might be useful\n! (like the number of rows/cols, or connected display information). A user can\n! get the filled-in structure by calling NvAPI_Mosaic_GetTopoGroup().\n!\n! You can then look at the detailed values within the structure. There are no\n! entrypoints which take this structure as input (effectively making it read-only)."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_MOSAIC_TOPO_GROUP { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< The brief details of this topo"] + pub brief: NV_MOSAIC_TOPO_BRIEF, + #[doc = "!< Number of topos in array below"] + pub count: NvU32, + pub topos: [NV_MOSAIC_TOPO_DETAILS; 2usize], +} +#[doc = "! \\ingroup mosaicapi\n! @{"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MOSAIC_GRID_TOPO_DISPLAY_V1 { + #[doc = "!< DisplayID of the display"] + pub displayId: NvU32, + #[doc = "!< (+overlap, -gap)"] + pub overlapX: NvS32, + #[doc = "!< (+overlap, -gap)"] + pub overlapY: NvS32, + #[doc = "!< Rotation of display"] + pub rotation: NV_ROTATE, + #[doc = "!< Reserved, must be 0"] + pub cloneGroup: NvU32, +} +#[doc = "! \\ingroup mosaicapi\n! @{"] +pub type NV_MOSAIC_GRID_TOPO_DISPLAY_V1 = _NV_MOSAIC_GRID_TOPO_DISPLAY_V1; +#[doc = "!< No pixel shift will be applied to this display."] +pub const _NV_PIXEL_SHIFT_TYPE_NV_PIXEL_SHIFT_TYPE_NO_PIXEL_SHIFT: _NV_PIXEL_SHIFT_TYPE = 0; +#[doc = "!< This display will be used to scanout top left pixels in 2x2 PixelShift configuration"] +pub const _NV_PIXEL_SHIFT_TYPE_NV_PIXEL_SHIFT_TYPE_2x2_TOP_LEFT_PIXELS: _NV_PIXEL_SHIFT_TYPE = 1; +#[doc = "!< This display will be used to scanout bottom right pixels in 2x2 PixelShift configuration"] +pub const _NV_PIXEL_SHIFT_TYPE_NV_PIXEL_SHIFT_TYPE_2x2_BOTTOM_RIGHT_PIXELS: _NV_PIXEL_SHIFT_TYPE = + 2; +#[doc = "!< This display will be used to scanout top right pixels in 2x2 PixelShift configuration"] +pub const _NV_PIXEL_SHIFT_TYPE_NV_PIXEL_SHIFT_TYPE_2x2_TOP_RIGHT_PIXELS: _NV_PIXEL_SHIFT_TYPE = 4; +#[doc = "!< This display will be used to scanout bottom left pixels in 2x2 PixelShift configuration"] +pub const _NV_PIXEL_SHIFT_TYPE_NV_PIXEL_SHIFT_TYPE_2x2_BOTTOM_LEFT_PIXELS: _NV_PIXEL_SHIFT_TYPE = 8; +pub type _NV_PIXEL_SHIFT_TYPE = ::std::os::raw::c_int; +pub use self::_NV_PIXEL_SHIFT_TYPE as NV_PIXEL_SHIFT_TYPE; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MOSAIC_GRID_TOPO_DISPLAY_V2 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< DisplayID of the display"] + pub displayId: NvU32, + #[doc = "!< (+overlap, -gap)"] + pub overlapX: NvS32, + #[doc = "!< (+overlap, -gap)"] + pub overlapY: NvS32, + #[doc = "!< Rotation of display"] + pub rotation: NV_ROTATE, + #[doc = "!< Reserved, must be 0"] + pub cloneGroup: NvU32, + #[doc = "!< Type of the pixel shift enabled display"] + pub pixelShiftType: NV_PIXEL_SHIFT_TYPE, +} +pub type NV_MOSAIC_GRID_TOPO_DISPLAY_V2 = _NV_MOSAIC_GRID_TOPO_DISPLAY_V2; +#[doc = "! \\ingroup mosaicapi\n! @{"] +pub type NV_MOSAIC_GRID_TOPO_DISPLAY = NV_MOSAIC_GRID_TOPO_DISPLAY_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MOSAIC_GRID_TOPO_V1 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Number of rows"] + pub rows: NvU32, + #[doc = "!< Number of columns"] + pub columns: NvU32, + #[doc = "!< Number of display details"] + pub displayCount: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Displays are done as [(row * columns) + column]"] + pub displays: [NV_MOSAIC_GRID_TOPO_DISPLAY_V1; 64usize], + #[doc = "!< Display settings"] + pub displaySettings: NV_MOSAIC_DISPLAY_SETTING_V1, +} +impl _NV_MOSAIC_GRID_TOPO_V1 { + #[inline] + pub fn applyWithBezelCorrect(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_applyWithBezelCorrect(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn applyWithBezelCorrect_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_applyWithBezelCorrect_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn immersiveGaming(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_immersiveGaming(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn immersiveGaming_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_immersiveGaming_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn baseMosaic(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_baseMosaic(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn baseMosaic_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_baseMosaic_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn driverReloadAllowed(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_driverReloadAllowed(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn driverReloadAllowed_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_driverReloadAllowed_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn acceleratePrimaryDisplay(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_acceleratePrimaryDisplay(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn acceleratePrimaryDisplay_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_acceleratePrimaryDisplay_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 27u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 27u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 27u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + applyWithBezelCorrect: NvU32, + immersiveGaming: NvU32, + baseMosaic: NvU32, + driverReloadAllowed: NvU32, + acceleratePrimaryDisplay: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let applyWithBezelCorrect: u32 = + unsafe { ::std::mem::transmute(applyWithBezelCorrect) }; + applyWithBezelCorrect as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let immersiveGaming: u32 = unsafe { ::std::mem::transmute(immersiveGaming) }; + immersiveGaming as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let baseMosaic: u32 = unsafe { ::std::mem::transmute(baseMosaic) }; + baseMosaic as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let driverReloadAllowed: u32 = unsafe { ::std::mem::transmute(driverReloadAllowed) }; + driverReloadAllowed as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let acceleratePrimaryDisplay: u32 = + unsafe { ::std::mem::transmute(acceleratePrimaryDisplay) }; + acceleratePrimaryDisplay as u64 + }); + __bindgen_bitfield_unit.set(5usize, 27u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_MOSAIC_GRID_TOPO_V1 = _NV_MOSAIC_GRID_TOPO_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MOSAIC_GRID_TOPO_V2 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Number of rows"] + pub rows: NvU32, + #[doc = "!< Number of columns"] + pub columns: NvU32, + #[doc = "!< Number of display details"] + pub displayCount: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Displays are done as [(row * columns) + column]"] + pub displays: [NV_MOSAIC_GRID_TOPO_DISPLAY_V2; 64usize], + #[doc = "!< Display settings"] + pub displaySettings: NV_MOSAIC_DISPLAY_SETTING_V1, +} +impl _NV_MOSAIC_GRID_TOPO_V2 { + #[inline] + pub fn applyWithBezelCorrect(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_applyWithBezelCorrect(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn applyWithBezelCorrect_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_applyWithBezelCorrect_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn immersiveGaming(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_immersiveGaming(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn immersiveGaming_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_immersiveGaming_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn baseMosaic(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_baseMosaic(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn baseMosaic_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_baseMosaic_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn driverReloadAllowed(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_driverReloadAllowed(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn driverReloadAllowed_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_driverReloadAllowed_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn acceleratePrimaryDisplay(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_acceleratePrimaryDisplay(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn acceleratePrimaryDisplay_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_acceleratePrimaryDisplay_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn pixelShift(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_pixelShift(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn pixelShift_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_pixelShift_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 26u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 26u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 6usize, + 26u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 26u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + applyWithBezelCorrect: NvU32, + immersiveGaming: NvU32, + baseMosaic: NvU32, + driverReloadAllowed: NvU32, + acceleratePrimaryDisplay: NvU32, + pixelShift: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let applyWithBezelCorrect: u32 = + unsafe { ::std::mem::transmute(applyWithBezelCorrect) }; + applyWithBezelCorrect as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let immersiveGaming: u32 = unsafe { ::std::mem::transmute(immersiveGaming) }; + immersiveGaming as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let baseMosaic: u32 = unsafe { ::std::mem::transmute(baseMosaic) }; + baseMosaic as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let driverReloadAllowed: u32 = unsafe { ::std::mem::transmute(driverReloadAllowed) }; + driverReloadAllowed as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let acceleratePrimaryDisplay: u32 = + unsafe { ::std::mem::transmute(acceleratePrimaryDisplay) }; + acceleratePrimaryDisplay as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let pixelShift: u32 = unsafe { ::std::mem::transmute(pixelShift) }; + pixelShift as u64 + }); + __bindgen_bitfield_unit.set(6usize, 26u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_MOSAIC_GRID_TOPO_V2 = _NV_MOSAIC_GRID_TOPO_V2; +pub type NV_MOSAIC_GRID_TOPO = NV_MOSAIC_GRID_TOPO_V2; +#[doc = "! \\ingroup mosaicapi"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_MOSAIC_DISPLAY_TOPO_STATUS { + pub version: NvU32, + #[doc = "!< (OUT) Any of the NV_MOSAIC_DISPLAYTOPO_ERROR_* flags."] + pub errorFlags: NvU32, + #[doc = "!< (OUT) Any of the NV_MOSAIC_DISPLAYTOPO_WARNING_* flags."] + pub warningFlags: NvU32, + #[doc = "!< (OUT) The number of valid entries in the displays array."] + pub displayCount: NvU32, + pub displays: [NV_MOSAIC_DISPLAY_TOPO_STATUS__bindgen_ty_1; 128usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_MOSAIC_DISPLAY_TOPO_STATUS__bindgen_ty_1 { + #[doc = "!< (OUT) The DisplayID of this display."] + pub displayId: NvU32, + #[doc = "!< (OUT) Any of the NV_MOSAIC_DISPLAYCAPS_PROBLEM_* flags."] + pub errorFlags: NvU32, + #[doc = "!< (OUT) Any of the NV_MOSAIC_DISPLAYTOPO_WARNING_* flags."] + pub warningFlags: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl NV_MOSAIC_DISPLAY_TOPO_STATUS__bindgen_ty_1 { + #[inline] + pub fn supportsRotation(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_supportsRotation(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supportsRotation_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_supportsRotation_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + supportsRotation: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let supportsRotation: u32 = unsafe { ::std::mem::transmute(supportsRotation) }; + supportsRotation as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! Used in NvAPI_GetCurrentMosaicTopology() and NvAPI_SetCurrentMosaicTopology()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_MOSAIC_TOPOLOGY { + #[doc = "!< Version number of the mosaic topology"] + pub version: NvU32, + #[doc = "!< Horizontal display count"] + pub rowCount: NvU32, + #[doc = "!< Vertical display count"] + pub colCount: NvU32, + pub gpuLayout: [[NV_MOSAIC_TOPOLOGY__bindgen_ty_1; 8usize]; 8usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_MOSAIC_TOPOLOGY__bindgen_ty_1 { + #[doc = "!< Physical GPU to be used in the topology"] + pub hPhysicalGPU: NvPhysicalGpuHandle, + #[doc = "!< Connected display target"] + pub displayOutputId: NvU32, + #[doc = "!< Pixels of overlap on the left of target: (+overlap, -gap)"] + pub overlapX: NvS32, + #[doc = "!< Pixels of overlap on the top of target: (+overlap, -gap)"] + pub overlapY: NvS32, +} +#[doc = "! Used in NvAPI_GetSupportedMosaicTopologies()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_MOSAIC_SUPPORTED_TOPOLOGIES { + pub version: NvU32, + #[doc = "!< Count of valid topologies"] + pub totalCount: NvU32, + #[doc = "!< Maximum number of topologies"] + pub topos: [NV_MOSAIC_TOPOLOGY; 16usize], +} +#[doc = "! Used in NvAPI_GSync_QueryCapabilities()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GSYNC_CAPABILITIES_V1 { + #[doc = "!< Version of the structure"] + pub version: NvU32, + #[doc = "!< Board ID"] + pub boardId: NvU32, + #[doc = "!< FPGA Revision"] + pub revision: NvU32, + #[doc = "!< Capabilities of the Sync board. Reserved for future use"] + pub capFlags: NvU32, +} +#[doc = "! Used in NvAPI_GSync_QueryCapabilities()."] +pub type NV_GSYNC_CAPABILITIES_V1 = _NV_GSYNC_CAPABILITIES_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GSYNC_CAPABILITIES_V2 { + #[doc = "!< Version of the structure"] + pub version: NvU32, + #[doc = "!< Board ID"] + pub boardId: NvU32, + #[doc = "!< FPGA major revision"] + pub revision: NvU32, + #[doc = "!< Capabilities of the Sync board. Reserved for future use"] + pub capFlags: NvU32, + #[doc = "!< FPGA minor revision"] + pub extendedRevision: NvU32, +} +pub type NV_GSYNC_CAPABILITIES_V2 = _NV_GSYNC_CAPABILITIES_V2; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GSYNC_CAPABILITIES_V3 { + #[doc = "!< Version of the structure"] + pub version: NvU32, + #[doc = "!< Board ID"] + pub boardId: NvU32, + #[doc = "!< FPGA major revision"] + pub revision: NvU32, + #[doc = "!< Capabilities of the Sync board. Reserved for future use"] + pub capFlags: NvU32, + #[doc = "!< FPGA minor revision"] + pub extendedRevision: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< This parameter returns the maximum possible value that can be programmed\n!< for multiplying / dividing house sync. Only valid if bIsMulDivSupported is set to 1."] + pub maxMulDivValue: NvU32, +} +impl _NV_GSYNC_CAPABILITIES_V3 { + #[inline] + pub fn bIsMulDivSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsMulDivSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsMulDivSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsMulDivSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsMulDivSupported: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsMulDivSupported: u32 = unsafe { ::std::mem::transmute(bIsMulDivSupported) }; + bIsMulDivSupported as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_GSYNC_CAPABILITIES_V3 = _NV_GSYNC_CAPABILITIES_V3; +pub type NV_GSYNC_CAPABILITIES = NV_GSYNC_CAPABILITIES_V3; +pub const _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_NONE: + _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR = 0; +pub const _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_PRIMARY: + _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR = 1; +pub const _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_SECONDARY: + _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR = 2; +pub const _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_TERTIARY: + _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR = 3; +pub const _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_QUARTERNARY: + _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR = 4; +#[doc = "! Connector values for a GPU. Used in NV_GSYNC_GPU."] +pub type _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR = ::std::os::raw::c_int; +#[doc = "! Connector values for a GPU. Used in NV_GSYNC_GPU."] +pub use self::_NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR as NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR; +pub const _NVAPI_GSYNC_DISPLAY_SYNC_STATE_NVAPI_GSYNC_DISPLAY_SYNC_STATE_UNSYNCED: + _NVAPI_GSYNC_DISPLAY_SYNC_STATE = 0; +pub const _NVAPI_GSYNC_DISPLAY_SYNC_STATE_NVAPI_GSYNC_DISPLAY_SYNC_STATE_SLAVE: + _NVAPI_GSYNC_DISPLAY_SYNC_STATE = 1; +pub const _NVAPI_GSYNC_DISPLAY_SYNC_STATE_NVAPI_GSYNC_DISPLAY_SYNC_STATE_MASTER: + _NVAPI_GSYNC_DISPLAY_SYNC_STATE = 2; +#[doc = "! Display sync states. Used in NV_GSYNC_DISPLAY."] +pub type _NVAPI_GSYNC_DISPLAY_SYNC_STATE = ::std::os::raw::c_int; +#[doc = "! Display sync states. Used in NV_GSYNC_DISPLAY."] +pub use self::_NVAPI_GSYNC_DISPLAY_SYNC_STATE as NVAPI_GSYNC_DISPLAY_SYNC_STATE; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GSYNC_GPU { + #[doc = "!< Version of the structure"] + pub version: NvU32, + #[doc = "!< GPU handle"] + pub hPhysicalGpu: NvPhysicalGpuHandle, + #[doc = "!< Indicates which connector on the device the GPU is connected to."] + pub connector: NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR, + #[doc = "!< GPU through which hPhysicalGpu is connected to the Sync device (if not directly connected)\n!< - this is NULL otherwise"] + pub hProxyPhysicalGpu: NvPhysicalGpuHandle, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + pub __bindgen_padding_0: u32, +} +impl _NV_GSYNC_GPU { + #[inline] + pub fn isSynced(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isSynced(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isSynced_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isSynced_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1(isSynced: NvU32, reserved: NvU32) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isSynced: u32 = unsafe { ::std::mem::transmute(isSynced) }; + isSynced as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_GSYNC_GPU = _NV_GSYNC_GPU; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GSYNC_DISPLAY { + #[doc = "!< Version of the structure"] + pub version: NvU32, + #[doc = "!< display identifier for displays.The GPU to which it is connected, can be retireved from NvAPI_SYS_GetPhysicalGpuFromDisplayId"] + pub displayId: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Is this display slave/master\n!< (Retrieved with topology or set by caller for enable/disable sync)"] + pub syncState: NVAPI_GSYNC_DISPLAY_SYNC_STATE, +} +impl _NV_GSYNC_DISPLAY { + #[inline] + pub fn isMasterable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMasterable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMasterable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMasterable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isMasterable: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isMasterable: u32 = unsafe { ::std::mem::transmute(isMasterable) }; + isMasterable as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_GSYNC_DISPLAY = _NV_GSYNC_DISPLAY; +pub const _NVAPI_GSYNC_POLARITY_NVAPI_GSYNC_POLARITY_RISING_EDGE: _NVAPI_GSYNC_POLARITY = 0; +pub const _NVAPI_GSYNC_POLARITY_NVAPI_GSYNC_POLARITY_FALLING_EDGE: _NVAPI_GSYNC_POLARITY = 1; +pub const _NVAPI_GSYNC_POLARITY_NVAPI_GSYNC_POLARITY_BOTH_EDGES: _NVAPI_GSYNC_POLARITY = 2; +#[doc = "! Source signal edge to be used for output pulse. See NV_GSYNC_CONTROL_PARAMS."] +pub type _NVAPI_GSYNC_POLARITY = ::std::os::raw::c_int; +#[doc = "! Source signal edge to be used for output pulse. See NV_GSYNC_CONTROL_PARAMS."] +pub use self::_NVAPI_GSYNC_POLARITY as NVAPI_GSYNC_POLARITY; +pub const _NVAPI_GSYNC_VIDEO_MODE_NVAPI_GSYNC_VIDEO_MODE_NONE: _NVAPI_GSYNC_VIDEO_MODE = 0; +pub const _NVAPI_GSYNC_VIDEO_MODE_NVAPI_GSYNC_VIDEO_MODE_TTL: _NVAPI_GSYNC_VIDEO_MODE = 1; +pub const _NVAPI_GSYNC_VIDEO_MODE_NVAPI_GSYNC_VIDEO_MODE_NTSCPALSECAM: _NVAPI_GSYNC_VIDEO_MODE = 2; +pub const _NVAPI_GSYNC_VIDEO_MODE_NVAPI_GSYNC_VIDEO_MODE_HDTV: _NVAPI_GSYNC_VIDEO_MODE = 3; +pub const _NVAPI_GSYNC_VIDEO_MODE_NVAPI_GSYNC_VIDEO_MODE_COMPOSITE: _NVAPI_GSYNC_VIDEO_MODE = 4; +#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] +pub type _NVAPI_GSYNC_VIDEO_MODE = ::std::os::raw::c_int; +#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] +pub use self::_NVAPI_GSYNC_VIDEO_MODE as NVAPI_GSYNC_VIDEO_MODE; +pub const _NVAPI_GSYNC_SYNC_SOURCE_NVAPI_GSYNC_SYNC_SOURCE_VSYNC: _NVAPI_GSYNC_SYNC_SOURCE = 0; +pub const _NVAPI_GSYNC_SYNC_SOURCE_NVAPI_GSYNC_SYNC_SOURCE_HOUSESYNC: _NVAPI_GSYNC_SYNC_SOURCE = 1; +#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] +pub type _NVAPI_GSYNC_SYNC_SOURCE = ::std::os::raw::c_int; +#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] +pub use self::_NVAPI_GSYNC_SYNC_SOURCE as NVAPI_GSYNC_SYNC_SOURCE; +#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GSYNC_DELAY { + #[doc = "!< Version of the structure"] + pub version: NvU32, + #[doc = "!< delay to be induced in number of horizontal lines."] + pub numLines: NvU32, + #[doc = "!< delay to be induced in number of pixels."] + pub numPixels: NvU32, + #[doc = "!< maximum number of lines supported at current display mode to induce delay. Updated by NvAPI_GSync_GetControlParameters(). Read only."] + pub maxLines: NvU32, + #[doc = "!< minimum number of pixels required at current display mode to induce delay. Updated by NvAPI_GSync_GetControlParameters(). Read only."] + pub minPixels: NvU32, +} +#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] +pub type NV_GSYNC_DELAY = _NV_GSYNC_DELAY; +#[doc = "! Used in NvAPI_GSync_GetControlParameters() and NvAPI_GSync_SetControlParameters()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GSYNC_CONTROL_PARAMS_V1 { + #[doc = "!< Version of the structure"] + pub version: NvU32, + #[doc = "!< Leading edge / Falling edge / both"] + pub polarity: NVAPI_GSYNC_POLARITY, + #[doc = "!< None, TTL, NTSCPALSECAM, HDTV"] + pub vmode: NVAPI_GSYNC_VIDEO_MODE, + #[doc = "!< Number of pulses to wait between framelock signal generation"] + pub interval: NvU32, + #[doc = "!< VSync/House sync"] + pub source: NVAPI_GSYNC_SYNC_SOURCE, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< The time delay between the frame sync signal and the GPUs signal."] + pub syncSkew: NV_GSYNC_DELAY, + #[doc = "!< Sync start delay for master."] + pub startupDelay: NV_GSYNC_DELAY, +} +impl _NV_GSYNC_CONTROL_PARAMS_V1 { + #[inline] + pub fn interlaceMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_interlaceMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn interlaceMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_interlaceMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn syncSourceIsOutput(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_syncSourceIsOutput(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn syncSourceIsOutput_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_syncSourceIsOutput_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 30u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 30u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 30u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + interlaceMode: NvU32, + syncSourceIsOutput: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let interlaceMode: u32 = unsafe { ::std::mem::transmute(interlaceMode) }; + interlaceMode as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let syncSourceIsOutput: u32 = unsafe { ::std::mem::transmute(syncSourceIsOutput) }; + syncSourceIsOutput as u64 + }); + __bindgen_bitfield_unit.set(2usize, 30u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! Used in NvAPI_GSync_GetControlParameters() and NvAPI_GSync_SetControlParameters()."] +pub type NV_GSYNC_CONTROL_PARAMS_V1 = _NV_GSYNC_CONTROL_PARAMS_V1; +pub const _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE_NVAPI_GSYNC_UNDEFINED_MODE: + _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE = 0; +pub const _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE_NVAPI_GSYNC_MULTIPLY_MODE: + _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE = 1; +pub const _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE_NVAPI_GSYNC_DIVIDE_MODE: + _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE = 2; +#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] +pub type _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE = ::std::os::raw::c_int; +#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] +pub use self::_NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE as NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GSYNC_CONTROL_PARAMS_V2 { + #[doc = "!< Version of the structure"] + pub version: NvU32, + #[doc = "!< Leading edge / Falling edge / both"] + pub polarity: NVAPI_GSYNC_POLARITY, + #[doc = "!< None, TTL, NTSCPALSECAM, HDTV"] + pub vmode: NVAPI_GSYNC_VIDEO_MODE, + #[doc = "!< Number of pulses to wait between framelock signal generation"] + pub interval: NvU32, + #[doc = "!< VSync/House sync"] + pub source: NVAPI_GSYNC_SYNC_SOURCE, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< The time delay between the frame sync signal and the GPUs signal."] + pub syncSkew: NV_GSYNC_DELAY, + #[doc = "!< Sync start delay for master."] + pub startupDelay: NV_GSYNC_DELAY, + #[doc = "!< Indicates multiplier/divider mode for the housesync signal.\n!< While setting multiplyDivideMode, source needs to be set as NVAPI_GSYNC_SYNC_SOURCE_HOUSESYNC."] + pub multiplyDivideMode: NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE, + #[doc = "!< Indicates the multiplier/divider value for the housesync signal. Only supported if bIsMulDivSupported field of the structure NV_GSYNC_CAPABILITIES is set to 1.\n!< The maximum supported value for this field can be obtained from maxMulDivValue field of the structure NV_GSYNC_CAPABILITIES."] + pub multiplyDivideValue: NvU8, +} +impl _NV_GSYNC_CONTROL_PARAMS_V2 { + #[inline] + pub fn interlaceMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_interlaceMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn interlaceMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_interlaceMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn syncSourceIsOutput(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_syncSourceIsOutput(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn syncSourceIsOutput_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_syncSourceIsOutput_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 30u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 30u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 30u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + interlaceMode: NvU32, + syncSourceIsOutput: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let interlaceMode: u32 = unsafe { ::std::mem::transmute(interlaceMode) }; + interlaceMode as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let syncSourceIsOutput: u32 = unsafe { ::std::mem::transmute(syncSourceIsOutput) }; + syncSourceIsOutput as u64 + }); + __bindgen_bitfield_unit.set(2usize, 30u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_GSYNC_CONTROL_PARAMS_V2 = _NV_GSYNC_CONTROL_PARAMS_V2; +pub type NV_GSYNC_CONTROL_PARAMS = NV_GSYNC_CONTROL_PARAMS_V2; +#[doc = "! Used in NvAPI_GSync_GetSyncStatus()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GSYNC_STATUS { + #[doc = "!< Version of the structure"] + pub version: NvU32, + #[doc = "!< Is timing in sync?"] + pub bIsSynced: NvU32, + #[doc = "!< Does the phase of the timing signal from the GPU = the phase of the master sync signal?"] + pub bIsStereoSynced: NvU32, + #[doc = "!< Is the sync signal available?"] + pub bIsSyncSignalAvailable: NvU32, +} +#[doc = "! Used in NvAPI_GSync_GetSyncStatus()."] +pub type NV_GSYNC_STATUS = _NV_GSYNC_STATUS; +pub const _NVAPI_GSYNC_RJ45_IO_NVAPI_GSYNC_RJ45_OUTPUT: _NVAPI_GSYNC_RJ45_IO = 0; +pub const _NVAPI_GSYNC_RJ45_IO_NVAPI_GSYNC_RJ45_INPUT: _NVAPI_GSYNC_RJ45_IO = 1; +#[doc = "!< This field is used to notify that the framelock is not actually present."] +pub const _NVAPI_GSYNC_RJ45_IO_NVAPI_GSYNC_RJ45_UNUSED: _NVAPI_GSYNC_RJ45_IO = 2; +#[doc = "! Used in NV_GSYNC_STATUS_PARAMS."] +pub type _NVAPI_GSYNC_RJ45_IO = ::std::os::raw::c_int; +#[doc = "! Used in NV_GSYNC_STATUS_PARAMS."] +pub use self::_NVAPI_GSYNC_RJ45_IO as NVAPI_GSYNC_RJ45_IO; +#[doc = "! \\ingroup gsyncapi\n! Used in NvAPI_GSync_GetStatusParameters()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GSYNC_STATUS_PARAMS_V1 { + pub version: NvU32, + #[doc = "!< The refresh rate"] + pub refreshRate: NvU32, + #[doc = "!< Configured as input / output"] + pub RJ45_IO: [NVAPI_GSYNC_RJ45_IO; 2usize], + #[doc = "!< Connected to ethernet hub? [ERRONEOUSLY CONNECTED!]"] + pub RJ45_Ethernet: [NvU32; 2usize], + #[doc = "!< Incoming house sync frequency in Hz"] + pub houseSyncIncoming: NvU32, + #[doc = "!< Is house sync connected?"] + pub bHouseSync: NvU32, +} +#[doc = "! \\ingroup gsyncapi\n! Used in NvAPI_GSync_GetStatusParameters()."] +pub type NV_GSYNC_STATUS_PARAMS_V1 = _NV_GSYNC_STATUS_PARAMS_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GSYNC_STATUS_PARAMS_V2 { + pub version: NvU32, + #[doc = "!< The refresh rate"] + pub refreshRate: NvU32, + #[doc = "!< Configured as input / output"] + pub RJ45_IO: [NVAPI_GSYNC_RJ45_IO; 2usize], + #[doc = "!< Connected to ethernet hub? [ERRONEOUSLY CONNECTED!]"] + pub RJ45_Ethernet: [NvU32; 2usize], + #[doc = "!< Incoming house sync frequency in Hz"] + pub houseSyncIncoming: NvU32, + #[doc = "!< Is house sync connected?"] + pub bHouseSync: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl _NV_GSYNC_STATUS_PARAMS_V2 { + #[inline] + pub fn bInternalSlave(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bInternalSlave(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bInternalSlave_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bInternalSlave_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bInternalSlave: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bInternalSlave: u32 = unsafe { ::std::mem::transmute(bInternalSlave) }; + bInternalSlave as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_GSYNC_STATUS_PARAMS_V2 = _NV_GSYNC_STATUS_PARAMS_V2; +pub type NV_GSYNC_STATUS_PARAMS = NV_GSYNC_STATUS_PARAMS_V2; +pub const _NV_RESOLVE_MODE_NV_RESOLVE_MODE_SAMPLE_0: _NV_RESOLVE_MODE = 0; +#[doc = "! \\ingroup dx\n! Valid modes for NvAPI_D3D11_ResolveSubresourceRegion() and NvAPI_D3D12_ResolveSubresourceRegion"] +pub type _NV_RESOLVE_MODE = ::std::os::raw::c_int; +#[doc = "! \\ingroup dx\n! Valid modes for NvAPI_D3D11_ResolveSubresourceRegion() and NvAPI_D3D12_ResolveSubresourceRegion"] +pub use self::_NV_RESOLVE_MODE as NV_RESOLVE_MODE; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of Single Pass Stereo HW feature\n! \\ingroup dx"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V1 { + pub version: NvU32, + pub bSinglePassStereoSupported: NvU32, +} +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of Single Pass Stereo HW feature\n! \\ingroup dx"] +pub type NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V1 = + _NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V2 { + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl _NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V2 { + #[inline] + pub fn bSinglePassStereoSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bSinglePassStereoSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bSinglePassStereoSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bSinglePassStereoSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bSinglePassStereoXYZWSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bSinglePassStereoXYZWSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bSinglePassStereoXYZWSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bSinglePassStereoXYZWSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 30u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 30u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 30u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bSinglePassStereoSupported: NvU32, + bSinglePassStereoXYZWSupported: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bSinglePassStereoSupported: u32 = + unsafe { ::std::mem::transmute(bSinglePassStereoSupported) }; + bSinglePassStereoSupported as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bSinglePassStereoXYZWSupported: u32 = + unsafe { ::std::mem::transmute(bSinglePassStereoXYZWSupported) }; + bSinglePassStereoXYZWSupported as u64 + }); + __bindgen_bitfield_unit.set(2usize, 30u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V2 = + _NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V2; +pub type NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS = NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V2; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of MultiView HW feature\n! \\ingroup dx"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_QUERY_MULTIVIEW_SUPPORT_PARAMS_V1 { + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl _NV_QUERY_MULTIVIEW_SUPPORT_PARAMS_V1 { + #[inline] + pub fn bMultiViewSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bMultiViewSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bMultiViewSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bMultiViewSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bSinglePassStereoSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bSinglePassStereoSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bSinglePassStereoSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bSinglePassStereoSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bSinglePassStereoXYZWSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_bSinglePassStereoXYZWSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bSinglePassStereoXYZWSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bSinglePassStereoXYZWSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 29u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 29u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 29u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 29u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bMultiViewSupported: NvU32, + bSinglePassStereoSupported: NvU32, + bSinglePassStereoXYZWSupported: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bMultiViewSupported: u32 = unsafe { ::std::mem::transmute(bMultiViewSupported) }; + bMultiViewSupported as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bSinglePassStereoSupported: u32 = + unsafe { ::std::mem::transmute(bSinglePassStereoSupported) }; + bSinglePassStereoSupported as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let bSinglePassStereoXYZWSupported: u32 = + unsafe { ::std::mem::transmute(bSinglePassStereoXYZWSupported) }; + bSinglePassStereoXYZWSupported as u64 + }); + __bindgen_bitfield_unit.set(3usize, 29u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of MultiView HW feature\n! \\ingroup dx"] +pub type NV_QUERY_MULTIVIEW_SUPPORT_PARAMS_V1 = _NV_QUERY_MULTIVIEW_SUPPORT_PARAMS_V1; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of MultiView HW feature\n! \\ingroup dx"] +pub type NV_QUERY_MULTIVIEW_SUPPORT_PARAMS = NV_QUERY_MULTIVIEW_SUPPORT_PARAMS_V1; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used for setting the Mode for MultiView HW Feature.\n! \\ingroup dx"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MULTIVIEW_PARAMS_V1 { + pub version: NvU32, + pub numViews: NvU32, + pub renderTargetIndexOffset: [NvU32; 4usize], + pub independentViewportMaskEnable: NvU8, +} +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used for setting the Mode for MultiView HW Feature.\n! \\ingroup dx"] +pub type NV_MULTIVIEW_PARAMS_V1 = _NV_MULTIVIEW_PARAMS_V1; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used for setting the Mode for MultiView HW Feature.\n! \\ingroup dx"] +pub type NV_MULTIVIEW_PARAMS = NV_MULTIVIEW_PARAMS_V1; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of Lens Matched Shading HW feature\n! \\ingroup dx"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_QUERY_MODIFIED_W_SUPPORT_PARAMS { + pub version: NvU32, + pub bModifiedWSupported: NvU32, +} +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of Lens Matched Shading HW feature\n! \\ingroup dx"] +pub type NV_QUERY_MODIFIED_W_SUPPORT_PARAMS_V1 = _NV_QUERY_MODIFIED_W_SUPPORT_PARAMS; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of Lens Matched Shading HW feature\n! \\ingroup dx"] +pub type NV_QUERY_MODIFIED_W_SUPPORT_PARAMS = NV_QUERY_MODIFIED_W_SUPPORT_PARAMS_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MODIFIED_W_COEFFICIENTS { + pub fA: f32, + pub fB: f32, + pub fAReserved: f32, + pub fBReserved: f32, + pub fReserved: [f32; 2usize], +} +pub type NV_MODIFIED_W_COEFFICIENTS = _NV_MODIFIED_W_COEFFICIENTS; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MODIFIED_W_PARAMS { + pub version: NvU32, + pub numEntries: NvU32, + pub modifiedWCoefficients: [NV_MODIFIED_W_COEFFICIENTS; 16usize], + pub id: NvU32, + pub reserved: [NvU32; 16usize], +} +pub type NV_MODIFIED_W_PARAMS_V1 = _NV_MODIFIED_W_PARAMS; +pub type NV_MODIFIED_W_PARAMS = NV_MODIFIED_W_PARAMS_V1; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to get sleep status\n! \\ingroup dx"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GET_SLEEP_STATUS_PARAMS { + #[doc = "!< (IN) Structure version"] + pub version: NvU32, + #[doc = "!< (OUT) Is low latency mode enabled?"] + pub bLowLatencyMode: NvBool, + #[doc = "!< (OUT) Is fullscreen VRR enabled?"] + pub bFsVrr: NvBool, + #[doc = "!< (OUT) Is Control Panel overriding VSYNC ON?"] + pub bCplVsyncOn: NvBool, + #[doc = "!< (OUT) Latest sleep interval in microseconds."] + pub sleepIntervalUs: NvU32, + #[doc = "!< (OUT) Is NvAPI_D3D_Sleep() being called?"] + pub bUseGameSleep: NvBool, + #[doc = "!< (OUT) Is in fullscreen/iFlip mode?"] + pub bFullscreenIFlip: NvBool, + #[doc = "!< (OUT) Latest Frame Generation multiplier used."] + pub fgMultiplier: NvU8, + #[doc = "!< (IN) Reserved. Must be set to 0s."] + pub rsvd: [NvU8; 119usize], +} +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to get sleep status\n! \\ingroup dx"] +pub type NV_GET_SLEEP_STATUS_PARAMS_V1 = _NV_GET_SLEEP_STATUS_PARAMS; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to get sleep status\n! \\ingroup dx"] +pub type NV_GET_SLEEP_STATUS_PARAMS = NV_GET_SLEEP_STATUS_PARAMS_V1; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to set sleep mode\n! \\ingroup dx"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_SET_SLEEP_MODE_PARAMS { + #[doc = "!< (IN) Structure version"] + pub version: NvU32, + #[doc = "!< (IN) Low latency mode enable/disable."] + pub bLowLatencyMode: NvBool, + #[doc = "!< (IN) Request maximum GPU clock frequency regardless of workload."] + pub bLowLatencyBoost: NvBool, + #[doc = "!< (IN) Minimum frame interval in microseconds. 0 = no frame rate limit."] + pub minimumIntervalUs: NvU32, + #[doc = "!< (IN) Allow latency markers to be used for runtime optimizations."] + pub bUseMarkersToOptimize: NvBool, + #[doc = "!< (IN) Consider all submission overlaps (both in between frames and within each frame)."] + pub bUseMinQueueTime: NvBool, + #[doc = "!< (IN) Reserved. Must be set to 0s."] + pub rsvd: [NvU8; 30usize], +} +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to set sleep mode\n! \\ingroup dx"] +pub type NV_SET_SLEEP_MODE_PARAMS_V1 = _NV_SET_SLEEP_MODE_PARAMS; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to set sleep mode\n! \\ingroup dx"] +pub type NV_SET_SLEEP_MODE_PARAMS = NV_SET_SLEEP_MODE_PARAMS_V1; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to send Reflex Sync data to UMD\n! \\ingroup dx"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_SET_REFLEX_SYNC_PARAMS { + #[doc = "!< (IN) Structure version"] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< (IN) Interval between VBLANKs in microseconds. (0 means N/A)"] + pub vblankIntervalUs: NvU32, + #[doc = "!< (IN) Amount of time in the completed frame queue. Can be negative. (0 means N/A)"] + pub timeInQueueUs: NvS32, + #[doc = "!< (IN) Target amount of time in the completed frame queue. (0 means N/A)"] + pub timeInQueueUsTarget: NvU32, + #[doc = "!< (IN) Specify the frame generation multipler to use. (0 means driver should auto-detect)"] + pub fgMultiplier: NvU8, + #[doc = "!< (IN) Reserved. Must be set to 0s."] + pub rsvd: [NvU8; 27usize], +} +impl _NV_SET_REFLEX_SYNC_PARAMS { + #[inline] + pub fn bEnable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bEnable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bEnable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bEnable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bDisable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bDisable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bDisable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bDisable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn flagsRsvd(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } + } + #[inline] + pub fn set_flagsRsvd(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 30u8, val as u64) + } + } + #[inline] + pub unsafe fn flagsRsvd_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 30u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_flagsRsvd_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 30u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bEnable: NvU32, + bDisable: NvU32, + flagsRsvd: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bEnable: u32 = unsafe { ::std::mem::transmute(bEnable) }; + bEnable as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bDisable: u32 = unsafe { ::std::mem::transmute(bDisable) }; + bDisable as u64 + }); + __bindgen_bitfield_unit.set(2usize, 30u8, { + let flagsRsvd: u32 = unsafe { ::std::mem::transmute(flagsRsvd) }; + flagsRsvd as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to send Reflex Sync data to UMD\n! \\ingroup dx"] +pub type NV_SET_REFLEX_SYNC_PARAMS_V1 = _NV_SET_REFLEX_SYNC_PARAMS; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to send Reflex Sync data to UMD\n! \\ingroup dx"] +pub type NV_SET_REFLEX_SYNC_PARAMS = NV_SET_REFLEX_SYNC_PARAMS_V1; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to get latency report.\n! \\ingroup dx"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LATENCY_RESULT_PARAMS { + #[doc = "!< (IN) Structure version"] + pub version: NvU32, + pub frameReport: [_NV_LATENCY_RESULT_PARAMS_FrameReport; 64usize], + pub rsvd: [NvU8; 32usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LATENCY_RESULT_PARAMS_FrameReport { + #[doc = "!< (OUT)"] + pub frameID: NvU64, + #[doc = "!< (OUT)"] + pub inputSampleTime: NvU64, + #[doc = "!< (OUT)"] + pub simStartTime: NvU64, + #[doc = "!< (OUT)"] + pub simEndTime: NvU64, + #[doc = "!< (OUT)"] + pub renderSubmitStartTime: NvU64, + #[doc = "!< (OUT)"] + pub renderSubmitEndTime: NvU64, + #[doc = "!< (OUT)"] + pub presentStartTime: NvU64, + #[doc = "!< (OUT)"] + pub presentEndTime: NvU64, + #[doc = "!< (OUT)"] + pub driverStartTime: NvU64, + #[doc = "!< (OUT)"] + pub driverEndTime: NvU64, + #[doc = "!< (OUT)"] + pub osRenderQueueStartTime: NvU64, + #[doc = "!< (OUT)"] + pub osRenderQueueEndTime: NvU64, + #[doc = "!< (OUT)"] + pub gpuRenderStartTime: NvU64, + #[doc = "!< (OUT)"] + pub gpuRenderEndTime: NvU64, + #[doc = "!< (OUT) Difference between gpuRenderStartTime and gpuRenderEndTime, excluding the idles in between, in microseconds."] + pub gpuActiveRenderTimeUs: NvU32, + #[doc = "!< (OUT) Difference between previous and current frame's gpuRenderEndTime, in microseconds."] + pub gpuFrameTimeUs: NvU32, + #[doc = "!< (OUT)"] + pub cameraConstructedTime: NvU64, + #[doc = "!< (OUT) Cross adapter copy time in microseconds."] + pub crossAdapterCopyTimeUs: NvU32, + #[doc = "!< (OUT) Frame generation time in microseconds."] + pub aiFrameTimeUs: NvU32, + pub rsvd: [NvU8; 104usize], +} +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to get latency report.\n! \\ingroup dx"] +pub type NV_LATENCY_RESULT_PARAMS_V1 = _NV_LATENCY_RESULT_PARAMS; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to get latency report.\n! \\ingroup dx"] +pub type NV_LATENCY_RESULT_PARAMS = NV_LATENCY_RESULT_PARAMS_V1; +pub const NV_LATENCY_MARKER_TYPE_SIMULATION_START: NV_LATENCY_MARKER_TYPE = 0; +pub const NV_LATENCY_MARKER_TYPE_SIMULATION_END: NV_LATENCY_MARKER_TYPE = 1; +pub const NV_LATENCY_MARKER_TYPE_RENDERSUBMIT_START: NV_LATENCY_MARKER_TYPE = 2; +pub const NV_LATENCY_MARKER_TYPE_RENDERSUBMIT_END: NV_LATENCY_MARKER_TYPE = 3; +pub const NV_LATENCY_MARKER_TYPE_PRESENT_START: NV_LATENCY_MARKER_TYPE = 4; +pub const NV_LATENCY_MARKER_TYPE_PRESENT_END: NV_LATENCY_MARKER_TYPE = 5; +pub const NV_LATENCY_MARKER_TYPE_INPUT_SAMPLE: NV_LATENCY_MARKER_TYPE = 6; +pub const NV_LATENCY_MARKER_TYPE_TRIGGER_FLASH: NV_LATENCY_MARKER_TYPE = 7; +pub const NV_LATENCY_MARKER_TYPE_PC_LATENCY_PING: NV_LATENCY_MARKER_TYPE = 8; +pub const NV_LATENCY_MARKER_TYPE_OUT_OF_BAND_RENDERSUBMIT_START: NV_LATENCY_MARKER_TYPE = 9; +pub const NV_LATENCY_MARKER_TYPE_OUT_OF_BAND_RENDERSUBMIT_END: NV_LATENCY_MARKER_TYPE = 10; +pub const NV_LATENCY_MARKER_TYPE_OUT_OF_BAND_PRESENT_START: NV_LATENCY_MARKER_TYPE = 11; +pub const NV_LATENCY_MARKER_TYPE_OUT_OF_BAND_PRESENT_END: NV_LATENCY_MARKER_TYPE = 12; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used define latency marker type\n! \\ingroup dx"] +pub type NV_LATENCY_MARKER_TYPE = ::std::os::raw::c_int; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used set latency markers\n! \\ingroup dx"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LATENCY_MARKER_PARAMS { + #[doc = "!< (IN) Structure version"] + pub version: NvU32, + pub frameID: NvU64, + pub markerType: NV_LATENCY_MARKER_TYPE, + pub rsvd0: NvU64, + pub rsvd: [NvU8; 56usize], +} +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used set latency markers\n! \\ingroup dx"] +pub type NV_LATENCY_MARKER_PARAMS_V1 = _NV_LATENCY_MARKER_PARAMS; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used set latency markers\n! \\ingroup dx"] +pub type NV_LATENCY_MARKER_PARAMS = NV_LATENCY_MARKER_PARAMS_V1; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used in NvAPI_D3D12_SetAsyncFrameMarker and NvAPI_D3D11_SetAsyncFrameMarker\n! \\ingroup dx"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_ASYNC_FRAME_MARKER_PARAMS_V1 { + #[doc = "!< (IN) Structure version"] + pub version: NvU32, + pub frameID: NvU64, + pub markerType: NV_LATENCY_MARKER_TYPE, + pub presentFrameID: NvU64, + pub vendorInternal: NvBool, + pub rsvd: [NvU8; 55usize], +} +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used in NvAPI_D3D12_SetAsyncFrameMarker and NvAPI_D3D11_SetAsyncFrameMarker\n! \\ingroup dx"] +pub type NV_ASYNC_FRAME_MARKER_PARAMS_V1 = _NV_ASYNC_FRAME_MARKER_PARAMS_V1; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used in NvAPI_D3D12_SetAsyncFrameMarker and NvAPI_D3D11_SetAsyncFrameMarker\n! \\ingroup dx"] +pub type NV_ASYNC_FRAME_MARKER_PARAMS = NV_ASYNC_FRAME_MARKER_PARAMS_V1; +pub const NV_OUT_OF_BAND_CQ_TYPE_OUT_OF_BAND_RENDER: NV_OUT_OF_BAND_CQ_TYPE = 0; +pub const NV_OUT_OF_BAND_CQ_TYPE_OUT_OF_BAND_PRESENT: NV_OUT_OF_BAND_CQ_TYPE = 1; +pub const NV_OUT_OF_BAND_CQ_TYPE_OUT_OF_BAND_IGNORE: NV_OUT_OF_BAND_CQ_TYPE = 2; +pub const NV_OUT_OF_BAND_CQ_TYPE_OUT_OF_BAND_RENDER_PRESENT: NV_OUT_OF_BAND_CQ_TYPE = 3; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used in NvAPI_D3D12_NotifyOutOfBandCommandQueue\n! \\ingroup dx"] +pub type NV_OUT_OF_BAND_CQ_TYPE = ::std::os::raw::c_int; +pub const _NV_D3D12_WORKSTATION_FEATURE_TYPE_NV_D3D12_WORKSTATION_FEATURE_TYPE_PRESENT_BARRIER: + _NV_D3D12_WORKSTATION_FEATURE_TYPE = 1; +pub const _NV_D3D12_WORKSTATION_FEATURE_TYPE_NV_D3D12_WORKSTATION_FEATURE_TYPE_RDMA_BAR1_SUPPORT: + _NV_D3D12_WORKSTATION_FEATURE_TYPE = 2; +#[doc = "! \\ingroup DX"] +pub type _NV_D3D12_WORKSTATION_FEATURE_TYPE = ::std::os::raw::c_int; +#[doc = "! \\ingroup DX"] +pub use self::_NV_D3D12_WORKSTATION_FEATURE_TYPE as NV_D3D12_WORKSTATION_FEATURE_TYPE; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_D3D12_WORKSTATION_FEATURE_RDMA_PROPERTIES { + pub rdmaHeapSize: NvU64, +} +pub type NV_D3D12_WORKSTATION_FEATURE_RDMA_PROPERTIES = + _NV_D3D12_WORKSTATION_FEATURE_RDMA_PROPERTIES; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_INITIALIZED: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 1; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_ENABLED: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 2; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_DLL_EXISTS: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 4; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_DLL_LOADED: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 8; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_DLL_SELECTED: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 16; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_PRESET: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 32; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_PERF_MODE: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 64; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_SCALING_RATIO: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 128; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_OPTIMAL_SETTINGS: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 256; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_CREATED: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 512; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_EVALUATE: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 1024; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_FG_MODE: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 8192; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_SR_DLAA_MODE: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 16384; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_FG_MULTI_FRAME: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 32768; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_ERR_FAILED: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 65536; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_ERR_DENIED: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 131072; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_ERR_DRS: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 262144; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_ERR_NOT_FOUND: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 524288; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_ERR_DLL_LOAD: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 1048576; +pub type NV_NGX_DLSS_OVERRIDE_BITFIELD = ::std::os::raw::c_int; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_NGX_DLSS_OVERRIDE_GET_STATE_PARAMS_V1 { + #[doc = "!< [in] Structure version"] + pub version: NvU32, + #[doc = "!< [in] Process Identifier"] + pub processIdentifier: NvU32, + #[doc = "!< [out] Feedback bits for Super Resolution"] + pub feedbackMaskSR: NvU64, + #[doc = "!< [out] Feedback bits for Ray Reconstruction"] + pub feedbackMaskRR: NvU64, + #[doc = "!< [out] Feedback bits for Frame Generation"] + pub feedbackMaskFG: NvU64, + #[doc = "!< [out] Scaling Ratio"] + pub scalingRatio: NvF32, + #[doc = "!< [out] Performance Mode"] + pub performanceMode: NvU32, + #[doc = "!< [out] Render Preset for SR/RR"] + pub renderPreset: NvU32, + #[doc = "!< [out] FG Override Frame Count Target"] + pub frameGenerationCount: NvU32, + #[doc = "!< [out] Render Preset for FG"] + pub frameGenerationPreset: NvU32, + #[doc = "!< [out] Frame Generation Mode"] + pub frameGenerationMode: NvU32, + #[doc = "!< Reserved for future use. Must be zero."] + pub reserved: [NvU32; 2usize], +} +pub type NV_NGX_DLSS_OVERRIDE_GET_STATE_PARAMS_V1 = _NV_NGX_DLSS_OVERRIDE_GET_STATE_PARAMS_V1; +pub type NV_NGX_DLSS_OVERRIDE_GET_STATE_PARAMS = NV_NGX_DLSS_OVERRIDE_GET_STATE_PARAMS_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_NGX_DLSS_OVERRIDE_SET_STATE_PARAMS_V1 { + #[doc = "!< [in] Structure version"] + pub version: NvU32, + #[doc = "!< [in] Process identifier of caller"] + pub processIdentifier: NvU32, + #[doc = "!< [in] DLSS feature ID"] + pub feature: NvU32, + #[doc = "!< [in] Feedback bits for DLSS feature"] + pub feedbackMask: NvU64, + #[doc = "!< Reserved for future use. Must be zero."] + pub reserved: [NvU64; 4usize], +} +pub type NV_NGX_DLSS_OVERRIDE_SET_STATE_PARAMS_V1 = _NV_NGX_DLSS_OVERRIDE_SET_STATE_PARAMS_V1; +pub type NV_NGX_DLSS_OVERRIDE_SET_STATE_PARAMS = NV_NGX_DLSS_OVERRIDE_SET_STATE_PARAMS_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NVVIOTOPOLOGYTARGET { + #[doc = "!< Handle to Physical GPU (This could be NULL for GVI device if its not binded)"] + pub hPhysicalGpu: NvPhysicalGpuHandle, + #[doc = "!, +} +impl _NV_DISPLAY_DRIVER_INFO { + #[inline] + pub fn bIsDCHDriver(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsDCHDriver(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsDCHDriver_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsDCHDriver_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsNVIDIAStudioPackage(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsNVIDIAStudioPackage(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsNVIDIAStudioPackage_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsNVIDIAStudioPackage_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsNVIDIAGameReadyPackage(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsNVIDIAGameReadyPackage(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsNVIDIAGameReadyPackage_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsNVIDIAGameReadyPackage_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsNVIDIARTXProductionBranchPackage(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsNVIDIARTXProductionBranchPackage(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsNVIDIARTXProductionBranchPackage_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsNVIDIARTXProductionBranchPackage_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsNVIDIARTXNewFeatureBranchPackage(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsNVIDIARTXNewFeatureBranchPackage(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsNVIDIARTXNewFeatureBranchPackage_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsNVIDIARTXNewFeatureBranchPackage_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 27u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 27u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 27u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsDCHDriver: NvU32, + bIsNVIDIAStudioPackage: NvU32, + bIsNVIDIAGameReadyPackage: NvU32, + bIsNVIDIARTXProductionBranchPackage: NvU32, + bIsNVIDIARTXNewFeatureBranchPackage: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsDCHDriver: u32 = unsafe { ::std::mem::transmute(bIsDCHDriver) }; + bIsDCHDriver as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bIsNVIDIAStudioPackage: u32 = + unsafe { ::std::mem::transmute(bIsNVIDIAStudioPackage) }; + bIsNVIDIAStudioPackage as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let bIsNVIDIAGameReadyPackage: u32 = + unsafe { ::std::mem::transmute(bIsNVIDIAGameReadyPackage) }; + bIsNVIDIAGameReadyPackage as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let bIsNVIDIARTXProductionBranchPackage: u32 = + unsafe { ::std::mem::transmute(bIsNVIDIARTXProductionBranchPackage) }; + bIsNVIDIARTXProductionBranchPackage as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let bIsNVIDIARTXNewFeatureBranchPackage: u32 = + unsafe { ::std::mem::transmute(bIsNVIDIARTXNewFeatureBranchPackage) }; + bIsNVIDIARTXNewFeatureBranchPackage as u64 + }); + __bindgen_bitfield_unit.set(5usize, 27u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_DISPLAY_DRIVER_INFO_V1 = _NV_DISPLAY_DRIVER_INFO; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_DISPLAY_DRIVER_INFO_V2 { + #[doc = "!< Structure Version."] + pub version: NvU32, + #[doc = "!< Contains the driver version after successful return."] + pub driverVersion: NvU32, + #[doc = "!< Contains the driver-branch string after successful return."] + pub szBuildBranch: NvAPI_ShortString, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< (OUT) Contains the driver base branch string after successful return."] + pub szBuildBaseBranch: NvAPI_ShortString, + #[doc = "!< Reserved for future use"] + pub reservedEx: NvU32, +} +impl _NV_DISPLAY_DRIVER_INFO_V2 { + #[inline] + pub fn bIsDCHDriver(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsDCHDriver(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsDCHDriver_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsDCHDriver_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsNVIDIAStudioPackage(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsNVIDIAStudioPackage(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsNVIDIAStudioPackage_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsNVIDIAStudioPackage_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsNVIDIAGameReadyPackage(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsNVIDIAGameReadyPackage(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsNVIDIAGameReadyPackage_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsNVIDIAGameReadyPackage_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsNVIDIARTXProductionBranchPackage(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsNVIDIARTXProductionBranchPackage(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsNVIDIARTXProductionBranchPackage_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsNVIDIARTXProductionBranchPackage_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsNVIDIARTXNewFeatureBranchPackage(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsNVIDIARTXNewFeatureBranchPackage(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsNVIDIARTXNewFeatureBranchPackage_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsNVIDIARTXNewFeatureBranchPackage_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 27u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 27u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 27u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsDCHDriver: NvU32, + bIsNVIDIAStudioPackage: NvU32, + bIsNVIDIAGameReadyPackage: NvU32, + bIsNVIDIARTXProductionBranchPackage: NvU32, + bIsNVIDIARTXNewFeatureBranchPackage: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsDCHDriver: u32 = unsafe { ::std::mem::transmute(bIsDCHDriver) }; + bIsDCHDriver as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bIsNVIDIAStudioPackage: u32 = + unsafe { ::std::mem::transmute(bIsNVIDIAStudioPackage) }; + bIsNVIDIAStudioPackage as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let bIsNVIDIAGameReadyPackage: u32 = + unsafe { ::std::mem::transmute(bIsNVIDIAGameReadyPackage) }; + bIsNVIDIAGameReadyPackage as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let bIsNVIDIARTXProductionBranchPackage: u32 = + unsafe { ::std::mem::transmute(bIsNVIDIARTXProductionBranchPackage) }; + bIsNVIDIARTXProductionBranchPackage as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let bIsNVIDIARTXNewFeatureBranchPackage: u32 = + unsafe { ::std::mem::transmute(bIsNVIDIARTXNewFeatureBranchPackage) }; + bIsNVIDIARTXNewFeatureBranchPackage as u64 + }); + __bindgen_bitfield_unit.set(5usize, 27u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_DISPLAY_DRIVER_INFO_V2 = _NV_DISPLAY_DRIVER_INFO_V2; +pub type NV_DISPLAY_DRIVER_INFO = NV_DISPLAY_DRIVER_INFO_V2; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_PHYSICAL_GPU_HANDLE_DATA { + pub hPhysicalGpu: NvPhysicalGpuHandle, + pub adapterType: NV_ADAPTER_TYPE, + pub reserved2: [NvU32; 4usize], +} +pub type NV_PHYSICAL_GPU_HANDLE_DATA = _NV_PHYSICAL_GPU_HANDLE_DATA; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_PHYSICAL_GPUS { + pub version: NvU32, + pub gpuHandleData: [NV_PHYSICAL_GPU_HANDLE_DATA; 64usize], + pub gpuHandleCount: NvU32, + pub reserved: [NvU32; 4usize], +} +pub type NV_PHYSICAL_GPUS_V1 = _NV_PHYSICAL_GPUS; +pub type NV_PHYSICAL_GPUS = NV_PHYSICAL_GPUS_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LOGICAL_GPU_HANDLE_DATA { + pub hLogicalGpu: NvLogicalGpuHandle, + pub adapterType: NV_ADAPTER_TYPE, + pub reserved: [NvU32; 4usize], +} +pub type NV_LOGICAL_GPU_HANDLE_DATA = _NV_LOGICAL_GPU_HANDLE_DATA; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LOGICAL_GPUS { + pub version: NvU32, + pub gpuHandleData: [NV_LOGICAL_GPU_HANDLE_DATA; 64usize], + pub gpuHandleCount: NvU32, + pub reserved: [NvU32; 4usize], +} +pub type NV_LOGICAL_GPUS_V1 = _NV_LOGICAL_GPUS; +pub type NV_LOGICAL_GPUS = NV_LOGICAL_GPUS_V1; +pub const _NV_NGX_DRIVER_FEATURE_ID_NV_NGX_DRIVER_FEATURE_ID_SET_FLIP_CONFIG_V2: + _NV_NGX_DRIVER_FEATURE_ID = 3423695; +pub type _NV_NGX_DRIVER_FEATURE_ID = ::std::os::raw::c_int; +pub use self::_NV_NGX_DRIVER_FEATURE_ID as NV_NGX_DRIVER_FEATURE_ID; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_NGX_DRIVER_FEATURE_SUPPORT_INFO { + #[doc = "!< [IN] Feature ID to query"] + pub featureId: NV_NGX_DRIVER_FEATURE_ID, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Reserved for future use"] + pub reserved2: [NvU32; 2usize], +} +impl _NV_NGX_DRIVER_FEATURE_SUPPORT_INFO { + #[inline] + pub fn bSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved1(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved1(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved1_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved1_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bSupported: NvU32, + reserved1: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bSupported: u32 = unsafe { ::std::mem::transmute(bSupported) }; + bSupported as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved1: u32 = unsafe { ::std::mem::transmute(reserved1) }; + reserved1 as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_NGX_DRIVER_FEATURE_SUPPORT_INFO = _NV_NGX_DRIVER_FEATURE_SUPPORT_INFO; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_NGX_GET_DRIVER_FEATURE_SUPPORT_PARAMS_V1 { + #[doc = "!< [IN] Structure version"] + pub version: NvU32, + #[doc = "!< [IN] Number of features to query (must be <= NVAPI_MAX_NGX_FEATURES_PER_QUERY)"] + pub featureCount: NvU32, + #[doc = "!< [INOUT] Feature query array"] + pub featureSupportInfo: [NV_NGX_DRIVER_FEATURE_SUPPORT_INFO; 16usize], + #[doc = "!< Reserved for future use"] + pub reserved: [NvU32; 6usize], +} +pub type NV_NGX_GET_DRIVER_FEATURE_SUPPORT_PARAMS_V1 = _NV_NGX_GET_DRIVER_FEATURE_SUPPORT_PARAMS_V1; +pub type NV_NGX_GET_DRIVER_FEATURE_SUPPORT_PARAMS = NV_NGX_GET_DRIVER_FEATURE_SUPPORT_PARAMS_V1; +#[doc = " Callback settings common to all client callbacks."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1 { + #[doc = " [in] Generic callback parameter which will be passed to the callback."] + pub pCallbackParam: *mut ::std::os::raw::c_void, + #[doc = " Reserved bytes for future expansion."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Callback settings common to all client callbacks."] +pub type NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1 = _NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1; +#[doc = " Callback settings common to all client callbacks."] +pub type NV_GPU_CLIENT_CALLBACK_SETTINGS_SUPER_V1 = NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1; +#[doc = " Callback settings common to all periodic client callbacks."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_PERIODIC_CALLBACK_SETTINGS_SUPER_V1 { + #[doc = " [in] Super class data."] + pub super_: NV_GPU_CLIENT_CALLBACK_SETTINGS_SUPER_V1, + #[doc = " [in] Minimum interval at which callback will be called.\n\n The callback may be invoked slower than this interval if underlying\n sampling rate does not align precisely to the provided period."] + pub callbackPeriodms: NvU32, + #[doc = " Reserved bytes for future expansion."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Callback settings common to all periodic client callbacks."] +pub type NV_GPU_CLIENT_PERIODIC_CALLBACK_SETTINGS_SUPER_V1 = + _NV_GPU_CLIENT_PERIODIC_CALLBACK_SETTINGS_SUPER_V1; +#[doc = " Callback data common to all client callbacks."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_CALLBACK_DATA_SUPER_V1 { + #[doc = " [out] Generic callback parameter which was passed in at registration time."] + pub pCallbackParam: *mut ::std::os::raw::c_void, + #[doc = " Reserved bytes for future expansion."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Callback data common to all client callbacks."] +pub type NV_GPU_CLIENT_CALLBACK_DATA_SUPER_V1 = _NV_GPU_CLIENT_CALLBACK_DATA_SUPER_V1; +pub const _NV_GPU_CLIENT_UTIL_DOMAIN_ID_NV_GPU_CLIENT_UTIL_DOMAIN_GRAPHICS: + _NV_GPU_CLIENT_UTIL_DOMAIN_ID = 0; +pub const _NV_GPU_CLIENT_UTIL_DOMAIN_ID_NV_GPU_CLIENT_UTIL_DOMAIN_FRAME_BUFFER: + _NV_GPU_CLIENT_UTIL_DOMAIN_ID = 1; +pub const _NV_GPU_CLIENT_UTIL_DOMAIN_ID_NV_GPU_CLIENT_UTIL_DOMAIN_VIDEO: + _NV_GPU_CLIENT_UTIL_DOMAIN_ID = 2; +#[doc = " Reserved for future use."] +pub const _NV_GPU_CLIENT_UTIL_DOMAIN_ID_NV_GPU_CLIENT_UTIL_DOMAIN_RSVD: + _NV_GPU_CLIENT_UTIL_DOMAIN_ID = 3; +#[doc = " Enumeration of different utilization domains"] +pub type _NV_GPU_CLIENT_UTIL_DOMAIN_ID = ::std::os::raw::c_int; +#[doc = " Enumeration of different utilization domains"] +pub use self::_NV_GPU_CLIENT_UTIL_DOMAIN_ID as NV_GPU_CLIENT_UTIL_DOMAIN_ID; +#[doc = " Data specific to a single utilization domain."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_UTILIZATION_DATA_V1 { + #[doc = " [out] Utilization domain identifier."] + pub utilId: NV_GPU_CLIENT_UTIL_DOMAIN_ID, + #[doc = " [out] Percentage of time where the domain is considered busy since the\n last sample. Units of percent*100; i.e. 5000 = 50%."] + pub utilizationPercent: NvU32, + #[doc = " Reserved bytes for future expansion."] + pub rsvd: [NvU8; 61usize], +} +#[doc = " Data specific to a single utilization domain."] +pub type NV_GPU_CLIENT_UTILIZATION_DATA_V1 = _NV_GPU_CLIENT_UTILIZATION_DATA_V1; +#[doc = " Data passed back to callback registered with\n @ref NvAPI_GPU_ClientRegisterForUtilizationSampleUpdates."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_CALLBACK_UTILIZATION_DATA_V1 { + #[doc = " [out] Super struct."] + pub super_: NV_GPU_CLIENT_CALLBACK_DATA_SUPER_V1, + #[doc = " [out] Number of valid entries in `utils` array."] + pub numUtils: NvU32, + #[doc = " [out] Time at which data was collected. Represented as elapsed\n microseconds since 00:00:00 UTC on January 1, 1970."] + pub timestamp: NvU64, + #[doc = " Reserved bytes for future expansion."] + pub rsvd: [NvU8; 64usize], + #[doc = " [out] Status data for each utilization domain."] + pub utils: [NV_GPU_CLIENT_UTILIZATION_DATA_V1; 4usize], +} +#[doc = " Data passed back to callback registered with\n @ref NvAPI_GPU_ClientRegisterForUtilizationSampleUpdates."] +pub type NV_GPU_CLIENT_CALLBACK_UTILIZATION_DATA_V1 = _NV_GPU_CLIENT_CALLBACK_UTILIZATION_DATA_V1; +#[doc = " Function prototype for a periodic utilization data callback that will be registered with NvAPI."] +pub type NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_V1 = ::std::option::Option< + unsafe extern "C" fn( + hPhysicalGpu: NvPhysicalGpuHandle, + pData: *mut NV_GPU_CLIENT_CALLBACK_UTILIZATION_DATA_V1, + ), +>; +#[doc = " Data required to register a periodic callback for utilization data."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_SETTINGS_V1 { + #[doc = " [in] Structure Version, must always be first."] + pub version: NvU32, + #[doc = " [in] Generic callback settings. Some data within will be passed to the\n callback when invoked."] + pub super_: NV_GPU_CLIENT_PERIODIC_CALLBACK_SETTINGS_SUPER_V1, + #[doc = " [in] Callback. Pass in NULL or nullptr to indicate request to unregister."] + pub callback: NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_V1, + #[doc = " Reserved bytes for future expansion."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Data required to register a periodic callback for utilization data."] +pub type NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_SETTINGS_V1 = + _NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_SETTINGS_V1; +#[doc = " Data required to register a periodic callback for utilization data."] +pub type NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_SETTINGS = + NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_SETTINGS_V1; +pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_INVALID: _NV_RISE_CONTENT_TYPE = 0; +pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_TEXT: _NV_RISE_CONTENT_TYPE = 1; +pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_GRAPH: _NV_RISE_CONTENT_TYPE = 2; +pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_CUSTOM_BEHAVIOR: _NV_RISE_CONTENT_TYPE = 3; +pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_CUSTOM_BEHAVIOR_RESULT: _NV_RISE_CONTENT_TYPE = + 4; +pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_INSTALLING: _NV_RISE_CONTENT_TYPE = 5; +pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_PROGRESS_UPDATE: _NV_RISE_CONTENT_TYPE = 6; +pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_READY: _NV_RISE_CONTENT_TYPE = 7; +pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_DOWNLOAD_REQUEST: _NV_RISE_CONTENT_TYPE = 8; +pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_UPDATE_INFO: _NV_RISE_CONTENT_TYPE = 9; +#[doc = " Enumeration of different RISE content types."] +pub type _NV_RISE_CONTENT_TYPE = ::std::os::raw::c_int; +#[doc = " Enumeration of different RISE content types."] +pub use self::_NV_RISE_CONTENT_TYPE as NV_RISE_CONTENT_TYPE; +#[doc = " Data passed back to callback."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_RISE_CALLBACK_DATA_V1 { + #[doc = " Super struct."] + pub super_: NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1, + #[doc = " RISE type of content"] + pub contentType: NV_RISE_CONTENT_TYPE, + #[doc = " RISE content."] + pub content: NvAPI_String, + #[doc = " Is this the last in the batch?"] + pub completed: NvBool, +} +#[doc = " Data passed back to callback."] +pub type NV_RISE_CALLBACK_DATA_V1 = _NV_RISE_CALLBACK_DATA_V1; +#[doc = " Callback for RISE update callbacks."] +pub type NV_RISE_CALLBACK_V1 = + ::std::option::Option; +#[doc = " Data required to register an update callback from the RISE."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_RISE_CALLBACK_SETTINGS_V1 { + #[doc = " [in] Structure Version, must always be first."] + pub version: NvU32, + #[doc = " [in] Generic callback parameter which will be passed to the callback."] + pub super_: NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1, + #[doc = " [in] Callback. Pass in NULL or nullptr to indicate request to unregister."] + pub callback: NV_RISE_CALLBACK_V1, + #[doc = " Reserved, must be set to zero by client."] + pub reserved: [NvU8; 32usize], +} +#[doc = " Data required to register an update callback from the RISE."] +pub type NV_RISE_CALLBACK_SETTINGS_V1 = _NV_RISE_CALLBACK_SETTINGS_V1; +#[doc = " Data required to register an update callback from the RISE."] +pub type NV_RISE_CALLBACK_SETTINGS = NV_RISE_CALLBACK_SETTINGS_V1; +#[doc = " Request contents sent to RISE."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_REQUEST_RISE_SETTINGS_V1 { + #[doc = " [in] Structure Version, must always be first."] + pub version: NvU32, + #[doc = " RISE type of content"] + pub contentType: NV_RISE_CONTENT_TYPE, + #[doc = " RISE request content."] + pub content: NvAPI_String, + #[doc = " Is the request fully sent?"] + pub completed: NvBool, + #[doc = " Reserved, must be set to zero by client."] + pub reserved: [NvU8; 32usize], +} +#[doc = " Request contents sent to RISE."] +pub type NV_REQUEST_RISE_SETTINGS_V1 = _NV_REQUEST_RISE_SETTINGS_V1; +#[doc = " Request contents sent to RISE."] +pub type NV_REQUEST_RISE_SETTINGS = NV_REQUEST_RISE_SETTINGS_V1; +#[doc = " Request contents sent to RISE."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_UNINSTALL_RISE_SETTINGS_V1 { + #[doc = " [in] Structure Version, must always be first."] + pub version: NvU32, + #[doc = " Reserved, must be set to zero by client."] + pub reserved: [NvU8; 32usize], +} +#[doc = " Request contents sent to RISE."] +pub type NV_UNINSTALL_RISE_SETTINGS_V1 = _NV_UNINSTALL_RISE_SETTINGS_V1; +#[doc = " Request contents sent to RISE."] +pub type NV_UNINSTALL_RISE_SETTINGS = NV_UNINSTALL_RISE_SETTINGS_V1; diff --git a/nvapi_trace/Cargo.toml b/nvapi_trace/Cargo.toml new file mode 100644 index 000000000..ed86c5453 --- /dev/null +++ b/nvapi_trace/Cargo.toml @@ -0,0 +1,29 @@ +[package] +name = "nvapi_trace" +version = "0.0.0" +authors = ["Andrzej Janik "] +edition = "2021" + +[lib] +name = "nvapi_trace" +crate-type = ["cdylib"] + +[dependencies] +format = { path = "../format" } +dark_api = { path = "../dark_api" } +cuda_macros = { path = "../cuda_macros" } +cuda_types = { path = "../cuda_types" } +zluda_trace_common = { path = "../zluda_trace_common" } +libloading = "0.8" +paste = "1.0" +unwrap_or = "1.0.1" +cglue = "0.3.5" +dynasm = "5.0" +dynasmrt = "5.0" +rustc-hash = "2.0.0" + +[package.metadata.zluda] +windows_only = true +windows_paths = ["trace/nvapi64.dll"] +windows32_paths = ["trace/nvapi.dll"] +32bit = true diff --git a/nvapi_trace/src/lib.rs b/nvapi_trace/src/lib.rs new file mode 100644 index 000000000..9fcc8dd06 --- /dev/null +++ b/nvapi_trace/src/lib.rs @@ -0,0 +1,704 @@ +use libloading::Library; +use rustc_hash::FxHashMap; +use std::{ + collections::hash_map, + ffi::c_void, + mem, ptr, + sync::{LazyLock, Mutex}, +}; +use zluda_trace_common::ReprUsize; + +static GLOBAL_STATE: LazyLock)>> = + LazyLock::new(get_global_state); + +fn get_global_state() -> Option<(Library, Mutex)> { + let cuda_lib = std::env::var("ZLUDA_NVAPI_LIB").ok().unwrap_or_else(|| { + if cfg!(target_pointer_width = "64") { + r"C:\Windows\System32\nvapi64.dll".to_string() + } else { + r"C:\Windows\System32\nvapi.dll".to_string() + } + }); + let lib = zluda_trace_common::dlopen_local_noredirect(cuda_lib).ok()?; + Some((Library::from(lib), Mutex::new(GlobalState::new()))) +} + +struct GlobalState { + thunks: FxHashMap, +} + +impl GlobalState { + fn new() -> Self { + GlobalState { + thunks: FxHashMap::default(), + } + } + + fn get_thunk( + &mut self, + original: *mut c_void, + report_fn: unsafe extern "C" fn(i32, u32), + interface: u32, + ) -> *mut c_void { + match self.thunks.entry(interface) { + hash_map::Entry::Occupied(entry) => *entry.get() as *mut c_void, + hash_map::Entry::Vacant(entry) => { + let thunk = get_thunk(original, report_fn, interface); + entry.insert(thunk as usize); + thunk + } + } + } +} + +macro_rules! interface_to_name { + ($({ $name:literal, $id:literal }),* $(,)?) => { + fn interface_to_name(interface: u32) -> Option<&'static str> { + match interface { + $( + $id => Some($name), + )* + _ => None, + } + } + }; +} + +interface_to_name!( + { "NvAPI_Initialize", 0x0150e828 }, + { "NvAPI_Unload", 0xd22bdd7e }, + { "NvAPI_GetErrorMessage", 0x6c2d048c }, + { "NvAPI_GetInterfaceVersionString", 0x01053fa5 }, + { "NvAPI_GPU_GetEDID", 0x37d32e69 }, + { "NvAPI_SetView", 0x0957d7b6 }, + { "NvAPI_SetViewEx", 0x06b89e68 }, + { "NvAPI_GetDisplayDriverVersion", 0xf951a4d1 }, + { "NvAPI_SYS_GetDriverAndBranchVersion", 0x2926aaad }, + { "NvAPI_GPU_GetMemoryInfo", 0x07f9b368 }, + { "NvAPI_GPU_GetMemoryInfoEx", 0xc0599498 }, + { "NvAPI_OGL_ExpertModeSet", 0x3805ef7a }, + { "NvAPI_OGL_ExpertModeGet", 0x22ed9516 }, + { "NvAPI_OGL_ExpertModeDefaultsSet", 0xb47a657e }, + { "NvAPI_OGL_ExpertModeDefaultsGet", 0xae921f12 }, + { "NvAPI_EnumPhysicalGPUs", 0xe5ac921f }, + { "NvAPI_EnumTCCPhysicalGPUs", 0xd9930b07 }, + { "NvAPI_EnumLogicalGPUs", 0x48b3ea59 }, + { "NvAPI_GetPhysicalGPUsFromDisplay", 0x34ef9506 }, + { "NvAPI_GetPhysicalGPUFromUnAttachedDisplay", 0x5018ed61 }, + { "NvAPI_GetLogicalGPUFromDisplay", 0xee1370cf }, + { "NvAPI_GetLogicalGPUFromPhysicalGPU", 0xadd604d1 }, + { "NvAPI_GetPhysicalGPUsFromLogicalGPU", 0xaea3fa32 }, + { "NvAPI_GetPhysicalGPUFromGPUID", 0x5380ad1a }, + { "NvAPI_GetGPUIDfromPhysicalGPU", 0x6533ea3e }, + { "NvAPI_GPU_GetShaderSubPipeCount", 0x0be17923 }, + { "NvAPI_GPU_GetGpuCoreCount", 0xc7026a87 }, + { "NvAPI_GPU_GetAllOutputs", 0x7d554f8e }, + { "NvAPI_GPU_GetConnectedOutputs", 0x1730bfc9 }, + { "NvAPI_GPU_GetConnectedSLIOutputs", 0x0680de09 }, + { "NvAPI_GPU_GetConnectedDisplayIds", 0x0078dba2 }, + { "NvAPI_GPU_GetAllDisplayIds", 0x785210a2 }, + { "NvAPI_GPU_GetConnectedOutputsWithLidState", 0xcf8caf39 }, + { "NvAPI_GPU_GetConnectedSLIOutputsWithLidState", 0x96043cc7 }, + { "NvAPI_GPU_GetSystemType", 0xbaaabfcc }, + { "NvAPI_GPU_GetActiveOutputs", 0xe3e89b6f }, + { "NvAPI_GPU_SetEDID", 0xe83d6456 }, + { "NvAPI_GPU_GetOutputType", 0x40a505e4 }, + { "NvAPI_GPU_ValidateOutputCombination", 0x34c9c2d4 }, + { "NvAPI_GPU_GetFullName", 0xceee8e9f }, + { "NvAPI_GPU_GetPCIIdentifiers", 0x2ddfb66e }, + { "NvAPI_GPU_GetGPUType", 0xc33baeb1 }, + { "NvAPI_GPU_GetBusType", 0x1bb18724 }, + { "NvAPI_GPU_GetBusId", 0x1be0b8e5 }, + { "NvAPI_GPU_GetBusSlotId", 0x2a0a350f }, + { "NvAPI_GPU_GetIRQ", 0xe4715417 }, + { "NvAPI_GPU_GetVbiosRevision", 0xacc3da0a }, + { "NvAPI_GPU_GetVbiosOEMRevision", 0x2d43fb31 }, + { "NvAPI_GPU_GetVbiosVersionString", 0xa561fd7d }, + { "NvAPI_GPU_GetAGPAperture", 0x6e042794 }, + { "NvAPI_GPU_GetCurrentAGPRate", 0xc74925a0 }, + { "NvAPI_GPU_GetCurrentPCIEDownstreamWidth", 0xd048c3b1 }, + { "NvAPI_GPU_GetPhysicalFrameBufferSize", 0x46fbeb03 }, + { "NvAPI_GPU_GetVirtualFrameBufferSize", 0x5a04b644 }, + { "NvAPI_GPU_GetQuadroStatus", 0xe332fa47 }, + { "NvAPI_GPU_GetBoardInfo", 0x22d54523 }, + { "NvAPI_GPU_GetRamBusWidth", 0x7975c581 }, + { "NvAPI_GPU_GetArchInfo", 0xd8265d24 }, + { "NvAPI_I2CRead", 0x2fde12c5 }, + { "NvAPI_I2CWrite", 0xe812eb07 }, + { "NvAPI_GPU_WorkstationFeatureSetup", 0x6c1f3fe4 }, + { "NvAPI_GPU_WorkstationFeatureQuery", 0x004537df }, + { "NvAPI_GPU_GetHDCPSupportStatus", 0xf089eef5 }, + { "NvAPI_GPU_CudaEnumComputeCapableGpus", 0x5786cc6e }, + { "NvAPI_GPU_GetTachReading", 0x5f608315 }, + { "NvAPI_GPU_GetECCStatusInfo", 0xca1ddaf3 }, + { "NvAPI_GPU_GetECCErrorInfo", 0xc71f85a6 }, + { "NvAPI_GPU_ResetECCErrorInfo", 0xc02eec20 }, + { "NvAPI_GPU_GetECCConfigurationInfo", 0x77a796f3 }, + { "NvAPI_GPU_SetECCConfiguration", 0x1cf639d9 }, + { "NvAPI_GPU_QueryWorkstationFeatureSupport", 0x80b1abb9 }, + { "NvAPI_GPU_SetScanoutIntensity", 0xa57457a4 }, + { "NvAPI_GPU_GetScanoutIntensityState", 0xe81ce836 }, + { "NvAPI_GPU_SetScanoutWarping", 0xb34bab4f }, + { "NvAPI_GPU_GetScanoutWarpingState", 0x6f5435af }, + { "NvAPI_GPU_SetScanoutCompositionParameter", 0xf898247d }, + { "NvAPI_GPU_GetScanoutCompositionParameter", 0x58fe51e6 }, + { "NvAPI_GPU_GetScanoutConfiguration", 0x6a9f5b63 }, + { "NvAPI_GPU_GetScanoutConfigurationEx", 0xe2e1e6f0 }, + { "NvAPI_GPU_GetAdapterIdFromPhysicalGpu", 0x0ff07fde }, + { "NvAPI_GPU_GetVirtualizationInfo", 0x44e022a9 }, + { "NvAPI_GPU_GetLogicalGpuInfo", 0x842b066e }, + { "NvAPI_GPU_GetLicensableFeatures", 0x3fc596aa }, + { "NvAPI_GPU_GetEncoderStatistics", 0xf0a9aeeb }, + { "NvAPI_GPU_GetEncoderSessionsInfo", 0xd8a72ce5 }, + { "NvAPI_GPU_GetGPUInfo", 0xafd1b02c }, + { "NvAPI_GPU_GetVRReadyData", 0x81d629c5 }, + { "NvAPI_GPU_GetGspFeatures", 0x581c4391 }, + { "NvAPI_GPU_GetUUID", 0xdc95673d }, + { "NvAPI_GPU_NVLINK_GetCaps", 0xbef1119d }, + { "NvAPI_GPU_NVLINK_GetStatus", 0xc72a38e3 }, + { "NvAPI_GPU_GetPerfDecreaseInfo", 0x7f7f4600 }, + { "NvAPI_GPU_GetPstatesInfoEx", 0x843c0256 }, + { "NvAPI_GPU_GetPstates20", 0x6ff81213 }, + { "NvAPI_GPU_GetCurrentPstate", 0x927da4f6 }, + { "NvAPI_GPU_GetDynamicPstatesInfoEx", 0x60ded2ed }, + { "NvAPI_GPU_GetThermalSettings", 0xe3640a56 }, + { "NvAPI_GPU_GetAllClockFrequencies", 0xdcb616c3 }, + { "NvAPI_GPU_QueryIlluminationSupport", 0xa629da31 }, + { "NvAPI_GPU_GetIllumination", 0x9a1b9365 }, + { "NvAPI_GPU_SetIllumination", 0x0254a187 }, + { "NvAPI_GPU_ClientIllumDevicesGetInfo", 0xd4100e58 }, + { "NvAPI_GPU_ClientIllumDevicesGetControl", 0x73c01d58 }, + { "NvAPI_GPU_ClientIllumDevicesSetControl", 0x57024c62 }, + { "NvAPI_GPU_ClientIllumZonesGetInfo", 0x4b81241b }, + { "NvAPI_GPU_ClientIllumZonesGetControl", 0x3dbf5764 }, + { "NvAPI_GPU_ClientIllumZonesSetControl", 0x197d065e }, + { "NvAPI_Event_RegisterCallback", 0xe6dbea69 }, + { "NvAPI_Event_UnregisterCallback", 0xde1f9b45 }, + { "NvAPI_EnumNvidiaDisplayHandle", 0x9abdd40d }, + { "NvAPI_EnumNvidiaUnAttachedDisplayHandle", 0x20de9260 }, + { "NvAPI_CreateDisplayFromUnAttachedDisplay", 0x63f9799e }, + { "NvAPI_GetAssociatedNvidiaDisplayHandle", 0x35c29134 }, + { "NvAPI_DISP_GetAssociatedUnAttachedNvidiaDisplayHandle", 0xa70503b2 }, + { "NvAPI_GetAssociatedNvidiaDisplayName", 0x22a78b05 }, + { "NvAPI_GetUnAttachedAssociatedDisplayName", 0x4888d790 }, + { "NvAPI_EnableHWCursor", 0x2863148d }, + { "NvAPI_DisableHWCursor", 0xab163097 }, + { "NvAPI_GetVBlankCounter", 0x67b5db55 }, + { "NvAPI_SetRefreshRateOverride", 0x3092ac32 }, + { "NvAPI_GetAssociatedDisplayOutputId", 0xd995937e }, + { "NvAPI_GetDisplayPortInfo", 0xc64ff367 }, + { "NvAPI_SetDisplayPort", 0xfa13e65a }, + { "NvAPI_GetHDMISupportInfo", 0x6ae16ec3 }, + { "NvAPI_Disp_InfoFrameControl", 0x6067af3f }, + { "NvAPI_Disp_ColorControl", 0x92f9d80d }, + { "NvAPI_Disp_GetHdrCapabilities", 0x84f2a8df }, + { "NvAPI_Disp_HdrColorControl", 0x351da224 }, + { "NvAPI_Disp_SetSourceColorSpace", 0x473b6caf }, + { "NvAPI_Disp_GetSourceColorSpace", 0xceedc85b }, + { "NvAPI_Disp_SetSourceHdrMetadata", 0x905eb63b }, + { "NvAPI_Disp_GetSourceHdrMetadata", 0x0d3f52da }, + { "NvAPI_Disp_SetOutputMode", 0x98e7661a }, + { "NvAPI_Disp_GetOutputMode", 0x81fed88d }, + { "NvAPI_Disp_SetHdrToneMapping", 0xdd6da362 }, + { "NvAPI_Disp_GetHdrToneMapping", 0xfbd36e71 }, + { "NvAPI_Disp_GetColorimetry", 0x00b421ad }, + { "NvAPI_DISP_GetTiming", 0x175167e9 }, + { "NvAPI_DISP_GetMonitorCapabilities", 0x3b05c7e1 }, + { "NvAPI_DISP_GetMonitorColorCapabilities", 0x6ae4cfb5 }, + { "NvAPI_DISP_EnumCustomDisplay", 0xa2072d59 }, + { "NvAPI_DISP_TryCustomDisplay", 0x1f7db630 }, + { "NvAPI_DISP_DeleteCustomDisplay", 0x552e5b9b }, + { "NvAPI_DISP_SaveCustomDisplay", 0x49882876 }, + { "NvAPI_DISP_RevertCustomDisplayTrial", 0xcbbd40f0 }, + { "NvAPI_GetView", 0xd6b99d89 }, + { "NvAPI_GetViewEx", 0xdbbc0af4 }, + { "NvAPI_GetSupportedViews", 0x66fb7fc0 }, + { "NvAPI_DISP_GetDisplayIdByDisplayName", 0xae457190 }, + { "NvAPI_DISP_GetGDIPrimaryDisplayId", 0x1e9d8a31 }, + { "NvAPI_DISP_GetDisplayConfig", 0x11abccf8 }, + { "NvAPI_DISP_SetDisplayConfig", 0x5d8cf8de }, + { "NvAPI_DISP_GetEdidData", 0x436ced76 }, + { "NvAPI_DISP_GetAdaptiveSyncData", 0xb73d1ee9 }, + { "NvAPI_DISP_SetAdaptiveSyncData", 0x3eebba1d }, + { "NvAPI_DISP_GetVirtualRefreshRateData", 0x8c00429a }, + { "NvAPI_DISP_SetVirtualRefreshRateData", 0x5abbe6a3 }, + { "NvAPI_DISP_SetPreferredStereoDisplay", 0xc9d0e25f }, + { "NvAPI_DISP_GetPreferredStereoDisplay", 0x1f6b4666 }, + { "NvAPI_DISP_GetNvManagedDedicatedDisplays", 0xdbdf0cb2 }, + { "NvAPI_DISP_AcquireDedicatedDisplay", 0x47c917ba }, + { "NvAPI_DISP_ReleaseDedicatedDisplay", 0x1247825f }, + { "NvAPI_DISP_GetNvManagedDedicatedDisplayMetadata", 0xd645d80c }, + { "NvAPI_DISP_SetNvManagedDedicatedDisplayMetadata", 0x3d8b129a }, + { "NvAPI_Disp_GetDisplayIdInfo", 0xbae8aa5e }, + { "NvAPI_Disp_GetDisplayIdsFromTarget", 0xe7e5f89e }, + { "NvAPI_Disp_GetVRRInfo", 0xdf8fda57 }, + { "NvAPI_Mosaic_GetSupportedTopoInfo", 0xfdb63c81 }, + { "NvAPI_Mosaic_GetTopoGroup", 0xcb89381d }, + { "NvAPI_Mosaic_GetOverlapLimits", 0x989685f0 }, + { "NvAPI_Mosaic_SetCurrentTopo", 0x9b542831 }, + { "NvAPI_Mosaic_GetCurrentTopo", 0xec32944e }, + { "NvAPI_Mosaic_EnableCurrentTopo", 0x5f1aa66c }, + { "NvAPI_Mosaic_GetDisplayViewportsByResolution", 0xdc6dc8d3 }, + { "NvAPI_Mosaic_SetDisplayGrids", 0x4d959a89 }, + { "NvAPI_Mosaic_ValidateDisplayGrids", 0xcf43903d }, + { "NvAPI_Mosaic_EnumDisplayModes", 0x78db97d7 }, + { "NvAPI_Mosaic_EnumDisplayGrids", 0xdf2887af }, + { "NvAPI_GetSupportedMosaicTopologies", 0x410b5c25 }, + { "NvAPI_GetCurrentMosaicTopology", 0xf60852bd }, + { "NvAPI_SetCurrentMosaicTopology", 0xd54b8989 }, + { "NvAPI_EnableCurrentMosaicTopology", 0x74073cc9 }, + { "NvAPI_GSync_EnumSyncDevices", 0xd9639601 }, + { "NvAPI_GSync_QueryCapabilities", 0x44a3f1d1 }, + { "NvAPI_GSync_GetTopology", 0x4562bc38 }, + { "NvAPI_GSync_SetSyncStateSettings", 0x60acdfdd }, + { "NvAPI_GSync_GetControlParameters", 0x16de1c6a }, + { "NvAPI_GSync_SetControlParameters", 0x8bbff88b }, + { "NvAPI_GSync_AdjustSyncDelay", 0x2d11ff51 }, + { "NvAPI_GSync_GetSyncStatus", 0xf1f5b434 }, + { "NvAPI_GSync_GetStatusParameters", 0x70d404ec }, + { "NvAPI_D3D_GetCurrentSLIState", 0x4b708b54 }, + { "NvAPI_D3D9_RegisterResource", 0xa064bdfc }, + { "NvAPI_D3D9_UnregisterResource", 0xbb2b17aa }, + { "NvAPI_D3D9_AliasSurfaceAsTexture", 0xe5ceae41 }, + { "NvAPI_D3D9_StretchRectEx", 0x22de03aa }, + { "NvAPI_D3D9_ClearRT", 0x332d3942 }, + { "NvAPI_D3D_GetObjectHandleForResource", 0xfceac864 }, + { "NvAPI_D3D_SetResourceHint", 0x6c0ed98c }, + { "NvAPI_D3D_BeginResourceRendering", 0x91123d6a }, + { "NvAPI_D3D_EndResourceRendering", 0x37e7191c }, + { "NvAPI_D3D9_GetSurfaceHandle", 0x0f2dd3f2 }, + { "NvAPI_D3D9_VideoSetStereoInfo", 0xb852f4db }, + { "NvAPI_D3D10_SetDepthBoundsTest", 0x4eadf5d2 }, + { "NvAPI_D3D11_CreateDevice", 0x6a16d3a0 }, + { "NvAPI_D3D11_CreateDeviceAndSwapChain", 0xbb939ee5 }, + { "NvAPI_D3D11_SetDepthBoundsTest", 0x7aaf7a04 }, + { "NvAPI_D3D11_IsNvShaderExtnOpCodeSupported", 0x5f68da40 }, + { "NvAPI_D3D11_SetNvShaderExtnSlot", 0x8e90bb9f }, + { "NvAPI_D3D12_SetNvShaderExtnSlotSpace", 0xac2dfeb5 }, + { "NvAPI_D3D12_SetNvShaderExtnSlotSpaceLocalThread", 0x43d867c0 }, + { "NvAPI_D3D11_SetNvShaderExtnSlotLocalThread", 0x0e6482a0 }, + { "NvAPI_D3D11_BeginUAVOverlapEx", 0xba08208a }, + { "NvAPI_D3D11_BeginUAVOverlap", 0x65b93ca8 }, + { "NvAPI_D3D11_EndUAVOverlap", 0x2216a357 }, + { "NvAPI_D3D11_GetResourceHandle", 0x09d52986 }, + { "NvAPI_D3D_SetFPSIndicatorState", 0xa776e8db }, + { "NvAPI_D3D9_Present", 0x05650beb }, + { "NvAPI_D3D9_QueryFrameCount", 0x9083e53a }, + { "NvAPI_D3D9_ResetFrameCount", 0xfa6a0675 }, + { "NvAPI_D3D9_QueryMaxSwapGroup", 0x5995410d }, + { "NvAPI_D3D9_QuerySwapGroup", 0xeba4d232 }, + { "NvAPI_D3D9_JoinSwapGroup", 0x7d44bb54 }, + { "NvAPI_D3D9_BindSwapBarrier", 0x9c39c246 }, + { "NvAPI_D3D_SetVerticalSyncMode", 0x5526cfd1 }, + { "NvAPI_D3D1x_Present", 0x03b845a1 }, + { "NvAPI_D3D1x_QueryFrameCount", 0x9152e055 }, + { "NvAPI_D3D1x_ResetFrameCount", 0xfbbb031a }, + { "NvAPI_D3D1x_QueryMaxSwapGroup", 0x9bb9d68f }, + { "NvAPI_D3D1x_QuerySwapGroup", 0x407f67aa }, + { "NvAPI_D3D1x_JoinSwapGroup", 0x14610cd7 }, + { "NvAPI_D3D1x_BindSwapBarrier", 0x9de8c729 }, + { "NvAPI_D3D12_QueryPresentBarrierSupport", 0xa15faef7 }, + { "NvAPI_D3D12_CreatePresentBarrierClient", 0x4d815de9 }, + { "NvAPI_D3D12_RegisterPresentBarrierResources", 0xd53c9ef0 }, + { "NvAPI_DestroyPresentBarrierClient", 0x3c5c351b }, + { "NvAPI_JoinPresentBarrier", 0x17f6bf82 }, + { "NvAPI_LeavePresentBarrier", 0xc3ec5a7f }, + { "NvAPI_QueryPresentBarrierFrameStatistics", 0x61b844a1 }, + { "NvAPI_D3D12_CreateDDisplayPresentBarrierClient", 0xb5a21987 }, + { "NvAPI_D3D11_CreateRasterizerState", 0xdb8d28af }, + { "NvAPI_D3D_ConfigureAnsel", 0x341c6c7f }, + { "NvAPI_D3D11_CreateTiledTexture2DArray", 0x7886981a }, + { "NvAPI_D3D11_CheckFeatureSupport", 0x106a487e }, + { "NvAPI_D3D11_CreateImplicitMSAATexture2D", 0xb8f79632 }, + { "NvAPI_D3D12_CreateCommittedImplicitMSAATexture2D", 0x24c6a07b }, + { "NvAPI_D3D11_ResolveSubresourceRegion", 0xe6bfedd6 }, + { "NvAPI_D3D12_ResolveSubresourceRegion", 0xc24a15bf }, + { "NvAPI_D3D11_TiledTexture2DArrayGetDesc", 0xf1a2b9d5 }, + { "NvAPI_D3D11_UpdateTileMappings", 0x9a06ea07 }, + { "NvAPI_D3D11_CopyTileMappings", 0xc09ee6bc }, + { "NvAPI_D3D11_TiledResourceBarrier", 0xd6839099 }, + { "NvAPI_D3D11_AliasMSAATexture2DAsNonMSAA", 0xf1c54fc9 }, + { "NvAPI_D3D11_CreateGeometryShaderEx_2", 0x99ed5c1c }, + { "NvAPI_D3D11_CreateVertexShaderEx", 0x0beaa0b2 }, + { "NvAPI_D3D11_CreateHullShaderEx", 0xb53cab00 }, + { "NvAPI_D3D11_CreateDomainShaderEx", 0xa0d7180d }, + { "NvAPI_D3D11_CreatePixelShaderEx_2", 0x4162822b }, + { "NvAPI_D3D11_CreateFastGeometryShaderExplicit", 0x71ab7c9c }, + { "NvAPI_D3D11_CreateFastGeometryShader", 0x525d43be }, + { "NvAPI_D3D11_DecompressView", 0x3a94e822 }, + { "NvAPI_D3D12_CreateGraphicsPipelineState", 0x2fc28856 }, + { "NvAPI_D3D12_CreateComputePipelineState", 0x2762deac }, + { "NvAPI_D3D12_SetDepthBoundsTestValues", 0xb9333fe9 }, + { "NvAPI_D3D12_CreateReservedResource", 0x2c85f101 }, + { "NvAPI_D3D12_CreateHeap", 0x5cb397cf }, + { "NvAPI_D3D12_CreateHeap2", 0x924be9d6 }, + { "NvAPI_D3D12_QueryCpuVisibleVidmem", 0x26322bc3 }, + { "NvAPI_D3D12_ReservedResourceGetDesc", 0x9aa2aabb }, + { "NvAPI_D3D12_UpdateTileMappings", 0xc6017a7d }, + { "NvAPI_D3D12_CopyTileMappings", 0x47f78194 }, + { "NvAPI_D3D12_ResourceAliasingBarrier", 0xb942bab7 }, + { "NvAPI_D3D12_CaptureUAVInfo", 0x6e5ea9db }, + { "NvAPI_D3D11_GetResourceGPUVirtualAddressEx", 0xaf6d14da }, + { "NvAPI_D3D11_EnumerateMetaCommands", 0xc7453ba8 }, + { "NvAPI_D3D11_CreateMetaCommand", 0xf505fba0 }, + { "NvAPI_D3D11_InitializeMetaCommand", 0xaec629e9 }, + { "NvAPI_D3D11_ExecuteMetaCommand", 0x82236c47 }, + { "NvAPI_D3D12_EnumerateMetaCommands", 0xcd9141d8 }, + { "NvAPI_D3D12_CreateMetaCommand", 0xeb29634b }, + { "NvAPI_D3D12_InitializeMetaCommand", 0xa4125399 }, + { "NvAPI_D3D12_ExecuteMetaCommand", 0xde24fc3d }, + { "NvAPI_D3D12_CreateCommittedResource", 0x027e98ae }, + { "NvAPI_D3D12_GetCopyableFootprints", 0xf6305eb5 }, + { "NvAPI_D3D12_CopyTextureRegion", 0x82b91b25 }, + { "NvAPI_D3D12_IsNvShaderExtnOpCodeSupported", 0x3dfacec8 }, + { "NvAPI_D3D12_GetOptimalThreadCountForMesh", 0xb43995cb }, + { "NvAPI_D3D_IsGSyncCapable", 0x9c1eed78 }, + { "NvAPI_D3D_IsGSyncActive", 0xe942b0ff }, + { "NvAPI_D3D12_SetFlipConfig", 0xf3148c42 }, + { "NvAPI_D3D1x_DisableShaderDiskCache", 0xd0cbca7d }, + { "NvAPI_D3D11_MultiGPU_GetCaps", 0xd2d25687 }, + { "NvAPI_D3D11_MultiGPU_Init", 0x017be49e }, + { "NvAPI_D3D11_CreateMultiGPUDevice", 0xbdb20007 }, + { "NvAPI_D3D_QuerySinglePassStereoSupport", 0x6f5f0a6d }, + { "NvAPI_D3D_SetSinglePassStereoMode", 0xa39e6e6e }, + { "NvAPI_D3D12_QuerySinglePassStereoSupport", 0x3b03791b }, + { "NvAPI_D3D12_SetSinglePassStereoMode", 0x83556d87 }, + { "NvAPI_D3D_QueryMultiViewSupport", 0xb6e0a41c }, + { "NvAPI_D3D_SetMultiViewMode", 0x8285c8da }, + { "NvAPI_D3D_QueryModifiedWSupport", 0xcbf9f4f5 }, + { "NvAPI_D3D_SetModifiedWMode", 0x06ea4bf4 }, + { "NvAPI_D3D12_QueryModifiedWSupport", 0x51235248 }, + { "NvAPI_D3D12_SetModifiedWMode", 0xe1fdaba7 }, + { "NvAPI_D3D_CreateLateLatchObject", 0x2db27d09 }, + { "NvAPI_D3D_QueryLateLatchSupport", 0x8ceca0ec }, + { "NvAPI_D3D_RegisterDevice", 0x8c02c4d0 }, + { "NvAPI_D3D11_MultiDrawInstancedIndirect", 0xd4e26bbf }, + { "NvAPI_D3D11_MultiDrawIndexedInstancedIndirect", 0x59e890f9 }, + { "NvAPI_D3D_ImplicitSLIControl", 0x2aede111 }, + { "NvAPI_D3D12_GetNeedsAppFPBlendClamping", 0x6ef4d2d1 }, + { "NvAPI_D3D12_UseDriverHeapPriorities", 0xf0d978a8 }, + { "NvAPI_D3D12_Mosaic_GetCompanionAllocations", 0xa46022c7 }, + { "NvAPI_D3D12_Mosaic_GetViewportAndGpuPartitions", 0xb092b818 }, + { "NvAPI_D3D1x_GetGraphicsCapabilities", 0x52b1499a }, + { "NvAPI_D3D12_GetGraphicsCapabilities", 0x01e87354 }, + { "NvAPI_D3D11_RSSetExclusiveScissorRects", 0xae4d73ef }, + { "NvAPI_D3D11_RSSetViewportsPixelShadingRates", 0x34f7938f }, + { "NvAPI_D3D11_CreateShadingRateResourceView", 0x99ca2dff }, + { "NvAPI_D3D11_RSSetShadingRateResourceView", 0x1b0c2f83 }, + { "NvAPI_D3D11_RSGetPixelShadingRateSampleOrder", 0x092442a1 }, + { "NvAPI_D3D11_RSSetPixelShadingRateSampleOrder", 0xa942373a }, + { "NvAPI_D3D_InitializeVRSHelper", 0x4780d70b }, + { "NvAPI_D3D_InitializeNvGazeHandler", 0x5b3b7479 }, + { "NvAPI_D3D_InitializeSMPAssist", 0x42763d0c }, + { "NvAPI_D3D_QuerySMPAssistSupport", 0xc57921de }, + { "NvAPI_D3D_GetSleepStatus", 0xaef96ca1 }, + { "NvAPI_D3D_SetSleepMode", 0xac1ca9e0 }, + { "NvAPI_D3D_Sleep", 0x852cd1d2 }, + { "NvAPI_D3D_SetReflexSync", 0xb9f6faff }, + { "NvAPI_D3D_GetLatency", 0x1a587f9c }, + { "NvAPI_D3D_SetLatencyMarker", 0xd9984c05 }, + { "NvAPI_D3D12_SetAsyncFrameMarker", 0x13c98f73 }, + { "NvAPI_D3D11_SetAsyncFrameMarker", 0x59c2c510 }, + { "NvAPI_D3D12_NotifyOutOfBandCommandQueue", 0x03d6e8cb }, + { "NvAPI_D3D12_SetCreateCommandQueueLowLatencyHint", 0x548c224f }, + { "NvAPI_D3D12_CreateCubinComputeShaderExV2", 0x299f5fdc }, + { "NvAPI_D3D12_CreateCubinComputeShader", 0x2a2c79e8 }, + { "NvAPI_D3D12_CreateCubinComputeShaderEx", 0x3151211b }, + { "NvAPI_D3D12_CreateCubinComputeShaderWithName", 0x1dc7261f }, + { "NvAPI_D3D12_LaunchCubinShader", 0x5c52bb86 }, + { "NvAPI_D3D12_DestroyCubinComputeShader", 0x7fb785ba }, + { "NvAPI_D3D12_GetCudaMergedTextureSamplerObject", 0x329fe6e0 }, + { "NvAPI_D3D12_GetCudaIndependentDescriptorObject", 0x0ddac234 }, + { "NvAPI_D3D12_GetCudaTextureObject", 0x80403fc9 }, + { "NvAPI_D3D12_GetCudaSurfaceObject", 0x48f5b2ee }, + { "NvAPI_D3D12_IsFatbinPTXSupported", 0x70c07832 }, + { "NvAPI_D3D12_CreateCuModule", 0xad1a677d }, + { "NvAPI_D3D12_EnumFunctionsInModule", 0x7ab88d88 }, + { "NvAPI_D3D12_CreateCuFunction", 0xe2436e22 }, + { "NvAPI_D3D12_LaunchCuKernelChain", 0x24973538 }, + { "NvAPI_D3D12_LaunchCuKernelChainEx", 0x846a9bf0 }, + { "NvAPI_D3D12_DestroyCuModule", 0x41c65285 }, + { "NvAPI_D3D12_DestroyCuFunction", 0xdf295ea6 }, + { "NvAPI_D3D11_CreateCubinComputeShaderExV2", 0xf2c71d48 }, + { "NvAPI_D3D11_CreateCubinComputeShader", 0x0ed98181 }, + { "NvAPI_D3D11_CreateCubinComputeShaderEx", 0x32c2a0f6 }, + { "NvAPI_D3D11_CreateCubinComputeShaderWithName", 0xb672be19 }, + { "NvAPI_D3D11_LaunchCubinShader", 0x427e236d }, + { "NvAPI_D3D11_DestroyCubinComputeShader", 0x01682c86 }, + { "NvAPI_D3D11_IsFatbinPTXSupported", 0x6086bd93 }, + { "NvAPI_D3D11_GetCudaIndependentViewObject", 0x34d2afa8 }, + { "NvAPI_D3D11_GetCudaMergedTextureSamplerObject", 0x5d637d8f }, + { "NvAPI_D3D11_CreateUnorderedAccessView", 0x74a497a1 }, + { "NvAPI_D3D11_CreateShaderResourceView", 0x65cb431e }, + { "NvAPI_D3D11_CreateSamplerState", 0x89eca416 }, + { "NvAPI_D3D11_GetCudaTextureObject", 0x9006fa68 }, + { "NvAPI_D3D11_GetResourceGPUVirtualAddress", 0x1819b423 }, + { "NvAPI_D3D12_GetRaytracingCaps", 0x85a6c2a0 }, + { "NvAPI_D3D12_EnableRaytracingValidation", 0x1de5991b }, + { "NvAPI_D3D12_RegisterRaytracingValidationMessageCallback", 0x8554eb38 }, + { "NvAPI_D3D12_UnregisterRaytracingValidationMessageCallback", 0x26975da6 }, + { "NvAPI_D3D12_FlushRaytracingValidationMessages", 0xb8fb1fcb }, + { "NvAPI_D3D12_GetRaytracingDisplacementMicromapArrayPrebuildInfo", 0xfa99b6de }, + { "NvAPI_D3D12_GetRaytracingOpacityMicromapArrayPrebuildInfo", 0x4726d180 }, + { "NvAPI_D3D12_SetCreatePipelineStateOptions", 0x5c607a27 }, + { "NvAPI_D3D12_CheckDriverMatchingIdentifierEx", 0xafb237d4 }, + { "NvAPI_D3D12_GetRaytracingAccelerationStructurePrebuildInfoEx", 0x8d025b77 }, + { "NvAPI_D3D12_BuildRaytracingOpacityMicromapArray", 0x814f8d11 }, + { "NvAPI_D3D12_RelocateRaytracingOpacityMicromapArray", 0x0425c538 }, + { "NvAPI_D3D12_BuildRaytracingDisplacementMicromapArray", 0x066f569d }, + { "NvAPI_D3D12_RelocateRaytracingDisplacementMicromapArray", 0x1c142308 }, + { "NvAPI_D3D12_EmitRaytracingDisplacementMicromapArrayPostbuildInfo", 0x68b9a790 }, + { "NvAPI_D3D12_EmitRaytracingOpacityMicromapArrayPostbuildInfo", 0x1d9a39b6 }, + { "NvAPI_D3D12_BuildRaytracingAccelerationStructureEx", 0xe24ead45 }, + { "NvAPI_D3D12_QueryWorkstationFeatureProperties", 0xa92ea23a }, + { "NvAPI_D3D12_CreateCommittedRDMABuffer", 0xe78dcb44 }, + { "NvAPI_D3D12_ConvertCooperativeVectorMatrix", 0x0f252cb3 }, + { "NvAPI_D3D12_ConvertCooperativeVectorMatrixMultiple", 0x96ba5235 }, + { "NvAPI_D3D12_GetPhysicalDeviceCooperativeVectorProperties", 0x8f182aec }, + { "NvAPI_D3D12_GetRaytracingMultiIndirectClusterOperationRequirementsInfo", 0x5c9163f4 }, + { "NvAPI_D3D12_RaytracingExecuteMultiIndirectClusterOperation", 0x67c798af }, + { "NvAPI_D3D12_GetRaytracingPartitionedTlasIndirectPrebuildInfo", 0xcdfdc5f2 }, + { "NvAPI_D3D12_BuildRaytracingPartitionedTlasIndirect", 0x7cfc6fc3 }, + { "NvAPI_NGX_GetNGXOverrideState", 0x3fd96fba }, + { "NvAPI_NGX_SetNGXOverrideState", 0xb60fcb4e }, + { "NvAPI_DirectD3D12GraphicsCommandList_Create", 0x74a4e712 }, + { "NvAPI_DirectD3D12GraphicsCommandList_Release", 0x99da3dde }, + { "NvAPI_DirectD3D12GraphicsCommandList_Reset", 0x999c26d8 }, + { "NvAPI_VIO_GetCapabilities", 0x1dc91303 }, + { "NvAPI_VIO_Open", 0x44ee4841 }, + { "NvAPI_VIO_Close", 0xd01bd237 }, + { "NvAPI_VIO_Status", 0x0e6ce4f1 }, + { "NvAPI_VIO_SyncFormatDetect", 0x118d48a3 }, + { "NvAPI_VIO_GetConfig", 0xd34a789b }, + { "NvAPI_VIO_SetConfig", 0x0e4eec07 }, + { "NvAPI_VIO_SetCSC", 0xa1ec8d74 }, + { "NvAPI_VIO_GetCSC", 0x7b0d72a3 }, + { "NvAPI_VIO_SetGamma", 0x964bf452 }, + { "NvAPI_VIO_GetGamma", 0x51d53d06 }, + { "NvAPI_VIO_SetSyncDelay", 0x2697a8d1 }, + { "NvAPI_VIO_GetSyncDelay", 0x462214a9 }, + { "NvAPI_VIO_GetPCIInfo", 0xb981d935 }, + { "NvAPI_VIO_IsRunning", 0x96bd040e }, + { "NvAPI_VIO_Start", 0xcde8e1a3 }, + { "NvAPI_VIO_Stop", 0x6ba2a5d6 }, + { "NvAPI_VIO_IsFrameLockModeCompatible", 0x7bf0a94d }, + { "NvAPI_VIO_EnumDevices", 0xfd7c5557 }, + { "NvAPI_VIO_QueryTopology", 0x869534e2 }, + { "NvAPI_VIO_EnumSignalFormats", 0xead72fe4 }, + { "NvAPI_VIO_EnumDataFormats", 0x221fa8e8 }, + { "NvAPI_Stereo_CreateConfigurationProfileRegistryKey", 0xbe7692ec }, + { "NvAPI_Stereo_DeleteConfigurationProfileRegistryKey", 0xf117b834 }, + { "NvAPI_Stereo_SetConfigurationProfileValue", 0x24409f48 }, + { "NvAPI_Stereo_DeleteConfigurationProfileValue", 0x49bceecf }, + { "NvAPI_Stereo_Enable", 0x239c4545 }, + { "NvAPI_Stereo_Disable", 0x2ec50c2b }, + { "NvAPI_Stereo_IsEnabled", 0x348ff8e1 }, + { "NvAPI_Stereo_GetStereoSupport", 0x296c434d }, + { "NvAPI_Stereo_CreateHandleFromIUnknown", 0xac7e37f4 }, + { "NvAPI_Stereo_DestroyHandle", 0x3a153134 }, + { "NvAPI_Stereo_Activate", 0xf6a1ad68 }, + { "NvAPI_Stereo_Deactivate", 0x2d68de96 }, + { "NvAPI_Stereo_IsActivated", 0x1fb0bc30 }, + { "NvAPI_Stereo_GetSeparation", 0x451f2134 }, + { "NvAPI_Stereo_SetSeparation", 0x5c069fa3 }, + { "NvAPI_Stereo_DecreaseSeparation", 0xda044458 }, + { "NvAPI_Stereo_IncreaseSeparation", 0xc9a8ecec }, + { "NvAPI_Stereo_GetConvergence", 0x4ab00934 }, + { "NvAPI_Stereo_SetConvergence", 0x3dd6b54b }, + { "NvAPI_Stereo_DecreaseConvergence", 0x4c87e317 }, + { "NvAPI_Stereo_IncreaseConvergence", 0xa17daabe }, + { "NvAPI_Stereo_GetFrustumAdjustMode", 0xe6839b43 }, + { "NvAPI_Stereo_SetFrustumAdjustMode", 0x7be27fa2 }, + { "NvAPI_Stereo_CaptureJpegImage", 0x932cb140 }, + { "NvAPI_Stereo_InitActivation", 0xc7177702 }, + { "NvAPI_Stereo_Trigger_Activation", 0x0d6c6cd2 }, + { "NvAPI_Stereo_CapturePngImage", 0x8b7e99b5 }, + { "NvAPI_Stereo_ReverseStereoBlitControl", 0x3cd58f89 }, + { "NvAPI_Stereo_SetNotificationMessage", 0x6b9b409e }, + { "NvAPI_Stereo_SetActiveEye", 0x96eea9f8 }, + { "NvAPI_Stereo_SetDriverMode", 0x5e8f0bec }, + { "NvAPI_Stereo_GetEyeSeparation", 0xce653127 }, + { "NvAPI_Stereo_IsWindowedModeSupported", 0x40c8ed5e }, + { "NvAPI_Stereo_SetSurfaceCreationMode", 0xf5dcfcba }, + { "NvAPI_Stereo_GetSurfaceCreationMode", 0x36f1c736 }, + { "NvAPI_Stereo_Debug_WasLastDrawStereoized", 0xed4416c5 }, + { "NvAPI_Stereo_SetDefaultProfile", 0x44f0ecd1 }, + { "NvAPI_Stereo_GetDefaultProfile", 0x624e21c2 }, + { "NvAPI_D3D1x_CreateSwapChain", 0x1bc21b66 }, + { "NvAPI_D3D9_CreateSwapChain", 0x1a131e09 }, + { "NvAPI_Vulkan_InitLowLatencyDevice", 0x5c1696b6 }, + { "NvAPI_Vulkan_DestroyLowLatencyDevice", 0x11a5932b }, + { "NvAPI_Vulkan_GetSleepStatus", 0xadf966af }, + { "NvAPI_Vulkan_SetSleepMode", 0x2acfd162 }, + { "NvAPI_Vulkan_Sleep", 0x36732b1e }, + { "NvAPI_Vulkan_GetLatency", 0x3233d44a }, + { "NvAPI_Vulkan_SetLatencyMarker", 0xa17d13d6 }, + { "NvAPI_Vulkan_NotifyOutOfBandVkQueue", 0x5d6d3840 }, + { "NvAPI_DRS_CreateSession", 0x0694d52e }, + { "NvAPI_DRS_DestroySession", 0xdad9cff8 }, + { "NvAPI_DRS_LoadSettings", 0x375dbd6b }, + { "NvAPI_DRS_SaveSettings", 0xfcbc7e14 }, + { "NvAPI_DRS_LoadSettingsFromFile", 0xd3ede889 }, + { "NvAPI_DRS_SaveSettingsToFile", 0x2be25df8 }, + { "NvAPI_DRS_CreateProfile", 0xcc176068 }, + { "NvAPI_DRS_DeleteProfile", 0x17093206 }, + { "NvAPI_DRS_SetCurrentGlobalProfile", 0x1c89c5df }, + { "NvAPI_DRS_GetCurrentGlobalProfile", 0x617bff9f }, + { "NvAPI_DRS_GetProfileInfo", 0x61cd6fd6 }, + { "NvAPI_DRS_SetProfileInfo", 0x16abd3a9 }, + { "NvAPI_DRS_FindProfileByName", 0x7e4a9a0b }, + { "NvAPI_DRS_EnumProfiles", 0xbc371ee0 }, + { "NvAPI_DRS_GetNumProfiles", 0x1dae4fbc }, + { "NvAPI_DRS_CreateApplication", 0x4347a9de }, + { "NvAPI_DRS_DeleteApplicationEx", 0xc5ea85a1 }, + { "NvAPI_DRS_DeleteApplication", 0x2c694bc6 }, + { "NvAPI_DRS_GetApplicationInfo", 0xed1f8c69 }, + { "NvAPI_DRS_EnumApplications", 0x7fa2173a }, + { "NvAPI_DRS_FindApplicationByName", 0xeee566b2 }, + { "NvAPI_DRS_SetSetting", 0x577dd202 }, + { "NvAPI_DRS_GetSetting", 0x73bf8338 }, + { "NvAPI_DRS_EnumSettings", 0xae3039da }, + { "NvAPI_DRS_EnumAvailableSettingIds", 0xf020614a }, + { "NvAPI_DRS_EnumAvailableSettingValues", 0x2ec39f90 }, + { "NvAPI_DRS_GetSettingIdFromName", 0xcb7309cd }, + { "NvAPI_DRS_GetSettingNameFromId", 0xd61cbe6e }, + { "NvAPI_DRS_DeleteProfileSetting", 0xe4a26362 }, + { "NvAPI_DRS_RestoreAllDefaults", 0x5927b094 }, + { "NvAPI_DRS_RestoreProfileDefault", 0xfa5f6134 }, + { "NvAPI_DRS_RestoreProfileDefaultSetting", 0x53f0381e }, + { "NvAPI_DRS_GetBaseProfile", 0xda8466a0 }, + { "NvAPI_SYS_GetChipSetInfo", 0x53dabbca }, + { "NvAPI_SYS_GetLidAndDockInfo", 0xcda14d8a }, + { "NvAPI_SYS_GetDisplayIdFromGpuAndOutputId", 0x08f2bab4 }, + { "NvAPI_SYS_GetGpuAndOutputIdFromDisplayId", 0x112ba1a5 }, + { "NvAPI_SYS_GetPhysicalGpuFromDisplayId", 0x9ea74659 }, + { "NvAPI_SYS_GetDisplayDriverInfo", 0x721faceb }, + { "NvAPI_SYS_GetPhysicalGPUs", 0xd3b24d2d }, + { "NvAPI_SYS_GetLogicalGPUs", 0xccfffc10 }, + { "NvAPI_NGX_GetDriverFeatureSupport", 0x6194b19d }, + { "NvAPI_GPU_ClientRegisterForUtilizationSampleUpdates", 0xadeeaf67 }, + { "NvAPI_RegisterRiseCallback", 0x9cfe8f94 }, + { "NvAPI_RequestRise", 0x5047de98 }, + { "NvAPI_UninstallRise", 0xab8d09f6 }, +); + +#[no_mangle] +pub unsafe extern "C" fn nvapi_QueryInterface(interface: u32) -> *mut c_void { + let maybe_fn_ptr_global = (&*GLOBAL_STATE).as_ref().and_then(|(lib, state)| { + let fn_ptr = lib + .get:: *mut c_void>(b"nvapi_QueryInterface\0") + .ok()?; + Some((fn_ptr, state)) + }); + let (fn_ptr, global_state) = + unwrap_or::unwrap_some_or!(maybe_fn_ptr_global, return ptr::null_mut()); + let export_table = unwrap_or::unwrap_some_or!( + ::zluda_trace_common::get_export_table(), + return ptr::null_mut() + ); + let format_args = dark_api::FnFfiWrapper(|| { + use std::io::Write; + let mut writer = Vec::new(); + let name = interface_to_name(interface); + match name { + Some(name) => write!(&mut writer, "(interface: {})", name).ok(), + None => write!(&mut writer, "(interface: {:#010x})", interface).ok(), + }; + dark_api::ByteVecFfi::new(writer) + }); + let underlying_fn = dark_api::FnFfiWrapper(|| { + let result = fn_ptr(interface); + result as usize + }); + let original: *mut c_void = ReprUsize::from_usize(export_table.logged_call( + cglue::slice::CSliceRef::from_str("nvapi_QueryInterface"), + 0, + cglue::trait_obj!(&format_args as dark_api::FnFfi), + cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), + ptr::null_mut::() as usize, + <*mut c_void as ReprUsize>::format_status, + )); + if cfg!(target_pointer_width = "32") && !original.is_null() { + global_state + .lock() + .ok() + .map(|mut state| state.get_thunk(original, report_fn, interface)) + .unwrap_or_else(|| get_thunk(original, report_fn, interface)) + } else { + original + } +} + +unsafe extern "C" fn report_fn(result: i32, interface: u32) { + let export_table = unwrap_or::unwrap_some_or!(::zluda_trace_common::get_export_table(), return); + let format_args = + dark_api::FnFfiWrapper(|| dark_api::ByteVecFfi::new("(...)".as_bytes().to_vec())); + let underlying_fn = dark_api::FnFfiWrapper(|| ReprUsize::to_usize(result)); + let (fn_name, interface) = match interface_to_name(interface) { + Some(name) => (name, 0), + None => ("", interface), + }; + export_table.logged_call( + cglue::slice::CSliceRef::from_str(fn_name), + interface, + cglue::trait_obj!(&format_args as dark_api::FnFfi), + cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), + ::INTERNAL_ERROR, + ::format_status, + ); +} + +#[cfg(target_arch = "x86")] +pub fn get_thunk( + original_fn: *mut c_void, + report_fn: unsafe extern "C" fn(i32, u32), + interface: u32, +) -> *mut c_void { + use dynasmrt::{dynasm, DynasmApi}; + let mut ops = dynasmrt::x86::Assembler::new().unwrap(); + let start = ops.offset(); + dynasm!(ops + ; .arch x86 + ; push ebp + ; mov ebp, esp + ; push DWORD [ebp+68] + ; push DWORD [ebp+64] + ; push DWORD [ebp+60] + ; push DWORD [ebp+56] + ; push DWORD [ebp+52] + ; push DWORD [ebp+48] + ; push DWORD [ebp+44] + ; push DWORD [ebp+40] + ; push DWORD [ebp+36] + ; push DWORD [ebp+32] + ; push DWORD [ebp+28] + ; push DWORD [ebp+24] + ; push DWORD [ebp+20] + ; push DWORD [ebp+16] + ; push DWORD [ebp+12] + ; push DWORD [ebp+8] + ; mov eax, original_fn as i32 + ; call eax + ; push interface as i32 + ; push eax + ; mov eax, report_fn as i32 + ; call eax + ; pop eax + ; leave + ; ret + ; int 3 + ); + let exe_buf = ops.finalize().unwrap(); + let result_fn = exe_buf.ptr(start); + std::mem::forget(exe_buf); + result_fn as *mut _ +} + +#[cfg(target_arch = "x86_64")] +pub fn get_thunk( + _original_fn: *mut c_void, + _report_fn: unsafe extern "C" fn(i32, u32), + _interface: u32, +) -> *mut c_void { + todo!() +} diff --git a/xtask/src/main.rs b/xtask/src/main.rs index 270464f7e..012e792b4 100644 --- a/xtask/src/main.rs +++ b/xtask/src/main.rs @@ -37,11 +37,14 @@ struct Cargo { release: Option, #[bpaf(long)] profile: Option, + #[bpaf(long)] + target: Option, #[bpaf(any("", Some), many)] _unused: Vec, } struct Project { + is_32bit: bool, #[cfg_attr(unix, allow(unused))] manifest_path: PathBuf, name: String, @@ -51,7 +54,7 @@ struct Project { } impl Project { - fn try_new(p: Package) -> Option { + fn try_new(p: Package, is_32bit: bool) -> Option { let name = p.name; let manifest_path = p.manifest_path.into(); serde_json::from_value::>(p.metadata) @@ -76,13 +79,14 @@ impl Project { target_name, target_kind, meta: m.zluda, + is_32bit, } }) } #[cfg(windows)] fn zip_compiler_output(&self) -> bool { - self.meta.windows_paths.is_empty() + self.meta.windows_paths(self.is_32bit).is_empty() } #[cfg(unix)] @@ -146,7 +150,7 @@ impl Project { target_dir, profile, libname, - self.meta.windows_paths.as_slice(), + self.meta.windows_paths(self.is_32bit).as_slice(), ) .map(move |(.., full_path, target)| { let copy_output = full_path.clone(); @@ -239,6 +243,10 @@ struct ZludaMetadata { linux_only: bool, #[serde(default)] windows_only: bool, + #[serde(default = "always_true", rename = "64bit")] + is_64bit: bool, + #[serde(default, rename = "32bit")] + is_32bit: bool, #[serde(default)] debug_only: bool, #[cfg_attr(not(unix), allow(unused))] @@ -249,9 +257,26 @@ struct ZludaMetadata { windows_paths: Vec, #[serde(default)] #[cfg_attr(unix, allow(unused))] + windows32_paths: Vec, + #[serde(default)] + #[cfg_attr(unix, allow(unused))] windows_extra_files: HashMap, } +impl ZludaMetadata { + fn windows_paths(&self, is_32bit: bool) -> &Vec { + if is_32bit && !self.windows32_paths.is_empty() { + &self.windows32_paths + } else { + &self.windows_paths + } + } +} + +fn always_true() -> bool { + true +} + fn main() { let options = match options().run_inner(Args::current_args()) { Ok(b) => b, @@ -272,21 +297,33 @@ fn main() { } fn compile(b: Build) -> (PathBuf, String, Vec) { - let profile = sniff_out_profile_name(&b.cargo_arguments); + let cargo_flags = sniff_out_cargo_flags(&b.cargo_arguments); let meta = MetadataCommand::new().no_deps().exec().unwrap(); - let target_directory = meta.target_directory.into_std_path_buf(); + let mut target_directory = meta.target_directory.into_std_path_buf(); + if let Some(target) = &cargo_flags.target { + target_directory.push(target); + } let projects = meta .packages .into_iter() - .filter_map(Project::try_new) + .filter_map(|pkg| Project::try_new(pkg, cargo_flags.is_32bit)) .filter(|project| { + if cargo_flags.is_32bit { + if !project.meta.is_32bit { + return false; + } + } else { + if !project.meta.is_64bit { + return false; + } + } if project.meta.linux_only && cfg!(windows) { return false; } if project.meta.windows_only && cfg!(not(windows)) { return false; } - if project.meta.debug_only && profile != "debug" { + if project.meta.debug_only && cargo_flags.profile != "debug" { return false; } true @@ -302,13 +339,21 @@ fn compile(b: Build) -> (PathBuf, String, Vec) { } command.args(b.cargo_arguments); assert!(command.status().unwrap().success()); - os::make_symlinks(&target_directory, &*projects, &*profile); - (target_directory, profile, projects) + os::make_symlinks(&target_directory, &*projects, &*cargo_flags.profile); + (target_directory, cargo_flags.profile, projects) } -fn sniff_out_profile_name(b: &[OsString]) -> String { +fn sniff_out_cargo_flags(b: &[OsString]) -> CargoFlags { let parsed_cargo_arguments = cargo().to_options().run_inner(b); - match parsed_cargo_arguments { + let (target, is_32bit) = match parsed_cargo_arguments.as_ref() { + Ok(Cargo { + target: Some(target), + .. + }) => (Some(target.clone()), target.starts_with("i686")), + Ok(Cargo { target: None, .. }) => (None, cfg!(target_pointer_width = "32")), + _ => (None, false), + }; + let profile = match parsed_cargo_arguments { Ok(Cargo { release: Some(true), .. @@ -318,9 +363,20 @@ fn sniff_out_profile_name(b: &[OsString]) -> String { .. }) => profile, _ => "debug".to_string(), + }; + CargoFlags { + profile, + target, + is_32bit, } } +struct CargoFlags { + profile: String, + target: Option, + is_32bit: bool, +} + fn zip(zip: Build) { let (target_dir, profile, projects) = compile(zip); os::zip(target_dir, profile, projects) diff --git a/zluda32/Cargo.toml b/zluda32/Cargo.toml new file mode 100644 index 000000000..c8e8bfd6e --- /dev/null +++ b/zluda32/Cargo.toml @@ -0,0 +1,41 @@ +[package] +name = "zluda32" +version = "0.0.0" +authors = ["Andrzej Janik "] +edition = "2021" + +[lib] +name = "nvcuda" +crate-type = ["cdylib"] + +[dependencies] +cuda_types = { path = "../cuda_types" } +cuda_macros = { path = "../cuda_macros" } +zluda_windows = { path = "../zluda_windows" } +zluda_server_common = { path = "../zluda_server_common" } +dark_api = { path = "../dark_api" } +paste = "1.0" +ipc-channel = "^0.21.0" +windows = { version = "0.62.2", features = [ + "Win32_Foundation", + "Win32_Storage_FileSystem", + "Win32_System_IO", + "Win32_System_Pipes", + "Win32_Security", +] } +# windows-sys = { version = "0.61.2", features = [ +# "Win32_Foundation", +# "Win32_System_Pipes", +# "Win32_Storage_FileSystem", +# ] } +rand = "0.10.1" +widestring = "1.2.1" +bitcode = "0.6.9" +postcard = "1.1.3" +bincode = "2.0.1" +rkyv = "0.8.15" + +[package.metadata.zluda] +windows_only = true +64bit = false +32bit = true diff --git a/zluda32/src/ipc.rs b/zluda32/src/ipc.rs new file mode 100644 index 000000000..7aff6c120 --- /dev/null +++ b/zluda32/src/ipc.rs @@ -0,0 +1,154 @@ +use cuda_types::cuda::CUerror; +use rand::distr::{Alphanumeric, SampleString}; +use rkyv::api::high::HighSerializer; +use rkyv::de::Pool; +use rkyv::rancor::{Failure, Strategy}; +use rkyv::rend::u32_le; +use rkyv::ser::allocator::ArenaHandle; +use rkyv::util::AlignedVec; +use rkyv::{rancor, Archive, Deserialize, Portable, Serialize}; +use std::io::{Read, Write}; +use std::os::windows::io::{AsHandle, AsRawHandle, FromRawHandle}; +// use rkyv::util::AlignedVec; +use std::num::NonZeroU32; +use std::process::{Child, Command, Stdio}; +use std::sync::{Mutex, OnceLock}; +use std::{mem, ptr}; +use widestring::{u16str, U16CString}; +use windows::core::{Error, Owned, PCSTR}; +use windows::Win32::Foundation::*; +use windows::Win32::System::Pipes::*; +use zluda_server_common::Opcode; + +fn server_path() -> &'static str { + if cfg!(debug_assertions) { + r"C:\dev\ZLUDA\target\debug\zluda64_server.exe" + } else { + "zluda64_server.exe" + } +} + +pub(crate) struct Server { + pipe: std::fs::File, + _child: Child, + buffer: AlignedVec, +} + +unsafe impl Sync for Server {} +unsafe impl Send for Server {} + +impl Server { + fn new(pipe: std::fs::File, child: Child) -> Self { + Self { + pipe, + _child: child, + buffer: AlignedVec::new(), + } + } + + unsafe fn start() -> Result { + let name = Alphanumeric.sample_string(&mut rand::rng(), 32); + let pipe_path = format!("\\\\.\\pipe\\zluda-{name}\0"); + let pipe = std::fs::File::from_raw_handle( + CreateNamedPipeA( + PCSTR(pipe_path.as_ptr()), + windows::Win32::Storage::FileSystem::PIPE_ACCESS_DUPLEX, + PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT | PIPE_REJECT_REMOTE_CLIENTS, + 1, + 4 * 1024, + 4 * 1024, + 0, + None, + )? + .0, + ); + let child = Command::new(server_path()) + .arg(&pipe_path[..pipe_path.len() - 1]) + .stdin(Stdio::null()) + .stdout(Stdio::null()) + .stderr(Stdio::null()) + .spawn()?; + zluda_windows::kill_child_on_process_exit(child.as_handle().as_raw_handle())?; + match ConnectNamedPipe(HANDLE(pipe.as_raw_handle()), None) { + Ok(_) => Ok(Server::new(pipe, child)), + Err(e) if e.code() == ERROR_PIPE_CONNECTED.into() => Ok(Server::new(pipe, child)), + Err(e) => Err(e), + } + } + + fn get() -> Result<&'static Mutex, CUerror> { + static LOCK: OnceLock, Error>> = OnceLock::new(); + LOCK.get_or_init(|| Ok(Mutex::new(unsafe { Server::start()? }))) + .as_ref() + .map_err(|_| CUerror::UNKNOWN) + } + + pub(crate) fn remote_call_zero_copy( + opcode: Opcode, + data: impl for<'a, 'b> Serialize< + HighSerializer<&'a mut AlignedVec, ArenaHandle<'b>, rkyv::rancor::Failure>, + >, + ) -> Result { + let this = &mut *Self::get()?.lock().map_err(|_| CUerror::UNKNOWN)?; + this.buffer.clear(); + this.pipe + .write_all(&(opcode as u32).to_le_bytes()[..]) + .map_err(|_| CUerror::UNKNOWN)?; + let slice = + rkyv::api::high::to_bytes_in::<_, rkyv::rancor::Failure>(&data, &mut this.buffer) + .map_err(|_| CUerror::UNKNOWN)?; + this.pipe.write_all(&slice).map_err(|_| CUerror::UNKNOWN)?; + read_return_code(this)?; + this.buffer.resize(mem::size_of::(), 0); + this.pipe + .read_exact(&mut this.buffer) + .map_err(|_| CUerror::UNKNOWN)?; + let output = unsafe { rkyv::access_unchecked::(&this.buffer) }; + Ok(output.clone()) + } + + pub(crate) fn remote_call_framed( + opcode: Opcode, + data: impl for<'a, 'b> Serialize< + HighSerializer<&'a mut AlignedVec, ArenaHandle<'b>, rkyv::rancor::Failure>, + >, + ) -> Result + where + ::Archived: Deserialize>, + { + let this = &mut *Self::get()?.lock().map_err(|_| CUerror::UNKNOWN)?; + this.buffer.clear(); + this.pipe + .write_all(&(opcode as u32).to_le_bytes()[..]) + .map_err(|_| CUerror::UNKNOWN)?; + let slice = + rkyv::api::high::to_bytes_in::<_, rkyv::rancor::Failure>(&data, &mut this.buffer) + .map_err(|_| CUerror::UNKNOWN)?; + this.pipe.write_all(&slice).map_err(|_| CUerror::UNKNOWN)?; + read_return_code(this)?; + let out_size = read_u32(this)?; + this.buffer.resize(out_size as usize, 0); + this.pipe + .read_exact(&mut this.buffer) + .map_err(|_| CUerror::UNKNOWN)?; + unsafe { rkyv::from_bytes_unchecked::(&this.buffer) } + .map_err(|_| CUerror::UNKNOWN) + } +} + +fn read_return_code(this: &mut Server) -> Result<(), CUerror> { + let code = read_u32(this)?; + match NonZeroU32::new(code) { + None => Ok(()), + Some(code) => Err(CUerror(code)), + } +} + +fn read_u32(this: &mut Server) -> Result { + let mut code_buffer = [0u8; 4]; + this.pipe + .read_exact(&mut code_buffer) + .map_err(|_| CUerror::UNKNOWN)?; + let code = u32::from_le_bytes(code_buffer); + Ok(code) +} diff --git a/zluda32/src/lib.rs b/zluda32/src/lib.rs new file mode 100644 index 000000000..bd9581b8c --- /dev/null +++ b/zluda32/src/lib.rs @@ -0,0 +1,717 @@ +use cuda_macros::cuda_function_declarations; +use cuda_types::cuda::*; +use dark_api::cuda::CudaDarkApi; +use paste::paste; +use std::sync::{Mutex, OnceLock}; +use std::{cell::RefCell, ffi::c_void, ptr}; +use zluda_server_common::*; + +mod ipc; + +macro_rules! not_implemented { + ($($abi:literal fn $fn_name:ident( $($arg_id:ident : $arg_type:ty),* ) -> $ret_type:ty;)*) => { + $( + #[cfg_attr(not(test), no_mangle)] + #[allow(improper_ctypes)] + #[allow(improper_ctypes_definitions)] + #[allow(unused_variables)] + pub unsafe extern $abi fn $fn_name ( $( $arg_id : $arg_type),* ) -> $ret_type { + Err(cuda_types::cuda::CUerror::NOT_SUPPORTED) + } + )* + }; +} + +macro_rules! implemented { + ($($abi:literal fn $fn_name:ident( $($arg_id:ident : $arg_type:ty),* ) -> $ret_type:ty;)*) => { + $( + #[cfg_attr(not(test), no_mangle)] + #[allow(improper_ctypes)] + #[allow(improper_ctypes_definitions)] + pub unsafe extern $abi fn $fn_name ( $( $arg_id : $arg_type),* ) -> $ret_type { + paste!{ [< $fn_name:snake >] ( $( $arg_id ),* ) } + } + )* + + }; +} + +cuda_function_declarations! { + not_implemented, + implemented <= [ + cuCtxCreate_v2, + cuCtxDetach, + cuCtxGetApiVersion, + cuCtxGetCurrent, + cuCtxGetDevice, + cuCtxSynchronize, + cuDeviceComputeCapability, + cuDeviceGet, + cuDeviceGetAttribute, + cuDeviceGetCount, + cuDeviceGetName, + cuDeviceGetProperties, + cuDeviceTotalMem_v2, + cuDriverGetVersion, + cuEventCreate, + cuEventDestroy_v2, + cuGetExportTable, + cuInit, + cuLaunchKernel, + cuMemAlloc_v2, + cuMemFreeHost, + cuMemFree_v2, + cuMemGetAddressRange_v2, + cuMemHostAlloc, + cuMemcpyDtoDAsync_v2, + cuMemcpyDtoHAsync_v2, + cuMemcpyHtoDAsync_v2, + cuMemsetD8_v2, + cuModuleGetFunction, + cuModuleGetGlobal_v2, + cuModuleGetTexRef, + cuStreamCreate, + cuStreamDestroy_v2, + cuTexRefSetAddressMode, + cuTexRefSetAddress_v2, + cuTexRefSetFilterMode, + cuTexRefSetFlags, + cuTexRefSetFormat, + cuTexRefSetMaxAnisotropy, + cuTexRefSetMipmapFilterMode, + cuTexRefSetMipmapLevelBias, + cuTexRefSetMipmapLevelClamp, + ] +} + +thread_local! { + pub(crate) static CONTEXT_STACK: ContextStack = ContextStack::new(); +} + +struct ContextStack(RefCell>); + +impl ContextStack { + fn new() -> Self { + ContextStack(RefCell::new(Vec::new())) + } + + fn push(&self, ctx: CUcontext, dev: CUdevice) { + self.0.borrow_mut().push((ctx, dev)); + } + + fn unwrap(&self, ctx: CUcontext) -> Result { + if ctx.0.is_null() { + let stack = self.0.borrow(); + stack + .last() + .map(|(ctx, _)| *ctx) + .ok_or(CUerror::INVALID_VALUE) + } else { + Ok(ctx) + } + } + + fn current(&self) -> (CUcontext, CUdevice) { + self.0 + .borrow() + .last() + .copied() + .unwrap_or((CUcontext(ptr::null_mut()), 0)) + } +} + +pub(crate) fn cu_init(flags: u32) -> Result<(), CUerror> { + ipc::Server::remote_call_zero_copy::(Opcode::cuInit, cuInitIn { Flags: flags })?; + Ok(()) +} + +pub(crate) fn cu_ctx_create_v2( + pctx: *mut CUcontext, + flags: ::core::ffi::c_uint, + dev: CUdevice, +) -> Result<(), CUerror> { + let ctx_ref = unsafe { pctx.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + let cu_ctx = CudaEncode::decode( + ipc::Server::remote_call_zero_copy::( + Opcode::cuCtxCreate_v2, + cuCtxCreate_v2In { flags, dev }, + )? + .pctx, + ); + CONTEXT_STACK.with(|stack| { + stack.push(cu_ctx, dev); + }); + *ctx_ref = cu_ctx; + Ok(()) +} + +pub(crate) fn cu_ctx_detach(ctx: CUcontext) -> Result<(), CUerror> { + unimplemented!() +} + +pub(crate) fn cu_ctx_get_api_version( + ctx: CUcontext, + version: *mut ::core::ffi::c_uint, +) -> Result<(), CUerror> { + let version = unsafe { version.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + let ctx = CONTEXT_STACK.with(|s| s.unwrap(ctx))?; + *version = CudaEncode::decode( + ipc::Server::remote_call_zero_copy::( + Opcode::cuCtxGetApiVersion, + cuCtxGetApiVersionIn { + ctx: CudaEncode::encode(ctx), + }, + )? + .version, + ); + Ok(()) +} + +pub(crate) fn cu_ctx_get_current(pctx: *mut CUcontext) -> Result<(), CUerror> { + let pctx = unsafe { pctx.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + *pctx = CONTEXT_STACK.with(|s| s.current()).0; + Ok(()) +} + +pub(crate) fn cu_ctx_get_device(device: *mut CUdevice) -> Result<(), CUerror> { + let device = unsafe { device.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + let (_, dev) = CONTEXT_STACK.with(|s| s.current()); + *device = dev; + Ok(()) +} + +pub(crate) fn cu_ctx_synchronize() -> Result<(), CUerror> { + unimplemented!() +} + +pub(crate) fn cu_device_compute_capability( + major: *mut ::core::ffi::c_int, + minor: *mut ::core::ffi::c_int, + dev: CUdevice, +) -> Result<(), CUerror> { + unimplemented!() +} + +pub(crate) fn cu_device_get( + device: *mut CUdevice, + ordinal: ::core::ffi::c_int, +) -> Result<(), CUerror> { + let device = unsafe { device.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + *device = ipc::Server::remote_call_zero_copy::( + Opcode::cuDeviceGet, + cuDeviceGetIn { ordinal }, + )? + .device; + Ok(()) +} + +pub(crate) fn cu_device_get_attribute( + pi: *mut ::core::ffi::c_int, + attrib: CUdevice_attribute, + dev: CUdevice, +) -> Result<(), CUerror> { + let pi = unsafe { pi.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + *pi = ipc::Server::remote_call_zero_copy::( + Opcode::cuDeviceGetAttribute, + cuDeviceGetAttributeIn { + attrib: CudaEncode::encode(attrib), + dev, + }, + )? + .pi; + Ok(()) +} + +pub(crate) fn cu_device_get_count(count: *mut ::core::ffi::c_int) -> Result<(), CUerror> { + let count = unsafe { count.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + *count = ipc::Server::remote_call_zero_copy::( + Opcode::cuDeviceGetCount, + cuDeviceGetCountIn {}, + )? + .count; + Ok(()) +} + +pub(crate) fn cu_device_get_name( + name: *mut ::core::ffi::c_char, + len: ::core::ffi::c_int, + dev: CUdevice, +) -> Result<(), CUerror> { + if name.is_null() { + return Err(CUerror::INVALID_VALUE); + } + let name_out = ipc::Server::remote_call_framed::( + Opcode::cuDeviceGetName, + cuDeviceGetNameIn { len, dev }, + )?; + unsafe { + std::ptr::copy_nonoverlapping( + name_out.name.as_ptr() as *const i8, + name, + (len as usize).min(name_out.name.len()), + ) + }; + Ok(()) +} + +pub(crate) fn cu_device_get_properties(prop: *mut CUdevprop, dev: CUdevice) -> Result<(), CUerror> { + unimplemented!() +} + +pub(crate) fn cu_device_total_mem_v2(bytes: *mut usize, dev: CUdevice) -> Result<(), CUerror> { + let bytes = unsafe { bytes.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + *bytes = ipc::Server::remote_call_zero_copy::( + Opcode::cuDeviceTotalMem_v2, + cuDeviceTotalMem_v2In { dev }, + )? + .bytes + .to_native() + .min(u32::MAX as u64) as usize; + Ok(()) +} + +pub(crate) fn cu_driver_get_version( + driver_version: *mut ::core::ffi::c_int, +) -> Result<(), CUerror> { + let driver_version = unsafe { driver_version.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + *driver_version = ipc::Server::remote_call_zero_copy::( + Opcode::cuDriverGetVersion, + cuDriverGetVersionIn {}, + )? + .driverVersion; + Ok(()) +} + +pub(crate) fn cu_event_create( + phEvent: *mut CUevent, + Flags: ::core::ffi::c_uint, +) -> Result<(), CUerror> { + unimplemented!() +} + +pub(crate) fn cu_event_destroy_v2(hEvent: CUevent) -> Result<(), CUerror> { + unimplemented!() +} + +static EXPORT_TABLE: ::dark_api::cuda::CudaDarkApiGlobalTable = + ::dark_api::cuda::CudaDarkApiGlobalTable::new::(); + +pub(crate) fn cu_get_export_table( + pp_export_table: *mut *const ::core::ffi::c_void, + p_export_table_id: *const CUuuid, +) -> Result<(), CUerror> { + if let (Some(result), Some(guid)) = + unsafe { (pp_export_table.as_mut(), p_export_table_id.as_ref()) } + { + if let Some(table) = EXPORT_TABLE.get(guid) { + *result = table.start(); + cuda_types::cuda::CUresult::SUCCESS + } else { + cuda_types::cuda::CUresult::ERROR_NOT_SUPPORTED + } + } else { + cuda_types::cuda::CUresult::ERROR_INVALID_VALUE + } +} + +pub(crate) fn cu_launch_kernel( + f: CUfunction, + gridDimX: ::core::ffi::c_uint, + gridDimY: ::core::ffi::c_uint, + gridDimZ: ::core::ffi::c_uint, + blockDimX: ::core::ffi::c_uint, + blockDimY: ::core::ffi::c_uint, + blockDimZ: ::core::ffi::c_uint, + sharedMemBytes: ::core::ffi::c_uint, + hStream: CUstream, + kernelParams: *mut *mut ::core::ffi::c_void, + extra: *mut *mut ::core::ffi::c_void, +) -> Result<(), CUerror> { + unimplemented!() +} + +pub(crate) fn cu_mem_alloc_v2(dptr: *mut CUdeviceptr, bytesize: usize) -> Result<(), CUerror> { + unimplemented!() +} + +pub(crate) fn cu_mem_free_host(p: *mut ::core::ffi::c_void) -> Result<(), CUerror> { + unimplemented!() +} + +pub(crate) fn cu_mem_free_v2(dptr: CUdeviceptr) -> Result<(), CUerror> { + unimplemented!() +} + +pub(crate) fn cu_mem_get_address_range_v2( + pbase: *mut CUdeviceptr, + psize: *mut usize, + dptr: CUdeviceptr, +) -> Result<(), CUerror> { + unimplemented!() +} + +pub(crate) fn cu_mem_host_alloc( + pp: *mut *mut ::core::ffi::c_void, + bytesize: usize, + Flags: ::core::ffi::c_uint, +) -> Result<(), CUerror> { + unimplemented!() +} + +pub(crate) fn cu_memcpy_dto_d_async_v2( + dstDevice: CUdeviceptr, + srcDevice: CUdeviceptr, + ByteCount: usize, + hStream: CUstream, +) -> Result<(), CUerror> { + unimplemented!() +} + +pub(crate) fn cu_memcpy_dto_h_async_v2( + dstHost: *mut ::core::ffi::c_void, + srcDevice: CUdeviceptr, + ByteCount: usize, + hStream: CUstream, +) -> Result<(), CUerror> { + unimplemented!() +} + +pub(crate) fn cu_memcpy_hto_d_async_v2( + dstDevice: CUdeviceptr, + srcHost: *const ::core::ffi::c_void, + ByteCount: usize, + hStream: CUstream, +) -> Result<(), CUerror> { + unimplemented!() +} + +pub(crate) fn cu_memset_d8_v2( + dstDevice: CUdeviceptr, + uc: ::core::ffi::c_uchar, + N: usize, +) -> Result<(), CUerror> { + unimplemented!() +} + +pub(crate) fn cu_module_get_function( + hfunc: *mut CUfunction, + hmod: CUmodule, + name: *const ::core::ffi::c_char, +) -> Result<(), CUerror> { + unimplemented!() +} + +pub(crate) fn cu_module_get_global_v2( + dptr: *mut CUdeviceptr, + bytes: *mut usize, + hmod: CUmodule, + name: *const ::core::ffi::c_char, +) -> Result<(), CUerror> { + unimplemented!() +} + +pub(crate) fn cu_module_get_tex_ref( + pTexRef: *mut CUtexref, + hmod: CUmodule, + name: *const ::core::ffi::c_char, +) -> Result<(), CUerror> { + unimplemented!() +} + +pub(crate) fn cu_stream_create( + phStream: *mut CUstream, + Flags: ::core::ffi::c_uint, +) -> Result<(), CUerror> { + unimplemented!() +} + +pub(crate) fn cu_stream_destroy_v2(hStream: CUstream) -> Result<(), CUerror> { + unimplemented!() +} + +pub(crate) fn cu_tex_ref_set_address_mode( + hTexRef: CUtexref, + dim: ::core::ffi::c_int, + am: CUaddress_mode, +) -> Result<(), CUerror> { + unimplemented!() +} + +pub(crate) fn cu_tex_ref_set_address_v2( + ByteOffset: *mut usize, + hTexRef: CUtexref, + dptr: CUdeviceptr, + bytes: usize, +) -> Result<(), CUerror> { + unimplemented!() +} + +pub(crate) fn cu_tex_ref_set_filter_mode( + hTexRef: CUtexref, + fm: CUfilter_mode, +) -> Result<(), CUerror> { + unimplemented!() +} + +pub(crate) fn cu_tex_ref_set_flags( + hTexRef: CUtexref, + Flags: ::core::ffi::c_uint, +) -> Result<(), CUerror> { + unimplemented!() +} + +pub(crate) fn cu_tex_ref_set_format( + hTexRef: CUtexref, + fmt: CUarray_format, + NumPackedComponents: ::core::ffi::c_int, +) -> Result<(), CUerror> { + unimplemented!() +} + +pub(crate) fn cu_tex_ref_set_max_anisotropy( + hTexRef: CUtexref, + maxAniso: ::core::ffi::c_uint, +) -> Result<(), CUerror> { + unimplemented!() +} + +pub(crate) fn cu_tex_ref_set_mipmap_filter_mode( + hTexRef: CUtexref, + fm: CUfilter_mode, +) -> Result<(), CUerror> { + unimplemented!() +} + +pub(crate) fn cu_tex_ref_set_mipmap_level_bias( + hTexRef: CUtexref, + bias: f32, +) -> Result<(), CUerror> { + unimplemented!() +} + +pub(crate) fn cu_tex_ref_set_mipmap_level_clamp( + hTexRef: CUtexref, + minMipmapLevelClamp: f32, + maxMipmapLevelClamp: f32, +) -> Result<(), CUerror> { + unimplemented!() +} + +struct UnknownBuffer { + buffer: std::cell::UnsafeCell<[u32; S]>, +} + +impl UnknownBuffer { + const fn new() -> Self { + UnknownBuffer { + buffer: std::cell::UnsafeCell::new([0; S]), + } + } + const fn len(&self) -> usize { + S + } +} + +unsafe impl Sync for UnknownBuffer {} + +static UNKNOWN_BUFFER1: UnknownBuffer<1024> = UnknownBuffer::new(); +static UNKNOWN_BUFFER2: UnknownBuffer<14> = UnknownBuffer::new(); + +struct DarkApi32; + +#[repr(C)] +struct AllocRecord { + x: usize, + y: usize, +} + +impl CudaDarkApi for DarkApi32 { + unsafe extern "system" fn get_module_from_cubin( + module: *mut cuda_types::cuda::CUmodule, + fatbinc_wrapper: *const cuda_types::dark_api::FatbincWrapper, + ) -> cuda_types::cuda::CUresult { + unimplemented!() + } + + unsafe extern "system" fn cudart_interface_fn2( + pctx: *mut cuda_types::cuda::CUcontext, + _dev: cuda_types::cuda::CUdevice, + ) -> cuda_types::cuda::CUresult { + let ctx = unsafe { pctx.as_mut() }.ok_or(cuda_types::cuda::CUerror::INVALID_VALUE)?; + *ctx = CUcontext(0xDEADBEEFu32 as _); + cuda_types::cuda::CUresult::SUCCESS + } + + unsafe extern "system" fn get_module_from_cubin_ext1( + result: *mut cuda_types::cuda::CUmodule, + fatbinc_wrapper: *const cuda_types::dark_api::FatbincWrapper, + arg3: *mut std::ffi::c_void, + arg4: *mut std::ffi::c_void, + arg5: u32, + ) -> cuda_types::cuda::CUresult { + unimplemented!() + } + + unsafe extern "system" fn cudart_interface_fn7(arg1: usize) -> () { + unimplemented!() + } + + unsafe extern "system" fn get_module_from_cubin_ext2( + fatbin_header: *const cuda_types::dark_api::FatbinHeader, + result: *mut cuda_types::cuda::CUmodule, + arg3: *mut std::ffi::c_void, + arg4: *mut std::ffi::c_void, + arg5: u32, + ) -> cuda_types::cuda::CUresult { + unimplemented!() + } + + unsafe extern "system" fn load_compilers() -> cuda_types::cuda::CUresult { + unimplemented!() + } + + unsafe extern "system" fn get_unknown_buffer1( + ptr: *mut *mut std::ffi::c_void, + size: *mut usize, + ) -> () { + *ptr = UNKNOWN_BUFFER1.buffer.get() as *mut std::ffi::c_void; + *size = UNKNOWN_BUFFER1.len(); + } + + unsafe extern "system" fn get_unknown_buffer2( + ptr: *mut *mut std::ffi::c_void, + size: *mut usize, + ) -> () { + *ptr = UNKNOWN_BUFFER2.buffer.get() as *mut std::ffi::c_void; + *size = UNKNOWN_BUFFER2.len(); + } + + unsafe extern "system" fn context_local_storage_put( + cu_ctx: cuda_types::cuda::CUcontext, + key: *mut std::ffi::c_void, + value: *mut std::ffi::c_void, + _dtor_cb: Option< + extern "system" fn( + cuda_types::cuda::CUcontext, + *mut std::ffi::c_void, + *mut std::ffi::c_void, + ), + >, + ) -> cuda_types::cuda::CUresult { + let cu_ctx = CONTEXT_STACK.with(|s| s.unwrap(cu_ctx))?; + ipc::Server::remote_call_zero_copy::( + Opcode::ContextLocalStoragePut, + ContextLocalStoragePutIn { + cu_ctx: cu_ctx.encode().into(), + key: (key as u32).into(), + value: (value as u32).into(), + }, + )?; + Ok(()) + } + + unsafe extern "system" fn context_local_storage_delete( + context: cuda_types::cuda::CUcontext, + key: *mut std::ffi::c_void, + ) -> cuda_types::cuda::CUresult { + unimplemented!() + } + + unsafe extern "system" fn context_local_storage_get( + value: *mut *mut std::ffi::c_void, + cu_ctx: cuda_types::cuda::CUcontext, + key: *mut std::ffi::c_void, + ) -> cuda_types::cuda::CUresult { + let value = unsafe { value.as_mut() }.ok_or(cuda_types::cuda::CUerror::INVALID_VALUE)?; + let cu_ctx = CONTEXT_STACK.with(|s| s.unwrap(cu_ctx))?; + *value = ipc::Server::remote_call_zero_copy::( + Opcode::ContextLocalStorageGet, + ContextLocalStorageGetIn { + cu_ctx: cu_ctx.encode().into(), + key: (key as u32).into(), + }, + )? + .value + .to_native() as _; + Ok(()) + } + + unsafe extern "system" fn ctx_create_v2_bypass( + pctx: *mut cuda_types::cuda::CUcontext, + flags: ::std::os::raw::c_uint, + dev: cuda_types::cuda::CUdevice, + ) -> cuda_types::cuda::CUresult { + cu_ctx_create_v2(pctx, flags, dev) + } + + unsafe extern "system" fn heap_alloc( + heap_alloc_record_ptr: *mut *const std::ffi::c_void, + arg2: usize, + arg3: usize, + ) -> cuda_types::cuda::CUresult { + let heap_alloc_record_ptr = heap_alloc_record_ptr as *mut *mut AllocRecord; + let alloc_record = Box::into_raw(Box::new(AllocRecord { x: arg2, y: arg3 })); + *heap_alloc_record_ptr = alloc_record; + Ok(()) + } + + unsafe extern "system" fn heap_free( + heap_alloc_record_ptr: *const std::ffi::c_void, + arg2: *mut usize, + ) -> cuda_types::cuda::CUresult { + let heap_alloc_record_ptr = heap_alloc_record_ptr as *mut AllocRecord; + let record = Box::from_raw(heap_alloc_record_ptr); + if !arg2.is_null() { + *arg2 = record.y; + } + Ok(()) + } + + unsafe extern "system" fn device_get_attribute_ext( + dev: cuda_types::cuda::CUdevice, + attribute: std::ffi::c_uint, + unknown: std::ffi::c_int, + result: *mut [usize; 2], + ) -> cuda_types::cuda::CUresult { + unimplemented!() + } + + unsafe extern "system" fn device_get_something( + result: *mut std::ffi::c_uchar, + dev: cuda_types::cuda::CUdevice, + ) -> cuda_types::cuda::CUresult { + unimplemented!() + } + + unsafe extern "system" fn integrity_check( + version: u32, + unix_seconds: u64, + result: *mut [u64; 2], + ) -> cuda_types::cuda::CUresult { + unimplemented!() + } + + unsafe extern "system" fn context_check( + ctx_in: cuda_types::cuda::CUcontext, + result1: *mut u32, + result2: *mut *const std::ffi::c_void, + ) -> cuda_types::cuda::CUresult { + unimplemented!() + } + + unsafe extern "system" fn check_fn3() -> u32 { + unimplemented!() + } + + unsafe extern "system" fn hybrid_runtime_load_get_proc_address( + name: *const std::ffi::c_char, + fn_ptr: *mut *const std::ffi::c_void, + token: *mut usize, + ) -> cuda_types::cuda::CUresult { + unimplemented!() + } + + unsafe extern "system" fn hybrid_runtime_free(token: usize) -> cuda_types::cuda::CUresult { + unimplemented!() + } +} diff --git a/zluda64_server/Cargo.toml b/zluda64_server/Cargo.toml new file mode 100644 index 000000000..a36c1d579 --- /dev/null +++ b/zluda64_server/Cargo.toml @@ -0,0 +1,23 @@ +[package] +name = "zluda64_server" +version = "0.0.0" +authors = ["Andrzej Janik "] +edition = "2021" + +[[bin]] +name = "zluda64_server" +path = "src/main.rs" + +[dependencies] +cuda_types = { path = "../cuda_types" } +cuda_macros = { path = "../cuda_macros" } +zluda_server_common = { path = "../zluda_server_common" } +dark_api = { path = "../dark_api" } +windows-sys = { version = "0.61.2", features = ["Win32_Foundation"] } +compio = { version = "0.18.0", features = ["macros", "fs"] } +slab = "0.4.12" +bincode = "2.0.1" +rkyv = "0.8.15" + +[package.metadata.zluda] +windows_only = true diff --git a/zluda64_server/src/main.rs b/zluda64_server/src/main.rs new file mode 100644 index 000000000..6aadad627 --- /dev/null +++ b/zluda64_server/src/main.rs @@ -0,0 +1,504 @@ +// Prevent the console window from appearing when running the server on Windows +#![windows_subsystem = "windows"] + +use compio::{ + buf::{buf_try, IoBuf, IoBufMut, ReserveError, ReserveExactError, SetLen}, + fs::named_pipe::{ClientOptions, NamedPipeClient}, + io::{AsyncRead, AsyncReadExt, AsyncReadManaged, AsyncWrite, AsyncWriteExt}, + BufResult, +}; +use cuda_macros::cuda_function_declarations; +use cuda_types::cuda::*; +use rkyv::{ + api::high::HighSerializer, + rend::{u32_le, u64_le}, + ser::allocator::ArenaHandle, + util::AlignedVec, + Archive, Portable, Serialize, +}; +use slab::Slab; +use std::{ + io::{self, Write}, + mem, ptr, +}; +use windows_sys::Win32::Foundation::ERROR_MORE_DATA; +use zluda_server_common::*; + +struct State { + handles: Slab, + dark_api: dark_api::cuda::ContextLocalStorageInterfaceV0301, +} + +impl State { + fn new() -> Result { + unsafe { cuInit(0) }?; + let mut table_ptr = std::ptr::null(); + unsafe { + cuGetExportTable( + &mut table_ptr, + &dark_api::cuda::ContextLocalStorageInterfaceV0301::GUID, + ) + }?; + let dark_api = unsafe { dark_api::cuda::ContextLocalStorageInterfaceV0301::new(table_ptr) }; + Ok(Self { + handles: Slab::new(), + dark_api, + }) + } + + fn insert(&mut self, handle: *mut T) -> u32 { + (self.handles.insert(handle as usize) as u32) + 1 + } + + fn get(&self, id: u32) -> Result<*mut T, CUerror> { + if id == 0 { + return Err(CUerror::INVALID_VALUE); + } + self.handles + .get((id - 1) as usize) + .map(|&handle| handle as *mut T) + .ok_or(CUerror::INVALID_VALUE) + } +} + +#[compio::main] +async fn main() -> std::io::Result<()> { + let pipe_name = std::env::args_os().nth(1).ok_or(std::io::Error::new( + std::io::ErrorKind::InvalidInput, + "Pipe name not provided", + ))?; + let mut client = ClientOptions::new() + .pipe_mode(compio::fs::named_pipe::PipeMode::Byte) + .read(true) + .write(true) + .open(pipe_name) + .await?; + let mut buffer = AlignedVecBuffer(AlignedVec::new()); + let mut state = State::new().map_err(|_| { + std::io::Error::new( + std::io::ErrorKind::Other, + "Failed to initialize CUDA context", + ) + })?; + loop { + let opcode = client.read_u32_le().await?; // Read the length prefix + buffer.clear(); + match Opcode::from_repr(opcode) { + Some(Opcode::cuInit) => { + buffer = handle_cuda_function::( + &mut client, + buffer, + cu_init, + ) + .await?; + } + Some(Opcode::cuDeviceGetCount) => { + buffer = handle_cuda_function::( + &mut client, + buffer, + cu_device_get_count, + ) + .await?; + } + Some(Opcode::cuDeviceGetAttribute) => { + buffer = handle_cuda_function::< + ArchivedcuDeviceGetAttributeIn, + cuDeviceGetAttributeOut, + >(&mut client, buffer, cu_device_get_attribute) + .await?; + } + Some(Opcode::cuDeviceGet) => { + buffer = handle_cuda_function::( + &mut client, + buffer, + cu_device_get, + ) + .await?; + } + Some(Opcode::cuCtxCreate_v2) => { + buffer = handle_cuda_function::( + &mut client, + buffer, + |input| cu_ctx_create_v2(input, &mut state), + ) + .await?; + } + Some(Opcode::cuDriverGetVersion) => { + buffer = + handle_cuda_function::( + &mut client, + buffer, + cu_driver_get_version, + ) + .await?; + } + Some(Opcode::cuDeviceGetName) => { + buffer = + handle_cuda_function_framed::( + &mut client, + buffer, + cu_device_get_name, + ) + .await?; + } + Some(Opcode::cuDeviceTotalMem_v2) => { + buffer = handle_cuda_function::< + ArchivedcuDeviceTotalMem_v2In, + cuDeviceTotalMem_v2Out, + >(&mut client, buffer, cu_device_total_mem_v2) + .await?; + } + Some(Opcode::ContextLocalStoragePut) => { + buffer = handle_cuda_function::< + ArchivedContextLocalStoragePutIn, + ContextLocalStoragePutOut, + >(&mut client, buffer, |input| { + context_local_storage_put(&mut state, input) + }) + .await?; + } + Some(Opcode::ContextLocalStorageGet) => { + buffer = handle_cuda_function::< + ArchivedContextLocalStorageGetIn, + ContextLocalStorageGetOut, + >(&mut client, buffer, |input| { + context_local_storage_get(&mut state, input) + }) + .await?; + } + Some(Opcode::cuCtxGetApiVersion) => { + buffer = + handle_cuda_function::( + &mut client, + buffer, + |input| cu_ctx_get_api_version(&mut state, input), + ) + .await?; + } + _ => { + client.write_u32_le(CUerror::NOT_SUPPORTED.0.get()).await?; + return Err(std::io::Error::new( + std::io::ErrorKind::Other, + "Unsupported operation", + )); + } + } + } +} + +fn cu_init(input: &ArchivedcuInitIn) -> Result { + unsafe { cuInit(input.Flags.to_native()) }?; + Ok(cuInitOut {}) +} + +fn cu_device_get_count( + _input: &ArchivedcuDeviceGetCountIn, +) -> Result { + let mut count = 0; + unsafe { cuDeviceGetCount(&mut count) }?; + Ok(cuDeviceGetCountOut { count }) +} + +fn cu_device_get_attribute( + input: &ArchivedcuDeviceGetAttributeIn, +) -> Result { + let mut pi = 0; + unsafe { + cuDeviceGetAttribute( + &mut pi, + CUdevice_attribute_enum(input.attrib.to_native()), + input.dev.to_native(), + ) + }?; + Ok(cuDeviceGetAttributeOut { pi }) +} + +fn cu_device_get(input: &ArchivedcuDeviceGetIn) -> Result { + let mut device = 0; + unsafe { cuDeviceGet(&mut device, input.ordinal.to_native()) }?; + Ok(cuDeviceGetOut { device }) +} + +fn cu_device_get_name(input: &ArchivedcuDeviceGetNameIn) -> Result { + let mut name = vec![0u8; input.len.to_native() as usize]; + unsafe { + cuDeviceGetName( + name.as_mut_ptr().cast(), + input.len.to_native(), + input.dev.to_native(), + ) + }?; + if let Some(pos) = name.iter().copied().position(|c| c == 0) { + name.truncate(pos); + } + Ok(cuDeviceGetNameOut { name }) +} + +fn cu_ctx_create_v2( + input: &ArchivedcuCtxCreate_v2In, + state: &mut State, +) -> Result { + let mut pctx = unsafe { mem::zeroed() }; + unsafe { cuCtxCreate_v2(&mut pctx, input.flags.to_native(), input.dev.to_native()) }?; + let pctx = state.insert(pctx.0); + Ok(cuCtxCreate_v2Out { pctx }) +} + +fn cu_device_total_mem_v2( + input: &ArchivedcuDeviceTotalMem_v2In, +) -> Result { + let mut bytes = 0usize; + unsafe { cuDeviceTotalMem_v2(&mut bytes, input.dev.to_native()) }?; + Ok(cuDeviceTotalMem_v2Out { + bytes: u64_le::from_native(bytes as u64), + }) +} + +fn cu_driver_get_version( + _input: &ArchivedcuDriverGetVersionIn, +) -> Result { + let mut driver_version = 0; + unsafe { cuDriverGetVersion(&mut driver_version) }?; + Ok(cuDriverGetVersionOut { + driverVersion: driver_version, + }) +} + +fn cu_ctx_get_api_version( + state: &mut State, + input: &ArchivedcuCtxGetApiVersionIn, +) -> Result { + let ctx = CUcontext(state.get(input.ctx.to_native())?); + let mut version = 0; + unsafe { cuCtxGetApiVersion(ctx, &mut version) }?; + Ok(cuCtxGetApiVersionOut { version }) +} + +fn context_local_storage_put( + state: &mut State, + input: &ArchivedContextLocalStoragePutIn, +) -> Result { + unsafe { + state.dark_api.context_local_storage_put( + CUcontext(state.get(input.cu_ctx.to_native())?), + input.key.to_native() as _, + input.value.to_native() as _, + None, + ) + }?; + Ok(ContextLocalStoragePutOut {}) +} + +fn context_local_storage_get( + state: &mut State, + input: &ArchivedContextLocalStorageGetIn, +) -> Result { + let mut value = ptr::null_mut(); + unsafe { + state.dark_api.context_local_storage_get( + &mut value, + CUcontext(state.get(input.cu_ctx.to_native())?), + input.key.to_native() as _, + ) + }?; + Ok(ContextLocalStorageGetOut { + value: u32_le::from_native(value as u32), + }) +} + +async fn handle_cuda_function( + client: &mut NamedPipeClient, + mut buffer: AlignedVecBuffer, + handler: impl FnOnce(&In) -> Result, +) -> std::io::Result +where + Out: for<'a, 'b> Serialize< + HighSerializer<&'a mut AlignedVec, ArenaHandle<'b>, rkyv::rancor::Failure>, + >, +{ + buffer = read_all::(buffer, client).await?; + let input = unsafe { rkyv::access_unchecked::(buffer.as_init()) }; + match handler(input) { + Ok(output) => { + buffer.clear(); + client.write_u32_le(0).await?; + rkyv::api::high::to_bytes_in::<_, rkyv::rancor::Failure>(&output, &mut buffer.0) + .map_err(|_| { + std::io::Error::new(std::io::ErrorKind::Other, "Failed to serialize response") + })?; + let ((), new_buffer) = buf_try!(@try client.write_all(buffer).await); + Ok(new_buffer) + } + Err(e) => { + client.write_u32_le(e.0.get()).await?; + Ok(buffer) + } + } +} + +async fn handle_cuda_function_framed( + client: &mut NamedPipeClient, + mut buffer: AlignedVecBuffer, + handler: impl FnOnce(&In) -> Result, +) -> std::io::Result +where + Out: for<'a, 'b> Serialize< + HighSerializer<&'a mut AlignedVec, ArenaHandle<'b>, rkyv::rancor::Failure>, + >, +{ + buffer = read_all::(buffer, client).await?; + let input = unsafe { rkyv::access_unchecked::(buffer.as_init()) }; + match handler(input) { + Ok(output) => { + buffer.clear(); + rkyv::api::high::to_bytes_in::<_, rkyv::rancor::Failure>(&output, &mut buffer.0) + .map_err(|_| { + std::io::Error::new(std::io::ErrorKind::Other, "Failed to serialize response") + })?; + let code_and_len = unsafe { + std::mem::transmute::<(u32, u32), [u8; 8]>((0u32, buffer.0.len() as u32)) + }; + client.write_all(code_and_len).await.0?; + let ((), new_buffer) = buf_try!(@try client.write_all(buffer).await); + Ok(new_buffer) + } + Err(e) => { + client.write_u32_le(e.0.get()).await?; + Ok(buffer) + } + } +} + +async fn read_all( + mut buffer: AlignedVecBuffer, + client: &mut NamedPipeClient, +) -> std::io::Result { + let mut remaining_read = mem::size_of::(); + buffer.clear(); + buffer.reserve(remaining_read)?; + while remaining_read > 0 { + let BufResult(read_result, new_buffer) = client.append(buffer).await; + let n = read_result?; + remaining_read = remaining_read.checked_sub(n).ok_or_else(|| { + std::io::Error::new( + std::io::ErrorKind::InvalidData, + "Read more bytes than expected", + ) + })?; + buffer = new_buffer; + } + Ok(buffer) +} + +struct AlignedVecBuffer(AlignedVec); + +impl AlignedVecBuffer { + fn clear(&mut self) { + self.0.clear(); + } +} + +impl IoBuf for AlignedVecBuffer { + fn as_init(&self) -> &[u8] { + self.0.as_slice() + } +} + +impl SetLen for AlignedVecBuffer { + unsafe fn set_len(&mut self, len: usize) { + unsafe { self.0.set_len(len) } + } +} + +impl IoBufMut for AlignedVecBuffer { + fn as_uninit(&mut self) -> &mut [std::mem::MaybeUninit] { + let ptr = self.0.as_mut_ptr() as *mut std::mem::MaybeUninit; + let cap = self.0.capacity(); + unsafe { std::slice::from_raw_parts_mut(ptr, cap) } + } + + fn reserve(&mut self, len: usize) -> Result<(), ReserveError> { + self.0.reserve(len); + Ok(()) + } + + fn reserve_exact(&mut self, len: usize) -> Result<(), ReserveExactError> { + if self.0.capacity() - self.0.len() >= len { + return Ok(()); + } + + self.0.reserve_exact(len); + + if self.0.capacity() - self.0.len() != len { + return Err(ReserveExactError::ExactSizeMismatch { + reserved: self.0.capacity() - self.0.len(), + expected: len, + }); + } + Ok(()) + } +} + +macro_rules! nop { + ($($abi:literal fn $fn_name:ident( $($arg_id:ident : $arg_type:ty),* ) -> $ret_type:ty;)*) => {}; +} + +macro_rules! implemented { + ($($abi:literal fn $fn_name:ident( $($arg_id:ident : $arg_type:ty),* ) -> $ret_type:ty;)*) => { + $( + #[link(name = "nvcuda", kind = "raw-dylib")] + unsafe extern $abi { + fn $fn_name ( $( $arg_id : $arg_type),* ) -> $ret_type; + } + )* + + }; +} + +cuda_function_declarations! { + nop, + implemented <= [ + cuCtxCreate_v2, + // cuCtxDetach, + cuCtxGetApiVersion, + // cuCtxGetCurrent, + // cuCtxGetDevice, + // cuCtxSynchronize, + // cuDeviceComputeCapability, + cuDeviceGet, + cuDeviceGetAttribute, + cuDeviceGetCount, + cuDeviceGetName, + // cuDeviceGetProperties, + cuDeviceTotalMem_v2, + cuDriverGetVersion, + // cuEventCreate, + // cuEventDestroy_v2, + cuGetExportTable, + cuInit, + // cuLaunchKernel, + // cuMemAlloc_v2, + // cuMemFreeHost, + // cuMemFree_v2, + // cuMemGetAddressRange_v2, + // cuMemHostAlloc, + // cuMemcpyDtoDAsync_v2, + // cuMemcpyDtoHAsync_v2, + // cuMemcpyHtoDAsync_v2, + // cuMemsetD8_v2, + // cuModuleGetFunction, + // cuModuleGetGlobal_v2, + // cuModuleGetTexRef, + // cuStreamCreate, + // cuStreamDestroy_v2, + // cuTexRefSetAddressMode, + // cuTexRefSetAddress_v2, + // cuTexRefSetFilterMode, + // cuTexRefSetFlags, + // cuTexRefSetFormat, + // cuTexRefSetMaxAnisotropy, + // cuTexRefSetMipmapFilterMode, + // cuTexRefSetMipmapLevelBias, + // cuTexRefSetMipmapLevelClamp, + ] +} diff --git a/zluda_common/src/constants.rs b/zluda_common/src/constants.rs index 8d316211b..fb468e9bf 100644 --- a/zluda_common/src/constants.rs +++ b/zluda_common/src/constants.rs @@ -2,6 +2,7 @@ pub const PROJECT_SUFFIX: &[u8] = b" [ZLUDA]\0"; const COMPUTE_CAPABILITY_MAJOR: i32 = 8; const COMPUTE_CAPABILITY_MINOR: i32 = 8; +#[cfg(target_pointer_width = "64")] pub const BLAS_HANDLE_COOKIE: usize = 0x57c3fdb0fd72b08e; pub fn compute_capability() -> (i32, i32) { diff --git a/zluda_common/src/lib.rs b/zluda_common/src/lib.rs index 8b2c19b5a..02fa9817a 100644 --- a/zluda_common/src/lib.rs +++ b/zluda_common/src/lib.rs @@ -135,6 +135,7 @@ macro_rules! from_cuda_nop { macro_rules! from_cuda_transmute { ($($from:ty => $to:ty),*) => { $( + #[cfg(target_pointer_width = "64")] impl<'a, E: CudaErrorType> FromCuda<'a, $from, E> for $to { fn from_cuda(x: &'a $from) -> Result { Ok(unsafe { std::mem::transmute(*x) }) diff --git a/zluda_inject/Cargo.toml b/zluda_inject/Cargo.toml index a334ded57..a8bd44775 100644 --- a/zluda_inject/Cargo.toml +++ b/zluda_inject/Cargo.toml @@ -13,7 +13,6 @@ windows = { version = "0.62.2", features = [ "Win32_Foundation", "Win32_System_Threading", "Win32_Security", - "Win32_System_JobObjects", "Win32_System_Diagnostics_Debug", "Win32_System_LibraryLoader", ] } @@ -34,3 +33,4 @@ zluda_ml = { path = "../zluda_ml" } [package.metadata.zluda] windows_only = true +32bit = true diff --git a/zluda_inject/src/bin.rs b/zluda_inject/src/bin.rs index a75ee40f6..dd571fbe1 100644 --- a/zluda_inject/src/bin.rs +++ b/zluda_inject/src/bin.rs @@ -7,10 +7,6 @@ use std::ffi::{CString, OsStr}; use std::path::PathBuf; use std::{env, mem, process, ptr}; use windows::Win32::Foundation::{HANDLE, WAIT_FAILED}; -use windows::Win32::System::JobObjects::{ - AssignProcessToJobObject, JobObjectExtendedLimitInformation, SetInformationJobObject, - JOBOBJECT_EXTENDED_LIMIT_INFORMATION, JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE, -}; use windows::Win32::System::Threading::{ self, GetExitCodeProcess, ResumeThread, WaitForSingleObject, CREATE_SUSPENDED, CREATE_UNICODE_ENVIRONMENT, @@ -69,7 +65,7 @@ pub fn main_impl() -> Result<(), Box> { Option::None ) }; - kill_child_on_process_exit(proc_info.hProcess)?; + zluda_windows::kill_child_on_process_exit(proc_info.hProcess)?; injection_env.copy_payloads_to_process(proc_info.hProcess)?; os_call! { ResumeThread(HANDLE(proc_info.hThread)), |x| x == -1i32 as u32 }; os_call! { WaitForSingleObject(HANDLE(proc_info.hProcess), Threading::INFINITE), |x| x == WAIT_FAILED }; @@ -338,19 +334,3 @@ impl InjectionConfig { Ok(result.into_vec()) } } - -fn kill_child_on_process_exit(child: detours_sys::HANDLE) -> Result<(), Box> { - let job_handle = unsafe { windows::Win32::System::JobObjects::CreateJobObjectA(None, None) }?; - let mut info = JOBOBJECT_EXTENDED_LIMIT_INFORMATION::default(); - info.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE; - unsafe { - SetInformationJobObject( - job_handle, - JobObjectExtendedLimitInformation, - &mut info as *mut _ as *mut _, - size_of_val(&info) as u32, - ) - }?; - unsafe { AssignProcessToJobObject(job_handle, HANDLE(child)) }?; - Ok(()) -} diff --git a/zluda_redirect/Cargo.toml b/zluda_redirect/Cargo.toml index e216fd7b2..9133e6567 100644 --- a/zluda_redirect/Cargo.toml +++ b/zluda_redirect/Cargo.toml @@ -36,3 +36,4 @@ rustc-hash = "2.0.0" [package.metadata.zluda] windows_only = true +32bit = true diff --git a/zluda_server_common/Cargo.toml b/zluda_server_common/Cargo.toml new file mode 100644 index 000000000..21d395b4f --- /dev/null +++ b/zluda_server_common/Cargo.toml @@ -0,0 +1,16 @@ +[package] +name = "zluda_server_common" +version = "0.0.0" +authors = ["Andrzej Janik "] +edition = "2021" + +[dependencies] +cuda_types = { path = "../cuda_types" } +cuda_macros = { path = "../cuda_macros" } +bitcode = "0.6.9" +paste = "1" +postcard = "1.1.3" +bincode = "2.0.1" +rkyv = "0.8.15" +strum = "0.28" +strum_macros = "0.28" diff --git a/zluda_server_common/src/lib.rs b/zluda_server_common/src/lib.rs new file mode 100644 index 000000000..4c1880d64 --- /dev/null +++ b/zluda_server_common/src/lib.rs @@ -0,0 +1,216 @@ +use bincode::{Decode, Encode}; +use cuda_macros::{cuda_function_declarations, generate_input_struct, generate_output_struct}; +use cuda_types::cuda::*; +use paste::paste; +use rkyv::rend::{u32_le, u64_le}; +use rkyv::{rend, Archive, Deserialize, Portable, Serialize}; +use std::ffi::CString; +use std::num::NonZeroU32; +use std::{ffi::CStr, num::NonZero}; +use strum_macros::FromRepr; + +macro_rules! noop { + ($($abi:literal fn $fn_name:ident( $($arg_id:ident : $arg_type:ty),* ) -> $ret_type:ty;)*) => {}; +} + +macro_rules! generate_messages_inout { + ($($abi:literal fn $fn_name:ident( $($arg_id:ident : $arg_type:ty),* ) -> $ret_type:ty;)*) => { + $( + generate_input_struct!($fn_name, $($arg_id : $arg_type),*); + generate_output_struct!($fn_name, $($arg_id : $arg_type),*); + )* + + #[repr(u32)] + #[derive(FromRepr)] + pub enum Opcode { + System = 0, + $( + $fn_name, + )* + cuDeviceGetName, + cuDeviceTotalMem_v2, + ContextLocalStoragePut, + ContextLocalStorageGet, + } + }; +} + +macro_rules! generate_messages_in { + ($($abi:literal fn $fn_name:ident( $($arg_id:ident : $arg_type:ty),* ) -> $ret_type:ty;)*) => { + $( + generate_input_struct!($fn_name, $($arg_id : $arg_type),*); + )* + }; +} + +cuda_function_declarations! { + noop, + generate_messages_inout <= [ + cuCtxCreate_v2, + cuCtxDetach, + cuCtxGetApiVersion, + cuCtxGetCurrent, + cuCtxGetDevice, + cuCtxSynchronize, + cuDeviceComputeCapability, + cuDeviceGet, + cuDeviceGetAttribute, + cuDeviceGetCount, + cuDeviceGetProperties, + cuDriverGetVersion, + cuEventCreate, + cuEventDestroy_v2, + //cuGetExportTable, + cuInit, + //cuLaunchKernel, + // cuMemAlloc_v2, + //cuMemFreeHost, + //cuMemFree_v2, + // cuMemGetAddressRange_v2, + //cuMemHostAlloc, + //cuMemcpyDtoDAsync_v2, + //cuMemcpyDtoHAsync_v2, + //cuMemcpyHtoDAsync_v2, + // cuMemsetD8_v2, + // cuModuleGetFunction, + // cuModuleGetGlobal_v2, + // cuModuleGetTexRef, + cuStreamCreate, + cuStreamDestroy_v2, + cuTexRefSetAddressMode, + // cuTexRefSetAddress_v2, + cuTexRefSetFilterMode, + cuTexRefSetFlags, + cuTexRefSetFormat, + cuTexRefSetMaxAnisotropy, + cuTexRefSetMipmapFilterMode, + cuTexRefSetMipmapLevelBias, + cuTexRefSetMipmapLevelClamp, + ], + generate_messages_in <= [ + cuDeviceGetName, + cuDeviceTotalMem_v2 + ] +} + +pub trait CudaEncode: Copy { + type WireObject; + fn encode(self) -> Self::WireObject; + fn decode(o: Self::WireObject) -> Self; +} + +macro_rules! encode_as_self { + ($type_:ty) => { + impl CudaEncode for $type_ { + type WireObject = Self; + fn encode(self) -> Self { + self + } + fn decode(o: Self::WireObject) -> Self { + o + } + } + }; +} + +macro_rules! encode_as_proxy { + ($type_:ty, $proxy_type:ty) => { + impl CudaEncode for $type_ { + type WireObject = $proxy_type; + fn encode(self) -> $proxy_type { + unsafe { std::mem::transmute::(self) } + } + fn decode(o: Self::WireObject) -> Self { + unsafe { std::mem::transmute::<$proxy_type, Self>(o) } + } + } + }; +} + +macro_rules! encode_as_u32 { + ($type_:ty) => { + impl CudaEncode for $type_ { + type WireObject = u32; + fn encode(self) -> u32 { + unsafe { std::mem::transmute_copy::(&self) } + } + fn decode(o: Self::WireObject) -> Self { + unsafe { std::mem::transmute_copy::(&o) } + } + } + }; +} + +encode_as_self!(u8); +encode_as_self!(i8); +encode_as_self!(u32); +encode_as_self!(i32); +encode_as_self!(f32); + +encode_as_proxy!(CUdevprop_v1, CUdevprop_v1_Wire); +encode_as_proxy!(CUdevice_attribute, u32); +encode_as_proxy!(CUfilter_mode, u32); +encode_as_proxy!(CUaddress_mode, u32); +encode_as_proxy!(CUarray_format, u32); + +encode_as_u32!(CUcontext); +encode_as_u32!(CUdeviceptr_v2); +encode_as_u32!(CUevent); +encode_as_u32!(CUfunction); +encode_as_u32!(CUmodule); +encode_as_u32!(CUstream); +encode_as_u32!(CUtexref); + +#[repr(C)] +#[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct CUdevprop_v1_Wire { + pub maxThreadsPerBlock: ::core::ffi::c_int, + pub maxThreadsDim: [::core::ffi::c_int; 3usize], + pub maxGridSize: [::core::ffi::c_int; 3usize], + pub sharedMemPerBlock: ::core::ffi::c_int, + pub totalConstantMemory: ::core::ffi::c_int, + pub SIMDWidth: ::core::ffi::c_int, + pub memPitch: ::core::ffi::c_int, + pub regsPerBlock: ::core::ffi::c_int, + pub clockRate: ::core::ffi::c_int, + pub textureAlign: ::core::ffi::c_int, +} + +unsafe impl Portable for CUdevprop_v1_Wire {} + +#[repr(C)] +#[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct cuDeviceGetNameOut { + pub name: Vec, +} + +#[repr(C)] +#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct cuDeviceTotalMem_v2Out { + pub bytes: u64_le, +} + +#[repr(C)] +#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct ContextLocalStoragePutIn { + pub cu_ctx: u32_le, + pub key: u32_le, + pub value: u32_le, +} + +#[repr(C)] +#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct ContextLocalStoragePutOut {} + +#[repr(C)] +#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct ContextLocalStorageGetIn { + pub cu_ctx: u32_le, + pub key: u32_le, +} + +#[repr(C)] +#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct ContextLocalStorageGetOut { + pub value: u32_le, +} diff --git a/zluda_trace/Cargo.toml b/zluda_trace/Cargo.toml index d36cb1cb1..decfa48f7 100644 --- a/zluda_trace/Cargo.toml +++ b/zluda_trace/Cargo.toml @@ -9,15 +9,14 @@ name = "zluda_trace" crate-type = ["cdylib"] [dependencies] -ptx = { path = "../ptx" } ptx_parser = { path = "../ptx_parser" } zluda_trace_common = { path = "../zluda_trace_common" } zluda_common = { path = "../zluda_common" } format = { path = "../format" } dark_api = { path = "../dark_api" } regex = "1.4" -dynasm = "1.2" -dynasmrt = "1.2" +dynasm = "5.0" +dynasmrt = "5.0" # we don't need elf32, but goblin has a bug where elf64 does not build without elf32 goblin = { version = "0.9", default-features = false, features = [ "elf64", @@ -52,3 +51,4 @@ linux_symlinks = [ "trace_nvidia/libcuda.so.1", ] windows_paths = ["trace/nvcuda.dll"] +32bit = true diff --git a/zluda_trace/src/lib.rs b/zluda_trace/src/lib.rs index b813f631e..967387497 100644 --- a/zluda_trace/src/lib.rs +++ b/zluda_trace/src/lib.rs @@ -147,13 +147,19 @@ struct InternalTableImpl; impl ::dark_api::zluda_trace::CudaDarkApi for InternalTableImpl { unsafe extern "system" fn logged_call( fn_name: cglue::slice::CSliceRef<'static, u8>, + nvapi_interface: u32, args: ::dark_api::FnFfiRef<::dark_api::ByteVecFfi>, fn_: ::dark_api::FnFfiRef, internal_error: usize, format_status: extern "C" fn(usize) -> ::dark_api::ByteVecFfi, ) -> usize { + let fn_name = if nvapi_interface == 0 { + CudaFunctionName::Normal(unsafe { fn_name.into_str() }) + } else { + CudaFunctionName::Nvapi(nvapi_interface) + }; GlobalState2::under_lock( - CudaFunctionName::Normal(unsafe { fn_name.into_str() }), + fn_name, Some(|| args.call().to_vec()), internal_error, |status| format_status(status).to_vec(), diff --git a/zluda_trace/src/log.rs b/zluda_trace/src/log.rs index 5915f1938..023d7979d 100644 --- a/zluda_trace/src/log.rs +++ b/zluda_trace/src/log.rs @@ -236,6 +236,7 @@ impl Write for WriteBuffer { pub(crate) enum CudaFunctionName { Normal(&'static str), Dark { guid: CUuuid, index: usize }, + Nvapi(u32) } impl Display for CudaFunctionName { @@ -257,6 +258,9 @@ impl Display for CudaFunctionName { } } } + CudaFunctionName::Nvapi(interface) => { + write!(f, "{{nvapi:{:#010x}}}", interface) + } } } } diff --git a/zluda_trace_blas/src/lib.rs b/zluda_trace_blas/src/lib.rs index b1bc28fdc..0ef7600eb 100644 --- a/zluda_trace_blas/src/lib.rs +++ b/zluda_trace_blas/src/lib.rs @@ -35,6 +35,7 @@ macro_rules! unimplemented { }); ReprUsize::from_usize(export_table.logged_call( cglue::slice::CSliceRef::from_str(stringify!($fn_name)), + 0, cglue::trait_obj!(&format_args as dark_api::FnFfi), cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), internal_error_untyped, diff --git a/zluda_trace_blaslt/src/lib.rs b/zluda_trace_blaslt/src/lib.rs index 5202a79dc..e1c4b1f1a 100644 --- a/zluda_trace_blaslt/src/lib.rs +++ b/zluda_trace_blaslt/src/lib.rs @@ -35,6 +35,7 @@ macro_rules! unimplemented { }); ReprUsize::from_usize(export_table.logged_call( cglue::slice::CSliceRef::from_str(stringify!($fn_name)), + 0, cglue::trait_obj!(&format_args as dark_api::FnFfi), cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), internal_error_untyped, diff --git a/zluda_trace_dnn8/src/lib.rs b/zluda_trace_dnn8/src/lib.rs index 6e98a384b..f0ebd0402 100644 --- a/zluda_trace_dnn8/src/lib.rs +++ b/zluda_trace_dnn8/src/lib.rs @@ -35,6 +35,7 @@ macro_rules! unimplemented { }); ReprUsize::from_usize(export_table.logged_call( cglue::slice::CSliceRef::from_str(stringify!($fn_name)), + 0, cglue::trait_obj!(&format_args as dark_api::FnFfi), cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), internal_error_untyped, diff --git a/zluda_trace_dnn9/src/lib.rs b/zluda_trace_dnn9/src/lib.rs index 5989ccb3a..96e1a7536 100644 --- a/zluda_trace_dnn9/src/lib.rs +++ b/zluda_trace_dnn9/src/lib.rs @@ -35,6 +35,7 @@ macro_rules! unimplemented { }); ReprUsize::from_usize(export_table.logged_call( cglue::slice::CSliceRef::from_str(stringify!($fn_name)), + 0, cglue::trait_obj!(&format_args as dark_api::FnFfi), cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), internal_error_untyped, diff --git a/zluda_trace_fft/src/lib.rs b/zluda_trace_fft/src/lib.rs index dbedc29fd..ca1f83881 100644 --- a/zluda_trace_fft/src/lib.rs +++ b/zluda_trace_fft/src/lib.rs @@ -35,6 +35,7 @@ macro_rules! unimplemented { }); ReprUsize::from_usize(export_table.logged_call( cglue::slice::CSliceRef::from_str(stringify!($fn_name)), + 0, cglue::trait_obj!(&format_args as dark_api::FnFfi), cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), internal_error_untyped, diff --git a/zluda_trace_nvml/src/lib.rs b/zluda_trace_nvml/src/lib.rs index 4eed6940f..8fe8b5b51 100644 --- a/zluda_trace_nvml/src/lib.rs +++ b/zluda_trace_nvml/src/lib.rs @@ -35,6 +35,7 @@ macro_rules! unimplemented { }); ReprUsize::from_usize(export_table.logged_call( cglue::slice::CSliceRef::from_str(stringify!($fn_name)), + 0, cglue::trait_obj!(&format_args as dark_api::FnFfi), cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), internal_error_untyped, diff --git a/zluda_trace_sparse/src/lib.rs b/zluda_trace_sparse/src/lib.rs index 44a286d0c..2e2d7683a 100644 --- a/zluda_trace_sparse/src/lib.rs +++ b/zluda_trace_sparse/src/lib.rs @@ -35,6 +35,7 @@ macro_rules! unimplemented { }); ReprUsize::from_usize(export_table.logged_call( cglue::slice::CSliceRef::from_str(stringify!($fn_name)), + 0, cglue::trait_obj!(&format_args as dark_api::FnFfi), cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), internal_error_untyped, diff --git a/zluda_windows/src/lib.rs b/zluda_windows/src/lib.rs index c9d482e70..26ba82846 100644 --- a/zluda_windows/src/lib.rs +++ b/zluda_windows/src/lib.rs @@ -13,11 +13,19 @@ use widestring::{u16str, U16Str, U16String}; use windows::{ core::{w, HRESULT, PCWSTR}, Win32::{ - Foundation::{HINSTANCE, HMODULE, HWND, LPARAM, S_OK, WPARAM}, - System::LibraryLoader::{ - GetModuleFileNameA, GetModuleFileNameW, GetModuleHandleExW, LoadLibraryExW, - GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, - LOAD_LIBRARY_SEARCH_DEFAULT_DIRS, LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR, + Foundation::{HANDLE, HINSTANCE, HMODULE, HWND, LPARAM, S_OK, WPARAM}, + System::{ + JobObjects::{ + AssignProcessToJobObject, JobObjectExtendedLimitInformation, + SetInformationJobObject, JOBOBJECT_EXTENDED_LIMIT_INFORMATION, + JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE, + }, + LibraryLoader::{ + GetModuleFileNameA, GetModuleFileNameW, GetModuleHandleExW, LoadLibraryExW, + GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, + GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, LOAD_LIBRARY_SEARCH_DEFAULT_DIRS, + LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR, + }, }, UI::{ Controls::{ @@ -30,9 +38,13 @@ use windows::{ }, }; -pub static LIBRARIES: [LibraryInfo; 16] = [ +#[cfg(target_pointer_width = "32")] +pub static LIBRARIES: [LibraryInfo; 2] = [NVCUDA, NVAPI]; + +#[cfg(target_pointer_width = "64")] +pub static LIBRARIES: [LibraryInfo; 17] = [ NVCUDA, NVML, DNN8, DNN9, BLAS13, BLAS12, BLAS11, BLAS_LT13, BLAS_LT12, BLAS_LT11, SPARSE12, - SPARSE11, SPARSE10, FFT12, FFT11, FFT10, + SPARSE11, SPARSE10, FFT12, FFT11, FFT10, NVAPI, ]; pub const NVCUDA: LibraryInfo = LibraryInfo { @@ -195,6 +207,22 @@ pub const FFT10: LibraryInfo = LibraryInfo { in_system32: false, }; +pub const NVAPI: LibraryInfo = LibraryInfo { + short_name: "nvapi", + is_alias: false, + #[cfg(target_pointer_width = "32")] + ascii_name: "nvapi.dll", + #[cfg(target_pointer_width = "64")] + ascii_name: "nvapi64.dll", + #[cfg(target_pointer_width = "32")] + utf16_name: u16str!("nvapi.dll"), + #[cfg(target_pointer_width = "64")] + utf16_name: u16str!("nvapi64.dll"), + guid: uuid!("f7449ed6-d01c-4376-9fc4-446eb2e4cf70"), + trace_env_var: "ZLUDA_NVAPI_LIB", + in_system32: true, +}; + #[derive(Debug)] pub struct LibraryInfo { pub short_name: &'static str, @@ -583,6 +611,22 @@ pub fn get_module_path_utf16(hm: HMODULE) -> OsString { OsString::from_wide(&buffer) } +pub fn kill_child_on_process_exit(child: *mut c_void) -> windows::core::Result<()> { + let job_handle = unsafe { windows::Win32::System::JobObjects::CreateJobObjectA(None, None) }?; + let mut info = JOBOBJECT_EXTENDED_LIMIT_INFORMATION::default(); + info.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE; + unsafe { + SetInformationJobObject( + job_handle, + JobObjectExtendedLimitInformation, + &mut info as *mut _ as *mut _, + size_of_val(&info) as u32, + ) + }?; + unsafe { AssignProcessToJobObject(job_handle, HANDLE(child)) }?; + Ok(()) +} + #[cfg(test)] mod tests { use super::*; From 7e2991c46c853ad45d202e884b8bd47f63f7b2d1 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Sat, 16 May 2026 20:08:11 -0700 Subject: [PATCH 38/85] Load modules --- Cargo.lock | 2 + cuda_types/src/dark_api.rs | 2 + dark_api/src/fatbin.rs | 8 +- zluda/src/impl/module.rs | 2 +- zluda32/Cargo.toml | 2 + zluda32/src/ipc.rs | 29 +++++- zluda32/src/lib.rs | 52 ++++++++-- zluda64_server/src/main.rs | 171 ++++++++++++++++++++++----------- zluda_server_common/src/lib.rs | 29 ++++-- zluda_trace/src/trace.rs | 7 +- 10 files changed, 222 insertions(+), 82 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 1976b0fa8..ae4e52989 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -5660,8 +5660,10 @@ dependencies = [ "postcard", "rand 0.10.1", "rkyv", + "unwrap_or", "widestring", "windows 0.62.2", + "zluda_common", "zluda_server_common", "zluda_windows", ] diff --git a/cuda_types/src/dark_api.rs b/cuda_types/src/dark_api.rs index bb7b2cfbf..c73863efc 100644 --- a/cuda_types/src/dark_api.rs +++ b/cuda_types/src/dark_api.rs @@ -68,6 +68,8 @@ bitflags! { pub struct FatbinFileHeaderFlags: u64 { const Is64Bit = 0x0000000000000001; const Debug = 0x0000000000000002; + const CUDA = 0x0000000000000004; + const OpenCL = 0x0000000000000008; const Linux = 0x0000000000000010; const Mac = 0x0000000000000020; const Windows = 0x0000000000000040; diff --git a/dark_api/src/fatbin.rs b/dark_api/src/fatbin.rs index 9488499a2..06a64d86f 100644 --- a/dark_api/src/fatbin.rs +++ b/dark_api/src/fatbin.rs @@ -196,7 +196,10 @@ impl<'a> FatbinFile<'a> { std::slice::from_raw_parts(start, self.header.compressed_size as usize) } - pub unsafe fn get_or_decompress_content(self) -> Result, FatbinError> { + pub unsafe fn get_or_decompress_content( + self, + strip_trailing_zero: bool, + ) -> Result, FatbinError> { let mut payload = if self .header .flags @@ -212,9 +215,8 @@ impl<'a> FatbinFile<'a> { } else { Cow::Borrowed(unsafe { self.get_non_compressed_payload() }) }; - // Remove trailing zeros - if self.header.kind == FatbinFileHeader::HEADER_KIND_PTX { + if strip_trailing_zero && self.header.kind == FatbinFileHeader::HEADER_KIND_PTX { match payload { Cow::Borrowed(ref mut slice) => { while slice.last() == Some(&0) { diff --git a/zluda/src/impl/module.rs b/zluda/src/impl/module.rs index c49051ddd..fea972735 100644 --- a/zluda/src/impl/module.rs +++ b/zluda/src/impl/module.rs @@ -91,7 +91,7 @@ fn get_best_ptx_and_compile( if file.header.kind != FatbinFileHeader::HEADER_KIND_PTX { return; } - if let Ok(text) = file.get_or_decompress_content() { + if let Ok(text) = file.get_or_decompress_content(true) { if let Some(text) = cow_bytes_to_str(text) { ptx_modules.push(text); } diff --git a/zluda32/Cargo.toml b/zluda32/Cargo.toml index c8e8bfd6e..0b1dcb41c 100644 --- a/zluda32/Cargo.toml +++ b/zluda32/Cargo.toml @@ -10,6 +10,7 @@ crate-type = ["cdylib"] [dependencies] cuda_types = { path = "../cuda_types" } +zluda_common = { path = "../zluda_common" } cuda_macros = { path = "../cuda_macros" } zluda_windows = { path = "../zluda_windows" } zluda_server_common = { path = "../zluda_server_common" } @@ -34,6 +35,7 @@ bitcode = "0.6.9" postcard = "1.1.3" bincode = "2.0.1" rkyv = "0.8.15" +unwrap_or = "1.0.1" [package.metadata.zluda] windows_only = true diff --git a/zluda32/src/ipc.rs b/zluda32/src/ipc.rs index 7aff6c120..cfc71dd04 100644 --- a/zluda32/src/ipc.rs +++ b/zluda32/src/ipc.rs @@ -107,7 +107,34 @@ impl Server { Ok(output.clone()) } - pub(crate) fn remote_call_framed( + pub(crate) fn remote_call_framed_in( + opcode: Opcode, + data: impl for<'a, 'b> Serialize< + HighSerializer<&'a mut AlignedVec, ArenaHandle<'b>, rkyv::rancor::Failure>, + >, + ) -> Result { + let this = &mut *Self::get()?.lock().map_err(|_| CUerror::UNKNOWN)?; + this.buffer.clear(); + this.pipe + .write_all(&(opcode as u32).to_le_bytes()[..]) + .map_err(|_| CUerror::UNKNOWN)?; + let slice = + rkyv::api::high::to_bytes_in::<_, rkyv::rancor::Failure>(&data, &mut this.buffer) + .map_err(|_| CUerror::UNKNOWN)?; + this.pipe + .write_all(&(slice.len() as u32).to_le_bytes()[..]) + .map_err(|_| CUerror::UNKNOWN)?; + this.pipe.write_all(&slice).map_err(|_| CUerror::UNKNOWN)?; + read_return_code(this)?; + this.buffer.resize(mem::size_of::(), 0); + this.pipe + .read_exact(&mut this.buffer) + .map_err(|_| CUerror::UNKNOWN)?; + let output = unsafe { rkyv::access_unchecked::(&this.buffer) }; + Ok(output.clone()) + } + + pub(crate) fn remote_call_framed_out( opcode: Opcode, data: impl for<'a, 'b> Serialize< HighSerializer<&'a mut AlignedVec, ArenaHandle<'b>, rkyv::rancor::Failure>, diff --git a/zluda32/src/lib.rs b/zluda32/src/lib.rs index bd9581b8c..f1491e8b4 100644 --- a/zluda32/src/lib.rs +++ b/zluda32/src/lib.rs @@ -4,6 +4,7 @@ use dark_api::cuda::CudaDarkApi; use paste::paste; use std::sync::{Mutex, OnceLock}; use std::{cell::RefCell, ffi::c_void, ptr}; +use zluda_common::{CodeLibraryRef, CodeModuleRef}; use zluda_server_common::*; mod ipc; @@ -59,21 +60,21 @@ cuda_function_declarations! { cuInit, cuLaunchKernel, cuMemAlloc_v2, - cuMemFreeHost, - cuMemFree_v2, - cuMemGetAddressRange_v2, - cuMemHostAlloc, cuMemcpyDtoDAsync_v2, cuMemcpyDtoHAsync_v2, cuMemcpyHtoDAsync_v2, + cuMemFree_v2, + cuMemFreeHost, + cuMemGetAddressRange_v2, + cuMemHostAlloc, cuMemsetD8_v2, cuModuleGetFunction, cuModuleGetGlobal_v2, cuModuleGetTexRef, cuStreamCreate, cuStreamDestroy_v2, - cuTexRefSetAddressMode, cuTexRefSetAddress_v2, + cuTexRefSetAddressMode, cuTexRefSetFilterMode, cuTexRefSetFlags, cuTexRefSetFormat, @@ -240,7 +241,7 @@ pub(crate) fn cu_device_get_name( if name.is_null() { return Err(CUerror::INVALID_VALUE); } - let name_out = ipc::Server::remote_call_framed::( + let name_out = ipc::Server::remote_call_framed_out::( Opcode::cuDeviceGetName, cuDeviceGetNameIn { len, dev }, )?; @@ -527,10 +528,45 @@ struct AllocRecord { impl CudaDarkApi for DarkApi32 { unsafe extern "system" fn get_module_from_cubin( - module: *mut cuda_types::cuda::CUmodule, + result: *mut cuda_types::cuda::CUmodule, fatbinc_wrapper: *const cuda_types::dark_api::FatbincWrapper, ) -> cuda_types::cuda::CUresult { - unimplemented!() + let result = match result.as_mut() { + Some(p) => p, + None => return CUresult::ERROR_INVALID_VALUE, + }; + let code_lib = CodeLibraryRef::try_load(fatbinc_wrapper.cast()) + .map_err(|_| CUerror::NO_BINARY_FOR_GPU)?; + let mut modules = Vec::with_capacity(1); + code_lib.iterate_modules(|_, module| match module { + Ok(CodeModuleRef::Text(ptx)) => { + modules.push(std::borrow::Cow::Borrowed(ptx.as_bytes())); + } + Ok(CodeModuleRef::File(file)) => { + if file.kind() == "ptx" { + if let Ok(text) = file.get_or_decompress_content(false) { + modules.push(text); + } + } + } + _ => {} + }); + let mut last_module = + unwrap_or::unwrap_some_or!(modules.pop(), return Err(CUerror::NO_BINARY_FOR_GPU)); + if last_module.last() != Some(&0) { + last_module.to_mut().push(0); + } + *result = CUmodule( + ipc::Server::remote_call_framed_in::( + Opcode::cuModuleLoadData, + cuModuleLoadDataIn { + image: last_module.into_owned(), + }, + )? + .module + .to_native() as _, + ); + Ok(()) } unsafe extern "system" fn cudart_interface_fn2( diff --git a/zluda64_server/src/main.rs b/zluda64_server/src/main.rs index 6aadad627..1a268f6ac 100644 --- a/zluda64_server/src/main.rs +++ b/zluda64_server/src/main.rs @@ -85,15 +85,11 @@ async fn main() -> std::io::Result<()> { buffer.clear(); match Opcode::from_repr(opcode) { Some(Opcode::cuInit) => { - buffer = handle_cuda_function::( - &mut client, - buffer, - cu_init, - ) - .await?; + buffer = handle_cuda_function::(&mut client, buffer, cu_init) + .await?; } Some(Opcode::cuDeviceGetCount) => { - buffer = handle_cuda_function::( + buffer = handle_cuda_function::( &mut client, buffer, cu_device_get_count, @@ -101,14 +97,15 @@ async fn main() -> std::io::Result<()> { .await?; } Some(Opcode::cuDeviceGetAttribute) => { - buffer = handle_cuda_function::< - ArchivedcuDeviceGetAttributeIn, - cuDeviceGetAttributeOut, - >(&mut client, buffer, cu_device_get_attribute) + buffer = handle_cuda_function::( + &mut client, + buffer, + cu_device_get_attribute, + ) .await?; } Some(Opcode::cuDeviceGet) => { - buffer = handle_cuda_function::( + buffer = handle_cuda_function::( &mut client, buffer, cu_device_get, @@ -116,7 +113,7 @@ async fn main() -> std::io::Result<()> { .await?; } Some(Opcode::cuCtxCreate_v2) => { - buffer = handle_cuda_function::( + buffer = handle_cuda_function::( &mut client, buffer, |input| cu_ctx_create_v2(input, &mut state), @@ -124,57 +121,63 @@ async fn main() -> std::io::Result<()> { .await?; } Some(Opcode::cuDriverGetVersion) => { + buffer = handle_cuda_function::( + &mut client, + buffer, + cu_driver_get_version, + ) + .await?; + } + Some(Opcode::cuDeviceGetName) => { + buffer = handle_cuda_function_framed_out::( + &mut client, + buffer, + cu_device_get_name, + ) + .await?; + } + Some(Opcode::cuDeviceTotalMem_v2) => { + buffer = handle_cuda_function::( + &mut client, + buffer, + cu_device_total_mem_v2, + ) + .await?; + } + Some(Opcode::ContextLocalStoragePut) => { buffer = - handle_cuda_function::( + handle_cuda_function::( &mut client, buffer, - cu_driver_get_version, + |input| context_local_storage_put(&mut state, input), ) .await?; } - Some(Opcode::cuDeviceGetName) => { + Some(Opcode::ContextLocalStorageGet) => { buffer = - handle_cuda_function_framed::( + handle_cuda_function::( &mut client, buffer, - cu_device_get_name, + |input| context_local_storage_get(&mut state, input), ) .await?; } - Some(Opcode::cuDeviceTotalMem_v2) => { - buffer = handle_cuda_function::< - ArchivedcuDeviceTotalMem_v2In, - cuDeviceTotalMem_v2Out, - >(&mut client, buffer, cu_device_total_mem_v2) - .await?; - } - Some(Opcode::ContextLocalStoragePut) => { - buffer = handle_cuda_function::< - ArchivedContextLocalStoragePutIn, - ContextLocalStoragePutOut, - >(&mut client, buffer, |input| { - context_local_storage_put(&mut state, input) - }) + Some(Opcode::cuCtxGetApiVersion) => { + buffer = handle_cuda_function::( + &mut client, + buffer, + |input| cu_ctx_get_api_version(&mut state, input), + ) .await?; } - Some(Opcode::ContextLocalStorageGet) => { - buffer = handle_cuda_function::< - ArchivedContextLocalStorageGetIn, - ContextLocalStorageGetOut, - >(&mut client, buffer, |input| { - context_local_storage_get(&mut state, input) - }) + Some(Opcode::cuModuleLoadData) => { + buffer = handle_cuda_function_framed_in::( + &mut client, + buffer, + |input| cu_module_load_data(&mut state, input), + ) .await?; } - Some(Opcode::cuCtxGetApiVersion) => { - buffer = - handle_cuda_function::( - &mut client, - buffer, - |input| cu_ctx_get_api_version(&mut state, input), - ) - .await?; - } _ => { client.write_u32_le(CUerror::NOT_SUPPORTED.0.get()).await?; return Err(std::io::Error::new( @@ -186,6 +189,17 @@ async fn main() -> std::io::Result<()> { } } +fn cu_module_load_data( + state: &mut State, + input: &ArchivedcuModuleLoadDataIn, +) -> Result { + let mut module = unsafe { mem::zeroed() }; + unsafe { cuModuleLoadData(&mut module, input.image.as_ptr().cast()) }?; + Ok(cuModuleLoadDataOut { + module: u32_le::from_native(state.insert(module.0)), + }) +} + fn cu_init(input: &ArchivedcuInitIn) -> Result { unsafe { cuInit(input.Flags.to_native()) }?; Ok(cuInitOut {}) @@ -241,7 +255,9 @@ fn cu_ctx_create_v2( let mut pctx = unsafe { mem::zeroed() }; unsafe { cuCtxCreate_v2(&mut pctx, input.flags.to_native(), input.dev.to_native()) }?; let pctx = state.insert(pctx.0); - Ok(cuCtxCreate_v2Out { pctx }) + Ok(cuCtxCreate_v2Out { + pctx: u32_le::from_native(pctx), + }) } fn cu_device_total_mem_v2( @@ -306,18 +322,18 @@ fn context_local_storage_get( }) } -async fn handle_cuda_function( +async fn handle_cuda_function( client: &mut NamedPipeClient, mut buffer: AlignedVecBuffer, - handler: impl FnOnce(&In) -> Result, + handler: impl FnOnce(&In::Archived) -> Result, ) -> std::io::Result where Out: for<'a, 'b> Serialize< HighSerializer<&'a mut AlignedVec, ArenaHandle<'b>, rkyv::rancor::Failure>, >, { - buffer = read_all::(buffer, client).await?; - let input = unsafe { rkyv::access_unchecked::(buffer.as_init()) }; + buffer = read_all::(buffer, client).await?; + let input = unsafe { rkyv::access_unchecked::(buffer.as_init()) }; match handler(input) { Ok(output) => { buffer.clear(); @@ -336,18 +352,49 @@ where } } -async fn handle_cuda_function_framed( +async fn handle_cuda_function_framed_in( client: &mut NamedPipeClient, mut buffer: AlignedVecBuffer, - handler: impl FnOnce(&In) -> Result, + handler: impl FnOnce(&In::Archived) -> Result, ) -> std::io::Result where Out: for<'a, 'b> Serialize< HighSerializer<&'a mut AlignedVec, ArenaHandle<'b>, rkyv::rancor::Failure>, >, { - buffer = read_all::(buffer, client).await?; - let input = unsafe { rkyv::access_unchecked::(buffer.as_init()) }; + let length_prefix = client.read_u32_le().await? as usize; + buffer = read_sized(buffer, client, length_prefix).await?; + let input = unsafe { rkyv::access_unchecked::(buffer.as_init()) }; + match handler(input) { + Ok(output) => { + buffer.clear(); + client.write_u32_le(0).await?; + rkyv::api::high::to_bytes_in::<_, rkyv::rancor::Failure>(&output, &mut buffer.0) + .map_err(|_| { + std::io::Error::new(std::io::ErrorKind::Other, "Failed to serialize response") + })?; + let ((), new_buffer) = buf_try!(@try client.write_all(buffer).await); + Ok(new_buffer) + } + Err(e) => { + client.write_u32_le(e.0.get()).await?; + Ok(buffer) + } + } +} + +async fn handle_cuda_function_framed_out( + client: &mut NamedPipeClient, + mut buffer: AlignedVecBuffer, + handler: impl FnOnce(&In::Archived) -> Result, +) -> std::io::Result +where + Out: for<'a, 'b> Serialize< + HighSerializer<&'a mut AlignedVec, ArenaHandle<'b>, rkyv::rancor::Failure>, + >, +{ + buffer = read_all::(buffer, client).await?; + let input = unsafe { rkyv::access_unchecked::(buffer.as_init()) }; match handler(input) { Ok(output) => { buffer.clear(); @@ -370,10 +417,17 @@ where } async fn read_all( + buffer: AlignedVecBuffer, + client: &mut NamedPipeClient, +) -> std::io::Result { + read_sized(buffer, client, mem::size_of::()).await +} + +async fn read_sized( mut buffer: AlignedVecBuffer, client: &mut NamedPipeClient, + mut remaining_read: usize, ) -> std::io::Result { - let mut remaining_read = mem::size_of::(); buffer.clear(); buffer.reserve(remaining_read)?; while remaining_read > 0 { @@ -489,6 +543,7 @@ cuda_function_declarations! { // cuModuleGetFunction, // cuModuleGetGlobal_v2, // cuModuleGetTexRef, + cuModuleLoadData, // cuStreamCreate, // cuStreamDestroy_v2, // cuTexRefSetAddressMode, diff --git a/zluda_server_common/src/lib.rs b/zluda_server_common/src/lib.rs index 4c1880d64..c32d25e13 100644 --- a/zluda_server_common/src/lib.rs +++ b/zluda_server_common/src/lib.rs @@ -29,6 +29,7 @@ macro_rules! generate_messages_inout { )* cuDeviceGetName, cuDeviceTotalMem_v2, + cuModuleLoadData, ContextLocalStoragePut, ContextLocalStorageGet, } @@ -130,12 +131,12 @@ macro_rules! encode_as_proxy { macro_rules! encode_as_u32 { ($type_:ty) => { impl CudaEncode for $type_ { - type WireObject = u32; - fn encode(self) -> u32 { - unsafe { std::mem::transmute_copy::(&self) } + type WireObject = u32_le; + fn encode(self) -> u32_le { + unsafe { std::mem::transmute_copy::(&self) } } fn decode(o: Self::WireObject) -> Self { - unsafe { std::mem::transmute_copy::(&o) } + unsafe { std::mem::transmute_copy::(&o) } } } }; @@ -148,10 +149,10 @@ encode_as_self!(i32); encode_as_self!(f32); encode_as_proxy!(CUdevprop_v1, CUdevprop_v1_Wire); -encode_as_proxy!(CUdevice_attribute, u32); -encode_as_proxy!(CUfilter_mode, u32); -encode_as_proxy!(CUaddress_mode, u32); -encode_as_proxy!(CUarray_format, u32); +encode_as_proxy!(CUdevice_attribute, u32_le); +encode_as_proxy!(CUfilter_mode, u32_le); +encode_as_proxy!(CUaddress_mode, u32_le); +encode_as_proxy!(CUarray_format, u32_le); encode_as_u32!(CUcontext); encode_as_u32!(CUdeviceptr_v2); @@ -214,3 +215,15 @@ pub struct ContextLocalStorageGetIn { pub struct ContextLocalStorageGetOut { pub value: u32_le, } + +#[repr(C)] +#[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct cuModuleLoadDataIn { + pub image: Vec, +} + +#[repr(C)] +#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct cuModuleLoadDataOut { + pub module: ::WireObject, +} diff --git a/zluda_trace/src/trace.rs b/zluda_trace/src/trace.rs index fa3315076..1db1c62c1 100644 --- a/zluda_trace/src/trace.rs +++ b/zluda_trace/src/trace.rs @@ -102,9 +102,10 @@ impl StateTracker { }) } Ok(zluda_common::CodeModuleRef::File(file)) => { - if let Some(buffer) = fn_logger - .try_(|_| file.get_or_decompress_content().map_err(ErrorEntry::from)) - { + if let Some(buffer) = fn_logger.try_(|_| { + file.get_or_decompress_content(true) + .map_err(ErrorEntry::from) + }) { self.record_new_submodule(index, &*buffer, fn_logger, file.kind()); } } From c4a8abffacde397f1ab7d73630d9a8970bd5c896 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Wed, 27 May 2026 23:19:43 -0700 Subject: [PATCH 39/85] Add unfinished global getter --- Cargo.lock | 15 ++++ zluda32/src/lib.rs | 31 +++++++- zluda64_server/Cargo.toml | 3 + zluda64_server/src/main.rs | 133 ++++++++++++++++++++++++++++++++- zluda_server_common/src/lib.rs | 29 +++++++ 5 files changed, 205 insertions(+), 6 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index ae4e52989..1fc76c4eb 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3365,6 +3365,12 @@ version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d" +[[package]] +name = "orderly-allocator" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "801f8900aedd8c4060d155f0c8e0269e011ddd0e061bf56a87e5d9ddba3ce995" + [[package]] name = "os_pipe" version = "1.2.3" @@ -3830,6 +3836,12 @@ dependencies = [ "rand 0.9.2", ] +[[package]] +name = "range-alloc" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ca45419789ae5a7899559e9512e58ca889e41f04f1f2445e9f4b290ceccd1d08" + [[package]] name = "raw-cpuid" version = "11.6.0" @@ -5677,7 +5689,10 @@ dependencies = [ "cuda_macros", "cuda_types", "dark_api", + "orderly-allocator", + "range-alloc", "rkyv", + "rustc-hash 2.1.1", "slab", "windows-sys 0.61.2", "zluda_server_common", diff --git a/zluda32/src/lib.rs b/zluda32/src/lib.rs index f1491e8b4..d85c3fb77 100644 --- a/zluda32/src/lib.rs +++ b/zluda32/src/lib.rs @@ -399,7 +399,21 @@ pub(crate) fn cu_module_get_function( hmod: CUmodule, name: *const ::core::ffi::c_char, ) -> Result<(), CUerror> { - unimplemented!() + let hfunc = unsafe { hfunc.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + *hfunc = CUfunction( + ipc::Server::remote_call_framed_in::( + Opcode::cuModuleGetFunction, + cuModuleGetFunctionIn { + hmod: CudaEncode::encode(hmod), + name: unsafe { std::ffi::CStr::from_ptr(name) } + .to_bytes_with_nul() + .to_vec(), + }, + )? + .hfunc + .to_native() as _, + ); + Ok(()) } pub(crate) fn cu_module_get_global_v2( @@ -408,7 +422,20 @@ pub(crate) fn cu_module_get_global_v2( hmod: CUmodule, name: *const ::core::ffi::c_char, ) -> Result<(), CUerror> { - unimplemented!() + let dptr = unsafe { dptr.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + let bytes = unsafe { bytes.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + let result = ipc::Server::remote_call_framed_in::( + Opcode::cuModuleGetGlobal_v2, + cuModuleGetGlobal_v2In { + hmod: CudaEncode::encode(hmod), + name: unsafe { std::ffi::CStr::from_ptr(name) } + .to_bytes_with_nul() + .to_vec(), + }, + )?; + *dptr = CudaEncode::decode(result.dptr); + *bytes = result.bytes.to_native() as usize; + Ok(()) } pub(crate) fn cu_module_get_tex_ref( diff --git a/zluda64_server/Cargo.toml b/zluda64_server/Cargo.toml index a36c1d579..69be4b5e9 100644 --- a/zluda64_server/Cargo.toml +++ b/zluda64_server/Cargo.toml @@ -18,6 +18,9 @@ compio = { version = "0.18.0", features = ["macros", "fs"] } slab = "0.4.12" bincode = "2.0.1" rkyv = "0.8.15" +orderly-allocator = "0.2.2" +range-alloc = "0.1.5" +rustc-hash = "2.0.0" [package.metadata.zluda] windows_only = true diff --git a/zluda64_server/src/main.rs b/zluda64_server/src/main.rs index 1a268f6ac..149ea5258 100644 --- a/zluda64_server/src/main.rs +++ b/zluda64_server/src/main.rs @@ -16,10 +16,13 @@ use rkyv::{ util::AlignedVec, Archive, Portable, Serialize, }; +use rustc_hash::FxHashMap; use slab::Slab; use std::{ + ffi::c_void, io::{self, Write}, - mem, ptr, + mem, + ptr::{self, NonNull}, }; use windows_sys::Win32::Foundation::ERROR_MORE_DATA; use zluda_server_common::*; @@ -27,6 +30,72 @@ use zluda_server_common::*; struct State { handles: Slab, dark_api: dark_api::cuda::ContextLocalStorageInterfaceV0301, + devmemory: Vec, +} + +struct Allocator { + device: u32, + start: Option<*mut c_void>, + allocator: range_alloc::RangeAllocator, + allocation_ends: FxHashMap, +} + +impl Allocator { + const ALLOCATION_UNIT: u32 = 128; + const ALLOCATOR_SIZE: u32 = 512 * 1024 * 1024; // 512 MiB + + fn new(device: u32) -> Self { + Self { + device, + start: None, + allocator: range_alloc::RangeAllocator::new( + // starting from 1 to avoid handing out null pointers + 1..Self::ALLOCATOR_SIZE / Self::ALLOCATION_UNIT, + ), + allocation_ends: FxHashMap::default(), + } + } + + fn get_or_allocate_device_ptr(&mut self) -> Result<*mut c_void, CUerror> { + match self.start { + Some(ptr) => Ok(ptr), + None => { + let mut dev_ptr = CUdeviceptr_v2(ptr::null_mut()); + unsafe { cuMemAlloc_v2(&mut dev_ptr, Self::ALLOCATOR_SIZE as usize) }?; + self.start = Some(dev_ptr.0); + Ok(dev_ptr.0) + } + } + } + + fn get_device_ptr(&self) -> Result<*mut c_void, CUerror> { + self.start.ok_or(CUerror::INVALID_VALUE) + } + + fn alloc(&mut self, size: u32) -> Result { + self.get_or_allocate_device_ptr()?; + let units = size.next_multiple_of(Self::ALLOCATION_UNIT) / Self::ALLOCATION_UNIT; + let offset = self + .allocator + .allocate_range(units) + .map_err(|_| CUerror::OUT_OF_MEMORY)?; + self.allocation_ends.insert(offset.start, offset.end); + Ok(offset.start * Self::ALLOCATION_UNIT) + } + + fn free(&mut self, start: u32) -> Result<(), CUerror> { + let end = self + .allocation_ends + .remove(&start) + .ok_or(CUerror::INVALID_VALUE)?; + self.allocator.free_range(start..end); + Ok(()) + } + + fn translate(&self, offset: u32) -> Result<*mut c_void, CUerror> { + let base_ptr = self.get_device_ptr()?; + Ok(base_ptr.wrapping_byte_add(offset as usize)) + } } impl State { @@ -40,9 +109,14 @@ impl State { ) }?; let dark_api = unsafe { dark_api::cuda::ContextLocalStorageInterfaceV0301::new(table_ptr) }; + let mut devices = 0; + unsafe { cuDeviceGetCount(&mut devices) }?; Ok(Self { handles: Slab::new(), dark_api, + devmemory: (0..devices) + .map(|device| Allocator::new(device as u32)) + .collect(), }) } @@ -178,6 +252,24 @@ async fn main() -> std::io::Result<()> { ) .await?; } + Some(Opcode::cuModuleGetFunction) => { + buffer = handle_cuda_function_framed_in::< + cuModuleGetFunctionIn, + cuModuleGetFunctionOut, + >(&mut client, buffer, |input| { + cu_module_get_function(&mut state, input) + }) + .await?; + } + Some(Opcode::cuModuleGetGlobal_v2) => { + buffer = handle_cuda_function_framed_in::< + cuModuleGetGlobal_v2In, + cuModuleGetGlobal_v2Out, + >(&mut client, buffer, |input| { + cu_module_get_global_v2(&mut state, input) + }) + .await?; + } _ => { client.write_u32_le(CUerror::NOT_SUPPORTED.0.get()).await?; return Err(std::io::Error::new( @@ -189,6 +281,39 @@ async fn main() -> std::io::Result<()> { } } +fn cu_module_get_global_v2( + state: &mut State, + input: &ArchivedcuModuleGetGlobal_v2In, +) -> Result { + let mut dptr = unsafe { mem::zeroed() }; + let mut bytes = unsafe { mem::zeroed() }; + let hmod = state.get(input.hmod.to_native())?; + unsafe { + cuModuleGetGlobal_v2( + &mut dptr, + &mut bytes, + CUmodule(hmod), + input.name.as_ptr().cast(), + ) + }?; + Ok(cuModuleGetGlobal_v2Out { + dptr: u32_le::from_native(state.insert(dptr.0)), + bytes: u64_le::from_native(bytes as u64), + }) +} + +fn cu_module_get_function( + state: &mut State, + input: &ArchivedcuModuleGetFunctionIn, +) -> Result { + let mut hfunc = unsafe { mem::zeroed() }; + let hmod = state.get(input.hmod.to_native())?; + unsafe { cuModuleGetFunction(&mut hfunc, CUmodule(hmod), input.name.as_ptr().cast()) }?; + Ok(cuModuleGetFunctionOut { + hfunc: u32_le::from_native(state.insert(hfunc.0)), + }) +} + fn cu_module_load_data( state: &mut State, input: &ArchivedcuModuleLoadDataIn, @@ -531,7 +656,7 @@ cuda_function_declarations! { cuGetExportTable, cuInit, // cuLaunchKernel, - // cuMemAlloc_v2, + cuMemAlloc_v2, // cuMemFreeHost, // cuMemFree_v2, // cuMemGetAddressRange_v2, @@ -540,8 +665,8 @@ cuda_function_declarations! { // cuMemcpyDtoHAsync_v2, // cuMemcpyHtoDAsync_v2, // cuMemsetD8_v2, - // cuModuleGetFunction, - // cuModuleGetGlobal_v2, + cuModuleGetFunction, + cuModuleGetGlobal_v2, // cuModuleGetTexRef, cuModuleLoadData, // cuStreamCreate, diff --git a/zluda_server_common/src/lib.rs b/zluda_server_common/src/lib.rs index c32d25e13..26d285226 100644 --- a/zluda_server_common/src/lib.rs +++ b/zluda_server_common/src/lib.rs @@ -32,6 +32,8 @@ macro_rules! generate_messages_inout { cuModuleLoadData, ContextLocalStoragePut, ContextLocalStorageGet, + cuModuleGetFunction, + cuModuleGetGlobal_v2 } }; } @@ -227,3 +229,30 @@ pub struct cuModuleLoadDataIn { pub struct cuModuleLoadDataOut { pub module: ::WireObject, } + +#[repr(C)] +#[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct cuModuleGetFunctionIn { + pub hmod: ::WireObject, + pub name: Vec, +} + +#[repr(C)] +#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct cuModuleGetFunctionOut { + pub hfunc: ::WireObject, +} + +#[repr(C)] +#[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct cuModuleGetGlobal_v2In { + pub hmod: ::WireObject, + pub name: Vec, +} + +#[repr(C)] +#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct cuModuleGetGlobal_v2Out { + pub dptr: ::WireObject, + pub bytes: u64_le, +} From fdd4f70014bb50821be44fa7e2faf8766366b6fc Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Sat, 30 May 2026 19:50:32 -0700 Subject: [PATCH 40/85] Set up internal dark api for 32 bit --- dark_api/src/lib.rs | 19 +++++++++ zluda/src/impl/driver.rs | 72 +++++++++++++++++++++++++++++++++ zluda/src/impl/library.rs | 4 +- zluda/src/impl/module.rs | 82 ++++++++++++++++++++++++++++++++------ zluda64_server/src/main.rs | 77 ++++++++++++++++++++++++++++++++++- 5 files changed, 238 insertions(+), 16 deletions(-) diff --git a/dark_api/src/lib.rs b/dark_api/src/lib.rs index 6b2d452e9..bb6db3c60 100644 --- a/dark_api/src/lib.rs +++ b/dark_api/src/lib.rs @@ -363,6 +363,25 @@ dark_api! { } } +// Purely for internal use by ZLUDA32 +dark_api! { + zluda32; + "{EE376A1B-B858-42EB-A52D-9A106D50D914}" => ZLUDA32_INTERNAL[2] { + [0] = get_module_globals( + names: *mut *mut u8, + initializers: *mut *const u8, + sizes: *mut u32, + alignments: *mut u32, + count: *mut u32, + module: cuda_types::cuda::CUmodule + ) -> cuda_types::cuda::CUresult, + [1] = get_function_info( + explicit_argument_count: *mut u32, + module: cuda_types::cuda::CUfunction + ) -> cuda_types::cuda::CUresult + } +} + #[repr(C)] pub struct ByteVecFfi { ptr: *mut u8, diff --git a/zluda/src/impl/driver.rs b/zluda/src/impl/driver.rs index 1a8987cb5..daab98a7e 100644 --- a/zluda/src/impl/driver.rs +++ b/zluda/src/impl/driver.rs @@ -469,6 +469,75 @@ fn get_device_hash_info() -> Result, CUerror> { static EXPORT_TABLE: ::dark_api::cuda::CudaDarkApiGlobalTable = ::dark_api::cuda::CudaDarkApiGlobalTable::new::(); +struct Zluda32DarkApi {} + +impl ::dark_api::zluda32::CudaDarkApi for Zluda32DarkApi { + unsafe extern "system" fn get_module_globals( + names: *mut *mut u8, + initializers: *mut *const u8, + sizes: *mut u32, + alignments: *mut u32, + count: *mut u32, + module: cuda_types::cuda::CUmodule, + ) -> cuda_types::cuda::CUresult { + let module: &module::Module = FromCuda::<_, CUerror>::from_cuda(&module)?; + let zluda32 = module.bit32.as_ref().ok_or(CUerror::NOT_FOUND)?; + if let Some(c) = count.as_mut() { + *c = zluda32.globals.len() as u32; + } + let mut names = if names.is_null() { + None + } else { + Some(slice::from_raw_parts_mut(names, zluda32.globals.len())) + }; + let mut initializers = if initializers.is_null() { + None + } else { + Some(slice::from_raw_parts_mut( + initializers, + zluda32.globals.len(), + )) + }; + let mut sizes = if sizes.is_null() { + None + } else { + Some(slice::from_raw_parts_mut(sizes, zluda32.globals.len())) + }; + let mut alignments = if alignments.is_null() { + None + } else { + Some(slice::from_raw_parts_mut(alignments, zluda32.globals.len())) + }; + if names.is_some() || initializers.is_some() || sizes.is_some() || alignments.is_some() { + for (i, global) in zluda32.globals.iter().enumerate() { + if let Some(names) = &mut names { + names[i] = global.name.as_ptr() as *mut u8; + } + if let Some(initializers) = &mut initializers { + initializers[i] = global.initializer.as_ptr(); + } + if let Some(sizes) = &mut sizes { + sizes[i] = global.initializer.len() as u32; + } + if let Some(alignments) = &mut alignments { + alignments[i] = global.align as u32; + } + } + } + Ok(()) + } + + unsafe extern "system" fn get_function_info( + explicit_argument_count: *mut u32, + module: cuda_types::cuda::CUfunction, + ) -> cuda_types::cuda::CUresult { + CUresult::ERROR_NOT_SUPPORTED + } +} + +static ZLUDA32_EXPORT_TABLE: ::dark_api::zluda32::CudaDarkApiGlobalTable = + ::dark_api::zluda32::CudaDarkApiGlobalTable::new::(); + pub(crate) fn get_export_table( pp_export_table: &mut *const ::core::ffi::c_void, p_export_table_id: &CUuuid, @@ -476,6 +545,9 @@ pub(crate) fn get_export_table( if let Some(table) = EXPORT_TABLE.get(p_export_table_id) { *pp_export_table = table.start(); cuda_types::cuda::CUresult::SUCCESS + } else if let Some(table) = ZLUDA32_EXPORT_TABLE.get(p_export_table_id) { + *pp_export_table = table.start(); + cuda_types::cuda::CUresult::SUCCESS } else { cuda_types::cuda::CUresult::ERROR_INVALID_VALUE } diff --git a/zluda/src/impl/library.rs b/zluda/src/impl/library.rs index 9869d8eca..98be33e67 100644 --- a/zluda/src/impl/library.rs +++ b/zluda/src/impl/library.rs @@ -21,8 +21,8 @@ impl Library { let module_lock = self.modules.get(device).ok_or(CUerror::INVALID_DEVICE)?; *module_lock.get_or_init(|| match self.data { LibraryData::Lazy(lib) => { - let (module, sm_version) = module::load_hip_module(lib)?; - Ok(Module::new(module, sm_version).wrap()) + let (module, sm_version, meta32) = module::load_hip_module(lib)?; + Ok(Module::new(module, sm_version, meta32).wrap()) } LibraryData::Eager(()) => Err(CUerror::NOT_SUPPORTED), }) diff --git a/zluda/src/impl/module.rs b/zluda/src/impl/module.rs index fea972735..643898dcb 100644 --- a/zluda/src/impl/module.rs +++ b/zluda/src/impl/module.rs @@ -17,6 +17,7 @@ use zluda_common::{CodeLibraryRef, CodeModuleRef, ZludaObject}; pub(crate) struct Module { pub(crate) base: hipModule_t, pub(crate) sm_version: u32, + pub(crate) bit32: Option, mutable: Mutex, } @@ -58,14 +59,64 @@ impl ZludaObject for Module { } } +pub(crate) struct Metadata32Bit { + pub globals: Vec, + pub explicit_arg_counts: FxHashMap, +} + +impl Metadata32Bit { + fn new(meta: &kernel_metadata::ModuleMetadata32Bit) -> Self { + let globals = meta + .globals + .iter() + .map(|g| kernel_metadata::Global32Bit { + name: g.name.to_string(), + initializer: g.initializer.to_vec(), + align: g.align, + }) + .collect(); + let explicit_arg_counts = meta + .explicit_arg_count + .iter() + .map(|kv| (kv.0.to_string(), kv.1)) + .collect(); + Self { + globals, + explicit_arg_counts, + } + } + + fn from_archived(archived: &kernel_metadata::ArchivedModuleMetadata32Bit) -> Self { + let globals = archived + .globals + .iter() + .map(|g| kernel_metadata::Global32Bit { + name: g.name.to_string(), + initializer: g.initializer.to_vec(), + align: g.align.to_native(), + }) + .collect(); + let explicit_arg_counts = archived + .explicit_arg_count + .iter() + .map(|kv| (kv.0.to_string(), kv.1.to_native())) + .collect(); + Self { + globals, + explicit_arg_counts, + } + } +} + impl Module { - pub(crate) fn new(base: hipModule_t, sm_version: u32) -> Self { + pub(crate) fn new(base: hipModule_t, sm_version: u32, bit32: Option) -> Self { Self { base, sm_version, mutable: Mutex::new(ModuleMutable { functions: FxHashMap::default(), }), + bit32, } } @@ -80,7 +131,7 @@ impl Module { fn get_best_ptx_and_compile( global_state: &GlobalState, image: CodeLibraryRef<'_>, -) -> Result<(hipModule_t, u32), CUerror> { +) -> Result<(hipModule_t, u32, Option), CUerror> { let mut ptx_modules = Vec::new(); unsafe { CodeLibraryRef::iterate_modules(image, |_, module| match module { @@ -168,12 +219,12 @@ fn get_best_ptx_and_compile( _ => None, }; let cached_binary = load_cached_binary(&mut cache_with_key); - let (elf_module, sm_version) = cached_binary + let (elf_module, sm_version, zluda32) = cached_binary .ok_or(CUerror::UNKNOWN) .or_else(|_| compile_and_cache(gcn_arch, attributes, module, &mut cache_with_key))?; let mut hip_module = unsafe { mem::zeroed() }; unsafe { hipModuleLoadData(&mut hip_module, elf_module.as_ptr().cast()) }?; - Ok((hip_module, sm_version)) + Ok((hip_module, sm_version, zluda32)) } fn cow_bytes_to_str<'a>(data: Cow<'a, [u8]>) -> Option> { @@ -183,7 +234,9 @@ fn cow_bytes_to_str<'a>(data: Cow<'a, [u8]>) -> Option> { } } -pub(crate) fn load_hip_module(library: CodeLibraryRef) -> Result<(hipModule_t, u32), CUerror> { +pub(crate) fn load_hip_module( + library: CodeLibraryRef, +) -> Result<(hipModule_t, u32, Option), CUerror> { let global_state = driver::global_state()?; get_best_ptx_and_compile(global_state, library) } @@ -229,14 +282,16 @@ fn get_cache_key<'a, 'b>( fn load_cached_binary( cache_with_key: &mut Option<(zluda_cache::ModuleCache, zluda_cache::ModuleKey)>, -) -> Option<(Vec, u32)> { +) -> Option<(Vec, u32, Option)> { let binary = cache_with_key .as_mut() .and_then(|(c, key)| c.get_module_binary(key))?; let sm_version = kernel_metadata::ModuleMetadataV1::read_object(&binary)? .sm_version .to_native(); - Some((binary, sm_version)) + let zluda32 = kernel_metadata::ModuleMetadata32Bit::read_object(&binary) + .map(Metadata32Bit::from_archived); + Some((binary, sm_version, zluda32)) } fn compile_and_cache( @@ -244,7 +299,7 @@ fn compile_and_cache( attributes: ExtraCacheAttributes, ast: ptx_parser::Module, cache_with_key: &mut Option<(zluda_cache::ModuleCache, zluda_cache::ModuleKey)>, -) -> Result<(Vec, u32), CUerror> { +) -> Result<(Vec, u32, Option), CUerror> { let llvm_module = ptx::to_llvm_module( ast, ptx::Attributes { @@ -255,6 +310,7 @@ fn compile_and_cache( .map_err(|_| CUerror::UNKNOWN)?; let ptx_impl = llvm_module.linked_bitcode(); let sm_version = llvm_module.metadata.sm_version; + let metadata32 = llvm_module.metadata32.as_ref().map(Metadata32Bit::new); let elf_module = llvm_zluda::compile( &llvm_module.context, gcn_arch, @@ -270,7 +326,7 @@ fn compile_and_cache( key.last_access = zluda_cache::ModuleCache::time_now(); cache.insert_module(key, &elf_module); } - Ok((elf_module, sm_version)) + Ok((elf_module, sm_version, metadata32)) } pub(crate) fn load(module: &mut CUmodule, fname: &CStr) -> CUresult { @@ -280,16 +336,16 @@ pub(crate) fn load(module: &mut CUmodule, fname: &CStr) -> CUresult { image.push(0); let library = unsafe { CodeLibraryRef::try_load(image.as_ptr() as *const std::ffi::c_void) } .map_err(|_| CUerror::NO_BINARY_FOR_GPU)?; - let (hip_module, sm_version) = load_hip_module(library)?; - *module = Module::new(hip_module, sm_version).wrap(); + let (hip_module, sm_version, meta32) = load_hip_module(library)?; + *module = Module::new(hip_module, sm_version, meta32).wrap(); Ok(()) } pub(crate) fn load_data(module: &mut CUmodule, image: &std::ffi::c_void) -> CUresult { let library = unsafe { CodeLibraryRef::try_load(image) }.map_err(|_| CUerror::NO_BINARY_FOR_GPU)?; - let (hip_module, sm_version) = load_hip_module(library)?; - *module = Module::new(hip_module, sm_version).wrap(); + let (hip_module, sm_version, meta32) = load_hip_module(library)?; + *module = Module::new(hip_module, sm_version, meta32).wrap(); Ok(()) } diff --git a/zluda64_server/src/main.rs b/zluda64_server/src/main.rs index 149ea5258..ec23d604f 100644 --- a/zluda64_server/src/main.rs +++ b/zluda64_server/src/main.rs @@ -19,7 +19,7 @@ use rkyv::{ use rustc_hash::FxHashMap; use slab::Slab; use std::{ - ffi::c_void, + ffi::{c_void, CString}, io::{self, Write}, mem, ptr::{self, NonNull}, @@ -31,6 +31,79 @@ struct State { handles: Slab, dark_api: dark_api::cuda::ContextLocalStorageInterfaceV0301, devmemory: Vec, + modules: ModuleLaunchData, +} + +struct ModuleLaunchData { + dark_api: dark_api::zluda32::Zluda32Internal, + modules: FxHashMap>, + functions: FxHashMap, +} + +impl ModuleLaunchData { + fn new() -> Result { + let mut zluda32_ptr = unsafe { mem::zeroed() }; + unsafe { cuGetExportTable(&mut zluda32_ptr, &dark_api::zluda32::Zluda32Internal::GUID) }?; + let zluda32 = unsafe { dark_api::zluda32::Zluda32Internal::new(zluda32_ptr) }; + Ok(Self { + dark_api: zluda32, + modules: FxHashMap::default(), + functions: FxHashMap::default(), + }) + } + + unsafe fn new_module(&mut self, module: CUmodule) -> Result<(), CUerror> { + let mut count = 0; + self.dark_api.get_module_globals( + ptr::null_mut(), + ptr::null_mut(), + ptr::null_mut(), + ptr::null_mut(), + &mut count, + module, + )?; + let mut names = vec![mem::zeroed(); count as usize]; + let mut initializers = vec![mem::zeroed(); count as usize]; + let mut sizes = vec![mem::zeroed(); count as usize]; + let mut alignments = vec![mem::zeroed(); count as usize]; + self.dark_api.get_module_globals( + names.as_mut_ptr(), + initializers.as_mut_ptr(), + sizes.as_mut_ptr(), + alignments.as_mut_ptr(), + &mut count, + module, + )?; + let globals = (0..count as usize) + .map(|i| { + Ok::<_, CUerror>(Global { + name: unsafe { CString::from_raw(names[i].cast()) } + .into_string() + .map_err(|_| CUerror::UNKNOWN)?, + initial_value: unsafe { + std::slice::from_raw_parts(initializers[i].cast(), sizes[i] as usize) + .to_vec() + }, + size: sizes[i], + alignment: alignments[i], + }) + }) + .collect::, _>>()?; + self.modules.insert(module, globals); + Ok(()) + } +} + +struct Global { + name: String, + initial_value: Vec, + size: u32, + alignment: u32, +} + +struct Function { + module: CUmodule, + explicit_argument_count: u32, } struct Allocator { @@ -117,6 +190,7 @@ impl State { devmemory: (0..devices) .map(|device| Allocator::new(device as u32)) .collect(), + modules: ModuleLaunchData::new()?, }) } @@ -320,6 +394,7 @@ fn cu_module_load_data( ) -> Result { let mut module = unsafe { mem::zeroed() }; unsafe { cuModuleLoadData(&mut module, input.image.as_ptr().cast()) }?; + unsafe { state.modules.new_module(module) }?; Ok(cuModuleLoadDataOut { module: u32_le::from_native(state.insert(module.0)), }) From 02f95ced547b30697f260d9ab1b3ce7363360132 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Sat, 30 May 2026 23:03:01 -0700 Subject: [PATCH 41/85] Fix modules --- zluda/src/impl/module.rs | 16 ++++--- zluda32/src/lib.rs | 5 ++- zluda64_server/src/main.rs | 92 +++++++++++++++++++++++++------------- 3 files changed, 74 insertions(+), 39 deletions(-) diff --git a/zluda/src/impl/module.rs b/zluda/src/impl/module.rs index 643898dcb..841a50658 100644 --- a/zluda/src/impl/module.rs +++ b/zluda/src/impl/module.rs @@ -60,7 +60,7 @@ impl ZludaObject for Module { } pub(crate) struct Metadata32Bit { - pub globals: Vec, + pub globals: Vec, pub explicit_arg_counts: FxHashMap, } @@ -69,8 +69,8 @@ impl Metadata32Bit { let globals = meta .globals .iter() - .map(|g| kernel_metadata::Global32Bit { - name: g.name.to_string(), + .map(|g| Global32Bit { + name: CString::new(&*g.name).unwrap(), initializer: g.initializer.to_vec(), align: g.align, }) @@ -90,8 +90,8 @@ impl Metadata32Bit { let globals = archived .globals .iter() - .map(|g| kernel_metadata::Global32Bit { - name: g.name.to_string(), + .map(|g| Global32Bit { + name: CString::new(g.name.as_str()).unwrap(), initializer: g.initializer.to_vec(), align: g.align.to_native(), }) @@ -108,6 +108,12 @@ impl Metadata32Bit { } } +pub(crate) struct Global32Bit { + pub name: CString, + pub initializer: Vec, + pub align: u32, +} + impl Module { pub(crate) fn new(base: hipModule_t, sm_version: u32, bit32: Option) -> Self { Self { diff --git a/zluda32/src/lib.rs b/zluda32/src/lib.rs index d85c3fb77..8634ac548 100644 --- a/zluda32/src/lib.rs +++ b/zluda32/src/lib.rs @@ -422,14 +422,15 @@ pub(crate) fn cu_module_get_global_v2( hmod: CUmodule, name: *const ::core::ffi::c_char, ) -> Result<(), CUerror> { + let mut bytes_fallback = 0usize; let dptr = unsafe { dptr.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - let bytes = unsafe { bytes.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + let bytes = unsafe { bytes.as_mut() }.unwrap_or(&mut bytes_fallback); let result = ipc::Server::remote_call_framed_in::( Opcode::cuModuleGetGlobal_v2, cuModuleGetGlobal_v2In { hmod: CudaEncode::encode(hmod), name: unsafe { std::ffi::CStr::from_ptr(name) } - .to_bytes_with_nul() + .to_bytes() .to_vec(), }, )?; diff --git a/zluda64_server/src/main.rs b/zluda64_server/src/main.rs index ec23d604f..507209d56 100644 --- a/zluda64_server/src/main.rs +++ b/zluda64_server/src/main.rs @@ -19,12 +19,12 @@ use rkyv::{ use rustc_hash::FxHashMap; use slab::Slab; use std::{ - ffi::{c_void, CString}, + ffi::{c_void, CStr, CString}, io::{self, Write}, mem, + ops::Range, ptr::{self, NonNull}, }; -use windows_sys::Win32::Foundation::ERROR_MORE_DATA; use zluda_server_common::*; struct State { @@ -52,7 +52,11 @@ impl ModuleLaunchData { }) } - unsafe fn new_module(&mut self, module: CUmodule) -> Result<(), CUerror> { + unsafe fn new_module( + &mut self, + devmemory: &mut Vec, + module: CUmodule, + ) -> Result<(), CUerror> { let mut count = 0; self.dark_api.get_module_globals( ptr::null_mut(), @@ -74,18 +78,29 @@ impl ModuleLaunchData { &mut count, module, )?; + let mut device = 0; + unsafe { cuCtxGetDevice(&mut device) }?; let globals = (0..count as usize) .map(|i| { + if alignments[i] > Allocator::ALLOCATION_UNIT { + return Err(CUerror::OUT_OF_MEMORY); + } + let initializer = std::slice::from_raw_parts(initializers[i], sizes[i] as usize); + let allocation = devmemory[device as usize].alloc_range(sizes[i])?; + let devptr = devmemory[device as usize].translate_range(allocation.clone())?; + unsafe { + cuMemcpyHtoD_v2( + CUdeviceptr_v2(devptr), + initializer.as_ptr().cast(), + initializer.len(), + ) + }?; Ok::<_, CUerror>(Global { - name: unsafe { CString::from_raw(names[i].cast()) } - .into_string() - .map_err(|_| CUerror::UNKNOWN)?, - initial_value: unsafe { - std::slice::from_raw_parts(initializers[i].cast(), sizes[i] as usize) - .to_vec() - }, + name: unsafe { CStr::from_ptr(names[i].cast()) } + .to_string_lossy() + .into_owned(), + allocation, size: sizes[i], - alignment: alignments[i], }) }) .collect::, _>>()?; @@ -96,9 +111,14 @@ impl ModuleLaunchData { struct Global { name: String, - initial_value: Vec, + allocation: Range, size: u32, - alignment: u32, +} + +impl Global { + fn address(&self) -> u32 { + self.allocation.start * Allocator::ALLOCATION_UNIT + } } struct Function { @@ -145,13 +165,16 @@ impl Allocator { self.start.ok_or(CUerror::INVALID_VALUE) } - fn alloc(&mut self, size: u32) -> Result { + fn alloc_range(&mut self, size: u32) -> Result, CUerror> { self.get_or_allocate_device_ptr()?; let units = size.next_multiple_of(Self::ALLOCATION_UNIT) / Self::ALLOCATION_UNIT; - let offset = self - .allocator + self.allocator .allocate_range(units) - .map_err(|_| CUerror::OUT_OF_MEMORY)?; + .map_err(|_| CUerror::OUT_OF_MEMORY) + } + + fn alloc(&mut self, size: u32) -> Result { + let offset = self.alloc_range(size)?; self.allocation_ends.insert(offset.start, offset.end); Ok(offset.start * Self::ALLOCATION_UNIT) } @@ -169,6 +192,11 @@ impl Allocator { let base_ptr = self.get_device_ptr()?; Ok(base_ptr.wrapping_byte_add(offset as usize)) } + + fn translate_range(&self, range: Range) -> Result<*mut c_void, CUerror> { + let base_ptr = self.get_device_ptr()?; + Ok(base_ptr.wrapping_byte_add(range.start as usize * Self::ALLOCATION_UNIT as usize)) + } } impl State { @@ -359,20 +387,19 @@ fn cu_module_get_global_v2( state: &mut State, input: &ArchivedcuModuleGetGlobal_v2In, ) -> Result { - let mut dptr = unsafe { mem::zeroed() }; - let mut bytes = unsafe { mem::zeroed() }; - let hmod = state.get(input.hmod.to_native())?; - unsafe { - cuModuleGetGlobal_v2( - &mut dptr, - &mut bytes, - CUmodule(hmod), - input.name.as_ptr().cast(), - ) - }?; + let hmod = state.get::(input.hmod.to_native())?; + let globals = state + .modules + .modules + .get(&CUmodule(hmod)) + .ok_or(CUerror::INVALID_VALUE)?; + let global = globals + .iter() + .find(|g| g.name.as_bytes() == input.name.as_slice()) + .ok_or(CUerror::NOT_FOUND)?; Ok(cuModuleGetGlobal_v2Out { - dptr: u32_le::from_native(state.insert(dptr.0)), - bytes: u64_le::from_native(bytes as u64), + dptr: u32_le::from_native(global.address()), + bytes: u64_le::from_native(global.size as u64), }) } @@ -394,7 +421,7 @@ fn cu_module_load_data( ) -> Result { let mut module = unsafe { mem::zeroed() }; unsafe { cuModuleLoadData(&mut module, input.image.as_ptr().cast()) }?; - unsafe { state.modules.new_module(module) }?; + unsafe { state.modules.new_module(&mut state.devmemory, module) }?; Ok(cuModuleLoadDataOut { module: u32_le::from_native(state.insert(module.0)), }) @@ -716,7 +743,7 @@ cuda_function_declarations! { // cuCtxDetach, cuCtxGetApiVersion, // cuCtxGetCurrent, - // cuCtxGetDevice, + cuCtxGetDevice, // cuCtxSynchronize, // cuDeviceComputeCapability, cuDeviceGet, @@ -738,6 +765,7 @@ cuda_function_declarations! { // cuMemHostAlloc, // cuMemcpyDtoDAsync_v2, // cuMemcpyDtoHAsync_v2, + cuMemcpyHtoD_v2, // cuMemcpyHtoDAsync_v2, // cuMemsetD8_v2, cuModuleGetFunction, From 0f581d44d4dc5b20c9425774d9dd4ea2d5302019 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Sat, 30 May 2026 23:39:42 -0700 Subject: [PATCH 42/85] Add alloc and copy --- zluda32/src/lib.rs | 42 +++++++++++++++++++++----- zluda64_server/src/main.rs | 55 +++++++++++++++++++++++++++++++++- zluda_server_common/src/lib.rs | 30 +++++++++++++++++-- 3 files changed, 116 insertions(+), 11 deletions(-) diff --git a/zluda32/src/lib.rs b/zluda32/src/lib.rs index 8634ac548..58381139b 100644 --- a/zluda32/src/lib.rs +++ b/zluda32/src/lib.rs @@ -2,6 +2,7 @@ use cuda_macros::cuda_function_declarations; use cuda_types::cuda::*; use dark_api::cuda::CudaDarkApi; use paste::paste; +use rkyv::rend::u32_le; use std::sync::{Mutex, OnceLock}; use std::{cell::RefCell, ffi::c_void, ptr}; use zluda_common::{CodeLibraryRef, CodeModuleRef}; @@ -332,7 +333,17 @@ pub(crate) fn cu_launch_kernel( } pub(crate) fn cu_mem_alloc_v2(dptr: *mut CUdeviceptr, bytesize: usize) -> Result<(), CUerror> { - unimplemented!() + let dptr = unsafe { dptr.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + *dptr = CudaEncode::decode( + ipc::Server::remote_call_zero_copy::( + Opcode::cuMemAlloc_v2, + cuMemAlloc_v2In { + bytesize: u32_le::from_native(bytesize as u32), + }, + )? + .dptr, + ); + Ok(()) } pub(crate) fn cu_mem_free_host(p: *mut ::core::ffi::c_void) -> Result<(), CUerror> { @@ -354,9 +365,12 @@ pub(crate) fn cu_mem_get_address_range_v2( pub(crate) fn cu_mem_host_alloc( pp: *mut *mut ::core::ffi::c_void, bytesize: usize, - Flags: ::core::ffi::c_uint, + _flags: ::core::ffi::c_uint, ) -> Result<(), CUerror> { - unimplemented!() + let pp = unsafe { pp.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + *pp = unsafe { std::alloc::alloc(std::alloc::Layout::from_size_align(bytesize, 32).unwrap()) } + .cast(); + Ok(()) } pub(crate) fn cu_memcpy_dto_d_async_v2( @@ -378,12 +392,24 @@ pub(crate) fn cu_memcpy_dto_h_async_v2( } pub(crate) fn cu_memcpy_hto_d_async_v2( - dstDevice: CUdeviceptr, - srcHost: *const ::core::ffi::c_void, - ByteCount: usize, - hStream: CUstream, + dst_device: CUdeviceptr, + src_host: *const ::core::ffi::c_void, + byte_count: usize, + h_stream: CUstream, ) -> Result<(), CUerror> { - unimplemented!() + if src_host.is_null() { + return Err(CUerror::INVALID_VALUE); + } + let slice = unsafe { std::slice::from_raw_parts(src_host.cast::(), byte_count) }; + ipc::Server::remote_call_framed_in::( + Opcode::cuMemcpyHtoDAsync_v2, + cuMemcpyHtoDAsync_v2In { + dst_device: CudaEncode::encode(dst_device), + src_host: slice.to_vec(), + stream: CudaEncode::encode(h_stream), + }, + )?; + Ok(()) } pub(crate) fn cu_memset_d8_v2( diff --git a/zluda64_server/src/main.rs b/zluda64_server/src/main.rs index 507209d56..b7f9ac7a4 100644 --- a/zluda64_server/src/main.rs +++ b/zluda64_server/src/main.rs @@ -372,6 +372,23 @@ async fn main() -> std::io::Result<()> { }) .await?; } + Some(Opcode::cuMemAlloc_v2) => { + buffer = handle_cuda_function::( + &mut client, + buffer, + |input| cu_mem_alloc_v2(&mut state, input), + ) + .await?; + } + Some(Opcode::cuMemcpyHtoDAsync_v2) => { + buffer = handle_cuda_function_framed_in::< + cuMemcpyHtoDAsync_v2In, + cuMemcpyHtoDAsync_v2Out, + >(&mut client, buffer, |input| { + cu_memcpy_hto_d_async_v2(&mut state, input) + }) + .await?; + } _ => { client.write_u32_le(CUerror::NOT_SUPPORTED.0.get()).await?; return Err(std::io::Error::new( @@ -383,6 +400,42 @@ async fn main() -> std::io::Result<()> { } } +fn cu_memcpy_hto_d_async_v2( + state: &mut State, + input: &ArchivedcuMemcpyHtoDAsync_v2In, +) -> Result { + let mut device = 0; + unsafe { cuCtxGetDevice(&mut device) }?; + let devptr = state.devmemory[device as usize].translate(input.dst_device.to_native())?; + let stream = input.stream.to_native(); + let stream = if stream == 0 { + CUstream(ptr::null_mut()) + } else { + CUstream(state.get(stream)?) + }; + unsafe { + cuMemcpyHtoDAsync_v2( + CUdeviceptr_v2(devptr), + input.src_host.as_ptr().cast(), + input.src_host.len(), + stream, + ) + }?; + Ok(cuMemcpyHtoDAsync_v2Out {}) +} + +fn cu_mem_alloc_v2( + state: &mut State, + input: &ArchivedcuMemAlloc_v2In, +) -> Result { + let mut device = 0; + unsafe { cuCtxGetDevice(&mut device) }?; + let fake_ptr = state.devmemory[device as usize].alloc(input.bytesize.to_native())?; + Ok(cuMemAlloc_v2Out { + dptr: u32_le::from_native(fake_ptr), + }) +} + fn cu_module_get_global_v2( state: &mut State, input: &ArchivedcuModuleGetGlobal_v2In, @@ -766,7 +819,7 @@ cuda_function_declarations! { // cuMemcpyDtoDAsync_v2, // cuMemcpyDtoHAsync_v2, cuMemcpyHtoD_v2, - // cuMemcpyHtoDAsync_v2, + cuMemcpyHtoDAsync_v2, // cuMemsetD8_v2, cuModuleGetFunction, cuModuleGetGlobal_v2, diff --git a/zluda_server_common/src/lib.rs b/zluda_server_common/src/lib.rs index 26d285226..829073c14 100644 --- a/zluda_server_common/src/lib.rs +++ b/zluda_server_common/src/lib.rs @@ -33,7 +33,9 @@ macro_rules! generate_messages_inout { ContextLocalStoragePut, ContextLocalStorageGet, cuModuleGetFunction, - cuModuleGetGlobal_v2 + cuModuleGetGlobal_v2, + cuMemAlloc_v2, + cuMemcpyHtoDAsync_v2 } }; } @@ -66,7 +68,7 @@ cuda_function_declarations! { //cuGetExportTable, cuInit, //cuLaunchKernel, - // cuMemAlloc_v2, + //cuMemAlloc_v2, //cuMemFreeHost, //cuMemFree_v2, // cuMemGetAddressRange_v2, @@ -256,3 +258,27 @@ pub struct cuModuleGetGlobal_v2Out { pub dptr: ::WireObject, pub bytes: u64_le, } + +#[repr(C)] +#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct cuMemAlloc_v2In { + pub bytesize: u32_le, +} + +#[repr(C)] +#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct cuMemAlloc_v2Out { + pub dptr: ::WireObject, +} + +#[repr(C)] +#[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct cuMemcpyHtoDAsync_v2In { + pub dst_device: ::WireObject, + pub src_host: Vec, + pub stream: ::WireObject, +} + +#[repr(C)] +#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct cuMemcpyHtoDAsync_v2Out {} From 0b8c5e9c4d30c2a4924a27e309728b600c35977b Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Sun, 31 May 2026 15:32:13 -0700 Subject: [PATCH 43/85] Better texrefs --- .../replace_instructions_with_functions.rs | 5 + ptx_parser/src/lib.rs | 2 +- zluda32/src/lib.rs | 15 ++- zluda64_server/src/main.rs | 117 +++++++++++++----- zluda_server_common/src/lib.rs | 16 ++- 5 files changed, 120 insertions(+), 35 deletions(-) diff --git a/ptx/src/pass/replace_instructions_with_functions.rs b/ptx/src/pass/replace_instructions_with_functions.rs index e7c368b7d..8b13547d9 100644 --- a/ptx/src/pass/replace_instructions_with_functions.rs +++ b/ptx/src/pass/replace_instructions_with_functions.rs @@ -301,6 +301,11 @@ fn run_instruction<'input>( }, .. } => { + let dtype = match dtype { + // For 32 bit + ast::ScalarType::U32 => ast::ScalarType::S32, + t => t, + }; let prefix = match type_ { ast::TexType::Texref => "texref", ast::TexType::Texobj => "texobj", diff --git a/ptx_parser/src/lib.rs b/ptx_parser/src/lib.rs index 34feb839e..8bf86c43a 100644 --- a/ptx_parser/src/lib.rs +++ b/ptx_parser/src/lib.rs @@ -4398,7 +4398,7 @@ derive_parser!( } } - .dtype: ScalarType = { .s32, .f32 }; + .dtype: ScalarType = { .u32, .s32, .f32 }; .ctype: ScalarType = { .s32, .f32 }; ); diff --git a/zluda32/src/lib.rs b/zluda32/src/lib.rs index 58381139b..dbda0acf0 100644 --- a/zluda32/src/lib.rs +++ b/zluda32/src/lib.rs @@ -466,11 +466,22 @@ pub(crate) fn cu_module_get_global_v2( } pub(crate) fn cu_module_get_tex_ref( - pTexRef: *mut CUtexref, + texref: *mut CUtexref, hmod: CUmodule, name: *const ::core::ffi::c_char, ) -> Result<(), CUerror> { - unimplemented!() + let texref = unsafe { texref.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + let result = ipc::Server::remote_call_framed_in::( + Opcode::cuModuleGetTexRef, + cuModuleGetTexRefIn { + hmod: CudaEncode::encode(hmod), + name: unsafe { std::ffi::CStr::from_ptr(name) } + .to_bytes_with_nul() + .to_vec(), + }, + )?; + *texref = CudaEncode::decode(result.texref); + Ok(()) } pub(crate) fn cu_stream_create( diff --git a/zluda64_server/src/main.rs b/zluda64_server/src/main.rs index b7f9ac7a4..1b4cfc6cc 100644 --- a/zluda64_server/src/main.rs +++ b/zluda64_server/src/main.rs @@ -28,15 +28,41 @@ use std::{ use zluda_server_common::*; struct State { - handles: Slab, + handles: HandlePool, dark_api: dark_api::cuda::ContextLocalStorageInterfaceV0301, devmemory: Vec, modules: ModuleLaunchData, } +struct HandlePool { + handles: Slab, +} + +impl HandlePool { + fn new() -> Self { + Self { + handles: Slab::new(), + } + } + + fn insert(&mut self, handle: *mut T) -> u32 { + (self.handles.insert(handle as usize) as u32) + 1 + } + + fn get(&self, id: u32) -> Result<*mut T, CUerror> { + if id == 0 { + return Err(CUerror::INVALID_VALUE); + } + self.handles + .get((id - 1) as usize) + .map(|&handle| handle as *mut T) + .ok_or(CUerror::INVALID_VALUE) + } +} + struct ModuleLaunchData { dark_api: dark_api::zluda32::Zluda32Internal, - modules: FxHashMap>, + modules: FxHashMap, functions: FxHashMap, } @@ -104,11 +130,20 @@ impl ModuleLaunchData { }) }) .collect::, _>>()?; - self.modules.insert(module, globals); + let module_data = Module { + globals, + texrefs: FxHashMap::default(), + }; + self.modules.insert(module, module_data); Ok(()) } } +struct Module { + globals: Vec, + texrefs: FxHashMap, u32>, +} + struct Global { name: String, allocation: Range, @@ -213,7 +248,7 @@ impl State { let mut devices = 0; unsafe { cuDeviceGetCount(&mut devices) }?; Ok(Self { - handles: Slab::new(), + handles: HandlePool::new(), dark_api, devmemory: (0..devices) .map(|device| Allocator::new(device as u32)) @@ -221,20 +256,6 @@ impl State { modules: ModuleLaunchData::new()?, }) } - - fn insert(&mut self, handle: *mut T) -> u32 { - (self.handles.insert(handle as usize) as u32) + 1 - } - - fn get(&self, id: u32) -> Result<*mut T, CUerror> { - if id == 0 { - return Err(CUerror::INVALID_VALUE); - } - self.handles - .get((id - 1) as usize) - .map(|&handle| handle as *mut T) - .ok_or(CUerror::INVALID_VALUE) - } } #[compio::main] @@ -389,6 +410,15 @@ async fn main() -> std::io::Result<()> { }) .await?; } + Some(Opcode::cuModuleGetTexRef) => { + buffer = + handle_cuda_function_framed_in::( + &mut client, + buffer, + |input| cu_module_get_tex_ref(&mut state, input), + ) + .await?; + } _ => { client.write_u32_le(CUerror::NOT_SUPPORTED.0.get()).await?; return Err(std::io::Error::new( @@ -400,6 +430,30 @@ async fn main() -> std::io::Result<()> { } } +fn cu_module_get_tex_ref( + state: &mut State, + input: &ArchivedcuModuleGetTexRefIn, +) -> Result { + let hmod = state.handles.get::(input.hmod.to_native())?; + let module = state + .modules + .modules + .get_mut(&CUmodule(hmod)) + .ok_or(CUerror::INVALID_VALUE)?; + let texref = match module.texrefs.entry(input.name.to_vec()) { + std::collections::hash_map::Entry::Occupied(entry) => *entry.get(), + std::collections::hash_map::Entry::Vacant(entry) => { + let mut texref = unsafe { mem::zeroed() }; + unsafe { cuModuleGetTexRef(&mut texref, CUmodule(hmod), input.name.as_ptr().cast()) }?; + let handle = state.handles.insert(texref); + *entry.insert(handle) + } + }; + Ok(cuModuleGetTexRefOut { + texref: u32_le::from_native(texref), + }) +} + fn cu_memcpy_hto_d_async_v2( state: &mut State, input: &ArchivedcuMemcpyHtoDAsync_v2In, @@ -411,7 +465,7 @@ fn cu_memcpy_hto_d_async_v2( let stream = if stream == 0 { CUstream(ptr::null_mut()) } else { - CUstream(state.get(stream)?) + CUstream(state.handles.get(stream)?) }; unsafe { cuMemcpyHtoDAsync_v2( @@ -440,15 +494,16 @@ fn cu_module_get_global_v2( state: &mut State, input: &ArchivedcuModuleGetGlobal_v2In, ) -> Result { - let hmod = state.get::(input.hmod.to_native())?; - let globals = state + let hmod = state.handles.get::(input.hmod.to_native())?; + let module = state .modules .modules .get(&CUmodule(hmod)) .ok_or(CUerror::INVALID_VALUE)?; - let global = globals + let global = module + .globals .iter() - .find(|g| g.name.as_bytes() == input.name.as_slice()) + .find(|global| global.name.as_bytes() == input.name.as_slice()) .ok_or(CUerror::NOT_FOUND)?; Ok(cuModuleGetGlobal_v2Out { dptr: u32_le::from_native(global.address()), @@ -461,10 +516,10 @@ fn cu_module_get_function( input: &ArchivedcuModuleGetFunctionIn, ) -> Result { let mut hfunc = unsafe { mem::zeroed() }; - let hmod = state.get(input.hmod.to_native())?; + let hmod = state.handles.get(input.hmod.to_native())?; unsafe { cuModuleGetFunction(&mut hfunc, CUmodule(hmod), input.name.as_ptr().cast()) }?; Ok(cuModuleGetFunctionOut { - hfunc: u32_le::from_native(state.insert(hfunc.0)), + hfunc: u32_le::from_native(state.handles.insert(hfunc.0)), }) } @@ -476,7 +531,7 @@ fn cu_module_load_data( unsafe { cuModuleLoadData(&mut module, input.image.as_ptr().cast()) }?; unsafe { state.modules.new_module(&mut state.devmemory, module) }?; Ok(cuModuleLoadDataOut { - module: u32_le::from_native(state.insert(module.0)), + module: u32_le::from_native(state.handles.insert(module.0)), }) } @@ -534,7 +589,7 @@ fn cu_ctx_create_v2( ) -> Result { let mut pctx = unsafe { mem::zeroed() }; unsafe { cuCtxCreate_v2(&mut pctx, input.flags.to_native(), input.dev.to_native()) }?; - let pctx = state.insert(pctx.0); + let pctx = state.handles.insert(pctx.0); Ok(cuCtxCreate_v2Out { pctx: u32_le::from_native(pctx), }) @@ -564,7 +619,7 @@ fn cu_ctx_get_api_version( state: &mut State, input: &ArchivedcuCtxGetApiVersionIn, ) -> Result { - let ctx = CUcontext(state.get(input.ctx.to_native())?); + let ctx = CUcontext(state.handles.get(input.ctx.to_native())?); let mut version = 0; unsafe { cuCtxGetApiVersion(ctx, &mut version) }?; Ok(cuCtxGetApiVersionOut { version }) @@ -576,7 +631,7 @@ fn context_local_storage_put( ) -> Result { unsafe { state.dark_api.context_local_storage_put( - CUcontext(state.get(input.cu_ctx.to_native())?), + CUcontext(state.handles.get(input.cu_ctx.to_native())?), input.key.to_native() as _, input.value.to_native() as _, None, @@ -593,7 +648,7 @@ fn context_local_storage_get( unsafe { state.dark_api.context_local_storage_get( &mut value, - CUcontext(state.get(input.cu_ctx.to_native())?), + CUcontext(state.handles.get(input.cu_ctx.to_native())?), input.key.to_native() as _, ) }?; @@ -823,7 +878,7 @@ cuda_function_declarations! { // cuMemsetD8_v2, cuModuleGetFunction, cuModuleGetGlobal_v2, - // cuModuleGetTexRef, + cuModuleGetTexRef, cuModuleLoadData, // cuStreamCreate, // cuStreamDestroy_v2, diff --git a/zluda_server_common/src/lib.rs b/zluda_server_common/src/lib.rs index 829073c14..0362638fa 100644 --- a/zluda_server_common/src/lib.rs +++ b/zluda_server_common/src/lib.rs @@ -35,7 +35,8 @@ macro_rules! generate_messages_inout { cuModuleGetFunction, cuModuleGetGlobal_v2, cuMemAlloc_v2, - cuMemcpyHtoDAsync_v2 + cuMemcpyHtoDAsync_v2, + cuModuleGetTexRef } }; } @@ -282,3 +283,16 @@ pub struct cuMemcpyHtoDAsync_v2In { #[repr(C)] #[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] pub struct cuMemcpyHtoDAsync_v2Out {} + +#[repr(C)] +#[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct cuModuleGetTexRefIn { + pub hmod: ::WireObject, + pub name: Vec, +} + +#[repr(C)] +#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct cuModuleGetTexRefOut { + pub texref: ::WireObject, +} From f0808158cb1f0e3eb895e44d91dbb3667b48ca1f Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Mon, 1 Jun 2026 01:08:15 -0700 Subject: [PATCH 44/85] Propagate arg informatrion --- Cargo.lock | 37 +++--- dark_api/src/lib.rs | 3 +- kernel_metadata/src/lib.rs | 2 +- ptx/src/pass/convert_32bit_to_64bit.rs | 19 ++- zluda/src/impl/driver.rs | 22 +++- zluda/src/impl/function.rs | 1 + zluda/src/impl/module.rs | 32 +++-- zluda32/Cargo.toml | 1 + zluda32/src/ipc.rs | 73 +++++------ zluda32/src/lib.rs | 174 +++++++++++++++++++------ zluda64_server/src/main.rs | 35 ++++- zluda_server_common/src/lib.rs | 37 +++++- 12 files changed, 315 insertions(+), 121 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 1fc76c4eb..e9e0157d9 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -190,7 +190,7 @@ dependencies = [ "proc-macro2", "quote", "regex", - "rustc-hash 2.1.1", + "rustc-hash 2.1.2", "shlex", "syn 2.0.117", ] @@ -825,7 +825,7 @@ version = "0.0.0" dependencies = [ "proc-macro2", "quote", - "rustc-hash 2.1.1", + "rustc-hash 2.1.2", "syn 2.0.117", ] @@ -2756,7 +2756,7 @@ dependencies = [ "mio", "postcard", "rand 0.9.2", - "rustc-hash 2.1.1", + "rustc-hash 2.1.2", "serde_core", "tempfile", "thiserror 2.0.12", @@ -3316,7 +3316,7 @@ dependencies = [ "format", "libloading", "paste", - "rustc-hash 2.1.1", + "rustc-hash 2.1.2", "unwrap_or", "zluda_trace_common", ] @@ -3334,7 +3334,7 @@ dependencies = [ "format", "libloading", "paste", - "rustc-hash 2.1.1", + "rustc-hash 2.1.2", "unwrap_or", "zluda_trace_common", ] @@ -3665,7 +3665,7 @@ dependencies = [ "pretty_assertions", "ptx_parser", "quick-error", - "rustc-hash 2.1.1", + "rustc-hash 2.1.2", "smallvec", "strum 0.28.0", "strum_macros 0.28.0", @@ -3682,7 +3682,7 @@ dependencies = [ "derive_more", "logos", "ptx_parser_macros", - "rustc-hash 2.1.1", + "rustc-hash 2.1.2", "strum 0.27.1", "thiserror 1.0.64", "winnow 0.6.20", @@ -3697,7 +3697,7 @@ dependencies = [ "proc-macro2", "ptx_parser_macros_impl", "quote", - "rustc-hash 2.1.1", + "rustc-hash 2.1.2", "syn 2.0.117", ] @@ -3707,7 +3707,7 @@ version = "0.0.0" dependencies = [ "proc-macro2", "quote", - "rustc-hash 2.1.1", + "rustc-hash 2.1.2", "syn 2.0.117", ] @@ -3997,9 +3997,9 @@ checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2" [[package]] name = "rustc-hash" -version = "2.1.1" +version = "2.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d" +checksum = "94300abf3f1ae2e2b8ffb7b58043de3d399c73fa6f4b73826402a5c457614dbe" [[package]] name = "rustc_version" @@ -5647,7 +5647,7 @@ dependencies = [ "paste", "ptx", "ptx_parser", - "rustc-hash 2.1.1", + "rustc-hash 2.1.2", "serde", "serde_json", "tempfile", @@ -5672,6 +5672,7 @@ dependencies = [ "postcard", "rand 0.10.1", "rkyv", + "rustc-hash 2.1.2", "unwrap_or", "widestring", "windows 0.62.2", @@ -5692,7 +5693,7 @@ dependencies = [ "orderly-allocator", "range-alloc", "rkyv", - "rustc-hash 2.1.1", + "rustc-hash 2.1.2", "slab", "windows-sys 0.61.2", "zluda_server_common", @@ -5708,7 +5709,7 @@ dependencies = [ "prettyplease", "proc-macro2", "quote", - "rustc-hash 2.1.1", + "rustc-hash 2.1.2", "syn 2.0.117", ] @@ -5778,7 +5779,7 @@ dependencies = [ "hip_runtime-sys", "libloading", "miopen-sys", - "rustc-hash 2.1.1", + "rustc-hash 2.1.2", "static_assertions", "zluda_common", "zluda_windows", @@ -5829,7 +5830,7 @@ dependencies = [ "argh", "bpaf", "detours-sys", - "rustc-hash 2.1.1", + "rustc-hash 2.1.2", "tempfile", "widestring", "windows 0.62.2", @@ -5874,7 +5875,7 @@ name = "zluda_redirect" version = "0.0.0" dependencies = [ "detours-sys", - "rustc-hash 2.1.1", + "rustc-hash 2.1.2", "unwrap_or", "widestring", "windows 0.62.2", @@ -5931,7 +5932,7 @@ dependencies = [ "paste", "ptx_parser", "regex", - "rustc-hash 2.1.1", + "rustc-hash 2.1.2", "unwrap_or", "windows 0.62.2", "zluda_common", diff --git a/dark_api/src/lib.rs b/dark_api/src/lib.rs index bb6db3c60..8580be9a2 100644 --- a/dark_api/src/lib.rs +++ b/dark_api/src/lib.rs @@ -376,8 +376,9 @@ dark_api! { module: cuda_types::cuda::CUmodule ) -> cuda_types::cuda::CUresult, [1] = get_function_info( + explicit_argument_sizes: *mut u32, explicit_argument_count: *mut u32, - module: cuda_types::cuda::CUfunction + func: cuda_types::cuda::CUfunction ) -> cuda_types::cuda::CUresult } } diff --git a/kernel_metadata/src/lib.rs b/kernel_metadata/src/lib.rs index d4db9baf3..8b6415cd4 100644 --- a/kernel_metadata/src/lib.rs +++ b/kernel_metadata/src/lib.rs @@ -43,7 +43,7 @@ pub struct Global32Bit { #[derive(Archive, Serialize, Deserialize, Debug)] pub struct ModuleMetadata32Bit { pub globals: Vec, - pub explicit_arg_count: Vec<(String, u32)>, + pub explicit_arg_sizes: Vec<(String, Vec)>, } // If the alignment is larger than u64, then we need different padding diff --git a/ptx/src/pass/convert_32bit_to_64bit.rs b/ptx/src/pass/convert_32bit_to_64bit.rs index 9760b0da8..8b1b9c22f 100644 --- a/ptx/src/pass/convert_32bit_to_64bit.rs +++ b/ptx/src/pass/convert_32bit_to_64bit.rs @@ -31,18 +31,18 @@ pub(super) fn run<'input>( TranslateError, > { let (global_ids, globals) = collect_globals(resolver, &directives)?; - let mut explicit_arg_count = Vec::new(); + let mut explicit_arg_sizes = Vec::new(); let directives = directives .into_iter() .filter_map(|directive| { - run_directive(resolver, directive, &global_ids, &mut explicit_arg_count).transpose() + run_directive(resolver, directive, &global_ids, &mut explicit_arg_sizes).transpose() }) .collect::, _>>()?; Ok(( directives, ModuleMetadata32Bit { globals, - explicit_arg_count, + explicit_arg_sizes, }, )) } @@ -136,7 +136,7 @@ fn run_directive<'input>( resolver: &mut GlobalStringIdentResolver2<'input>, directive: Directive2, SpirvWord>, globals_ids: &[SpirvWord], - explicit_arg_count: &mut Vec<(String, u32)>, + explicit_arg_sizes: &mut Vec<(String, Vec)>, ) -> Result, SpirvWord>>, TranslateError> { Ok(match directive { Directive2::Variable(linking, varinfo) if pass_through_variable(&varinfo) => { @@ -146,7 +146,7 @@ fn run_directive<'input>( resolver, method, globals_ids, - explicit_arg_count, + explicit_arg_sizes, )?)), _ => None, }) @@ -156,7 +156,7 @@ fn run_method<'input>( resolver: &mut GlobalStringIdentResolver2<'input>, mut method: Function, SpirvWord>, globals_ids: &[SpirvWord], - explicit_arg_count: &mut Vec<(String, u32)>, + explicit_arg_sizes: &mut Vec<(String, Vec)>, ) -> Result, SpirvWord>, TranslateError> { let is_kernel = method.is_kernel(); if let Some(ref mut body) = method.body { @@ -181,7 +181,12 @@ fn run_method<'input>( }) .ok_or_else(error_unreachable)? .to_string(); - explicit_arg_count.push((text_name, method.input_arguments.len() as u32)); + let argument_sizes = method + .input_arguments + .iter() + .map(|arg| arg.info.v_type.layout().unwrap().size() as u32) + .collect(); + explicit_arg_sizes.push((text_name, argument_sizes)); let implicit_memory_ptr = add_hidden_argument( resolver, ast::ScalarType::B64, diff --git a/zluda/src/impl/driver.rs b/zluda/src/impl/driver.rs index daab98a7e..a399f1f80 100644 --- a/zluda/src/impl/driver.rs +++ b/zluda/src/impl/driver.rs @@ -528,10 +528,26 @@ impl ::dark_api::zluda32::CudaDarkApi for Zluda32DarkApi { } unsafe extern "system" fn get_function_info( - explicit_argument_count: *mut u32, - module: cuda_types::cuda::CUfunction, + explicit_sizes_out: *mut u32, + explicit_count_out: *mut u32, + func: cuda_types::cuda::CUfunction, ) -> cuda_types::cuda::CUresult { - CUresult::ERROR_NOT_SUPPORTED + let func: &function::Function = FromCuda::<_, CUerror>::from_cuda(&func)?; + let explicit_arg_sizes = match &func.explicit_arg_sizes { + Some(sizes) => sizes, + None => return CUresult::ERROR_NOT_FOUND, + }; + if !explicit_sizes_out.is_null() { + std::ptr::copy_nonoverlapping( + explicit_arg_sizes.as_ptr(), + explicit_sizes_out, + explicit_arg_sizes.len(), + ); + } + if let Some(explicit_count_out) = explicit_count_out.as_mut() { + *explicit_count_out = explicit_arg_sizes.len() as u32; + } + Ok(()) } } diff --git a/zluda/src/impl/function.rs b/zluda/src/impl/function.rs index 6dd6f3144..6053083ba 100644 --- a/zluda/src/impl/function.rs +++ b/zluda/src/impl/function.rs @@ -5,6 +5,7 @@ use std::mem; pub(crate) struct Function { pub(crate) base: hipFunction_t, pub(crate) sm_version: u32, + pub(crate) explicit_arg_sizes: Option>, } impl<'a, E: zluda_common::CudaErrorType> zluda_common::FromCuda<'a, CUfunction, E> diff --git a/zluda/src/impl/module.rs b/zluda/src/impl/module.rs index 841a50658..e06c6dc45 100644 --- a/zluda/src/impl/module.rs +++ b/zluda/src/impl/module.rs @@ -31,6 +31,7 @@ impl ModuleMutable { module: hipModule_t, sm_version: u32, name: CString, + explicit_arg_sizes: Option>, ) -> Result<&Function, CUerror> { Ok(match self.functions.entry(name) { hash_map::Entry::Occupied(entry) => &*entry.into_mut(), @@ -40,6 +41,7 @@ impl ModuleMutable { let func = Box::new(Function { base: func_handle, sm_version, + explicit_arg_sizes, }); &*entry.insert(func) } @@ -61,7 +63,7 @@ impl ZludaObject for Module { pub(crate) struct Metadata32Bit { pub globals: Vec, - pub explicit_arg_counts: FxHashMap, + pub explicit_arg_sizes: FxHashMap>, } impl Metadata32Bit { @@ -75,14 +77,14 @@ impl Metadata32Bit { align: g.align, }) .collect(); - let explicit_arg_counts = meta - .explicit_arg_count + let explicit_arg_sizes = meta + .explicit_arg_sizes .iter() - .map(|kv| (kv.0.to_string(), kv.1)) + .map(|kv| (kv.0.to_string(), kv.1.clone())) .collect(); Self { globals, - explicit_arg_counts, + explicit_arg_sizes, } } @@ -96,14 +98,19 @@ impl Metadata32Bit { align: g.align.to_native(), }) .collect(); - let explicit_arg_counts = archived - .explicit_arg_count + let explicit_arg_sizes = archived + .explicit_arg_sizes .iter() - .map(|kv| (kv.0.to_string(), kv.1.to_native())) + .map(|kv| { + ( + kv.0.to_string(), + kv.1.iter().map(|&x| x.to_native()).collect(), + ) + }) .collect(); Self { globals, - explicit_arg_counts, + explicit_arg_sizes, } } } @@ -128,8 +135,13 @@ impl Module { pub(crate) fn get_function<'a>(&'a self, name: &CStr) -> Result<&'static Function, CUerror> { let mut mutable = self.mutable.lock().map_err(|_| CUerror::UNKNOWN)?; + let explicit_args = self.bit32.as_ref().and_then(|meta| { + meta.explicit_arg_sizes + .get(name.to_str().ok()?) + .map(Vec::clone) + }); mutable - .get_function(self.base, self.sm_version, name.to_owned()) + .get_function(self.base, self.sm_version, name.to_owned(), explicit_args) .map(|f| unsafe { (f as *const Function).as_ref().unwrap() }) } } diff --git a/zluda32/Cargo.toml b/zluda32/Cargo.toml index 0b1dcb41c..6dec35bd4 100644 --- a/zluda32/Cargo.toml +++ b/zluda32/Cargo.toml @@ -36,6 +36,7 @@ postcard = "1.1.3" bincode = "2.0.1" rkyv = "0.8.15" unwrap_or = "1.0.1" +rustc-hash = "2.0.0" [package.metadata.zluda] windows_only = true diff --git a/zluda32/src/ipc.rs b/zluda32/src/ipc.rs index cfc71dd04..d4b235d94 100644 --- a/zluda32/src/ipc.rs +++ b/zluda32/src/ipc.rs @@ -46,7 +46,7 @@ impl Server { } } - unsafe fn start() -> Result { + pub unsafe fn start() -> Result { let name = Alphanumeric.sample_string(&mut rand::rng(), 32); let pipe_path = format!("\\\\.\\pipe\\zluda-{name}\0"); let pipe = std::fs::File::from_raw_handle( @@ -76,65 +76,59 @@ impl Server { } } - fn get() -> Result<&'static Mutex, CUerror> { - static LOCK: OnceLock, Error>> = OnceLock::new(); - LOCK.get_or_init(|| Ok(Mutex::new(unsafe { Server::start()? }))) - .as_ref() - .map_err(|_| CUerror::UNKNOWN) - } - pub(crate) fn remote_call_zero_copy( + &mut self, opcode: Opcode, data: impl for<'a, 'b> Serialize< HighSerializer<&'a mut AlignedVec, ArenaHandle<'b>, rkyv::rancor::Failure>, >, ) -> Result { - let this = &mut *Self::get()?.lock().map_err(|_| CUerror::UNKNOWN)?; - this.buffer.clear(); - this.pipe + self.buffer.clear(); + self.pipe .write_all(&(opcode as u32).to_le_bytes()[..]) .map_err(|_| CUerror::UNKNOWN)?; let slice = - rkyv::api::high::to_bytes_in::<_, rkyv::rancor::Failure>(&data, &mut this.buffer) + rkyv::api::high::to_bytes_in::<_, rkyv::rancor::Failure>(&data, &mut self.buffer) .map_err(|_| CUerror::UNKNOWN)?; - this.pipe.write_all(&slice).map_err(|_| CUerror::UNKNOWN)?; - read_return_code(this)?; - this.buffer.resize(mem::size_of::(), 0); - this.pipe - .read_exact(&mut this.buffer) + self.pipe.write_all(&slice).map_err(|_| CUerror::UNKNOWN)?; + read_return_code(self)?; + self.buffer.resize(mem::size_of::(), 0); + self.pipe + .read_exact(&mut self.buffer) .map_err(|_| CUerror::UNKNOWN)?; - let output = unsafe { rkyv::access_unchecked::(&this.buffer) }; + let output = unsafe { rkyv::access_unchecked::(&self.buffer) }; Ok(output.clone()) } pub(crate) fn remote_call_framed_in( + &mut self, opcode: Opcode, data: impl for<'a, 'b> Serialize< HighSerializer<&'a mut AlignedVec, ArenaHandle<'b>, rkyv::rancor::Failure>, >, ) -> Result { - let this = &mut *Self::get()?.lock().map_err(|_| CUerror::UNKNOWN)?; - this.buffer.clear(); - this.pipe + self.buffer.clear(); + self.pipe .write_all(&(opcode as u32).to_le_bytes()[..]) .map_err(|_| CUerror::UNKNOWN)?; let slice = - rkyv::api::high::to_bytes_in::<_, rkyv::rancor::Failure>(&data, &mut this.buffer) + rkyv::api::high::to_bytes_in::<_, rkyv::rancor::Failure>(&data, &mut self.buffer) .map_err(|_| CUerror::UNKNOWN)?; - this.pipe + self.pipe .write_all(&(slice.len() as u32).to_le_bytes()[..]) .map_err(|_| CUerror::UNKNOWN)?; - this.pipe.write_all(&slice).map_err(|_| CUerror::UNKNOWN)?; - read_return_code(this)?; - this.buffer.resize(mem::size_of::(), 0); - this.pipe - .read_exact(&mut this.buffer) + self.pipe.write_all(&slice).map_err(|_| CUerror::UNKNOWN)?; + read_return_code(self)?; + self.buffer.resize(mem::size_of::(), 0); + self.pipe + .read_exact(&mut self.buffer) .map_err(|_| CUerror::UNKNOWN)?; - let output = unsafe { rkyv::access_unchecked::(&this.buffer) }; + let output = unsafe { rkyv::access_unchecked::(&self.buffer) }; Ok(output.clone()) } pub(crate) fn remote_call_framed_out( + &mut self, opcode: Opcode, data: impl for<'a, 'b> Serialize< HighSerializer<&'a mut AlignedVec, ArenaHandle<'b>, rkyv::rancor::Failure>, @@ -143,22 +137,21 @@ impl Server { where ::Archived: Deserialize>, { - let this = &mut *Self::get()?.lock().map_err(|_| CUerror::UNKNOWN)?; - this.buffer.clear(); - this.pipe + self.buffer.clear(); + self.pipe .write_all(&(opcode as u32).to_le_bytes()[..]) .map_err(|_| CUerror::UNKNOWN)?; let slice = - rkyv::api::high::to_bytes_in::<_, rkyv::rancor::Failure>(&data, &mut this.buffer) + rkyv::api::high::to_bytes_in::<_, rkyv::rancor::Failure>(&data, &mut self.buffer) .map_err(|_| CUerror::UNKNOWN)?; - this.pipe.write_all(&slice).map_err(|_| CUerror::UNKNOWN)?; - read_return_code(this)?; - let out_size = read_u32(this)?; - this.buffer.resize(out_size as usize, 0); - this.pipe - .read_exact(&mut this.buffer) + self.pipe.write_all(&slice).map_err(|_| CUerror::UNKNOWN)?; + read_return_code(self)?; + let out_size = read_u32(self)?; + self.buffer.resize(out_size as usize, 0); + self.pipe + .read_exact(&mut self.buffer) .map_err(|_| CUerror::UNKNOWN)?; - unsafe { rkyv::from_bytes_unchecked::(&this.buffer) } + unsafe { rkyv::from_bytes_unchecked::(&self.buffer) } .map_err(|_| CUerror::UNKNOWN) } } diff --git a/zluda32/src/lib.rs b/zluda32/src/lib.rs index dbda0acf0..f4c113350 100644 --- a/zluda32/src/lib.rs +++ b/zluda32/src/lib.rs @@ -2,10 +2,17 @@ use cuda_macros::cuda_function_declarations; use cuda_types::cuda::*; use dark_api::cuda::CudaDarkApi; use paste::paste; +use rkyv::api::high::HighSerializer; +use rkyv::de::Pool; +use rkyv::rancor::{Failure, Strategy}; use rkyv::rend::u32_le; +use rkyv::ser::allocator::ArenaHandle; +use rkyv::util::AlignedVec; +use rkyv::{Archive, Deserialize, Portable, Serialize}; +use rustc_hash::FxHashMap; use std::sync::{Mutex, OnceLock}; use std::{cell::RefCell, ffi::c_void, ptr}; -use zluda_common::{CodeLibraryRef, CodeModuleRef}; +use zluda_common::{CodeLibraryRef, CodeModuleRef, CudaErrorType}; use zluda_server_common::*; mod ipc; @@ -122,8 +129,69 @@ impl ContextStack { } } +struct GlobalState { + function_args: FxHashMap>, + server: ipc::Server, +} + +impl GlobalState { + fn get() -> Result<&'static Mutex, CUerror> { + static LOCK: OnceLock, windows::core::Error>> = OnceLock::new(); + LOCK.get_or_init(|| { + Ok(Mutex::new(GlobalState { + function_args: FxHashMap::default(), + server: unsafe { ipc::Server::start() }?, + })) + }) + .as_ref() + .map_err(|_| CUerror::UNKNOWN) + } + + pub(crate) fn remote_call_zero_copy( + opcode: Opcode, + data: impl for<'a, 'b> Serialize< + HighSerializer<&'a mut AlignedVec, ArenaHandle<'b>, rkyv::rancor::Failure>, + >, + ) -> Result { + Self::get()? + .lock() + .map_err(|_| CUerror::UNKNOWN)? + .server + .remote_call_zero_copy(opcode, data) + } + + pub(crate) fn remote_call_framed_in( + opcode: Opcode, + data: impl for<'a, 'b> Serialize< + HighSerializer<&'a mut AlignedVec, ArenaHandle<'b>, rkyv::rancor::Failure>, + >, + ) -> Result { + Self::get()? + .lock() + .map_err(|_| CUerror::UNKNOWN)? + .server + .remote_call_framed_in(opcode, data) + } + + pub(crate) fn remote_call_framed_out( + opcode: Opcode, + data: impl for<'a, 'b> Serialize< + HighSerializer<&'a mut AlignedVec, ArenaHandle<'b>, rkyv::rancor::Failure>, + >, + ) -> Result + where + ::Archived: Deserialize>, + { + Self::get()? + .lock() + .map_err(|_| CUerror::UNKNOWN)? + .server + .remote_call_framed_out(opcode, data) + } +} + pub(crate) fn cu_init(flags: u32) -> Result<(), CUerror> { - ipc::Server::remote_call_zero_copy::(Opcode::cuInit, cuInitIn { Flags: flags })?; + GlobalState::remote_call_zero_copy::(Opcode::cuInit, cuInitIn { Flags: flags })?; Ok(()) } @@ -134,7 +202,7 @@ pub(crate) fn cu_ctx_create_v2( ) -> Result<(), CUerror> { let ctx_ref = unsafe { pctx.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; let cu_ctx = CudaEncode::decode( - ipc::Server::remote_call_zero_copy::( + GlobalState::remote_call_zero_copy::( Opcode::cuCtxCreate_v2, cuCtxCreate_v2In { flags, dev }, )? @@ -158,7 +226,7 @@ pub(crate) fn cu_ctx_get_api_version( let version = unsafe { version.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; let ctx = CONTEXT_STACK.with(|s| s.unwrap(ctx))?; *version = CudaEncode::decode( - ipc::Server::remote_call_zero_copy::( + GlobalState::remote_call_zero_copy::( Opcode::cuCtxGetApiVersion, cuCtxGetApiVersionIn { ctx: CudaEncode::encode(ctx), @@ -199,7 +267,7 @@ pub(crate) fn cu_device_get( ordinal: ::core::ffi::c_int, ) -> Result<(), CUerror> { let device = unsafe { device.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - *device = ipc::Server::remote_call_zero_copy::( + *device = GlobalState::remote_call_zero_copy::( Opcode::cuDeviceGet, cuDeviceGetIn { ordinal }, )? @@ -213,7 +281,7 @@ pub(crate) fn cu_device_get_attribute( dev: CUdevice, ) -> Result<(), CUerror> { let pi = unsafe { pi.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - *pi = ipc::Server::remote_call_zero_copy::( + *pi = GlobalState::remote_call_zero_copy::( Opcode::cuDeviceGetAttribute, cuDeviceGetAttributeIn { attrib: CudaEncode::encode(attrib), @@ -226,7 +294,7 @@ pub(crate) fn cu_device_get_attribute( pub(crate) fn cu_device_get_count(count: *mut ::core::ffi::c_int) -> Result<(), CUerror> { let count = unsafe { count.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - *count = ipc::Server::remote_call_zero_copy::( + *count = GlobalState::remote_call_zero_copy::( Opcode::cuDeviceGetCount, cuDeviceGetCountIn {}, )? @@ -242,7 +310,7 @@ pub(crate) fn cu_device_get_name( if name.is_null() { return Err(CUerror::INVALID_VALUE); } - let name_out = ipc::Server::remote_call_framed_out::( + let name_out = GlobalState::remote_call_framed_out::( Opcode::cuDeviceGetName, cuDeviceGetNameIn { len, dev }, )?; @@ -262,7 +330,7 @@ pub(crate) fn cu_device_get_properties(prop: *mut CUdevprop, dev: CUdevice) -> R pub(crate) fn cu_device_total_mem_v2(bytes: *mut usize, dev: CUdevice) -> Result<(), CUerror> { let bytes = unsafe { bytes.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - *bytes = ipc::Server::remote_call_zero_copy::( + *bytes = GlobalState::remote_call_zero_copy::( Opcode::cuDeviceTotalMem_v2, cuDeviceTotalMem_v2In { dev }, )? @@ -276,7 +344,7 @@ pub(crate) fn cu_driver_get_version( driver_version: *mut ::core::ffi::c_int, ) -> Result<(), CUerror> { let driver_version = unsafe { driver_version.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - *driver_version = ipc::Server::remote_call_zero_copy::( + *driver_version = GlobalState::remote_call_zero_copy::( Opcode::cuDriverGetVersion, cuDriverGetVersionIn {}, )? @@ -318,24 +386,42 @@ pub(crate) fn cu_get_export_table( pub(crate) fn cu_launch_kernel( f: CUfunction, - gridDimX: ::core::ffi::c_uint, - gridDimY: ::core::ffi::c_uint, - gridDimZ: ::core::ffi::c_uint, - blockDimX: ::core::ffi::c_uint, - blockDimY: ::core::ffi::c_uint, - blockDimZ: ::core::ffi::c_uint, - sharedMemBytes: ::core::ffi::c_uint, - hStream: CUstream, - kernelParams: *mut *mut ::core::ffi::c_void, + grid_dim_x: ::core::ffi::c_uint, + grid_dim_y: ::core::ffi::c_uint, + grid_dim_z: ::core::ffi::c_uint, + block_dim_x: ::core::ffi::c_uint, + block_dim_y: ::core::ffi::c_uint, + block_dim_z: ::core::ffi::c_uint, + shared_mem_bytes: ::core::ffi::c_uint, + stream: CUstream, + kernel_params: *mut *mut ::core::ffi::c_void, extra: *mut *mut ::core::ffi::c_void, ) -> Result<(), CUerror> { - unimplemented!() + if !extra.is_null() { + return Err(CUerror::NOT_SUPPORTED); + } + GlobalState::remote_call_framed_in::( + Opcode::cuLaunchKernel, + cuLaunchKernelIn { + f: CudaEncode::encode(f), + grid_dim_x: u32_le::from_native(grid_dim_x), + grid_dim_y: u32_le::from_native(grid_dim_y), + grid_dim_z: u32_le::from_native(grid_dim_z), + block_dim_x: u32_le::from_native(block_dim_x), + block_dim_y: u32_le::from_native(block_dim_y), + block_dim_z: u32_le::from_native(block_dim_z), + shared_mem_bytes: u32_le::from_native(shared_mem_bytes), + stream: CudaEncode::encode(stream), + kernel_params: Vec::new(), + }, + )?; + Ok(()) } pub(crate) fn cu_mem_alloc_v2(dptr: *mut CUdeviceptr, bytesize: usize) -> Result<(), CUerror> { let dptr = unsafe { dptr.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; *dptr = CudaEncode::decode( - ipc::Server::remote_call_zero_copy::( + GlobalState::remote_call_zero_copy::( Opcode::cuMemAlloc_v2, cuMemAlloc_v2In { bytesize: u32_le::from_native(bytesize as u32), @@ -401,7 +487,7 @@ pub(crate) fn cu_memcpy_hto_d_async_v2( return Err(CUerror::INVALID_VALUE); } let slice = unsafe { std::slice::from_raw_parts(src_host.cast::(), byte_count) }; - ipc::Server::remote_call_framed_in::( + GlobalState::remote_call_framed_in::( Opcode::cuMemcpyHtoDAsync_v2, cuMemcpyHtoDAsync_v2In { dst_device: CudaEncode::encode(dst_device), @@ -426,19 +512,31 @@ pub(crate) fn cu_module_get_function( name: *const ::core::ffi::c_char, ) -> Result<(), CUerror> { let hfunc = unsafe { hfunc.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + let mut state = GlobalState::get()?.lock().map_err(|_| CUerror::UNKNOWN)?; *hfunc = CUfunction( - ipc::Server::remote_call_framed_in::( - Opcode::cuModuleGetFunction, - cuModuleGetFunctionIn { - hmod: CudaEncode::encode(hmod), - name: unsafe { std::ffi::CStr::from_ptr(name) } - .to_bytes_with_nul() - .to_vec(), - }, - )? - .hfunc - .to_native() as _, + state + .server + .remote_call_framed_in::( + Opcode::cuModuleGetFunction, + cuModuleGetFunctionIn { + hmod: CudaEncode::encode(hmod), + name: unsafe { std::ffi::CStr::from_ptr(name) } + .to_bytes_with_nul() + .to_vec(), + }, + )? + .hfunc + .to_native() as _, ); + let arg_sizes_out = state + .server + .remote_call_framed_out::( + Opcode::zludaGetFunctionArgs, + zludaGetFunctionArgsIn { + f: CudaEncode::encode(*hfunc), + }, + )?; + state.function_args.insert(*hfunc, arg_sizes_out.args); Ok(()) } @@ -451,7 +549,7 @@ pub(crate) fn cu_module_get_global_v2( let mut bytes_fallback = 0usize; let dptr = unsafe { dptr.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; let bytes = unsafe { bytes.as_mut() }.unwrap_or(&mut bytes_fallback); - let result = ipc::Server::remote_call_framed_in::( + let result = GlobalState::remote_call_framed_in::( Opcode::cuModuleGetGlobal_v2, cuModuleGetGlobal_v2In { hmod: CudaEncode::encode(hmod), @@ -471,7 +569,7 @@ pub(crate) fn cu_module_get_tex_ref( name: *const ::core::ffi::c_char, ) -> Result<(), CUerror> { let texref = unsafe { texref.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - let result = ipc::Server::remote_call_framed_in::( + let result = GlobalState::remote_call_framed_in::( Opcode::cuModuleGetTexRef, cuModuleGetTexRefIn { hmod: CudaEncode::encode(hmod), @@ -622,7 +720,7 @@ impl CudaDarkApi for DarkApi32 { last_module.to_mut().push(0); } *result = CUmodule( - ipc::Server::remote_call_framed_in::( + GlobalState::remote_call_framed_in::( Opcode::cuModuleLoadData, cuModuleLoadDataIn { image: last_module.into_owned(), @@ -700,7 +798,7 @@ impl CudaDarkApi for DarkApi32 { >, ) -> cuda_types::cuda::CUresult { let cu_ctx = CONTEXT_STACK.with(|s| s.unwrap(cu_ctx))?; - ipc::Server::remote_call_zero_copy::( + GlobalState::remote_call_zero_copy::( Opcode::ContextLocalStoragePut, ContextLocalStoragePutIn { cu_ctx: cu_ctx.encode().into(), @@ -725,7 +823,7 @@ impl CudaDarkApi for DarkApi32 { ) -> cuda_types::cuda::CUresult { let value = unsafe { value.as_mut() }.ok_or(cuda_types::cuda::CUerror::INVALID_VALUE)?; let cu_ctx = CONTEXT_STACK.with(|s| s.unwrap(cu_ctx))?; - *value = ipc::Server::remote_call_zero_copy::( + *value = GlobalState::remote_call_zero_copy::( Opcode::ContextLocalStorageGet, ContextLocalStorageGetIn { cu_ctx: cu_ctx.encode().into(), diff --git a/zluda64_server/src/main.rs b/zluda64_server/src/main.rs index 1b4cfc6cc..a9c937cc8 100644 --- a/zluda64_server/src/main.rs +++ b/zluda64_server/src/main.rs @@ -419,6 +419,15 @@ async fn main() -> std::io::Result<()> { ) .await?; } + Some(Opcode::zludaGetFunctionArgs) => { + buffer = handle_cuda_function_framed_out::< + zludaGetFunctionArgsIn, + zludaGetFunctionArgsOut, + >(&mut client, buffer, |input| { + zluda_get_function_args(&mut state, input) + }) + .await?; + } _ => { client.write_u32_le(CUerror::NOT_SUPPORTED.0.get()).await?; return Err(std::io::Error::new( @@ -430,6 +439,30 @@ async fn main() -> std::io::Result<()> { } } +fn zluda_get_function_args( + state: &mut State, + input: &ArchivedzludaGetFunctionArgsIn, +) -> Result { + let hfunc = state.handles.get(input.f.to_native())?; + let mut count = 0; + unsafe { + state.modules.dark_api.get_function_info( + std::ptr::null_mut(), + &mut count, + CUfunction(hfunc), + ) + }?; + let mut arg_sizes = vec![0; count as usize]; + unsafe { + state.modules.dark_api.get_function_info( + arg_sizes.as_mut_ptr(), + &mut count, + CUfunction(hfunc), + ) + }?; + Ok(zludaGetFunctionArgsOut { args: arg_sizes }) +} + fn cu_module_get_tex_ref( state: &mut State, input: &ArchivedcuModuleGetTexRefIn, @@ -865,7 +898,7 @@ cuda_function_declarations! { // cuEventDestroy_v2, cuGetExportTable, cuInit, - // cuLaunchKernel, + cuLaunchKernel, cuMemAlloc_v2, // cuMemFreeHost, // cuMemFree_v2, diff --git a/zluda_server_common/src/lib.rs b/zluda_server_common/src/lib.rs index 0362638fa..5029cb312 100644 --- a/zluda_server_common/src/lib.rs +++ b/zluda_server_common/src/lib.rs @@ -36,7 +36,9 @@ macro_rules! generate_messages_inout { cuModuleGetGlobal_v2, cuMemAlloc_v2, cuMemcpyHtoDAsync_v2, - cuModuleGetTexRef + cuModuleGetTexRef, + cuLaunchKernel, + zludaGetFunctionArgs } }; } @@ -68,7 +70,7 @@ cuda_function_declarations! { cuEventDestroy_v2, //cuGetExportTable, cuInit, - //cuLaunchKernel, + // cuLaunchKernel, //cuMemAlloc_v2, //cuMemFreeHost, //cuMemFree_v2, @@ -296,3 +298,34 @@ pub struct cuModuleGetTexRefIn { pub struct cuModuleGetTexRefOut { pub texref: ::WireObject, } + +#[repr(C)] +#[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct cuLaunchKernelIn { + pub f: ::WireObject, + pub grid_dim_x: u32_le, + pub grid_dim_y: u32_le, + pub grid_dim_z: u32_le, + pub block_dim_x: u32_le, + pub block_dim_y: u32_le, + pub block_dim_z: u32_le, + pub shared_mem_bytes: u32_le, + pub stream: ::WireObject, + pub kernel_params: Vec>, +} + +#[repr(C)] +#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct cuLaunchKernelOut {} + +#[repr(C)] +#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct zludaGetFunctionArgsIn { + pub f: ::WireObject, +} + +#[repr(C)] +#[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct zludaGetFunctionArgsOut { + pub args: Vec, +} From ad965c5a9d26780c4657fe48cd6cec2b120dfe34 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Tue, 2 Jun 2026 00:25:37 -0700 Subject: [PATCH 45/85] Fix kernel launch --- Cargo.lock | 2 + ptx/src/test/spirv_run/mod.rs | 9 ++-- zluda/src/impl/driver.rs | 11 +++-- zluda/src/impl/function.rs | 3 +- zluda/src/impl/module.rs | 40 +++++++++++----- zluda32/src/lib.rs | 47 +++++++++++++++++-- zluda64_server/src/main.rs | 83 +++++++++++++++++++++++++++++----- zluda_server_common/Cargo.toml | 1 + zluda_server_common/src/lib.rs | 2 +- 9 files changed, 161 insertions(+), 37 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index e9e0157d9..0c2e73c20 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -853,6 +853,7 @@ dependencies = [ "format", "lz4-sys", "paste", + "rkyv", "uuid", "zstd-safe", ] @@ -5892,6 +5893,7 @@ dependencies = [ "bitcode", "cuda_macros", "cuda_types", + "dark_api", "paste", "postcard", "rkyv", diff --git a/ptx/src/test/spirv_run/mod.rs b/ptx/src/test/spirv_run/mod.rs index faa2f3d50..f71f47c1e 100644 --- a/ptx/src/test/spirv_run/mod.rs +++ b/ptx/src/test/spirv_run/mod.rs @@ -1541,9 +1541,12 @@ fn run_zluda32 + Copy + Debug, Output: From + Copy + Debug + ) .unwrap(); let zluda32 = kernel_metadata::ModuleMetadata32Bit::read_object(&elf_module).unwrap(); - assert_eq!(zluda32.explicit_arg_count.len(), 1); - assert_eq!(zluda32.explicit_arg_count[0].0, name.to_str().unwrap()); - assert_eq!(zluda32.explicit_arg_count[0].1, 2); + assert_eq!(zluda32.explicit_args_size_align.len(), 1); + assert_eq!( + zluda32.explicit_args_size_align[0].0, + name.to_str().unwrap() + ); + assert_eq!(zluda32.explicit_args_size_align[0].1.len(), 2); let mut module = unsafe { mem::zeroed() }; unsafe { hipModuleLoadData(&mut module, elf_module.as_ptr() as _) }.unwrap(); let mut kernel = unsafe { mem::zeroed() }; diff --git a/zluda/src/impl/driver.rs b/zluda/src/impl/driver.rs index a399f1f80..11e593c7e 100644 --- a/zluda/src/impl/driver.rs +++ b/zluda/src/impl/driver.rs @@ -1,5 +1,6 @@ use crate::r#impl::{self, context, device, function, module}; use cuda_types::cuda::*; +use dark_api::FunctionArgInfo; use hip_runtime_sys::*; use libloading::Library; use std::{ @@ -528,24 +529,24 @@ impl ::dark_api::zluda32::CudaDarkApi for Zluda32DarkApi { } unsafe extern "system" fn get_function_info( - explicit_sizes_out: *mut u32, + explicit_sizes_out: *mut FunctionArgInfo, explicit_count_out: *mut u32, func: cuda_types::cuda::CUfunction, ) -> cuda_types::cuda::CUresult { let func: &function::Function = FromCuda::<_, CUerror>::from_cuda(&func)?; - let explicit_arg_sizes = match &func.explicit_arg_sizes { + let explicit_args_size_align = match &func.explicit_args_size_align { Some(sizes) => sizes, None => return CUresult::ERROR_NOT_FOUND, }; if !explicit_sizes_out.is_null() { std::ptr::copy_nonoverlapping( - explicit_arg_sizes.as_ptr(), + explicit_args_size_align.as_ptr(), explicit_sizes_out, - explicit_arg_sizes.len(), + explicit_args_size_align.len(), ); } if let Some(explicit_count_out) = explicit_count_out.as_mut() { - *explicit_count_out = explicit_arg_sizes.len() as u32; + *explicit_count_out = explicit_args_size_align.len() as u32; } Ok(()) } diff --git a/zluda/src/impl/function.rs b/zluda/src/impl/function.rs index 6053083ba..aea11d554 100644 --- a/zluda/src/impl/function.rs +++ b/zluda/src/impl/function.rs @@ -1,11 +1,12 @@ use cuda_types::cuda::{CUfunction, CUfunction_attribute, CUkernel}; +use dark_api::FunctionArgInfo; use hip_runtime_sys::*; use std::mem; pub(crate) struct Function { pub(crate) base: hipFunction_t, pub(crate) sm_version: u32, - pub(crate) explicit_arg_sizes: Option>, + pub(crate) explicit_args_size_align: Option>, } impl<'a, E: zluda_common::CudaErrorType> zluda_common::FromCuda<'a, CUfunction, E> diff --git a/zluda/src/impl/module.rs b/zluda/src/impl/module.rs index e06c6dc45..f49c72478 100644 --- a/zluda/src/impl/module.rs +++ b/zluda/src/impl/module.rs @@ -2,6 +2,7 @@ use super::driver; use crate::r#impl::function; use crate::r#impl::{driver::GlobalState, function::Function}; use cuda_types::{cuda::*, dark_api::FatbinFileHeader}; +use dark_api::FunctionArgInfo; use hip_runtime_sys::*; use rustc_hash::FxHashMap; use std::collections::hash_map; @@ -31,7 +32,7 @@ impl ModuleMutable { module: hipModule_t, sm_version: u32, name: CString, - explicit_arg_sizes: Option>, + explicit_args_size_align: Option>, ) -> Result<&Function, CUerror> { Ok(match self.functions.entry(name) { hash_map::Entry::Occupied(entry) => &*entry.into_mut(), @@ -41,7 +42,7 @@ impl ModuleMutable { let func = Box::new(Function { base: func_handle, sm_version, - explicit_arg_sizes, + explicit_args_size_align, }); &*entry.insert(func) } @@ -63,7 +64,7 @@ impl ZludaObject for Module { pub(crate) struct Metadata32Bit { pub globals: Vec, - pub explicit_arg_sizes: FxHashMap>, + pub explicit_args_size_align: FxHashMap>, } impl Metadata32Bit { @@ -77,14 +78,24 @@ impl Metadata32Bit { align: g.align, }) .collect(); - let explicit_arg_sizes = meta - .explicit_arg_sizes + let explicit_args_size_align = meta + .explicit_args_size_align .iter() - .map(|kv| (kv.0.to_string(), kv.1.clone())) + .map(|(key, value)| { + let key = key.to_string(); + let value = value + .iter() + .map(|(size, align)| FunctionArgInfo { + size: *size, + align: *align, + }) + .collect(); + (key, value) + }) .collect(); Self { globals, - explicit_arg_sizes, + explicit_args_size_align, } } @@ -98,19 +109,24 @@ impl Metadata32Bit { align: g.align.to_native(), }) .collect(); - let explicit_arg_sizes = archived - .explicit_arg_sizes + let explicit_args_size_align = archived + .explicit_args_size_align .iter() .map(|kv| { ( kv.0.to_string(), - kv.1.iter().map(|&x| x.to_native()).collect(), + kv.1.iter() + .map(|x| FunctionArgInfo { + size: x.0.to_native(), + align: x.1.to_native(), + }) + .collect(), ) }) .collect(); Self { globals, - explicit_arg_sizes, + explicit_args_size_align, } } } @@ -136,7 +152,7 @@ impl Module { pub(crate) fn get_function<'a>(&'a self, name: &CStr) -> Result<&'static Function, CUerror> { let mut mutable = self.mutable.lock().map_err(|_| CUerror::UNKNOWN)?; let explicit_args = self.bit32.as_ref().and_then(|meta| { - meta.explicit_arg_sizes + meta.explicit_args_size_align .get(name.to_str().ok()?) .map(Vec::clone) }); diff --git a/zluda32/src/lib.rs b/zluda32/src/lib.rs index f4c113350..d0fd5b0bc 100644 --- a/zluda32/src/lib.rs +++ b/zluda32/src/lib.rs @@ -1,6 +1,7 @@ use cuda_macros::cuda_function_declarations; use cuda_types::cuda::*; use dark_api::cuda::CudaDarkApi; +use dark_api::FunctionArgInfo; use paste::paste; use rkyv::api::high::HighSerializer; use rkyv::de::Pool; @@ -10,6 +11,8 @@ use rkyv::ser::allocator::ArenaHandle; use rkyv::util::AlignedVec; use rkyv::{Archive, Deserialize, Portable, Serialize}; use rustc_hash::FxHashMap; +use std::alloc::Layout; +use std::slice; use std::sync::{Mutex, OnceLock}; use std::{cell::RefCell, ffi::c_void, ptr}; use zluda_common::{CodeLibraryRef, CodeModuleRef, CudaErrorType}; @@ -130,7 +133,7 @@ impl ContextStack { } struct GlobalState { - function_args: FxHashMap>, + function_args: FxHashMap>, server: ipc::Server, } @@ -397,10 +400,46 @@ pub(crate) fn cu_launch_kernel( kernel_params: *mut *mut ::core::ffi::c_void, extra: *mut *mut ::core::ffi::c_void, ) -> Result<(), CUerror> { - if !extra.is_null() { + if !kernel_params.is_null() || extra.is_null() { return Err(CUerror::NOT_SUPPORTED); } - GlobalState::remote_call_framed_in::( + let mut state = GlobalState::get()?.lock().map_err(|_| CUerror::UNKNOWN)?; + let args = state.function_args.get(&f).ok_or(CUerror::INVALID_VALUE)?; + let extra_slice = unsafe { std::slice::from_raw_parts(extra, 5) }; + if extra_slice[0] != CU_LAUNCH_PARAM_BUFFER_POINTER_AS_INT as _ { + return Err(CUerror::INVALID_VALUE); + } + if extra_slice[2] != CU_LAUNCH_PARAM_BUFFER_SIZE_AS_INT as _ { + return Err(CUerror::INVALID_VALUE); + } + if extra_slice[4] != CU_LAUNCH_PARAM_END_AS_INT as _ { + return Err(CUerror::INVALID_VALUE); + } + let arg_ptr = extra_slice[1]; + let arg_size = unsafe { *extra_slice[3].cast::() }; + let mut total_size = 0; + let kernel_params = args + .iter() + .scan( + unsafe { Layout::from_size_align_unchecked(0, 1) }, + |layout, arg_info| { + let (new_layout, offset) = layout.extend(arg_info.to_layout().unwrap()).unwrap(); + total_size = offset + arg_info.size as usize; + *layout = new_layout; + let start = arg_ptr.wrapping_byte_add(offset as usize).cast::(); + Some(Ok(unsafe { + std::slice::from_raw_parts(start, arg_info.size as usize) + } + .to_vec())) + }, + ) + .collect::, CUerror>>()?; + if total_size as usize != arg_size { + return Err(CUerror::INVALID_VALUE); + } + dbg!(arg_size); + dbg!(&kernel_params); + state.server.remote_call_framed_in::( Opcode::cuLaunchKernel, cuLaunchKernelIn { f: CudaEncode::encode(f), @@ -412,7 +451,7 @@ pub(crate) fn cu_launch_kernel( block_dim_z: u32_le::from_native(block_dim_z), shared_mem_bytes: u32_le::from_native(shared_mem_bytes), stream: CudaEncode::encode(stream), - kernel_params: Vec::new(), + kernel_params, }, )?; Ok(()) diff --git a/zluda64_server/src/main.rs b/zluda64_server/src/main.rs index a9c937cc8..d940de8fb 100644 --- a/zluda64_server/src/main.rs +++ b/zluda64_server/src/main.rs @@ -9,6 +9,7 @@ use compio::{ }; use cuda_macros::cuda_function_declarations; use cuda_types::cuda::*; +use dark_api::FunctionArgInfo; use rkyv::{ api::high::HighSerializer, rend::{u32_le, u64_le}, @@ -24,6 +25,7 @@ use std::{ mem, ops::Range, ptr::{self, NonNull}, + rc::Rc, }; use zluda_server_common::*; @@ -131,7 +133,7 @@ impl ModuleLaunchData { }) .collect::, _>>()?; let module_data = Module { - globals, + globals: Rc::new(globals), texrefs: FxHashMap::default(), }; self.modules.insert(module, module_data); @@ -140,7 +142,7 @@ impl ModuleLaunchData { } struct Module { - globals: Vec, + globals: Rc>, texrefs: FxHashMap, u32>, } @@ -157,12 +159,10 @@ impl Global { } struct Function { - module: CUmodule, - explicit_argument_count: u32, + globals: Rc>, } struct Allocator { - device: u32, start: Option<*mut c_void>, allocator: range_alloc::RangeAllocator, allocation_ends: FxHashMap, @@ -172,9 +172,8 @@ impl Allocator { const ALLOCATION_UNIT: u32 = 128; const ALLOCATOR_SIZE: u32 = 512 * 1024 * 1024; // 512 MiB - fn new(device: u32) -> Self { + fn new() -> Self { Self { - device, start: None, allocator: range_alloc::RangeAllocator::new( // starting from 1 to avoid handing out null pointers @@ -250,9 +249,7 @@ impl State { Ok(Self { handles: HandlePool::new(), dark_api, - devmemory: (0..devices) - .map(|device| Allocator::new(device as u32)) - .collect(), + devmemory: (0..devices).map(|_| Allocator::new()).collect(), modules: ModuleLaunchData::new()?, }) } @@ -428,6 +425,14 @@ async fn main() -> std::io::Result<()> { }) .await?; } + Some(Opcode::cuLaunchKernel) => { + buffer = handle_cuda_function_framed_in::( + &mut client, + buffer, + |input| cu_launch_kernel(&mut state, input), + ) + .await?; + } _ => { client.write_u32_le(CUerror::NOT_SUPPORTED.0.get()).await?; return Err(std::io::Error::new( @@ -439,6 +444,55 @@ async fn main() -> std::io::Result<()> { } } +fn cu_launch_kernel( + state: &mut State, + input: &ArchivedcuLaunchKernelIn, +) -> Result { + let mut device = 0; + unsafe { cuCtxGetDevice(&mut device) }?; + let mut params = input + .kernel_params + .iter() + .map(|p| p.as_ptr().cast_mut().cast::()) + .collect::>(); + let mut base64_ptr = state.devmemory[device as usize].get_device_ptr()?; + params.push(ptr::from_mut(&mut base64_ptr).cast()); + let function = CUfunction(state.handles.get(input.f.to_native())?); + let function_info = state + .modules + .functions + .get(&function) + .ok_or(CUerror::INVALID_VALUE)?; + let globals = function_info + .globals + .iter() + .map(|global| global.allocation.start * Allocator::ALLOCATION_UNIT) + .collect::>(); + for g in globals.iter() { + params.push(ptr::from_ref(g).cast_mut().cast()); + } + unsafe { + cuLaunchKernel( + function, + input.grid_dim_x.to_native(), + input.grid_dim_y.to_native(), + input.grid_dim_z.to_native(), + input.block_dim_x.to_native(), + input.block_dim_y.to_native(), + input.block_dim_z.to_native(), + input.shared_mem_bytes.to_native(), + if input.stream == 0 { + CUstream(ptr::null_mut()) + } else { + CUstream(state.handles.get(input.stream.to_native())?) + }, + params.as_mut_ptr(), + std::ptr::null_mut(), + ) + }?; + Ok(cuLaunchKernelOut {}) +} + fn zluda_get_function_args( state: &mut State, input: &ArchivedzludaGetFunctionArgsIn, @@ -452,7 +506,7 @@ fn zluda_get_function_args( CUfunction(hfunc), ) }?; - let mut arg_sizes = vec![0; count as usize]; + let mut arg_sizes = vec![FunctionArgInfo { size: 0, align: 0 }; count as usize]; unsafe { state.modules.dark_api.get_function_info( arg_sizes.as_mut_ptr(), @@ -551,6 +605,13 @@ fn cu_module_get_function( let mut hfunc = unsafe { mem::zeroed() }; let hmod = state.handles.get(input.hmod.to_native())?; unsafe { cuModuleGetFunction(&mut hfunc, CUmodule(hmod), input.name.as_ptr().cast()) }?; + state + .modules + .functions + .entry(hfunc) + .or_insert_with(|| Function { + globals: Rc::clone(&state.modules.modules[&CUmodule(hmod)].globals), + }); Ok(cuModuleGetFunctionOut { hfunc: u32_le::from_native(state.handles.insert(hfunc.0)), }) diff --git a/zluda_server_common/Cargo.toml b/zluda_server_common/Cargo.toml index 21d395b4f..c1b9de263 100644 --- a/zluda_server_common/Cargo.toml +++ b/zluda_server_common/Cargo.toml @@ -5,6 +5,7 @@ authors = ["Andrzej Janik "] edition = "2021" [dependencies] +dark_api = { path = "../dark_api" } cuda_types = { path = "../cuda_types" } cuda_macros = { path = "../cuda_macros" } bitcode = "0.6.9" diff --git a/zluda_server_common/src/lib.rs b/zluda_server_common/src/lib.rs index 5029cb312..ae1bc78b9 100644 --- a/zluda_server_common/src/lib.rs +++ b/zluda_server_common/src/lib.rs @@ -327,5 +327,5 @@ pub struct zludaGetFunctionArgsIn { #[repr(C)] #[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] pub struct zludaGetFunctionArgsOut { - pub args: Vec, + pub args: Vec, } From ee7f50ee8cc81a54fb188e9b9d0aa4c7307194dd Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Tue, 2 Jun 2026 00:26:22 -0700 Subject: [PATCH 46/85] Add unused --- dark_api/Cargo.toml | 29 ++++++++++----------- dark_api/src/lib.rs | 35 +++++++++++++++++++++++--- kernel_metadata/src/lib.rs | 2 +- ptx/src/pass/convert_32bit_to_64bit.rs | 27 ++++++++++++++------ 4 files changed, 67 insertions(+), 26 deletions(-) diff --git a/dark_api/Cargo.toml b/dark_api/Cargo.toml index f65e53827..c5c65bb82 100644 --- a/dark_api/Cargo.toml +++ b/dark_api/Cargo.toml @@ -1,14 +1,15 @@ -[package] -name = "dark_api" -version = "0.0.0" -edition = "2021" - -[dependencies] -cuda_types = { path = "../cuda_types" } -format = { path = "../format" } -uuid = "1.16" -paste = "1.0" -bit-vec = "0.8.0" -cglue = "0.3.5" -lz4-sys = "1.9" -zstd-safe = { version = "7.2.4", features = ["std"] } +[package] +name = "dark_api" +version = "0.0.0" +edition = "2021" + +[dependencies] +cuda_types = { path = "../cuda_types" } +format = { path = "../format" } +uuid = "1.16" +paste = "1.0" +bit-vec = "0.8.0" +cglue = "0.3.5" +lz4-sys = "1.9" +zstd-safe = { version = "7.2.4", features = ["std"] } +rkyv = "0.8.15" diff --git a/dark_api/src/lib.rs b/dark_api/src/lib.rs index 8580be9a2..e3eac45fb 100644 --- a/dark_api/src/lib.rs +++ b/dark_api/src/lib.rs @@ -1,6 +1,7 @@ -use std::ffi::c_void; - use cuda_types::cuda::CUuuid; +use format::CudaDisplay; +use rkyv::traits::{Archive, Deserialize, Serialize}; +use std::ffi::c_void; pub mod fatbin; @@ -363,6 +364,34 @@ dark_api! { } } +#[repr(C)] +#[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone, Copy)] +pub struct FunctionArgInfo { + pub size: u32, + pub align: u32, +} + +impl FunctionArgInfo { + pub fn to_layout(self) -> Option { + std::alloc::Layout::from_size_align(self.size as usize, self.align as usize).ok() + } +} + +impl CudaDisplay for FunctionArgInfo { + fn write( + &self, + _fn_name: &'static str, + _index: usize, + writer: &mut (impl std::io::Write + ?Sized), + ) -> std::io::Result<()> { + writer.write_all(b"{ size: ")?; + CudaDisplay::write(&self.size, "", 0, writer)?; + writer.write_all(b", align: ")?; + CudaDisplay::write(&self.align, "", 0, writer)?; + writer.write_all(b" }") + } +} + // Purely for internal use by ZLUDA32 dark_api! { zluda32; @@ -376,7 +405,7 @@ dark_api! { module: cuda_types::cuda::CUmodule ) -> cuda_types::cuda::CUresult, [1] = get_function_info( - explicit_argument_sizes: *mut u32, + explicit_arguments: *mut crate::FunctionArgInfo, explicit_argument_count: *mut u32, func: cuda_types::cuda::CUfunction ) -> cuda_types::cuda::CUresult diff --git a/kernel_metadata/src/lib.rs b/kernel_metadata/src/lib.rs index 8b6415cd4..40b817141 100644 --- a/kernel_metadata/src/lib.rs +++ b/kernel_metadata/src/lib.rs @@ -43,7 +43,7 @@ pub struct Global32Bit { #[derive(Archive, Serialize, Deserialize, Debug)] pub struct ModuleMetadata32Bit { pub globals: Vec, - pub explicit_arg_sizes: Vec<(String, Vec)>, + pub explicit_args_size_align: Vec<(String, Vec<(u32, u32)>)>, } // If the alignment is larger than u64, then we need different padding diff --git a/ptx/src/pass/convert_32bit_to_64bit.rs b/ptx/src/pass/convert_32bit_to_64bit.rs index 8b1b9c22f..6ebc7f582 100644 --- a/ptx/src/pass/convert_32bit_to_64bit.rs +++ b/ptx/src/pass/convert_32bit_to_64bit.rs @@ -31,18 +31,24 @@ pub(super) fn run<'input>( TranslateError, > { let (global_ids, globals) = collect_globals(resolver, &directives)?; - let mut explicit_arg_sizes = Vec::new(); + let mut explicit_args_size_align = Vec::new(); let directives = directives .into_iter() .filter_map(|directive| { - run_directive(resolver, directive, &global_ids, &mut explicit_arg_sizes).transpose() + run_directive( + resolver, + directive, + &global_ids, + &mut explicit_args_size_align, + ) + .transpose() }) .collect::, _>>()?; Ok(( directives, ModuleMetadata32Bit { globals, - explicit_arg_sizes, + explicit_args_size_align, }, )) } @@ -136,7 +142,7 @@ fn run_directive<'input>( resolver: &mut GlobalStringIdentResolver2<'input>, directive: Directive2, SpirvWord>, globals_ids: &[SpirvWord], - explicit_arg_sizes: &mut Vec<(String, Vec)>, + explicit_args_size_align: &mut Vec<(String, Vec<(u32, u32)>)>, ) -> Result, SpirvWord>>, TranslateError> { Ok(match directive { Directive2::Variable(linking, varinfo) if pass_through_variable(&varinfo) => { @@ -146,7 +152,7 @@ fn run_directive<'input>( resolver, method, globals_ids, - explicit_arg_sizes, + explicit_args_size_align, )?)), _ => None, }) @@ -156,7 +162,7 @@ fn run_method<'input>( resolver: &mut GlobalStringIdentResolver2<'input>, mut method: Function, SpirvWord>, globals_ids: &[SpirvWord], - explicit_arg_sizes: &mut Vec<(String, Vec)>, + explicit_args_size_align: &mut Vec<(String, Vec<(u32, u32)>)>, ) -> Result, SpirvWord>, TranslateError> { let is_kernel = method.is_kernel(); if let Some(ref mut body) = method.body { @@ -184,9 +190,14 @@ fn run_method<'input>( let argument_sizes = method .input_arguments .iter() - .map(|arg| arg.info.v_type.layout().unwrap().size() as u32) + .map(|arg| { + let layout = arg.info.v_type.layout().unwrap(); + let size = layout.size() as u32; + let align = layout.align() as u32; + (size, align) + }) .collect(); - explicit_arg_sizes.push((text_name, argument_sizes)); + explicit_args_size_align.push((text_name, argument_sizes)); let implicit_memory_ptr = add_hidden_argument( resolver, ast::ScalarType::B64, From ed71e85e0414fc21fea7861d810236e434e55a02 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Tue, 2 Jun 2026 21:16:18 -0700 Subject: [PATCH 47/85] Copy and sync --- zluda32/src/lib.rs | 37 ++++++++++++++++------ zluda64_server/src/main.rs | 56 ++++++++++++++++++++++++++++++++-- zluda_server_common/src/lib.rs | 17 ++++++++++- 3 files changed, 98 insertions(+), 12 deletions(-) diff --git a/zluda32/src/lib.rs b/zluda32/src/lib.rs index d0fd5b0bc..607772e0f 100644 --- a/zluda32/src/lib.rs +++ b/zluda32/src/lib.rs @@ -254,7 +254,11 @@ pub(crate) fn cu_ctx_get_device(device: *mut CUdevice) -> Result<(), CUerror> { } pub(crate) fn cu_ctx_synchronize() -> Result<(), CUerror> { - unimplemented!() + GlobalState::remote_call_zero_copy::( + Opcode::cuCtxSynchronize, + cuCtxSynchronizeIn {}, + )?; + Ok(()) } pub(crate) fn cu_device_compute_capability( @@ -493,8 +497,10 @@ pub(crate) fn cu_mem_host_alloc( _flags: ::core::ffi::c_uint, ) -> Result<(), CUerror> { let pp = unsafe { pp.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - *pp = unsafe { std::alloc::alloc(std::alloc::Layout::from_size_align(bytesize, 32).unwrap()) } - .cast(); + *pp = unsafe { + std::alloc::alloc_zeroed(std::alloc::Layout::from_size_align(bytesize, 32).unwrap()) + } + .cast(); Ok(()) } @@ -508,12 +514,25 @@ pub(crate) fn cu_memcpy_dto_d_async_v2( } pub(crate) fn cu_memcpy_dto_h_async_v2( - dstHost: *mut ::core::ffi::c_void, - srcDevice: CUdeviceptr, - ByteCount: usize, - hStream: CUstream, + dst_host: *mut ::core::ffi::c_void, + src_device: CUdeviceptr, + byte_count: usize, + stream: CUstream, ) -> Result<(), CUerror> { - unimplemented!() + if dst_host.is_null() || src_device.0.is_null() { + return Err(CUerror::INVALID_VALUE); + } + let dst_slice = unsafe { std::slice::from_raw_parts_mut(dst_host.cast::(), byte_count) }; + let result = GlobalState::remote_call_framed_out::( + Opcode::cuMemcpyDtoHAsync_v2, + cuMemcpyDtoHAsync_v2In { + src_device: CudaEncode::encode(src_device), + stream: CudaEncode::encode(stream), + byte_count: u32_le::from_native(byte_count as u32), + }, + )?; + dst_slice.copy_from_slice(&result.dst_host); + Ok(()) } pub(crate) fn cu_memcpy_hto_d_async_v2( @@ -522,7 +541,7 @@ pub(crate) fn cu_memcpy_hto_d_async_v2( byte_count: usize, h_stream: CUstream, ) -> Result<(), CUerror> { - if src_host.is_null() { + if src_host.is_null() || dst_device.0.is_null() { return Err(CUerror::INVALID_VALUE); } let slice = unsafe { std::slice::from_raw_parts(src_host.cast::(), byte_count) }; diff --git a/zluda64_server/src/main.rs b/zluda64_server/src/main.rs index d940de8fb..8a1f7165b 100644 --- a/zluda64_server/src/main.rs +++ b/zluda64_server/src/main.rs @@ -433,6 +433,23 @@ async fn main() -> std::io::Result<()> { ) .await?; } + Some(Opcode::cuCtxSynchronize) => { + buffer = handle_cuda_function::( + &mut client, + buffer, + |input| cu_ctx_synchronize(&mut state, input), + ) + .await?; + } + Some(Opcode::cuMemcpyDtoHAsync_v2) => { + buffer = handle_cuda_function_framed_out::< + cuMemcpyDtoHAsync_v2In, + cuMemcpyDtoHAsync_v2Out, + >(&mut client, buffer, |input| { + cu_memcpy_dtoh_async_v2(&mut state, input) + }) + .await?; + } _ => { client.write_u32_le(CUerror::NOT_SUPPORTED.0.get()).await?; return Err(std::io::Error::new( @@ -444,6 +461,40 @@ async fn main() -> std::io::Result<()> { } } +fn cu_memcpy_dtoh_async_v2( + state: &mut State, + input: &ArchivedcuMemcpyDtoHAsync_v2In, +) -> Result { + let mut device = 0; + unsafe { cuCtxGetDevice(&mut device) }?; + let devptr = state.devmemory[device as usize].translate(input.src_device.to_native())?; + let stream = input.stream.to_native(); + let stream = if stream == 0 { + CUstream(ptr::null_mut()) + } else { + CUstream(state.handles.get(stream)?) + }; + let mut dst_host = vec![0u8; input.byte_count.to_native() as usize]; + unsafe { + cuMemcpyDtoHAsync_v2( + dst_host.as_mut_ptr().cast(), + CUdeviceptr_v2(devptr), + input.byte_count.to_native() as usize, + stream, + ) + }?; + unsafe { cuStreamSynchronize(stream) }?; + Ok(cuMemcpyDtoHAsync_v2Out { dst_host }) +} + +fn cu_ctx_synchronize( + state: &mut State, + input: &ArchivedcuCtxSynchronizeIn, +) -> Result { + unsafe { cuCtxSynchronize() }?; + Ok(cuCtxSynchronizeOut {}) +} + fn cu_launch_kernel( state: &mut State, input: &ArchivedcuLaunchKernelIn, @@ -946,7 +997,7 @@ cuda_function_declarations! { cuCtxGetApiVersion, // cuCtxGetCurrent, cuCtxGetDevice, - // cuCtxSynchronize, + cuCtxSynchronize, // cuDeviceComputeCapability, cuDeviceGet, cuDeviceGetAttribute, @@ -966,7 +1017,7 @@ cuda_function_declarations! { // cuMemGetAddressRange_v2, // cuMemHostAlloc, // cuMemcpyDtoDAsync_v2, - // cuMemcpyDtoHAsync_v2, + cuMemcpyDtoHAsync_v2, cuMemcpyHtoD_v2, cuMemcpyHtoDAsync_v2, // cuMemsetD8_v2, @@ -985,5 +1036,6 @@ cuda_function_declarations! { // cuTexRefSetMipmapFilterMode, // cuTexRefSetMipmapLevelBias, // cuTexRefSetMipmapLevelClamp, + cuStreamSynchronize, ] } diff --git a/zluda_server_common/src/lib.rs b/zluda_server_common/src/lib.rs index ae1bc78b9..ee6427769 100644 --- a/zluda_server_common/src/lib.rs +++ b/zluda_server_common/src/lib.rs @@ -38,7 +38,8 @@ macro_rules! generate_messages_inout { cuMemcpyHtoDAsync_v2, cuModuleGetTexRef, cuLaunchKernel, - zludaGetFunctionArgs + zludaGetFunctionArgs, + cuMemcpyDtoHAsync_v2 } }; } @@ -329,3 +330,17 @@ pub struct zludaGetFunctionArgsIn { pub struct zludaGetFunctionArgsOut { pub args: Vec, } + +#[repr(C)] +#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct cuMemcpyDtoHAsync_v2In { + pub src_device: ::WireObject, + pub stream: ::WireObject, + pub byte_count: u32_le, +} + +#[repr(C)] +#[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct cuMemcpyDtoHAsync_v2Out { + pub dst_host: Vec, +} From a4018363d454ec1d2b878ff9287b853e29a19508 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Fri, 5 Jun 2026 00:24:12 -0700 Subject: [PATCH 48/85] Fix compiler --- ptx/src/pass/llvm/emit.rs | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/ptx/src/pass/llvm/emit.rs b/ptx/src/pass/llvm/emit.rs index 5eae98702..f23a488f5 100644 --- a/ptx/src/pass/llvm/emit.rs +++ b/ptx/src/pass/llvm/emit.rs @@ -1689,6 +1689,17 @@ impl<'a> MethodEmitContext<'a> { (data.state_space, ast::StateSpace::Generic) } }; + if self.base_32bit_memory.is_some() + && matches!( + to_space, + ast::StateSpace::Global | ast::StateSpace::Generic | ast::StateSpace::Const + ) + { + return self.emit_mov(ast::MovArgs { + dst: arguments.dst, + src: arguments.src, + }); + } let from_type = get_pointer_type(self.context, from_space)?; let dest_type = get_pointer_type(self.context, to_space)?; let src = self.resolver.value(arguments.src)?; From 2fc6f6638bfc25b081036bfec8575efdedb3fbd0 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Sat, 6 Jun 2026 00:42:04 -0700 Subject: [PATCH 49/85] More texref --- zluda/src/impl/hipfix.rs | 3 + zluda/src/impl/tex.rs | 3 + zluda32/src/ipc.rs | 3 +- zluda32/src/lib.rs | 104 ++++++++++++++++++-------- zluda64_server/src/main.rs | 130 ++++++++++++++++++++++++++++++--- zluda_server_common/src/lib.rs | 14 +++- 6 files changed, 212 insertions(+), 45 deletions(-) diff --git a/zluda/src/impl/hipfix.rs b/zluda/src/impl/hipfix.rs index f8de70767..3326da8cd 100644 --- a/zluda/src/impl/hipfix.rs +++ b/zluda/src/impl/hipfix.rs @@ -18,6 +18,9 @@ const HIP_TRSA_OVERRIDE_FORMAT: u32 = 1; pub(crate) unsafe fn refresh_texref(raw_texref: *mut textureReference) -> hipError_t { let texref = raw_texref.as_ref().ok_or(hipErrorCode_t::InvalidValue)?; let mut res_desc = std::mem::zeroed(); + if texref.textureObject.is_null() { + return Ok(()); + } hipTexObjectGetResourceDesc(&mut res_desc, texref.textureObject)?; match res_desc.resType { HIPresourcetype::HIP_RESOURCE_TYPE_ARRAY => hipTexRefSetArray( diff --git a/zluda/src/impl/tex.rs b/zluda/src/impl/tex.rs index 225e10a2a..347469a65 100644 --- a/zluda/src/impl/tex.rs +++ b/zluda/src/impl/tex.rs @@ -101,6 +101,9 @@ pub(crate) unsafe fn ref_set_address_v2( dev_ptr: hipDeviceptr_t, bytes: usize, ) -> hipError_t { + if dev_ptr.0.is_null() { + return hipUnbindTexture(texref); + } hipTexRefSetAddress(byte_offset, texref, dev_ptr, bytes) } diff --git a/zluda32/src/ipc.rs b/zluda32/src/ipc.rs index d4b235d94..fc527aec6 100644 --- a/zluda32/src/ipc.rs +++ b/zluda32/src/ipc.rs @@ -24,7 +24,8 @@ fn server_path() -> &'static str { if cfg!(debug_assertions) { r"C:\dev\ZLUDA\target\debug\zluda64_server.exe" } else { - "zluda64_server.exe" + //"zluda64_server.exe" + r"C:\dev\ZLUDA\target\release\zluda64_server.exe" } } diff --git a/zluda32/src/lib.rs b/zluda32/src/lib.rs index 607772e0f..5b8c69739 100644 --- a/zluda32/src/lib.rs +++ b/zluda32/src/lib.rs @@ -441,8 +441,6 @@ pub(crate) fn cu_launch_kernel( if total_size as usize != arg_size { return Err(CUerror::INVALID_VALUE); } - dbg!(arg_size); - dbg!(&kernel_params); state.server.remote_call_framed_in::( Opcode::cuLaunchKernel, cuLaunchKernelIn { @@ -488,7 +486,17 @@ pub(crate) fn cu_mem_get_address_range_v2( psize: *mut usize, dptr: CUdeviceptr, ) -> Result<(), CUerror> { - unimplemented!() + let pbase = unsafe { pbase.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + let psize = unsafe { psize.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + let result = GlobalState::remote_call_zero_copy::( + Opcode::cuMemGetAddressRange_v2, + cuMemGetAddressRange_v2In { + dptr: CudaEncode::encode(dptr), + }, + )?; + *pbase = CudaEncode::decode(result.pbase); + *psize = result.psize.to_native() as usize; + Ok(()) } pub(crate) fn cu_mem_host_alloc( @@ -652,71 +660,103 @@ pub(crate) fn cu_stream_destroy_v2(hStream: CUstream) -> Result<(), CUerror> { } pub(crate) fn cu_tex_ref_set_address_mode( - hTexRef: CUtexref, - dim: ::core::ffi::c_int, - am: CUaddress_mode, + _tex_ref: CUtexref, + _dim: ::core::ffi::c_int, + _am: CUaddress_mode, ) -> Result<(), CUerror> { - unimplemented!() + // TODO + Ok(()) } pub(crate) fn cu_tex_ref_set_address_v2( - ByteOffset: *mut usize, - hTexRef: CUtexref, + byte_offset: *mut usize, + tex_ref: CUtexref, dptr: CUdeviceptr, bytes: usize, ) -> Result<(), CUerror> { - unimplemented!() + let mut bytes_fallback = 0usize; + let byte_offset = unsafe { byte_offset.as_mut() }.unwrap_or(&mut bytes_fallback); + let result = GlobalState::remote_call_zero_copy::( + Opcode::cuTexRefSetAddress_v2, + cuTexRefSetAddress_v2In { + hTexRef: CudaEncode::encode(tex_ref), + dptr: CudaEncode::encode(dptr), + bytes: u32_le::from_native(bytes as u32), + }, + )?; + *byte_offset = CudaEncode::decode(result.ByteOffset); + Ok(()) } pub(crate) fn cu_tex_ref_set_filter_mode( - hTexRef: CUtexref, - fm: CUfilter_mode, + _tex_ref: CUtexref, + _fm: CUfilter_mode, ) -> Result<(), CUerror> { - unimplemented!() + // TODO + Ok(()) } pub(crate) fn cu_tex_ref_set_flags( - hTexRef: CUtexref, - Flags: ::core::ffi::c_uint, + tex_ref: CUtexref, + flags: ::core::ffi::c_uint, ) -> Result<(), CUerror> { - unimplemented!() + GlobalState::remote_call_zero_copy::( + Opcode::cuTexRefSetFlags, + cuTexRefSetFlagsIn { + hTexRef: CudaEncode::encode(tex_ref), + Flags: flags, + }, + )?; + Ok(()) } pub(crate) fn cu_tex_ref_set_format( - hTexRef: CUtexref, + tex_ref: CUtexref, fmt: CUarray_format, - NumPackedComponents: ::core::ffi::c_int, + num_packed_components: ::core::ffi::c_int, ) -> Result<(), CUerror> { - unimplemented!() + GlobalState::remote_call_zero_copy::( + Opcode::cuTexRefSetFormat, + cuTexRefSetFormatIn { + hTexRef: CudaEncode::encode(tex_ref), + fmt: fmt.0.into(), + NumPackedComponents: num_packed_components, + }, + )?; + Ok(()) } pub(crate) fn cu_tex_ref_set_max_anisotropy( - hTexRef: CUtexref, - maxAniso: ::core::ffi::c_uint, + _tex_ref: CUtexref, + _max_aniso: ::core::ffi::c_uint, ) -> Result<(), CUerror> { - unimplemented!() + // TODO + Ok(()) } pub(crate) fn cu_tex_ref_set_mipmap_filter_mode( - hTexRef: CUtexref, - fm: CUfilter_mode, + _tex_ref: CUtexref, + _fm: CUfilter_mode, ) -> Result<(), CUerror> { - unimplemented!() + // TODO + Ok(()) } pub(crate) fn cu_tex_ref_set_mipmap_level_bias( - hTexRef: CUtexref, - bias: f32, + _tex_ref: CUtexref, + _bias: f32, ) -> Result<(), CUerror> { - unimplemented!() + // TODO + Ok(()) } pub(crate) fn cu_tex_ref_set_mipmap_level_clamp( - hTexRef: CUtexref, - minMipmapLevelClamp: f32, - maxMipmapLevelClamp: f32, + _tex_ref: CUtexref, + _min_mipmap_level_clamp: f32, + _max_mipmap_level_clamp: f32, ) -> Result<(), CUerror> { - unimplemented!() + // TODO + Ok(()) } struct UnknownBuffer { diff --git a/zluda64_server/src/main.rs b/zluda64_server/src/main.rs index 8a1f7165b..10cfd24d5 100644 --- a/zluda64_server/src/main.rs +++ b/zluda64_server/src/main.rs @@ -20,6 +20,7 @@ use rkyv::{ use rustc_hash::FxHashMap; use slab::Slab; use std::{ + collections::BTreeMap, ffi::{c_void, CStr, CString}, io::{self, Write}, mem, @@ -165,7 +166,7 @@ struct Function { struct Allocator { start: Option<*mut c_void>, allocator: range_alloc::RangeAllocator, - allocation_ends: FxHashMap, + allocation_ends: BTreeMap, } impl Allocator { @@ -179,7 +180,7 @@ impl Allocator { // starting from 1 to avoid handing out null pointers 1..Self::ALLOCATOR_SIZE / Self::ALLOCATION_UNIT, ), - allocation_ends: FxHashMap::default(), + allocation_ends: BTreeMap::new(), } } @@ -231,6 +232,19 @@ impl Allocator { let base_ptr = self.get_device_ptr()?; Ok(base_ptr.wrapping_byte_add(range.start as usize * Self::ALLOCATION_UNIT as usize)) } + + fn get_range(&self, mut offset: u32) -> Option> { + offset /= Self::ALLOCATION_UNIT; + // Find last pair where `start <= ptr` + let (start, alloc) = self.allocation_ends.range(..=offset).rev().next()?; + let range = *start..*alloc; + // Check if allocation contains the pointer + if range.contains(&offset) { + Some(range) + } else { + None + } + } } impl State { @@ -437,7 +451,7 @@ async fn main() -> std::io::Result<()> { buffer = handle_cuda_function::( &mut client, buffer, - |input| cu_ctx_synchronize(&mut state, input), + cu_ctx_synchronize, ) .await?; } @@ -450,6 +464,39 @@ async fn main() -> std::io::Result<()> { }) .await?; } + Some(Opcode::cuMemGetAddressRange_v2) => { + buffer = handle_cuda_function::< + cuMemGetAddressRange_v2In, + cuMemGetAddressRange_v2Out, + >(&mut client, buffer, |input| { + cu_mem_get_address_range_v2(&mut state, input) + }) + .await?; + } + Some(Opcode::cuTexRefSetAddress_v2) => { + buffer = handle_cuda_function::( + &mut client, + buffer, + |input| cu_tex_ref_set_address_v2(&mut state, input), + ) + .await?; + } + Some(Opcode::cuTexRefSetFlags) => { + buffer = handle_cuda_function::( + &mut client, + buffer, + |input| cu_tex_ref_set_flags(&mut state, input), + ) + .await?; + } + Some(Opcode::cuTexRefSetFormat) => { + buffer = handle_cuda_function::( + &mut client, + buffer, + |input| cu_tex_ref_set_format(&mut state, input), + ) + .await?; + } _ => { client.write_u32_le(CUerror::NOT_SUPPORTED.0.get()).await?; return Err(std::io::Error::new( @@ -461,6 +508,72 @@ async fn main() -> std::io::Result<()> { } } +fn cu_tex_ref_set_format( + state: &mut State, + input: &ArchivedcuTexRefSetFormatIn, +) -> Result { + let tex_ref = state.handles.get(input.hTexRef.to_native())?; + unsafe { + cuTexRefSetFormat( + tex_ref, + CUarray_format(input.fmt.to_native()), + input.NumPackedComponents.to_native(), + ) + }?; + Ok(cuTexRefSetFormatOut {}) +} + +fn cu_tex_ref_set_flags( + state: &mut State, + input: &ArchivedcuTexRefSetFlagsIn, +) -> Result { + let tex_ref = state.handles.get(input.hTexRef.to_native())?; + unsafe { cuTexRefSetFlags(tex_ref, input.Flags.to_native()) }?; + Ok(cuTexRefSetFlagsOut {}) +} + +fn cu_tex_ref_set_address_v2( + state: &mut State, + input: &ArchivedcuTexRefSetAddress_v2In, +) -> Result { + let mut device = 0; + unsafe { cuCtxGetDevice(&mut device) }?; + let mut byte_offset = 0; + let dptr = input.dptr.to_native(); + let dptr = if dptr != 0 { + CUdeviceptr_v2(state.devmemory[device as usize].translate(dptr)?) + } else { + CUdeviceptr_v2(ptr::null_mut()) + }; + unsafe { + cuTexRefSetAddress_v2( + &mut byte_offset, + state.handles.get(input.hTexRef.to_native())?, + dptr, + input.bytes.to_native() as usize, + ) + }?; + Ok(cuTexRefSetAddress_v2Out { + ByteOffset: (byte_offset as u32).into(), + }) +} + +fn cu_mem_get_address_range_v2( + state: &mut State, + input: &ArchivedcuMemGetAddressRange_v2In, +) -> Result { + let mut device = 0; + unsafe { cuCtxGetDevice(&mut device) }?; + let allocator = &state.devmemory[device as usize]; + let range = allocator + .get_range(input.dptr.to_native()) + .ok_or(CUerror::INVALID_VALUE)?; + Ok(cuMemGetAddressRange_v2Out { + pbase: (range.start * Allocator::ALLOCATION_UNIT).into(), + psize: ((range.end - range.start) * Allocator::ALLOCATION_UNIT).into(), + }) +} + fn cu_memcpy_dtoh_async_v2( state: &mut State, input: &ArchivedcuMemcpyDtoHAsync_v2In, @@ -487,10 +600,7 @@ fn cu_memcpy_dtoh_async_v2( Ok(cuMemcpyDtoHAsync_v2Out { dst_host }) } -fn cu_ctx_synchronize( - state: &mut State, - input: &ArchivedcuCtxSynchronizeIn, -) -> Result { +fn cu_ctx_synchronize(input: &ArchivedcuCtxSynchronizeIn) -> Result { unsafe { cuCtxSynchronize() }?; Ok(cuCtxSynchronizeOut {}) } @@ -1028,10 +1138,10 @@ cuda_function_declarations! { // cuStreamCreate, // cuStreamDestroy_v2, // cuTexRefSetAddressMode, - // cuTexRefSetAddress_v2, + cuTexRefSetAddress_v2, // cuTexRefSetFilterMode, - // cuTexRefSetFlags, - // cuTexRefSetFormat, + cuTexRefSetFlags, + cuTexRefSetFormat, // cuTexRefSetMaxAnisotropy, // cuTexRefSetMipmapFilterMode, // cuTexRefSetMipmapLevelBias, diff --git a/zluda_server_common/src/lib.rs b/zluda_server_common/src/lib.rs index ee6427769..cf1e28a06 100644 --- a/zluda_server_common/src/lib.rs +++ b/zluda_server_common/src/lib.rs @@ -75,7 +75,7 @@ cuda_function_declarations! { //cuMemAlloc_v2, //cuMemFreeHost, //cuMemFree_v2, - // cuMemGetAddressRange_v2, + cuMemGetAddressRange_v2, //cuMemHostAlloc, //cuMemcpyDtoDAsync_v2, //cuMemcpyDtoHAsync_v2, @@ -87,7 +87,7 @@ cuda_function_declarations! { cuStreamCreate, cuStreamDestroy_v2, cuTexRefSetAddressMode, - // cuTexRefSetAddress_v2, + cuTexRefSetAddress_v2, cuTexRefSetFilterMode, cuTexRefSetFlags, cuTexRefSetFormat, @@ -170,6 +170,16 @@ encode_as_u32!(CUmodule); encode_as_u32!(CUstream); encode_as_u32!(CUtexref); +impl CudaEncode for usize { + type WireObject = u32_le; + fn encode(self) -> u32_le { + (self as u32).into() + } + fn decode(o: Self::WireObject) -> Self { + o.to_native() as usize + } +} + #[repr(C)] #[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] pub struct CUdevprop_v1_Wire { From a1a1fd51b87dac73ab500118377d187d72dde14f Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Sat, 6 Jun 2026 01:05:27 -0700 Subject: [PATCH 50/85] Better check for cvta --- ptx/src/pass/llvm/emit.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ptx/src/pass/llvm/emit.rs b/ptx/src/pass/llvm/emit.rs index f23a488f5..d260b9072 100644 --- a/ptx/src/pass/llvm/emit.rs +++ b/ptx/src/pass/llvm/emit.rs @@ -1691,7 +1691,7 @@ impl<'a> MethodEmitContext<'a> { }; if self.base_32bit_memory.is_some() && matches!( - to_space, + data.state_space, ast::StateSpace::Global | ast::StateSpace::Generic | ast::StateSpace::Const ) { From 9887f1509c5191e5f30a821a9357336678d060f1 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Sat, 6 Jun 2026 01:35:41 -0700 Subject: [PATCH 51/85] Move texrefs to global space --- ptx/lib/zluda_ptx_impl.bc | 2 +- ptx/lib/zluda_ptx_impl.cpp | 39 +++++++++++++++++++------------------- 2 files changed, 21 insertions(+), 20 deletions(-) diff --git a/ptx/lib/zluda_ptx_impl.bc b/ptx/lib/zluda_ptx_impl.bc index 18faf0642..4e3e75df4 100644 --- a/ptx/lib/zluda_ptx_impl.bc +++ b/ptx/lib/zluda_ptx_impl.bc @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:75830bf46a0eec919a2fd37a3d0922152bb34622f368a6ffa01bbe1d7ef193ec +oid sha256:cc872660a9289e0796b6f8de1cb0a51bf62c895d9ac0f2eaf680d7a46628d470 size 45052 diff --git a/ptx/lib/zluda_ptx_impl.cpp b/ptx/lib/zluda_ptx_impl.cpp index fb232ffe0..96c41ec44 100644 --- a/ptx/lib/zluda_ptx_impl.cpp +++ b/ptx/lib/zluda_ptx_impl.cpp @@ -50,6 +50,7 @@ then cd to the directory with this file and run this simple command: #include #include +#define GLOBAL_SPACE __attribute__((address_space(1))) #define SHARED_SPACE __attribute__((address_space(3))) #define CONSTANT_SPACE __attribute__((address_space(4))) @@ -1034,25 +1035,25 @@ extern "C" c; } - static std::pair get_image_and_sampler(uint64_t texobj) __device__ + static std::pair get_image_and_sampler(uint64_t texobj) __device__ { - unsigned int CONSTANT_SPACE *image = (unsigned int CONSTANT_SPACE *)texobj; - unsigned int ADDRESS_SPACE_CONSTANT *sampler = image + HIP_SAMPLER_OBJECT_OFFSET_DWORD; + unsigned int GLOBAL_SPACE *image = (unsigned int GLOBAL_SPACE *)texobj; + unsigned int GLOBAL_SPACE *sampler = image + HIP_SAMPLER_OBJECT_OFFSET_DWORD; return {image, sampler}; } - static v4f32 sample_1D(CONSTANT_SPACE void *image, CONSTANT_SPACE void *sampler, float coord) __device__ + static v4f32 sample_1D(GLOBAL_SPACE void *image, GLOBAL_SPACE void *sampler, float coord) __device__ { __device__ v4f32 __llvm_amdgcn_image_sample_lz_1d_v4f32_f32(uint32_t, float, v8s32, v4s32, bool, int, int) __asm("llvm.amdgcn.image.sample.lz.1d.v4f32.f32"); - CONSTANT_SPACE v8s32 *image_typed = (CONSTANT_SPACE v8s32 *)image; - CONSTANT_SPACE v4s32 *sampler_typed = (CONSTANT_SPACE v4s32 *)sampler; + GLOBAL_SPACE v8s32 *image_typed = (GLOBAL_SPACE v8s32 *)image; + GLOBAL_SPACE v4s32 *sampler_typed = (GLOBAL_SPACE v4s32 *)sampler; return __llvm_amdgcn_image_sample_lz_1d_v4f32_f32(0xf, coord, *image_typed, *sampler_typed, false, 0, 0); } - static v4f32 sample_1Db(CONSTANT_SPACE void *image, s32 coord) __device__ + static v4f32 sample_1Db(GLOBAL_SPACE void *image, s32 coord) __device__ { __device__ v4f32 __llvm_amdgcn_struct_buffer_load_format_v4f32(v4s32, int, int, int, int) __asm("llvm.amdgcn.struct.buffer.load.format.v4f32"); - CONSTANT_SPACE v4s32 *image_typed = (CONSTANT_SPACE v4s32 *)image; + GLOBAL_SPACE v4s32 *image_typed = (GLOBAL_SPACE v4s32 *)image; return __llvm_amdgcn_struct_buffer_load_format_v4f32(*image_typed, coord, 0, 0, 0); } #define tex_1d(RETURN_TYPE) \ @@ -1062,7 +1063,7 @@ extern "C" auto result = sample_1D(i, s, coord.x); \ return v4##RETURN_TYPE{std::bit_cast(result.x), std::bit_cast(result.y), std::bit_cast(result.z), std::bit_cast(result.w)}; \ } \ - v4##RETURN_TYPE FUNC(texref_1d_v4_##RETURN_TYPE##_f32)(struct textureReference CONSTANT_SPACE * texref, v1f32 coord) \ + v4##RETURN_TYPE FUNC(texref_1d_v4_##RETURN_TYPE##_f32)(struct textureReference GLOBAL_SPACE * texref, v1f32 coord) \ { \ return FUNC_CALL(texobj_1d_v4_##RETURN_TYPE##_f32)(uint64_t(texref->textureObject), coord); \ } @@ -1073,7 +1074,7 @@ extern "C" auto result = sample_1Db(i, coord.x); \ return v4##RETURN_TYPE{std::bit_cast(result.x), std::bit_cast(result.y), std::bit_cast(result.z), std::bit_cast(result.w)}; \ } \ - v4##RETURN_TYPE FUNC(texref_1d_v4_##RETURN_TYPE##_s32)(struct textureReference CONSTANT_SPACE * texref, v1s32 coord) \ + v4##RETURN_TYPE FUNC(texref_1d_v4_##RETURN_TYPE##_s32)(struct textureReference GLOBAL_SPACE * texref, v1s32 coord) \ { \ return FUNC_CALL(texobj_1d_v4_##RETURN_TYPE##_s32)(uint64_t(texref->textureObject), coord); \ } @@ -1083,11 +1084,11 @@ extern "C" tex_1db(s32); tex_1db(f32); - static v4f32 sample_2D(CONSTANT_SPACE void *image, CONSTANT_SPACE void *sampler, v2f32 coord) __device__ + static v4f32 sample_2D(GLOBAL_SPACE void *image, GLOBAL_SPACE void *sampler, v2f32 coord) __device__ { __device__ v4f32 __llvm_amdgcn_image_sample_lz_2d_v4f32_f32(uint32_t, float, float, v8s32, v4s32, bool, int, int) __asm("llvm.amdgcn.image.sample.lz.2d.v4f32.f32"); - CONSTANT_SPACE v8s32 *image_typed = (CONSTANT_SPACE v8s32 *)image; - CONSTANT_SPACE v4s32 *sampler_typed = (CONSTANT_SPACE v4s32 *)sampler; + GLOBAL_SPACE v8s32 *image_typed = (GLOBAL_SPACE v8s32 *)image; + GLOBAL_SPACE v4s32 *sampler_typed = (GLOBAL_SPACE v4s32 *)sampler; return __llvm_amdgcn_image_sample_lz_2d_v4f32_f32(0xf, coord.x, coord.y, *image_typed, *sampler_typed, false, 0, 0); } #define tex_2d(RETURN_TYPE, COORD_TYPE) \ @@ -1097,7 +1098,7 @@ extern "C" auto result = sample_2D(i, s, v2f32{float(coord.x), float(coord.y)}); \ return v4##RETURN_TYPE{std::bit_cast(result.x), std::bit_cast(result.y), std::bit_cast(result.z), std::bit_cast(result.w)}; \ } \ - v4##RETURN_TYPE FUNC(texref_2d_v4_##RETURN_TYPE##_##COORD_TYPE)(struct textureReference CONSTANT_SPACE * texref, v2##COORD_TYPE coord) \ + v4##RETURN_TYPE FUNC(texref_2d_v4_##RETURN_TYPE##_##COORD_TYPE)(struct textureReference GLOBAL_SPACE * texref, v2##COORD_TYPE coord) \ { \ return FUNC_CALL(texobj_2d_v4_##RETURN_TYPE##_##COORD_TYPE)(uint64_t(texref->textureObject), coord); \ } @@ -1107,21 +1108,21 @@ extern "C" tex_2d(f32, s32); tex_2d(s32, f32); - static v4f32 sample_3D(CONSTANT_SPACE void *image, CONSTANT_SPACE void *sampler, v4f32 coord) __device__ + static v4f32 sample_3D(GLOBAL_SPACE void *image, GLOBAL_SPACE void *sampler, v4f32 coord) __device__ { __device__ v4f32 __llvm_amdgcn_image_sample_lz_3d_v4f32_f32(uint32_t, float, float, float, v8s32, v4s32, bool, int, int) __asm("llvm.amdgcn.image.sample.lz.3d.v4f32.f32"); - CONSTANT_SPACE v8s32 *image_typed = (CONSTANT_SPACE v8s32 *)image; - CONSTANT_SPACE v4s32 *sampler_typed = (CONSTANT_SPACE v4s32 *)sampler; + GLOBAL_SPACE v8s32 *image_typed = (GLOBAL_SPACE v8s32 *)image; + GLOBAL_SPACE v4s32 *sampler_typed = (GLOBAL_SPACE v4s32 *)sampler; return __llvm_amdgcn_image_sample_lz_3d_v4f32_f32(0xf, coord.x, coord.y, coord.z, *image_typed, *sampler_typed, false, 0, 0); } #define tex_3d(RETURN_TYPE, COORD_TYPE) \ v4##RETURN_TYPE FUNC(texobj_3d_v4_##RETURN_TYPE##_##COORD_TYPE)(uint64_t texobj, v4##COORD_TYPE coord) \ { \ auto [i, s] = get_image_and_sampler(texobj); \ - auto result = sample_3D(i, s, v4f32{float(coord.x), float(coord.y), float(coord.z), float(coord.w)}); \ + auto result = sample_3D(i, s, v4f32{float(coord.x), float(coord.y), float(coord.z), float(coord.w)}); \ return v4##RETURN_TYPE{std::bit_cast(result.x), std::bit_cast(result.y), std::bit_cast(result.z), std::bit_cast(result.w)}; \ } \ - v4##RETURN_TYPE FUNC(texref_3d_v4_##RETURN_TYPE##_##COORD_TYPE)(struct textureReference CONSTANT_SPACE * texref, v4##COORD_TYPE coord) \ + v4##RETURN_TYPE FUNC(texref_3d_v4_##RETURN_TYPE##_##COORD_TYPE)(struct textureReference GLOBAL_SPACE * texref, v4##COORD_TYPE coord) \ { \ return FUNC_CALL(texobj_3d_v4_##RETURN_TYPE##_##COORD_TYPE)(uint64_t(texref->textureObject), coord); \ } From dd6026aa127e5358133e444e6edbd7ffbb030ec5 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Sat, 6 Jun 2026 01:41:03 -0700 Subject: [PATCH 52/85] Discard value names in release --- llvm_zluda/src/utils.rs | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/llvm_zluda/src/utils.rs b/llvm_zluda/src/utils.rs index f407bbb0e..b0a2e267b 100644 --- a/llvm_zluda/src/utils.rs +++ b/llvm_zluda/src/utils.rs @@ -23,7 +23,11 @@ pub struct Context(LLVMContextRef); impl Context { pub fn new() -> Self { - Self(unsafe { LLVMContextCreate() }) + let ctx = unsafe { LLVMContextCreate() }; + if !cfg!(debug_assertions) { + unsafe { LLVMContextSetDiscardValueNames(ctx, 1) }; + } + Self(ctx) } pub fn get(&self) -> LLVMContextRef { From 959e66a124da9bc2993bc1a6361df19861038cb6 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Sun, 21 Jun 2026 22:30:15 -0700 Subject: [PATCH 53/85] Use generic address space for consts --- ptx/src/pass/llvm/attributes.rs | 2 +- ptx/src/pass/llvm/emit.rs | 503 +++++++++++++++++--------------- ptx/src/pass/llvm/mod.rs | 11 +- ptx/src/pass/mod.rs | 2 +- 4 files changed, 286 insertions(+), 232 deletions(-) diff --git a/ptx/src/pass/llvm/attributes.rs b/ptx/src/pass/llvm/attributes.rs index ffde4c6c9..1b60584ed 100644 --- a/ptx/src/pass/llvm/attributes.rs +++ b/ptx/src/pass/llvm/attributes.rs @@ -38,7 +38,7 @@ fn emit_attribute( module.get(), attribute_type, name.as_ptr(), - get_state_space(ast::StateSpace::Const)?, + get_state_space(ast::StateSpace::Const, false)?, ) }; unsafe { LLVMSetLinkage(global, llvm_zluda::LLVMLinkage::LLVMExternalLinkage) }; diff --git a/ptx/src/pass/llvm/emit.rs b/ptx/src/pass/llvm/emit.rs index d260b9072..f21f48f26 100644 --- a/ptx/src/pass/llvm/emit.rs +++ b/ptx/src/pass/llvm/emit.rs @@ -66,9 +66,10 @@ pub(crate) fn run<'input>( context: &Context, id_defs: GlobalStringIdentResolver2<'input>, directives: Vec, SpirvWord>>, + is_32bit: bool, ) -> Result { let module = llvm::Module::new(context, LLVM_UNNAMED); - let mut emit_ctx = ModuleEmitContext::new(context, &module, &id_defs); + let mut emit_ctx = ModuleEmitContext::new(context, &module, &id_defs, is_32bit); for directive in directives { match directive { Directive2::Variable(linking, variable) => emit_ctx.emit_global(linking, variable)?, @@ -83,12 +84,223 @@ pub(crate) fn run<'input>( Ok(module) } +#[derive(Debug, Clone, Copy)] +struct ZludaTypeToLLVM { + context: LLVMContextRef, + is_32bit: bool, +} + +impl ZludaTypeToLLVM { + fn get_state_space(&self, space: ast::StateSpace) -> Result { + get_state_space(space, self.is_32bit) + } + + fn get_input_argument_type( + &self, + v_type: &ast::Type, + state_space: ast::StateSpace, + ) -> Result { + match state_space { + ast::StateSpace::ParamEntry | ast::StateSpace::Shared => Ok(unsafe { + LLVMPointerTypeInContext(self.context, self.get_state_space(state_space)?) + }), + ast::StateSpace::Reg => self.get_type(v_type), + ast::StateSpace::Global | ast::StateSpace::Const + if matches!(v_type, ast::Type::Texref) => + { + Ok(unsafe { + LLVMPointerTypeInContext(self.context, self.get_state_space(state_space)?) + }) + } + _ => return Err(error_unreachable()), + } + } + + fn get_pointer_type<'ctx>( + &self, + to_space: ast::StateSpace, + ) -> Result { + Ok(unsafe { LLVMPointerTypeInContext(self.context, self.get_state_space(to_space)?) }) + } + + fn get_type(&self, type_: &ast::Type) -> Result { + Ok(match type_ { + ast::Type::Scalar(scalar) => get_scalar_type(self.context, *scalar), + ast::Type::Vector(size, scalar) => { + let base_type = get_scalar_type(self.context, *scalar); + unsafe { LLVMVectorType(base_type, *size as u32) } + } + ast::Type::Array(vec, scalar, dimensions) => { + let mut underlying_type = get_scalar_type(self.context, *scalar); + if let Some(size) = vec { + underlying_type = unsafe { LLVMVectorType(underlying_type, size.get() as u32) }; + } + if dimensions.is_empty() { + return Ok(unsafe { LLVMArrayType2(underlying_type, 0) }); + } + dimensions + .iter() + .rfold(underlying_type, |result, dimension| unsafe { + LLVMArrayType2(result, *dimension as u64) + }) + } + ast::Type::Texref => { + // Definitions taken from ROCm LLVM output + let format_desc = unsafe { + LLVMStructCreateNamed(self.context, c"struct.hipChannelFormatDesc".as_ptr()) + }; + let llvm_i32 = get_scalar_type(self.context, ast::ScalarType::B32); + let mut format_desc_fields = [llvm_i32, llvm_i32, llvm_i32, llvm_i32, llvm_i32]; + unsafe { + LLVMStructSetBody( + format_desc, + format_desc_fields.as_mut_ptr(), + format_desc_fields.len() as u32, + 0, + ) + }; + let texture_reference = unsafe { + LLVMStructCreateNamed(self.context, c"struct.textureReference".as_ptr()) + }; + let llvm_a3i32 = unsafe { LLVMArrayType2(llvm_i32, 3) }; + let llvm_float = get_scalar_type(self.context, ast::ScalarType::F32); + let llvm_ptr = self.get_pointer_type(ast::StateSpace::Generic)?; + let mut texture_reference_fields = [ + llvm_i32, + llvm_i32, + llvm_i32, + llvm_a3i32, + format_desc, + llvm_i32, + llvm_i32, + llvm_i32, + llvm_float, + llvm_float, + llvm_float, + llvm_ptr, + llvm_i32, + llvm_i32, + ]; + unsafe { + LLVMStructSetBody( + texture_reference, + texture_reference_fields.as_mut_ptr(), + texture_reference_fields.len() as u32, + 0, + ) + }; + let texture = + unsafe { LLVMStructCreateNamed(self.context, c"struct.texture".as_ptr()) }; + let mut texture_fields = [texture_reference]; + unsafe { + LLVMStructSetBody( + texture, + texture_fields.as_mut_ptr(), + texture_fields.len() as u32, + 0, + ) + }; + texture + } + }) + } + + fn get_anonymous_struct_type<'a>( + &self, + elem_types: impl Iterator, + ) -> Result { + let mut elem_types = elem_types + .map(|t| self.get_type(t)) + .collect::, _>>()?; + Ok(unsafe { + LLVMStructTypeInContext( + self.context, + elem_types.as_mut_ptr(), + elem_types.len() as u32, + 0, + ) + }) + } + + fn get_function_type_impl<'a>( + &self, + mut return_args: impl DoubleEndedIterator + + ExactSizeIterator, + input_args: impl Iterator>, + struct_kind: StructKind, + ) -> Result { + let mut input_args = input_args.collect::, _>>()?; + let return_type = match return_args.len() { + 0 => unsafe { LLVMVoidTypeInContext(self.context) }, + 1 => self.get_type(&return_args.next().unwrap())?, + _ => match struct_kind { + StructKind::Named => self.get_or_create_struct_type(return_args)?, + StructKind::Anonymous => self.get_anonymous_struct_type(return_args)?, + }, + }; + + Ok(unsafe { + LLVMFunctionType( + return_type, + input_args.as_mut_ptr(), + input_args.len() as u32, + 0, + ) + }) + } + + fn get_function_type<'a>( + &self, + return_args: impl DoubleEndedIterator + + ExactSizeIterator, + input_args: impl Iterator>, + ) -> Result { + self.get_function_type_impl(return_args, input_args, StructKind::Named) + } + + fn get_intrinsic_type<'a>( + &self, + return_args: impl DoubleEndedIterator + + ExactSizeIterator, + input_args: impl Iterator>, + ) -> Result { + self.get_function_type_impl(return_args, input_args, StructKind::Anonymous) + } + + fn get_or_create_struct_type<'a>( + &self, + mut elem_types: impl Iterator, + ) -> Result { + use std::fmt::Write; + let (mut name, types) = elem_types.try_fold( + ("struct".to_string(), Vec::new()), + |(mut name, mut types), t| { + name.push('.'); + if let ast::Type::Scalar(scalar) = t { + write!(name, "{}", LLVMTypeDisplay(*scalar)).ok(); + } else { + return Err(error_unreachable()); + } + types.push(self.get_type(t)?); + Ok((name, types)) + }, + )?; + name.push('\0'); + let mut struct_type = unsafe { LLVMGetTypeByName2(self.context, name.as_ptr().cast()) }; + if struct_type.is_null() { + struct_type = create_struct_type(self.context, name, types); + } + Ok(struct_type) + } +} + struct ModuleEmitContext<'a, 'input> { context: LLVMContextRef, module: LLVMModuleRef, builder: Builder, id_defs: &'a GlobalStringIdentResolver2<'input>, resolver: ResolveIdent, + llvm_types: ZludaTypeToLLVM, } impl<'a, 'input> ModuleEmitContext<'a, 'input> { @@ -96,6 +308,7 @@ impl<'a, 'input> ModuleEmitContext<'a, 'input> { context: &Context, module: &llvm::Module, id_defs: &'a GlobalStringIdentResolver2<'input>, + is_32bit: bool, ) -> Self { ModuleEmitContext { context: context.get(), @@ -103,6 +316,10 @@ impl<'a, 'input> ModuleEmitContext<'a, 'input> { builder: Builder::new(context), id_defs, resolver: ResolveIdent::new(&id_defs), + llvm_types: ZludaTypeToLLVM { + context: context.get(), + is_32bit, + }, } } @@ -126,11 +343,11 @@ impl<'a, 'input> ModuleEmitContext<'a, 'input> { let name = CString::new(name).map_err(|_| error_unreachable())?; let mut fn_ = unsafe { LLVMGetNamedFunction(self.module, name.as_ptr()) }; if fn_ == ptr::null_mut() { - let fn_type = get_function_type( - self.context, + let fn_type = self.llvm_types.get_function_type( method.return_arguments.iter().map(|v| &v.info.v_type), method.input_arguments.iter().map(|v| { - get_input_argument_type(self.context, &v.info.v_type, v.info.state_space) + self.llvm_types + .get_input_argument_type(&v.info.v_type, v.info.state_space) }), )?; fn_ = unsafe { LLVMAddFunction(self.module, name.as_ptr(), fn_type) }; @@ -176,7 +393,7 @@ impl<'a, 'input> ModuleEmitContext<'a, 'input> { LLVMCreateTypeAttribute( self.context, attr_kind, - get_type(self.context, ¶m.info.v_type)?, + self.llvm_types.get_type(¶m.info.v_type)?, ) }; unsafe { LLVMAddAttributeAtIndex(fn_, i as u32 + 1, attr) }; @@ -212,8 +429,13 @@ impl<'a, 'input> ModuleEmitContext<'a, 'input> { unsafe { LLVMAppendBasicBlockInContext(self.context, fn_, LLVM_UNNAMED.as_ptr()) }; unsafe { LLVMPositionBuilderAtEnd(self.builder.get(), real_bb) }; let base_32bit_memory = method.kernel_meta32.as_ref().map(|m| m.implicit_memory_ptr); - let mut method_emitter = - MethodEmitContext::new(self, fn_, variables_builder, base_32bit_memory); + let mut method_emitter: MethodEmitContext<'_> = MethodEmitContext::new( + self, + fn_, + variables_builder, + self.llvm_types, + base_32bit_memory, + ); for var in method.return_arguments { method_emitter.emit_variable(var)?; } @@ -256,13 +478,13 @@ impl<'a, 'input> ModuleEmitContext<'a, 'input> { .transpose() .map_err(|_| error_unreachable())? .unwrap_or(Cow::Borrowed(LLVM_UNNAMED)); - let llvm_type = get_type(self.context, &var.info.v_type)?; + let llvm_type = self.llvm_types.get_type(&var.info.v_type)?; let global = unsafe { LLVMAddGlobalInAddressSpace( self.module, llvm_type, name.as_ptr(), - get_state_space(var.info.state_space)?, + self.llvm_types.get_state_space(var.info.state_space)?, ) }; if matches!(var.info.v_type, ast::Type::Texref) { @@ -440,23 +662,6 @@ fn llvm_ftz(ftz: bool) -> &'static str { } } -fn get_input_argument_type( - context: LLVMContextRef, - v_type: &ast::Type, - state_space: ast::StateSpace, -) -> Result { - match state_space { - ast::StateSpace::ParamEntry | ast::StateSpace::Shared => { - Ok(unsafe { LLVMPointerTypeInContext(context, get_state_space(state_space)?) }) - } - ast::StateSpace::Reg => get_type(context, v_type), - ast::StateSpace::Global | ast::StateSpace::Const if matches!(v_type, ast::Type::Texref) => { - Ok(unsafe { LLVMPointerTypeInContext(context, get_state_space(state_space)?) }) - } - _ => return Err(error_unreachable()), - } -} - struct MethodEmitContext<'a> { context: LLVMContextRef, module: LLVMModuleRef, @@ -465,6 +670,7 @@ struct MethodEmitContext<'a> { variables_builder: Builder, resolver: &'a mut ResolveIdent, carry_flag: Option, + llvm_types: ZludaTypeToLLVM, base_32bit_memory: Option, } @@ -473,6 +679,7 @@ impl<'a> MethodEmitContext<'a> { parent: &'a mut ModuleEmitContext, method: LLVMValueRef, variables_builder: Builder, + llvm_types: ZludaTypeToLLVM, base_32bit_memory: Option, ) -> MethodEmitContext<'a> { MethodEmitContext { @@ -483,6 +690,7 @@ impl<'a> MethodEmitContext<'a> { resolver: &mut parent.resolver, method, carry_flag: None, + llvm_types, base_32bit_memory: base_32bit_memory, } } @@ -539,8 +747,8 @@ impl<'a> MethodEmitContext<'a> { let alloca = unsafe { LLVMZludaBuildAlloca( self.variables_builder.get(), - get_type(self.context, &var.info.v_type)?, - get_state_space(var.info.state_space)?, + self.llvm_types.get_type(&var.info.v_type)?, + self.llvm_types.get_state_space(var.info.state_space)?, self.resolver.get_or_add_raw(var.name), ) }; @@ -678,7 +886,7 @@ impl<'a> MethodEmitContext<'a> { arguments: ast::LdArgs, ) -> Result<(), TranslateError> { let builder = self.builder; - let underlying_type = get_type(self.context, &data.typ)?; + let underlying_type = self.llvm_types.get_type(&data.typ)?; let needs_cast = not_supported_by_atomics(data.qualifier, underlying_type); let op_type = if needs_cast { unsafe { @@ -722,7 +930,7 @@ impl<'a> MethodEmitContext<'a> { ), ConversionKind::SignExtend => { let src = self.resolver.value(conversion.src)?; - let type_ = get_type(self.context, &conversion.to_type)?; + let type_ = self.llvm_types.get_type(&conversion.to_type)?; self.resolver.with_result(conversion.dst, |dst| unsafe { LLVMBuildSExt(builder, src, type_, dst) }); @@ -730,7 +938,7 @@ impl<'a> MethodEmitContext<'a> { } ConversionKind::BitToPtr => { let src = self.resolver.value(conversion.src)?; - let ptr_type = get_pointer_type(self.context, conversion.to_space)?; + let ptr_type = self.llvm_types.get_pointer_type(conversion.to_space)?; if let ( Some(base32), ast::StateSpace::Global | ast::StateSpace::Generic | ast::StateSpace::Const, @@ -762,8 +970,18 @@ impl<'a> MethodEmitContext<'a> { Ok(()) } ConversionKind::PtrToPtr => { + if conversion.from_space == conversion.to_space { + // With opaque pointers it's meaningless + return self.emit_mov(ast::MovArgs { + dst: conversion.dst, + src: conversion.src, + }); + } + if self.base_32bit_memory.is_some() { + return Err(error_todo()); + } let src = self.resolver.value(conversion.src)?; - let dst_type = get_pointer_type(self.context, conversion.to_space)?; + let dst_type = self.llvm_types.get_pointer_type(conversion.to_space)?; self.resolver.with_result(conversion.dst, |dst| unsafe { LLVMBuildAddrSpaceCast(builder, src, dst_type, dst) }); @@ -771,7 +989,7 @@ impl<'a> MethodEmitContext<'a> { } ConversionKind::AddressOf => { let src = self.resolver.value(conversion.src)?; - let dst_type = get_type(self.context, &conversion.to_type)?; + let dst_type = self.llvm_types.get_type(&conversion.to_type)?; if let ( Some(_), ast::StateSpace::Global | ast::StateSpace::Generic | ast::StateSpace::Const, @@ -803,7 +1021,7 @@ impl<'a> MethodEmitContext<'a> { let from_layout = from_type.layout(); let to_layout = to_type.layout().ok_or_else(error_unreachable)?; if from_layout.size() == to_layout.size() { - let dst_type = get_type(self.context, &to_type)?; + let dst_type = self.llvm_types.get_type(&to_type)?; if from_type.kind() != ast::ScalarKind::Float && to_type_scalar.kind() != ast::ScalarKind::Float { @@ -889,7 +1107,7 @@ impl<'a> MethodEmitContext<'a> { | (ast::Type::Scalar(..), ast::Type::Vector(..)) | (ast::Type::Scalar(..), ast::Type::Array(..)) | (ast::Type::Array(..), ast::Type::Scalar(..)) => { - let dst_type = get_type(self.context, to_type)?; + let dst_type = self.llvm_types.get_type(to_type)?; self.resolver.with_result(dst, |dst| unsafe { LLVMBuildBitCast(self.builder, src, dst_type, dst) }); @@ -974,7 +1192,7 @@ impl<'a> MethodEmitContext<'a> { LLVMZludaBuildAlloca( self.variables_builder.get(), LLVMIntTypeInContext(self.context, 1), - get_state_space(ast::StateSpace::Reg)?, + self.llvm_types.get_state_space(ast::StateSpace::Reg)?, c"__ZLUDA_REG_CC_CF".as_ptr(), ) }; @@ -1138,7 +1356,7 @@ impl<'a> MethodEmitContext<'a> { arguments: ast::StArgs, ) -> Result<(), TranslateError> { let ptr = self.resolver.value(arguments.src1)?; - let underlying_type = get_type(self.context, &data.typ)?; + let underlying_type = self.llvm_types.get_type(&data.typ)?; let needs_cast = not_supported_by_atomics(data.qualifier, underlying_type); let mut value = self.resolver.value(arguments.src2)?; if needs_cast { @@ -1185,12 +1403,11 @@ impl<'a> MethodEmitContext<'a> { [dst] => self.resolver.get_or_add_raw(*dst), _ => LLVM_UNNAMED.as_ptr(), }; - let type_ = get_function_type( - self.context, + let type_ = self.llvm_types.get_function_type( data.return_arguments.iter().map(|(type_, ..)| type_), data.input_arguments .iter() - .map(|(type_, space)| get_input_argument_type(self.context, &type_, *space)), + .map(|(type_, space)| self.llvm_types.get_input_argument_type(&type_, *space)), )?; let mut input_arguments = arguments .input_arguments @@ -1351,7 +1568,7 @@ impl<'a> MethodEmitContext<'a> { .iter() .map(|(value, type_)| { let value = self.resolver.value(*value)?; - let lowered_type = get_type(self.context, type_)?; + let lowered_type = self.llvm_types.get_type(type_)?; let load = unsafe { LLVMBuildLoad2(self.builder, lowered_type, value, LLVM_UNNAMED.as_ptr()) }; @@ -1368,8 +1585,9 @@ impl<'a> MethodEmitContext<'a> { [] => unsafe { LLVMBuildRetVoid(self.builder) }, [(value, _)] => unsafe { LLVMBuildRet(self.builder, *value) }, loads => { - let struct_type = - get_or_create_struct_type(self.context, loads.iter().map(|(_, type_)| *type_))?; + let struct_type = self + .llvm_types + .get_or_create_struct_type(loads.iter().map(|(_, type_)| *type_))?; let mut value = unsafe { LLVMGetUndef(struct_type) }; for (i, (load, _)) in loads.iter().enumerate() { value = unsafe { @@ -1580,10 +1798,9 @@ impl<'a> MethodEmitContext<'a> { }); } } else { - let vector_type = get_type( - self.context, - &ast::Type::Vector(repack.unpacked.len() as u8, repack.typ), - )?; + let vector_type = self + .llvm_types + .get_type(&ast::Type::Vector(repack.unpacked.len() as u8, repack.typ))?; let mut temp_vec = unsafe { LLVMGetUndef(vector_type) }; for (index, src_id) in repack.unpacked.iter().enumerate() { let dst = if index == repack.unpacked.len() - 1 { @@ -1700,8 +1917,8 @@ impl<'a> MethodEmitContext<'a> { src: arguments.src, }); } - let from_type = get_pointer_type(self.context, from_space)?; - let dest_type = get_pointer_type(self.context, to_space)?; + let from_type = self.llvm_types.get_pointer_type(from_space)?; + let dest_type = self.llvm_types.get_pointer_type(to_space)?; let src = self.resolver.value(arguments.src)?; let temp_ptr = unsafe { LLVMBuildIntToPtr(self.builder, src, from_type, LLVM_UNNAMED.as_ptr()) }; @@ -1789,8 +2006,7 @@ impl<'a> MethodEmitContext<'a> { return_types: Vec<&ast::Type>, arguments: Vec<(LLVMValueRef, LLVMTypeRef)>, ) -> Result { - let fn_type = get_intrinsic_type( - self.context, + let fn_type = self.llvm_types.get_intrinsic_type( return_types.iter().copied(), arguments.iter().map(|(_, type_)| Ok(*type_)), )?; @@ -3239,10 +3455,10 @@ impl<'a> MethodEmitContext<'a> { let vector_result = unsafe { LLVMBuildInsertElement( self.builder, - LLVMGetPoison(get_type( - self.context, - &ast::Type::Vector(2, ast::ScalarType::U16), - )?), + LLVMGetPoison( + self.llvm_types + .get_type(&ast::Type::Vector(2, ast::ScalarType::U16))?, + ), setp_result_0, zero, LLVM_UNNAMED.as_ptr(), @@ -3272,10 +3488,10 @@ impl<'a> MethodEmitContext<'a> { let vector_result = unsafe { LLVMBuildInsertElement( self.builder, - LLVMGetPoison(get_type( - self.context, - &ast::Type::Vector(2, ast::ScalarType::F16), - )?), + LLVMGetPoison( + self.llvm_types + .get_type(&ast::Type::Vector(2, ast::ScalarType::F16))?, + ), setp_result_0, zero, LLVM_UNNAMED.as_ptr(), @@ -3658,13 +3874,6 @@ fn apply_qualifier( Ok(()) } -fn get_pointer_type<'ctx>( - context: LLVMContextRef, - to_space: ast::StateSpace, -) -> Result { - Ok(unsafe { LLVMPointerTypeInContext(context, get_state_space(to_space)?) }) -} - // https://llvm.org/docs/AMDGPUUsage.html#memory-scopes fn get_scope(scope: ast::MemScope) -> Result<*const i8, TranslateError> { Ok(match scope { @@ -3705,111 +3914,6 @@ fn get_ordering_failure(semantics: ast::AtomSemantics) -> LLVMAtomicOrdering { } } -fn get_type(context: LLVMContextRef, type_: &ast::Type) -> Result { - Ok(match type_ { - ast::Type::Scalar(scalar) => get_scalar_type(context, *scalar), - ast::Type::Vector(size, scalar) => { - let base_type = get_scalar_type(context, *scalar); - unsafe { LLVMVectorType(base_type, *size as u32) } - } - ast::Type::Array(vec, scalar, dimensions) => { - let mut underlying_type = get_scalar_type(context, *scalar); - if let Some(size) = vec { - underlying_type = unsafe { LLVMVectorType(underlying_type, size.get() as u32) }; - } - if dimensions.is_empty() { - return Ok(unsafe { LLVMArrayType2(underlying_type, 0) }); - } - dimensions - .iter() - .rfold(underlying_type, |result, dimension| unsafe { - LLVMArrayType2(result, *dimension as u64) - }) - } - ast::Type::Texref => { - // Definitions taken from ROCm LLVM output - let format_desc = - unsafe { LLVMStructCreateNamed(context, c"struct.hipChannelFormatDesc".as_ptr()) }; - let llvm_i32 = get_scalar_type(context, ast::ScalarType::B32); - let mut format_desc_fields = [llvm_i32, llvm_i32, llvm_i32, llvm_i32, llvm_i32]; - unsafe { - LLVMStructSetBody( - format_desc, - format_desc_fields.as_mut_ptr(), - format_desc_fields.len() as u32, - 0, - ) - }; - let texture_reference = - unsafe { LLVMStructCreateNamed(context, c"struct.textureReference".as_ptr()) }; - let llvm_a3i32 = unsafe { LLVMArrayType2(llvm_i32, 3) }; - let llvm_float = get_scalar_type(context, ast::ScalarType::F32); - let llvm_ptr = get_pointer_type(context, ast::StateSpace::Generic)?; - let mut texture_reference_fields = [ - llvm_i32, - llvm_i32, - llvm_i32, - llvm_a3i32, - format_desc, - llvm_i32, - llvm_i32, - llvm_i32, - llvm_float, - llvm_float, - llvm_float, - llvm_ptr, - llvm_i32, - llvm_i32, - ]; - unsafe { - LLVMStructSetBody( - texture_reference, - texture_reference_fields.as_mut_ptr(), - texture_reference_fields.len() as u32, - 0, - ) - }; - let texture = unsafe { LLVMStructCreateNamed(context, c"struct.texture".as_ptr()) }; - let mut texture_fields = [texture_reference]; - unsafe { - LLVMStructSetBody( - texture, - texture_fields.as_mut_ptr(), - texture_fields.len() as u32, - 0, - ) - }; - texture - } - }) -} - -fn get_or_create_struct_type<'a>( - context: LLVMContextRef, - mut elem_types: impl Iterator, -) -> Result { - use std::fmt::Write; - let (mut name, types) = elem_types.try_fold( - ("struct".to_string(), Vec::new()), - |(mut name, mut types), t| { - name.push('.'); - if let ast::Type::Scalar(scalar) = t { - write!(name, "{}", LLVMTypeDisplay(*scalar)).ok(); - } else { - return Err(error_unreachable()); - } - types.push(get_type(context, t)?); - Ok((name, types)) - }, - )?; - name.push('\0'); - let mut struct_type = unsafe { LLVMGetTypeByName2(context, name.as_ptr().cast()) }; - if struct_type.is_null() { - struct_type = create_struct_type(context, name, types); - } - Ok(struct_type) -} - fn create_struct_type( context: LLVMContextRef, name: String, @@ -3827,68 +3931,11 @@ fn create_struct_type( llvm_type } -fn get_anonymous_struct_type<'a>( - context: LLVMContextRef, - elem_types: impl Iterator, -) -> Result { - let mut elem_types = elem_types - .map(|t| get_type(context, t)) - .collect::, _>>()?; - Ok(unsafe { - LLVMStructTypeInContext(context, elem_types.as_mut_ptr(), elem_types.len() as u32, 0) - }) -} - enum StructKind { Named, Anonymous, } -fn get_function_type_impl<'a>( - context: LLVMContextRef, - mut return_args: impl DoubleEndedIterator - + ExactSizeIterator, - input_args: impl Iterator>, - struct_kind: StructKind, -) -> Result { - let mut input_args = input_args.collect::, _>>()?; - let return_type = match return_args.len() { - 0 => unsafe { LLVMVoidTypeInContext(context) }, - 1 => get_type(context, &return_args.next().unwrap())?, - _ => match struct_kind { - StructKind::Named => get_or_create_struct_type(context, return_args)?, - StructKind::Anonymous => get_anonymous_struct_type(context, return_args)?, - }, - }; - - Ok(unsafe { - LLVMFunctionType( - return_type, - input_args.as_mut_ptr(), - input_args.len() as u32, - 0, - ) - }) -} - -fn get_function_type<'a>( - context: LLVMContextRef, - return_args: impl DoubleEndedIterator - + ExactSizeIterator, - input_args: impl Iterator>, -) -> Result { - get_function_type_impl(context, return_args, input_args, StructKind::Named) -} - -fn get_intrinsic_type<'a>( - context: LLVMContextRef, - return_args: impl DoubleEndedIterator - + ExactSizeIterator, - input_args: impl Iterator>, -) -> Result { - get_function_type_impl(context, return_args, input_args, StructKind::Anonymous) -} - struct ResolveIdent { words: HashMap, values: HashMap, diff --git a/ptx/src/pass/llvm/mod.rs b/ptx/src/pass/llvm/mod.rs index ebfe86dcb..6fc3556a7 100644 --- a/ptx/src/pass/llvm/mod.rs +++ b/ptx/src/pass/llvm/mod.rs @@ -46,7 +46,7 @@ fn get_scalar_type(context: LLVMContextRef, type_: ast::ScalarType) -> LLVMTypeR } } -fn get_state_space(space: ast::StateSpace) -> Result { +fn get_state_space(space: ast::StateSpace, is_32bit: bool) -> Result { match space { ast::StateSpace::Reg => Ok(PRIVATE_ADDRESS_SPACE), ast::StateSpace::Generic => Ok(GENERIC_ADDRESS_SPACE), @@ -58,7 +58,14 @@ fn get_state_space(space: ast::StateSpace) -> Result { ast::StateSpace::ParamFunc => Err(error_todo()), ast::StateSpace::Local => Ok(PRIVATE_ADDRESS_SPACE), ast::StateSpace::Global => Ok(GLOBAL_ADDRESS_SPACE), - ast::StateSpace::Const => Ok(CONSTANT_ADDRESS_SPACE), + ast::StateSpace::Const => Ok(if is_32bit { + // FIXME: This is probably incorrect, but when using constant or + // global address space, we get incorrect codegen. Might be a bug + // in LLVM, might be a bug in ZLUDA + GENERIC_ADDRESS_SPACE + } else { + CONSTANT_ADDRESS_SPACE + }), ast::StateSpace::Shared => Ok(SHARED_ADDRESS_SPACE), ast::StateSpace::SharedCta => Err(error_todo()), ast::StateSpace::SharedCluster => Err(error_todo()), diff --git a/ptx/src/pass/mod.rs b/ptx/src/pass/mod.rs index 77f00bf6e..530490e31 100644 --- a/ptx/src/pass/mod.rs +++ b/ptx/src/pass/mod.rs @@ -112,7 +112,7 @@ pub fn to_llvm_module<'input>( let directives = hoist_globals::run(directives)?; on_pass_end("hoist_globals"); let context = llvm_zluda::utils::Context::new(); - let llvm_ir = llvm::emit::run(&context, flat_resolver, directives)?; + let llvm_ir = llvm::emit::run(&context, flat_resolver, directives, ast.address_size == 32)?; let attributes_ir = llvm::attributes::run(&context, attributes)?; on_pass_end("emit_llvm"); Ok(Module { From 3a0f2b5028b82eb926de9448a1f8b2883cfe6856 Mon Sep 17 00:00:00 2001 From: Hemang Joshi Date: Sat, 23 May 2026 09:56:46 +0530 Subject: [PATCH 54/85] Fix typo: compatiblity -> compatibility in xtask comment (#639) --- xtask/src/main.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/xtask/src/main.rs b/xtask/src/main.rs index 012e792b4..c362655d2 100644 --- a/xtask/src/main.rs +++ b/xtask/src/main.rs @@ -439,7 +439,7 @@ mod os { // Unfortunately when linking against amdhip64.so, it encodes SONAME with versioned // filename, e.g. libamdhip64.so.7. We instead want to link against unversioned - // libamdhip64.so to allow compatiblity with both ROCm 6 and ROCm 7 + // libamdhip64.so to allow compatibility with both ROCm 6 and ROCm 7 // We use `patchelf`. I've tried arwen library: https://nichmor.github.io/arwen/, // it supports replacing DT_NEEDED entries, but it seems to produce broken binaries pub fn strip_rocm_versions_from_dt_needed(target_dir: &PathBuf, profile: &str) { From 4f500e9bdd98925fb8fb69c629d420a894027644 Mon Sep 17 00:00:00 2001 From: Hemang Joshi Date: Mon, 25 May 2026 07:58:04 +0530 Subject: [PATCH 55/85] Fix typo: overriden -> overridden in zluda_redirect (#641) --- zluda_redirect/src/lib.rs | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/zluda_redirect/src/lib.rs b/zluda_redirect/src/lib.rs index 4bf5abdf0..376c4c4a1 100644 --- a/zluda_redirect/src/lib.rs +++ b/zluda_redirect/src/lib.rs @@ -754,20 +754,20 @@ struct DetourDetachGuard { state: DetourUndoState, suspended_threads: Vec, // First element is the original fn, second is the new fn - overriden_non_cuda_fns: Vec<(*mut *mut c_void, *mut c_void)>, + overridden_non_cuda_fns: Vec<(*mut *mut c_void, *mut c_void)>, } impl DetourDetachGuard { // First element in the pair is ptr to original fn, second argument is the // new function. We accept *mut *mut c_void instead of *mut c_void as the // first element in the pair, because somehow otherwise original functions - // also get overriden, so for example ZludaLoadLibraryExW ends calling + // also get overridden, so for example ZludaLoadLibraryExW ends calling // itself recursively until stack overflow exception occurs unsafe fn new<'a>() -> Option { let mut result = DetourDetachGuard { state: DetourUndoState::DoNothing, suspended_threads: Vec::new(), - overriden_non_cuda_fns: Vec::new(), + overridden_non_cuda_fns: Vec::new(), }; if DetourTransactionBegin() != NO_ERROR as i32 { return None; @@ -781,7 +781,7 @@ impl DetourDetachGuard { return None; } } - result.overriden_non_cuda_fns.extend_from_slice(&[ + result.overridden_non_cuda_fns.extend_from_slice(&[ ( &raw mut LOAD_LIBRARY_A as *mut _ as *mut *mut c_void, ZludaLoadLibraryA as *mut c_void, @@ -824,7 +824,7 @@ impl DetourDetachGuard { ), (&raw mut LDR_LOAD_DLL as *mut _ as _, ZludaLdrLoadDll as _), ]); - for (original_fn, new_fn) in result.overriden_non_cuda_fns.iter().copied() { + for (original_fn, new_fn) in result.overridden_non_cuda_fns.iter().copied() { if DetourAttach(original_fn, new_fn) != NO_ERROR as i32 { return None; } @@ -911,7 +911,7 @@ impl Drop for DetourDetachGuard { DetourUndoState::DetachDetours => unsafe { DetourTransactionBegin(); DetourUpdateThread(GetCurrentThread().0); - for (original_fn, new_fn) in self.overriden_non_cuda_fns.iter().copied() { + for (original_fn, new_fn) in self.overridden_non_cuda_fns.iter().copied() { DetourDetach(original_fn, new_fn); } if let Ok(mut nvrtc_detours) = nvrtc_detours().lock() { From a79a6bf92dd53e15e37dd60f40d0777a3dc3e31f Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Wed, 27 May 2026 10:23:06 -0700 Subject: [PATCH 56/85] Implement match.any.sync, fix popc.b64 (#642) --- Cargo.lock | 1352 +- Cargo.toml | 5 - cuda_check/Cargo.toml | 2 +- cuda_macros/src/lib.rs | 92 +- cuda_types/src/dark_api.rs | 2 - dark_api/Cargo.toml | 29 +- dark_api/src/fatbin.rs | 8 +- dark_api/src/lib.rs | 54 +- kernel_metadata/src/lib.rs | 2 +- llvm_zluda/src/utils.rs | 6 +- nvapi/Cargo.toml | 26 - nvapi/src/lib.rs | 726 - nvapi/src/nvapi.rs | 19879 ---------------- nvapi_trace/Cargo.toml | 29 - nvapi_trace/src/lib.rs | 704 - ptx/lib/zluda_ptx_impl.bc | 4 +- ptx/lib/zluda_ptx_impl.cpp | 51 +- ptx/src/pass/convert_32bit_to_64bit.rs | 30 +- ptx/src/pass/insert_post_saturation.rs | 1 + .../instruction_mode_to_global_mode/mod.rs | 1 + ptx/src/pass/llvm/attributes.rs | 2 +- ptx/src/pass/llvm/emit.rs | 523 +- ptx/src/pass/llvm/mod.rs | 11 +- ptx/src/pass/mod.rs | 2 +- .../replace_instructions_with_functions.rs | 9 +- ptx/src/test/ll/match_sync.ll | 45 + ptx/src/test/ll/popc.ll | 12 +- ptx/src/test/ll/popc_b64.ll | 35 + ptx/src/test/spirv_run/match_sync.ptx | 32 + ptx/src/test/spirv_run/mod.rs | 79 +- ptx/src/test/spirv_run/popc_b64.ptx | 22 + ptx_parser/src/ast.rs | 12 + ptx_parser/src/lib.rs | 120 +- ptx_parser_macros/src/lib.rs | 48 +- ptx_parser_macros_impl/src/parser.rs | 23 +- xtask/src/main.rs | 78 +- zluda/src/impl/driver.rs | 89 - zluda/src/impl/function.rs | 2 - zluda/src/impl/hipfix.rs | 3 - zluda/src/impl/library.rs | 4 +- zluda/src/impl/module.rs | 120 +- zluda/src/impl/tex.rs | 3 - zluda32/Cargo.toml | 44 - zluda32/src/ipc.rs | 175 - zluda32/src/lib.rs | 1014 - zluda64_server/Cargo.toml | 26 - zluda64_server/src/main.rs | 1151 - zluda_common/src/constants.rs | 1 - zluda_common/src/lib.rs | 1 - zluda_inject/Cargo.toml | 2 +- zluda_inject/src/bin.rs | 22 +- zluda_redirect/Cargo.toml | 1 - zluda_server_common/Cargo.toml | 17 - zluda_server_common/src/lib.rs | 356 - zluda_trace/Cargo.toml | 6 +- zluda_trace/src/lib.rs | 8 +- zluda_trace/src/log.rs | 4 - zluda_trace/src/trace.rs | 7 +- zluda_trace_blas/src/lib.rs | 1 - zluda_trace_blaslt/src/lib.rs | 1 - zluda_trace_dnn8/src/lib.rs | 1 - zluda_trace_dnn9/src/lib.rs | 1 - zluda_trace_fft/src/lib.rs | 1 - zluda_trace_nvml/src/lib.rs | 1 - zluda_trace_sparse/src/lib.rs | 1 - zluda_windows/src/lib.rs | 58 +- 66 files changed, 875 insertions(+), 26302 deletions(-) delete mode 100644 nvapi/Cargo.toml delete mode 100644 nvapi/src/lib.rs delete mode 100644 nvapi/src/nvapi.rs delete mode 100644 nvapi_trace/Cargo.toml delete mode 100644 nvapi_trace/src/lib.rs create mode 100644 ptx/src/test/ll/match_sync.ll create mode 100644 ptx/src/test/ll/popc_b64.ll create mode 100644 ptx/src/test/spirv_run/match_sync.ptx create mode 100644 ptx/src/test/spirv_run/popc_b64.ptx delete mode 100644 zluda32/Cargo.toml delete mode 100644 zluda32/src/ipc.rs delete mode 100644 zluda32/src/lib.rs delete mode 100644 zluda64_server/Cargo.toml delete mode 100644 zluda64_server/src/main.rs delete mode 100644 zluda_server_common/Cargo.toml delete mode 100644 zluda_server_common/src/lib.rs diff --git a/Cargo.lock b/Cargo.lock index 0c2e73c20..eb27ec012 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -84,7 +84,7 @@ dependencies = [ "argh_shared", "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -108,21 +108,6 @@ version = "0.7.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50" -[[package]] -name = "async-task" -version = "4.7.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de" - -[[package]] -name = "atomic-polyfill" -version = "1.0.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8cf2bce30dfe09ef0bfaef228b9d414faaf7e563035494d7fe092dba54b300f4" -dependencies = [ - "critical-section", -] - [[package]] name = "autocfg" version = "1.4.0" @@ -135,33 +120,13 @@ version = "0.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3a8241f3ebb85c056b509d4327ad0358fbbba6ffb340bf388f26350aeda225b1" -[[package]] -name = "bincode" -version = "2.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "36eaf5d7b090263e8150820482d5d93cd964a81e4019913c972f4edcc6edb740" -dependencies = [ - "bincode_derive", - "serde", - "unty", -] - -[[package]] -name = "bincode_derive" -version = "2.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bf95709a440f45e986983918d0e8a1f30a9b1df04918fc828670606804ac3c09" -dependencies = [ - "virtue", -] - [[package]] name = "bindgen" version = "0.70.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f49d8fed880d473ea71efb9bf597651e77201bdd4893efe54c9e5d65ae04ce6f" dependencies = [ - "bitflags 2.11.1", + "bitflags 2.9.1", "cexpr", "clang-sys", "itertools 0.13.0", @@ -172,7 +137,7 @@ dependencies = [ "regex", "rustc-hash 1.1.0", "shlex", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -181,7 +146,7 @@ version = "0.71.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5f58bf3d7db68cfbac37cfc485a8d711e87e064c3d0fe0435b92f7a407f9d6b3" dependencies = [ - "bitflags 2.11.1", + "bitflags 2.9.1", "cexpr", "clang-sys", "itertools 0.13.0", @@ -190,9 +155,9 @@ dependencies = [ "proc-macro2", "quote", "regex", - "rustc-hash 2.1.2", + "rustc-hash 2.1.1", "shlex", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -201,30 +166,6 @@ version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7" -[[package]] -name = "bitcode" -version = "0.6.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0a6ed1b54d8dc333e7be604d00fa9262f4635485ffea923647b6521a5fff045d" -dependencies = [ - "arrayvec", - "bitcode_derive", - "bytemuck", - "glam", - "serde", -] - -[[package]] -name = "bitcode_derive" -version = "0.6.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "238b90427dfad9da4a9abd60f3ec1cdee6b80454bde49ed37f1781dd8e9dc7f9" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.117", -] - [[package]] name = "bitflags" version = "1.3.2" @@ -233,9 +174,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" [[package]] name = "bitflags" -version = "2.11.1" +version = "2.9.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c4512299f36f043ab09a583e57bceb5a5aab7a73db1805848e8fef3c9e8c78b3" +checksum = "1b8e56985ec62d17e9c1001dc89c88ecd7dc08e47eba5ec7c29c7b5eeecde967" [[package]] name = "blake3" @@ -278,7 +219,7 @@ checksum = "fefb4feeec9a091705938922f26081aad77c64cd2e76cd1c4a9ece8e42e1618a" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -318,7 +259,7 @@ checksum = "89385e82b5d1821d2219e0b095efa2cc1f246cbf99080f3be46a1a85c0d392d9" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -338,7 +279,7 @@ checksum = "f9abbd1bc6865053c427f7198e6af43bfdedc55ab791faed4fbd361d789575ff" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -373,10 +314,10 @@ dependencies = [ "gemm", "half", "libm", - "memmap2", + "memmap2 0.9.7", "num-traits", "num_cpus", - "rand 0.9.2", + "rand", "rand_distr", "rayon", "safetensors", @@ -435,12 +376,6 @@ version = "1.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" -[[package]] -name = "cfg_aliases" -version = "0.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724" - [[package]] name = "cglue" version = "0.3.5" @@ -479,17 +414,6 @@ dependencies = [ "syn 1.0.109", ] -[[package]] -name = "chacha20" -version = "0.10.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6f8d983286843e49675a4b7a2d174efe136dc93a18d69130dd18198a6c167601" -dependencies = [ - "cfg-if", - "cpufeatures 0.3.0", - "rand_core 0.10.0", -] - [[package]] name = "clang-sys" version = "1.8.1" @@ -516,15 +440,6 @@ dependencies = [ "cc", ] -[[package]] -name = "cobs" -version = "0.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0fa961b519f0b462e3a3b4a34b64d119eeaca1d59af726fe450bbba07a9fc0a1" -dependencies = [ - "thiserror 2.0.12", -] - [[package]] name = "compiler" version = "0.0.0" @@ -538,143 +453,6 @@ dependencies = [ "thiserror 2.0.12", ] -[[package]] -name = "compio" -version = "0.18.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9b84ee96a86948d04388f3a0b8c36b9f0a6b40b3528ac0d65737e53632fb37fe" -dependencies = [ - "compio-buf", - "compio-driver", - "compio-fs", - "compio-io", - "compio-log", - "compio-macros", - "compio-runtime", -] - -[[package]] -name = "compio-buf" -version = "0.8.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a00d719dbd8c602ab0d25d219cbc6b517008858de7a8d6c51b4dc95aefff4dce" -dependencies = [ - "arrayvec", - "bytes", - "libc", -] - -[[package]] -name = "compio-driver" -version = "0.11.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "74d42d98dc890ee4db00c1e68a723391711aab6d67085880d716b72830f7c715" -dependencies = [ - "cfg-if", - "cfg_aliases", - "compio-buf", - "compio-log", - "crossbeam-queue", - "flume", - "futures-util", - "io-uring", - "io_uring_buf_ring", - "libc", - "once_cell", - "paste", - "pin-project-lite", - "polling", - "slab", - "smallvec", - "socket2", - "synchrony", - "thin-cell", - "windows-sys 0.61.2", -] - -[[package]] -name = "compio-fs" -version = "0.11.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "65ee36e1acf2cec4835efe9a986c012b2462c5ef53580e4ee84ae6d5a3d8e3b3" -dependencies = [ - "cfg-if", - "cfg_aliases", - "compio-buf", - "compio-driver", - "compio-io", - "compio-runtime", - "libc", - "os_pipe", - "pin-project-lite", - "widestring", - "windows-sys 0.61.2", -] - -[[package]] -name = "compio-io" -version = "0.9.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "637522f28a64fd5f7dcceaa4ddef13fa8d8020025e8c993f7a069e237835580e" -dependencies = [ - "compio-buf", - "futures-util", - "paste", - "synchrony", -] - -[[package]] -name = "compio-log" -version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fc4e560213c1996b618da369b7c9109564b41af9033802ae534465c4ee4e132f" -dependencies = [ - "tracing", -] - -[[package]] -name = "compio-macros" -version = "0.1.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f05ed201484967dc70de77a8f7a02b29aaa8e6c81cbea2e75492ee0c8d97766b" -dependencies = [ - "proc-macro-crate 3.3.0", - "proc-macro2", - "quote", - "syn 2.0.117", -] - -[[package]] -name = "compio-runtime" -version = "0.11.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d6c1c71f011bdd9c8f30e97d877b606505ee6d241c7782cfaed172f66acbd9cd" -dependencies = [ - "async-task", - "compio-buf", - "compio-driver", - "compio-log", - "core_affinity", - "crossbeam-queue", - "futures-util", - "libc", - "once_cell", - "pin-project-lite", - "scoped-tls", - "slab", - "socket2", - "windows-sys 0.61.2", -] - -[[package]] -name = "concurrent-queue" -version = "2.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4ca0197aee26d1ae37445ee532fefce43251d24cc7c166799f4d46817f1d3973" -dependencies = [ - "crossbeam-utils", -] - [[package]] name = "console" version = "0.16.1" @@ -703,17 +481,6 @@ dependencies = [ "unicode-segmentation", ] -[[package]] -name = "core_affinity" -version = "0.8.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a034b3a7b624016c6e13f5df875747cc25f884156aad2abd12b6c46797971342" -dependencies = [ - "libc", - "num_cpus", - "winapi", -] - [[package]] name = "cpufeatures" version = "0.2.17" @@ -723,15 +490,6 @@ dependencies = [ "libc", ] -[[package]] -name = "cpufeatures" -version = "0.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b2a41393f66f16b0823bb79094d54ac5fbd34ab292ddafb9a0456ac9f87d201" -dependencies = [ - "libc", -] - [[package]] name = "crc32fast" version = "1.5.0" @@ -741,21 +499,6 @@ dependencies = [ "cfg-if", ] -[[package]] -name = "critical-section" -version = "1.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "790eea4361631c5e7d22598ecd5723ff611904e3344ce8720784c93e3d83d40b" - -[[package]] -name = "crossbeam-channel" -version = "0.5.15" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2" -dependencies = [ - "crossbeam-utils", -] - [[package]] name = "crossbeam-deque" version = "0.8.6" @@ -775,15 +518,6 @@ dependencies = [ "crossbeam-utils", ] -[[package]] -name = "crossbeam-queue" -version = "0.3.12" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0f58bbc28f91df819d0aa2a2c00cd19754769c2fad90579b3592b1c9ba7a3115" -dependencies = [ - "crossbeam-utils", -] - [[package]] name = "crossbeam-utils" version = "0.8.21" @@ -814,8 +548,8 @@ dependencies = [ "cuda_types", "libloading", "owo-colors", - "rand 0.10.1", - "windows 0.62.2", + "rand", + "windows", "zluda_windows", ] @@ -825,15 +559,15 @@ version = "0.0.0" dependencies = [ "proc-macro2", "quote", - "rustc-hash 2.1.2", - "syn 2.0.117", + "rustc-hash 2.1.1", + "syn 2.0.89", ] [[package]] name = "cuda_types" version = "0.0.0" dependencies = [ - "bitflags 2.11.1", + "bitflags 2.9.1", "cuda_macros", "hip_runtime-sys", "hipblaslt-sys", @@ -853,7 +587,6 @@ dependencies = [ "format", "lz4-sys", "paste", - "rkyv", "uuid", "zstd-safe", ] @@ -879,7 +612,7 @@ dependencies = [ "proc-macro2", "quote", "strsim", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -890,7 +623,7 @@ checksum = "fc34b93ccb385b40dc71c6fceac4b2ad23662c7eeb248cf10d529b7e055b6ead" dependencies = [ "darling_core", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -935,7 +668,7 @@ checksum = "30542c1ad912e0e3d22a1935c290e12e8a29d704a420177a31faad4a601a0800" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -956,7 +689,7 @@ dependencies = [ "darling", "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -966,7 +699,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ab63b0e2bf4d5928aff72e83a7dace85d7bba5fe12dcc3c5a572d78caffd3f3c" dependencies = [ "derive_builder_core", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -986,7 +719,7 @@ checksum = "cb7330aeadfbe296029522e6c40f315320aba36fc43a5b3632f3795348f3bd22" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", "unicode-xid", ] @@ -1019,7 +752,7 @@ dependencies = [ "dsl_auto_type", "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -1039,7 +772,7 @@ version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "209c735641a413bc68c4923a9d6ad4bcb3ca306b794edaa7eb0b3228a99ffb25" dependencies = [ - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -1087,7 +820,7 @@ checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -1101,7 +834,7 @@ dependencies = [ "heck", "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -1143,29 +876,28 @@ checksum = "e1d926b4d407d372f141f93bb444696142c29d32962ccbd3531117cf3aa0bfa9" [[package]] name = "dynasm" -version = "5.0.0" +version = "1.2.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "df4bf11ba8aecc00489b7ec4e8963cd3860651c3ea2a114394f8ba7e92a0e94a" +checksum = "add9a102807b524ec050363f09e06f1504214b0e1c7797f64261c891022dce8b" dependencies = [ - "bitflags 2.11.1", + "bitflags 1.3.2", "byteorder", "lazy_static", - "proc-macro-error2", + "proc-macro-error", "proc-macro2", "quote", - "syn 2.0.117", + "syn 1.0.109", ] [[package]] name = "dynasmrt" -version = "5.0.0" +version = "1.2.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b38e5331d851567729d892ed28d898d22f49a96940b29e23b5c3e681bd30ffb3" +checksum = "64fba5a42bd76a17cad4bfa00de168ee1cbfa06a5e8ce992ae880218c05641a9" dependencies = [ "byteorder", "dynasm", - "fnv", - "memmap2", + "memmap2 0.5.10", ] [[package]] @@ -1188,18 +920,6 @@ dependencies = [ "winreg", ] -[[package]] -name = "embedded-io" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ef1a6892d9eef45c8fa6b9e0086428a2cca8491aca8f787c534a3d6d0bcb3ced" - -[[package]] -name = "embedded-io" -version = "0.6.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "edd0f118536f44f5ccd48bcb8b111bdc3de888b58c74639dfb034a357d0f206d" - [[package]] name = "encode_unicode" version = "1.0.0" @@ -1224,7 +944,7 @@ dependencies = [ "heck", "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -1258,7 +978,7 @@ version = "0.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7223ae2d2f179b803433d9c830478527e92b8117eab39460edae7f1614d9fb73" dependencies = [ - "heapless 0.8.0", + "heapless", "serde", ] @@ -1311,19 +1031,10 @@ checksum = "719a903cc23e4a89e87962c2a80fdb45cdaad0983a89bd150bb57b4c8571a7d5" dependencies = [ "half", "num-traits", - "rand 0.9.2", + "rand", "rand_distr", ] -[[package]] -name = "flume" -version = "0.12.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5e139bc46ca777eb5efaf62df0ab8cc5fd400866427e56c68b22e414e53bd3be" -dependencies = [ - "spin", -] - [[package]] name = "fnv" version = "1.0.7" @@ -1359,49 +1070,6 @@ dependencies = [ "uuid", ] -[[package]] -name = "futures-core" -version = "0.3.32" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d" - -[[package]] -name = "futures-macro" -version = "0.3.32" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e835b70203e41293343137df5c0664546da5745f82ec9b84d40be8336958447b" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.117", -] - -[[package]] -name = "futures-sink" -version = "0.3.32" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c39754e157331b013978ec91992bde1ac089843443c49cbc7f46150b0fad0893" - -[[package]] -name = "futures-task" -version = "0.3.32" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393" - -[[package]] -name = "futures-util" -version = "0.3.32" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6" -dependencies = [ - "futures-core", - "futures-macro", - "futures-sink", - "futures-task", - "pin-project-lite", - "slab", -] - [[package]] name = "gemm" version = "0.19.0" @@ -1521,21 +1189,6 @@ dependencies = [ "seq-macro", ] -[[package]] -name = "generator" -version = "0.8.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "52f04ae4152da20c76fe800fa48659201d5cf627c5149ca0b707b69d7eef6cf9" -dependencies = [ - "cc", - "cfg-if", - "libc", - "log", - "rustversion", - "windows-link 0.2.1", - "windows-result 0.4.1", -] - [[package]] name = "generic-array" version = "0.14.7" @@ -1565,24 +1218,10 @@ checksum = "26145e563e54f2cadc477553f1ec5ee650b00862f0a58bcd12cbdc5f0ea2d2f4" dependencies = [ "cfg-if", "libc", - "r-efi 5.3.0", + "r-efi", "wasi 0.14.2+wasi-0.2.4", ] -[[package]] -name = "getrandom" -version = "0.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0de51e6874e94e7bf76d726fc5d13ba782deca734ff60d5bb2fb2607c7406555" -dependencies = [ - "cfg-if", - "libc", - "r-efi 6.0.0", - "rand_core 0.10.0", - "wasip2", - "wasip3", -] - [[package]] name = "gix" version = "0.71.0" @@ -1706,7 +1345,7 @@ dependencies = [ "bstr", "gix-chunk", "gix-hash 0.17.0", - "memmap2", + "memmap2 0.9.7", "thiserror 2.0.12", ] @@ -1737,7 +1376,7 @@ version = "0.14.12" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8dc2c844c4cf141884678cabef736fd91dd73068b9146e6f004ba1a0457944b6" dependencies = [ - "bitflags 2.11.1", + "bitflags 2.9.1", "bstr", "gix-path", "libc", @@ -1901,7 +1540,7 @@ version = "0.19.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "20972499c03473e773a2099e5fd0c695b9b72465837797a51a43391a1635a030" dependencies = [ - "bitflags 2.11.1", + "bitflags 2.9.1", "bstr", "gix-features 0.41.1", "gix-path", @@ -1961,7 +1600,7 @@ version = "0.39.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "855bece2d4153453aa5d0a80d51deea1ce8cd6a3b4cf213da85ac344ccb908a7" dependencies = [ - "bitflags 2.11.1", + "bitflags 2.9.1", "bstr", "filetime", "fnv", @@ -1977,7 +1616,7 @@ dependencies = [ "hashbrown 0.14.5", "itoa", "libc", - "memmap2", + "memmap2 0.9.7", "rustix 0.38.37", "smallvec", "thiserror 2.0.12", @@ -2049,7 +1688,7 @@ dependencies = [ "gix-hashtable", "gix-object", "gix-path", - "memmap2", + "memmap2 0.9.7", "smallvec", "thiserror 2.0.12", ] @@ -2098,7 +1737,7 @@ version = "0.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "fef8422c3c9066d649074b24025125963f85232bfad32d6d16aea9453b82ec14" dependencies = [ - "bitflags 2.11.1", + "bitflags 2.9.1", "bstr", "gix-attributes", "gix-config-value", @@ -2153,7 +1792,7 @@ dependencies = [ "gix-tempfile", "gix-utils 0.2.0", "gix-validate 0.9.4", - "memmap2", + "memmap2 0.9.7", "thiserror 2.0.12", "winnow 0.7.10", ] @@ -2178,7 +1817,7 @@ version = "0.33.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "342caa4e158df3020cadf62f656307c3948fe4eacfdf67171d7212811860c3e9" dependencies = [ - "bitflags 2.11.1", + "bitflags 2.9.1", "bstr", "gix-commitgraph", "gix-date", @@ -2211,7 +1850,7 @@ version = "0.10.12" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "47aeb0f13de9ef2f3033f5ff218de30f44db827ac9f1286f9ef050aacddd5888" dependencies = [ - "bitflags 2.11.1", + "bitflags 2.9.1", "gix-path", "libc", "windows-sys 0.52.0", @@ -2311,7 +1950,7 @@ version = "0.45.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "36c0b049f8bdb61b20016694102f7b507f2e1727e83e9c5e6dad4f7d84ff7384" dependencies = [ - "bitflags 2.11.1", + "bitflags 2.9.1", "gix-commitgraph", "gix-date", "gix-hash 0.17.0", @@ -2396,12 +2035,6 @@ dependencies = [ "gix-validate 0.9.4", ] -[[package]] -name = "glam" -version = "0.32.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f70749695b063ecbf6b62949ccccde2e733ec3ecbbd71d467dca4e5c6c97cca0" - [[package]] name = "glob" version = "0.3.1" @@ -2429,20 +2062,11 @@ dependencies = [ "cfg-if", "crunchy", "num-traits", - "rand 0.9.2", + "rand", "rand_distr", "zerocopy", ] -[[package]] -name = "hash32" -version = "0.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b0c35f58762feb77d74ebe43bdbc3210f09be9fe6742234d573bacc26ed92b67" -dependencies = [ - "byteorder", -] - [[package]] name = "hash32" version = "0.3.1" @@ -2484,27 +2108,13 @@ dependencies = [ "serde_core", ] -[[package]] -name = "heapless" -version = "0.7.17" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cdc6457c0eb62c71aac4bc17216026d8410337c4126773b9c5daba343f17964f" -dependencies = [ - "atomic-polyfill", - "hash32 0.2.1", - "rustc_version", - "serde", - "spin", - "stable_deref_trait", -] - [[package]] name = "heapless" version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0bfb9eb618601c89945a70e254898da93b13be0388091d42117462b265bb3fad" dependencies = [ - "hash32 0.3.1", + "hash32", "stable_deref_trait", ] @@ -2645,12 +2255,6 @@ dependencies = [ "zerovec", ] -[[package]] -name = "id-arena" -version = "2.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954" - [[package]] name = "ident_case" version = "1.0.1" @@ -2695,7 +2299,6 @@ checksum = "8c9c992b02b5b4c94ea26e32fe5bccb7aa7d9f390ab5c1221ff895bc7ea8b652" dependencies = [ "equivalent", "hashbrown 0.15.2", - "serde", ] [[package]] @@ -2720,60 +2323,19 @@ dependencies = [ "proc-macro2", "proc-macro2-diagnostics", "quote", - "syn 2.0.117", + "syn 2.0.89", "version_check", ] [[package]] -name = "io-uring" -version = "0.7.11" +name = "is-terminal" +version = "0.4.17" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fdd7bddefd0a8833b88a4b68f90dae22c7450d11b354198baee3874fd811b344" +checksum = "3640c1c38b8e4e43584d8df18be5fc6b0aa314ce6ebf51b53313d4306cca8e46" dependencies = [ - "bitflags 2.11.1", - "cfg-if", + "hermit-abi", "libc", -] - -[[package]] -name = "io_uring_buf_ring" -version = "0.2.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1838759bb8c2f24cf05a35429d83145c4aa6af43f8ad38477295e12a7320a80e" -dependencies = [ - "bytes", - "io-uring", - "rustix 1.1.4", -] - -[[package]] -name = "ipc-channel" -version = "0.21.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a441490012d80e9aea75fb27503df8e87e9557dcfc6fe4244dde86bfc12e94e3" -dependencies = [ - "crossbeam-channel", - "libc", - "mio", - "postcard", - "rand 0.9.2", - "rustc-hash 2.1.2", - "serde_core", - "tempfile", - "thiserror 2.0.12", - "uuid", - "windows 0.61.3", -] - -[[package]] -name = "is-terminal" -version = "0.4.17" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3640c1c38b8e4e43584d8df18be5fc6b0aa314ce6ebf51b53313d4306cca8e46" -dependencies = [ - "hermit-abi", - "libc", - "windows-sys 0.61.2", + "windows-sys 0.61.2", ] [[package]] @@ -2880,17 +2442,11 @@ version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe" -[[package]] -name = "leb128fmt" -version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2" - [[package]] name = "libc" -version = "0.2.184" +version = "0.2.174" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "48f5d2a454e16a5ea0f4ced81bd44e4cfc7bd3a507b61887c99fd3538b28e4af" +checksum = "1171693293099992e19cddea4e8b849964e9846f4acee11b3948bcc337be8776" [[package]] name = "libloading" @@ -2914,7 +2470,7 @@ version = "0.1.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d" dependencies = [ - "bitflags 2.11.1", + "bitflags 2.9.1", "libc", "redox_syscall", ] @@ -2947,9 +2503,9 @@ checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89" [[package]] name = "linux-raw-sys" -version = "0.12.1" +version = "0.9.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53" +checksum = "fe7db12097d22ec582439daf8618b8fdd1a7bef6270e9af3b1ebcd30893cf413" [[package]] name = "litemap" @@ -3025,7 +2581,7 @@ dependencies = [ "proc-macro2", "quote", "regex-syntax", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -3037,20 +2593,6 @@ dependencies = [ "logos-codegen", ] -[[package]] -name = "loom" -version = "0.7.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "419e0dc8046cb947daa77eb95ae174acfbddb7673b4151f56d1eed8e93fbfaca" -dependencies = [ - "cfg-if", - "generator", - "pin-utils", - "scoped-tls", - "tracing", - "tracing-subscriber", -] - [[package]] name = "lz4-sys" version = "1.11.1+lz4-1.10.0" @@ -3061,15 +2603,6 @@ dependencies = [ "libc", ] -[[package]] -name = "matchers" -version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d1525a2a28c7f4fa0fc98bb91ae755d1e2d1505079e05539e35bc876b5d65ae9" -dependencies = [ - "regex-automata", -] - [[package]] name = "maybe-async" version = "0.2.10" @@ -3078,7 +2611,7 @@ checksum = "5cf92c10c7e361d6b99666ec1c6f9805b0bea2c3bd8c78dc6fe98ac5bd78db11" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -3089,9 +2622,18 @@ checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3" [[package]] name = "memmap2" -version = "0.9.10" +version = "0.5.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "714098028fe011992e1c3962653c96b2d578c4b4bce9036e15ff220319b1e0e3" +checksum = "83faa42c0a078c393f6b29d5db232d8be22776a891f8f56e5284faee4a20b327" +dependencies = [ + "libc", +] + +[[package]] +name = "memmap2" +version = "0.9.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "483758ad303d734cec05e5c12b41d7e93e6a6390c5e9dae6bdeb7c1259012d28" dependencies = [ "libc", "stable_deref_trait", @@ -3133,17 +2675,6 @@ dependencies = [ "adler2", ] -[[package]] -name = "mio" -version = "1.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "50b7e5b27aa02a74bac8c3f23f448f8d87ff11f92d3aac1a6ed369ee08cc56c1" -dependencies = [ - "libc", - "wasi 0.11.1+wasi-snapshot-preview1", - "windows-sys 0.61.2", -] - [[package]] name = "miopen-sys" version = "0.0.0" @@ -3168,7 +2699,7 @@ checksum = "4568f25ccbd45ab5d5603dc34318c1ec56b117531781260002151b8530a9f931" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -3187,15 +2718,6 @@ dependencies = [ "minimal-lexical", ] -[[package]] -name = "nu-ansi-term" -version = "0.50.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5" -dependencies = [ - "windows-sys 0.61.2", -] - [[package]] name = "num" version = "0.4.3" @@ -3306,40 +2828,6 @@ dependencies = [ "libc", ] -[[package]] -name = "nvapi" -version = "0.0.0" -dependencies = [ - "cglue", - "cuda_macros", - "cuda_types", - "dark_api", - "format", - "libloading", - "paste", - "rustc-hash 2.1.2", - "unwrap_or", - "zluda_trace_common", -] - -[[package]] -name = "nvapi_trace" -version = "0.0.0" -dependencies = [ - "cglue", - "cuda_macros", - "cuda_types", - "dark_api", - "dynasm", - "dynasmrt", - "format", - "libloading", - "paste", - "rustc-hash 2.1.2", - "unwrap_or", - "zluda_trace_common", -] - [[package]] name = "object" version = "0.38.1" @@ -3366,22 +2854,6 @@ version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d" -[[package]] -name = "orderly-allocator" -version = "0.2.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "801f8900aedd8c4060d155f0c8e0269e011ddd0e061bf56a87e5d9ddba3ce995" - -[[package]] -name = "os_pipe" -version = "1.2.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7d8fae84b431384b68627d0f9b3b1245fcf9f46f6c0e3dc902e9dce64edd1967" -dependencies = [ - "libc", - "windows-sys 0.61.2", -] - [[package]] name = "owo-colors" version = "4.2.3" @@ -3443,18 +2915,6 @@ dependencies = [ "indexmap", ] -[[package]] -name = "pin-project-lite" -version = "0.2.17" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd" - -[[package]] -name = "pin-utils" -version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" - [[package]] name = "pkg-config" version = "0.3.32" @@ -3467,20 +2927,6 @@ version = "0.2.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6" -[[package]] -name = "polling" -version = "3.11.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5d0e4f59085d47d8241c88ead0f274e8a0cb551f3625263c05eb8dd897c34218" -dependencies = [ - "cfg-if", - "concurrent-queue", - "hermit-abi", - "pin-project-lite", - "rustix 1.1.4", - "windows-sys 0.61.2", -] - [[package]] name = "portable-atomic" version = "1.11.1" @@ -3496,19 +2942,6 @@ dependencies = [ "portable-atomic", ] -[[package]] -name = "postcard" -version = "1.1.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6764c3b5dd454e283a30e6dfe78e9b31096d9e32036b5d1eaac7a6119ccb9a24" -dependencies = [ - "cobs", - "embedded-io 0.4.0", - "embedded-io 0.6.1", - "heapless 0.7.17", - "serde", -] - [[package]] name = "potential_utf" version = "0.1.2" @@ -3550,7 +2983,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "64d1ec885c64d0457d564db4ec299b2dae3f9c02808b8ad9c3a089c591b18033" dependencies = [ "proc-macro2", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -3572,32 +3005,34 @@ dependencies = [ ] [[package]] -name = "proc-macro-error-attr2" -version = "2.0.0" +name = "proc-macro-error" +version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "96de42df36bb9bba5542fe9f1a054b8cc87e172759a1868aa05c1f3acc89dfc5" +checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c" dependencies = [ + "proc-macro-error-attr", "proc-macro2", "quote", + "syn 1.0.109", + "version_check", ] [[package]] -name = "proc-macro-error2" -version = "2.0.1" +name = "proc-macro-error-attr" +version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "11ec05c52be0a07b08061f7dd003e7d7092e0472bc731b4af7bb1ef876109802" +checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869" dependencies = [ - "proc-macro-error-attr2", "proc-macro2", "quote", - "syn 2.0.117", + "version_check", ] [[package]] name = "proc-macro2" -version = "1.0.106" +version = "1.0.92" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934" +checksum = "37d3544b3f2748c54e147655edb5025752e2303145b5aefb3c3ea2c78b973bb0" dependencies = [ "unicode-ident", ] @@ -3610,7 +3045,7 @@ checksum = "af066a9c399a26e020ada66a034357a868728e72cd426f3adcd35f80d88d88c8" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", "version_check", "yansi", ] @@ -3642,7 +3077,7 @@ checksum = "7347867d0a7e1208d93b46767be83e2b8f978c3dad35f775ac8d8847551d6fe1" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -3666,7 +3101,7 @@ dependencies = [ "pretty_assertions", "ptx_parser", "quick-error", - "rustc-hash 2.1.2", + "rustc-hash 2.1.1", "smallvec", "strum 0.28.0", "strum_macros 0.28.0", @@ -3683,7 +3118,7 @@ dependencies = [ "derive_more", "logos", "ptx_parser_macros", - "rustc-hash 2.1.2", + "rustc-hash 2.1.1", "strum 0.27.1", "thiserror 1.0.64", "winnow 0.6.20", @@ -3698,8 +3133,8 @@ dependencies = [ "proc-macro2", "ptx_parser_macros_impl", "quote", - "rustc-hash 2.1.2", - "syn 2.0.117", + "rustc-hash 2.1.1", + "syn 2.0.89", ] [[package]] @@ -3708,8 +3143,8 @@ version = "0.0.0" dependencies = [ "proc-macro2", "quote", - "rustc-hash 2.1.2", - "syn 2.0.117", + "rustc-hash 2.1.1", + "syn 2.0.89", ] [[package]] @@ -3753,9 +3188,9 @@ checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0" [[package]] name = "quote" -version = "1.0.45" +version = "1.0.37" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924" +checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af" dependencies = [ "proc-macro2", ] @@ -3766,12 +3201,6 @@ version = "5.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f" -[[package]] -name = "r-efi" -version = "6.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf" - [[package]] name = "rancor" version = "0.1.1" @@ -3788,18 +3217,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1" dependencies = [ "rand_chacha", - "rand_core 0.9.5", -] - -[[package]] -name = "rand" -version = "0.10.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d2e8e8bcc7961af1fdac401278c6a831614941f6164ee3bf4ce61b7edb162207" -dependencies = [ - "chacha20", - "getrandom 0.4.2", - "rand_core 0.10.0", + "rand_core", ] [[package]] @@ -3809,7 +3227,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb" dependencies = [ "ppv-lite86", - "rand_core 0.9.5", + "rand_core", ] [[package]] @@ -3821,12 +3239,6 @@ dependencies = [ "getrandom 0.3.3", ] -[[package]] -name = "rand_core" -version = "0.10.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0c8d0fd677905edcbeedbf2edb6494d676f0e98d54d5cf9bda0b061cb8fb8aba" - [[package]] name = "rand_distr" version = "0.5.1" @@ -3834,22 +3246,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6a8615d50dcf34fa31f7ab52692afec947c4dd0ab803cc87cb3b0b4570ff7463" dependencies = [ "num-traits", - "rand 0.9.2", + "rand", ] -[[package]] -name = "range-alloc" -version = "0.1.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ca45419789ae5a7899559e9512e58ca889e41f04f1f2445e9f4b290ceccd1d08" - [[package]] name = "raw-cpuid" version = "11.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "498cd0dc59d73224351ee52a95fee0f1a617a2eae0e7d9d720cc622c73a54186" dependencies = [ - "bitflags 2.11.1", + "bitflags 2.9.1", ] [[package]] @@ -3884,7 +3290,7 @@ version = "0.5.11" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d2f103c6d277498fbceb16e84d317e2a400f160f46904d5f5410848c829511a3" dependencies = [ - "bitflags 2.11.1", + "bitflags 2.9.1", ] [[package]] @@ -3969,7 +3375,7 @@ checksum = "8100bb34c0a1d0f907143db3149e6b4eea3c33b9ee8b189720168e818303986f" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -3998,9 +3404,9 @@ checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2" [[package]] name = "rustc-hash" -version = "2.1.2" +version = "2.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "94300abf3f1ae2e2b8ffb7b58043de3d399c73fa6f4b73826402a5c457614dbe" +checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d" [[package]] name = "rustc_version" @@ -4017,7 +3423,7 @@ version = "0.38.37" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8acb788b847c24f28525660c4d7758620a7210875711f79e7f663cc152726811" dependencies = [ - "bitflags 2.11.1", + "bitflags 2.9.1", "errno", "libc", "linux-raw-sys 0.4.14", @@ -4026,15 +3432,15 @@ dependencies = [ [[package]] name = "rustix" -version = "1.1.4" +version = "1.0.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190" +checksum = "d97817398dd4bb2e6da002002db259209759911da105da92bec29ccb12cf58bf" dependencies = [ - "bitflags 2.11.1", + "bitflags 2.9.1", "errno", "libc", - "linux-raw-sys 0.12.1", - "windows-sys 0.61.2", + "linux-raw-sys 0.9.3", + "windows-sys 0.59.0", ] [[package]] @@ -4078,12 +3484,6 @@ dependencies = [ "winapi-util", ] -[[package]] -name = "scoped-tls" -version = "1.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294" - [[package]] name = "scopeguard" version = "1.2.0" @@ -4107,7 +3507,7 @@ checksum = "1783eabc414609e28a5ba76aee5ddd52199f7107a0b24c2e9746a1ecc34a683d" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -4152,7 +3552,7 @@ checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -4183,7 +3583,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba" dependencies = [ "cfg-if", - "cpufeatures 0.2.17", + "cpufeatures", "digest", ] @@ -4197,15 +3597,6 @@ dependencies = [ "sha1", ] -[[package]] -name = "sharded-slab" -version = "0.1.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6" -dependencies = [ - "lazy_static", -] - [[package]] name = "shell-words" version = "1.1.0" @@ -4249,37 +3640,12 @@ version = "0.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e" -[[package]] -name = "slab" -version = "0.4.12" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5" - [[package]] name = "smallvec" version = "1.15.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03" -[[package]] -name = "socket2" -version = "0.6.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3a766e1110788c36f4fa1c2b71b387a7815aa65f88ce0229841826633d93723e" -dependencies = [ - "libc", - "windows-sys 0.61.2", -] - -[[package]] -name = "spin" -version = "0.9.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67" -dependencies = [ - "lock_api", -] - [[package]] name = "stable_deref_trait" version = "1.2.0" @@ -4323,7 +3689,7 @@ dependencies = [ "proc-macro2", "quote", "rustversion", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -4335,7 +3701,7 @@ dependencies = [ "heck", "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -4370,25 +3736,15 @@ dependencies = [ [[package]] name = "syn" -version = "2.0.117" +version = "2.0.89" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99" +checksum = "44d46482f1c1c87acd84dea20c1bf5ebff4c757009ed6bf19cfd36fb10e92c4e" dependencies = [ "proc-macro2", "quote", "unicode-ident", ] -[[package]] -name = "synchrony" -version = "0.1.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c174d82fd56da8214ec095cfe4568e59e5ccb49d060e70c2f98e3ba352b23e45" -dependencies = [ - "futures-util", - "loom", -] - [[package]] name = "synstructure" version = "0.13.2" @@ -4397,7 +3753,7 @@ checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -4406,7 +3762,7 @@ version = "0.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "01198a2debb237c62b6826ec7081082d951f46dbb64b0e8c7649a452230d1dfc" dependencies = [ - "bitflags 2.11.1", + "bitflags 2.9.1", "byteorder", "enum-as-inner", "libc", @@ -4440,16 +3796,10 @@ dependencies = [ "fastrand", "getrandom 0.3.3", "once_cell", - "rustix 1.1.4", + "rustix 1.0.5", "windows-sys 0.59.0", ] -[[package]] -name = "thin-cell" -version = "0.1.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4164c6c316ba9733b0ab021e7f9852c788a4b991b49c25820f1be48e1d41345b" - [[package]] name = "thiserror" version = "1.0.64" @@ -4476,7 +3826,7 @@ checksum = "08904e7672f5eb876eaaf87e0ce17857500934f4981c4a0ab2b4aa98baac7fc3" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -4487,16 +3837,7 @@ checksum = "7f7cf42b4507d8ea322120659672cf1b9dbb93f8f2d4ecfd6e51350ff5b17a1d" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", -] - -[[package]] -name = "thread_local" -version = "1.1.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f60246a4944f24f6e018aa17cdeffb7818b76356965d03b07d6a9886e8962185" -dependencies = [ - "cfg-if", + "syn 2.0.89", ] [[package]] @@ -4622,55 +3963,6 @@ version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "fcc842091f2def52017664b53082ecbbeb5c7731092bad69d2c63050401dfd64" -[[package]] -name = "tracing" -version = "0.1.44" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100" -dependencies = [ - "pin-project-lite", - "tracing-core", -] - -[[package]] -name = "tracing-core" -version = "0.1.36" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a" -dependencies = [ - "once_cell", - "valuable", -] - -[[package]] -name = "tracing-log" -version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3" -dependencies = [ - "log", - "once_cell", - "tracing-core", -] - -[[package]] -name = "tracing-subscriber" -version = "0.3.23" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cb7f578e5945fb242538965c2d0b04418d38ec25c79d160cd279bf0731c8d319" -dependencies = [ - "matchers", - "nu-ansi-term", - "once_cell", - "regex-automata", - "sharded-slab", - "smallvec", - "thread_local", - "tracing", - "tracing-core", - "tracing-log", -] - [[package]] name = "trie-hard" version = "0.1.0" @@ -4740,12 +4032,6 @@ version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "323402cff2dd658f39ca17c789b502021b3f18707c91cdf22e3838e1b4023817" -[[package]] -name = "unty" -version = "0.0.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6d49784317cd0d1ee7ec5c716dd598ec5b4483ea832a2dced265471cc0f690ae" - [[package]] name = "unwrap_or" version = "1.0.1" @@ -4775,17 +4061,10 @@ version = "1.18.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2f87b8aa10b915a06587d0dec516c282ff295b475d94abf425d62b57710070a2" dependencies = [ - "getrandom 0.3.3", "js-sys", "wasm-bindgen", ] -[[package]] -name = "valuable" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65" - [[package]] name = "vcpkg" version = "0.2.15" @@ -4836,12 +4115,6 @@ version = "0.9.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" -[[package]] -name = "virtue" -version = "0.0.18" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "051eb1abcf10076295e815102942cc58f9d5e3b4560e46e53c21e8ff6f3af7b1" - [[package]] name = "vswhom" version = "0.1.0" @@ -4887,24 +4160,6 @@ dependencies = [ "wit-bindgen-rt", ] -[[package]] -name = "wasip2" -version = "1.0.2+wasi-0.2.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9517f9239f02c069db75e65f174b3da828fe5f5b945c4dd26bd25d89c03ebcf5" -dependencies = [ - "wit-bindgen", -] - -[[package]] -name = "wasip3" -version = "0.4.0+wasi-0.3.0-rc-2026-01-06" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5" -dependencies = [ - "wit-bindgen", -] - [[package]] name = "wasm-bindgen" version = "0.2.104" @@ -4928,7 +4183,7 @@ dependencies = [ "log", "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", "wasm-bindgen-shared", ] @@ -4950,7 +4205,7 @@ checksum = "9f07d2f20d4da7b26400c9f4a0511e6e0345b040694e8a75bd41d578fa4421d7" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", "wasm-bindgen-backend", "wasm-bindgen-shared", ] @@ -4964,40 +4219,6 @@ dependencies = [ "unicode-ident", ] -[[package]] -name = "wasm-encoder" -version = "0.244.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319" -dependencies = [ - "leb128fmt", - "wasmparser", -] - -[[package]] -name = "wasm-metadata" -version = "0.244.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909" -dependencies = [ - "anyhow", - "indexmap", - "wasm-encoder", - "wasmparser", -] - -[[package]] -name = "wasmparser" -version = "0.244.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe" -dependencies = [ - "bitflags 2.11.1", - "hashbrown 0.15.2", - "indexmap", - "semver", -] - [[package]] name = "web-time" version = "1.1.0" @@ -5045,38 +4266,16 @@ version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" -[[package]] -name = "windows" -version = "0.61.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9babd3a767a4c1aef6900409f85f5d53ce2544ccdfaa86dad48c91782c6d6893" -dependencies = [ - "windows-collections 0.2.0", - "windows-core 0.61.2", - "windows-future 0.2.1", - "windows-link 0.1.3", - "windows-numerics 0.2.0", -] - [[package]] name = "windows" version = "0.62.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "527fadee13e0c05939a6a05d5bd6eec6cd2e3dbd648b9f8e447c6518133d8580" dependencies = [ - "windows-collections 0.3.2", - "windows-core 0.62.2", - "windows-future 0.3.2", - "windows-numerics 0.3.1", -] - -[[package]] -name = "windows-collections" -version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3beeceb5e5cfd9eb1d76b381630e82c4241ccd0d27f1a39ed41b2760b255c5e8" -dependencies = [ - "windows-core 0.61.2", + "windows-collections", + "windows-core", + "windows-future", + "windows-numerics", ] [[package]] @@ -5085,20 +4284,7 @@ version = "0.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "23b2d95af1a8a14a3c7367e1ed4fc9c20e0a26e79551b1454d72583c97cc6610" dependencies = [ - "windows-core 0.62.2", -] - -[[package]] -name = "windows-core" -version = "0.61.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3" -dependencies = [ - "windows-implement", - "windows-interface", - "windows-link 0.1.3", - "windows-result 0.3.4", - "windows-strings 0.4.2", + "windows-core", ] [[package]] @@ -5109,20 +4295,9 @@ checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb" dependencies = [ "windows-implement", "windows-interface", - "windows-link 0.2.1", - "windows-result 0.4.1", - "windows-strings 0.5.1", -] - -[[package]] -name = "windows-future" -version = "0.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fc6a41e98427b19fe4b73c550f060b59fa592d7d686537eebf9385621bfbad8e" -dependencies = [ - "windows-core 0.61.2", - "windows-link 0.1.3", - "windows-threading 0.1.0", + "windows-link", + "windows-result", + "windows-strings", ] [[package]] @@ -5131,9 +4306,9 @@ version = "0.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e1d6f90251fe18a279739e78025bd6ddc52a7e22f921070ccdc67dde84c605cb" dependencies = [ - "windows-core 0.62.2", - "windows-link 0.2.1", - "windows-threading 0.2.1", + "windows-core", + "windows-link", + "windows-threading", ] [[package]] @@ -5144,7 +4319,7 @@ checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -5155,48 +4330,23 @@ checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] -[[package]] -name = "windows-link" -version = "0.1.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a" - [[package]] name = "windows-link" version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" -[[package]] -name = "windows-numerics" -version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9150af68066c4c5c07ddc0ce30421554771e528bde427614c61038bc2c92c2b1" -dependencies = [ - "windows-core 0.61.2", - "windows-link 0.1.3", -] - [[package]] name = "windows-numerics" version = "0.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6e2e40844ac143cdb44aead537bbf727de9b044e107a0f1220392177d15b0f26" dependencies = [ - "windows-core 0.62.2", - "windows-link 0.2.1", -] - -[[package]] -name = "windows-result" -version = "0.3.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6" -dependencies = [ - "windows-link 0.1.3", + "windows-core", + "windows-link", ] [[package]] @@ -5205,16 +4355,7 @@ version = "0.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5" dependencies = [ - "windows-link 0.2.1", -] - -[[package]] -name = "windows-strings" -version = "0.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57" -dependencies = [ - "windows-link 0.1.3", + "windows-link", ] [[package]] @@ -5223,7 +4364,7 @@ version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091" dependencies = [ - "windows-link 0.2.1", + "windows-link", ] [[package]] @@ -5250,7 +4391,7 @@ version = "0.61.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" dependencies = [ - "windows-link 0.2.1", + "windows-link", ] [[package]] @@ -5269,22 +4410,13 @@ dependencies = [ "windows_x86_64_msvc", ] -[[package]] -name = "windows-threading" -version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b66463ad2e0ea3bbf808b7f1d371311c80e115c0b71d60efc142cafbcfb057a6" -dependencies = [ - "windows-link 0.1.3", -] - [[package]] name = "windows-threading" version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3949bd5b99cafdf1c7ca86b43ca564028dfe27d66958f2470940f73d86d75b37" dependencies = [ - "windows-link 0.2.1", + "windows-link", ] [[package]] @@ -5363,101 +4495,13 @@ dependencies = [ "windows-sys 0.59.0", ] -[[package]] -name = "wit-bindgen" -version = "0.51.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5" -dependencies = [ - "wit-bindgen-rust-macro", -] - -[[package]] -name = "wit-bindgen-core" -version = "0.51.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc" -dependencies = [ - "anyhow", - "heck", - "wit-parser", -] - [[package]] name = "wit-bindgen-rt" version = "0.39.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6f42320e61fe2cfd34354ecb597f86f413484a798ba44a8ca1165c58d42da6c1" dependencies = [ - "bitflags 2.11.1", -] - -[[package]] -name = "wit-bindgen-rust" -version = "0.51.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21" -dependencies = [ - "anyhow", - "heck", - "indexmap", - "prettyplease", - "syn 2.0.117", - "wasm-metadata", - "wit-bindgen-core", - "wit-component", -] - -[[package]] -name = "wit-bindgen-rust-macro" -version = "0.51.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0c0f9bfd77e6a48eccf51359e3ae77140a7f50b1e2ebfe62422d8afdaffab17a" -dependencies = [ - "anyhow", - "prettyplease", - "proc-macro2", - "quote", - "syn 2.0.117", - "wit-bindgen-core", - "wit-bindgen-rust", -] - -[[package]] -name = "wit-component" -version = "0.244.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2" -dependencies = [ - "anyhow", - "bitflags 2.11.1", - "indexmap", - "log", - "serde", - "serde_derive", - "serde_json", - "wasm-encoder", - "wasm-metadata", - "wasmparser", - "wit-parser", -] - -[[package]] -name = "wit-parser" -version = "0.244.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736" -dependencies = [ - "anyhow", - "id-arena", - "indexmap", - "log", - "semver", - "serde", - "serde_derive", - "serde_json", - "unicode-xid", - "wasmparser", + "bitflags 2.9.1", ] [[package]] @@ -5473,7 +4517,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0d65cbf2f12c15564212d48f4e3dfb87923d25d611f2aed18f4cb23f0413d89e" dependencies = [ "libc", - "rustix 1.1.4", + "rustix 1.0.5", ] [[package]] @@ -5516,7 +4560,7 @@ checksum = "38da3c9736e16c5d3c8c597a9aaa5d1fa565d0532ae05e27c24aa62fb32c0ab6" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", "synstructure", ] @@ -5537,7 +4581,7 @@ checksum = "9ecf5b4cc5364572d7f4c329661bcc82724222973f2cab6f050a4e5c22f75181" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -5557,7 +4601,7 @@ checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", "synstructure", ] @@ -5591,7 +4635,7 @@ checksum = "5b96237efa0c878c64bd89c436f661be4e46b2f3eff1ebb976f7ef2321d2f58f" dependencies = [ "proc-macro2", "quote", - "syn 2.0.117", + "syn 2.0.89", ] [[package]] @@ -5648,58 +4692,17 @@ dependencies = [ "paste", "ptx", "ptx_parser", - "rustc-hash 2.1.2", + "rustc-hash 2.1.1", "serde", "serde_json", "tempfile", "vergen-gix", - "windows 0.62.2", + "windows", "zluda_cache", "zluda_common", "zluda_windows", ] -[[package]] -name = "zluda32" -version = "0.0.0" -dependencies = [ - "bincode", - "bitcode", - "cuda_macros", - "cuda_types", - "dark_api", - "ipc-channel", - "paste", - "postcard", - "rand 0.10.1", - "rkyv", - "rustc-hash 2.1.2", - "unwrap_or", - "widestring", - "windows 0.62.2", - "zluda_common", - "zluda_server_common", - "zluda_windows", -] - -[[package]] -name = "zluda64_server" -version = "0.0.0" -dependencies = [ - "bincode", - "compio", - "cuda_macros", - "cuda_types", - "dark_api", - "orderly-allocator", - "range-alloc", - "rkyv", - "rustc-hash 2.1.2", - "slab", - "windows-sys 0.61.2", - "zluda_server_common", -] - [[package]] name = "zluda_bindgen" version = "0.1.0" @@ -5710,8 +4713,8 @@ dependencies = [ "prettyplease", "proc-macro2", "quote", - "rustc-hash 2.1.2", - "syn 2.0.117", + "rustc-hash 2.1.1", + "syn 2.0.89", ] [[package]] @@ -5780,7 +4783,7 @@ dependencies = [ "hip_runtime-sys", "libloading", "miopen-sys", - "rustc-hash 2.1.2", + "rustc-hash 2.1.1", "static_assertions", "zluda_common", "zluda_windows", @@ -5808,9 +4811,9 @@ dependencies = [ "half", "libloading", "paste", - "rand 0.9.2", + "rand", "rand_chacha", - "windows 0.62.2", + "windows", "zluda_common", "zluda_dnn", "zluda_windows", @@ -5831,11 +4834,11 @@ dependencies = [ "argh", "bpaf", "detours-sys", - "rustc-hash 2.1.2", + "rustc-hash 2.1.1", "tempfile", "widestring", - "windows 0.62.2", - "windows-core 0.62.2", + "windows", + "windows-core", "zluda_ml", "zluda_redirect", "zluda_trace", @@ -5876,31 +4879,15 @@ name = "zluda_redirect" version = "0.0.0" dependencies = [ "detours-sys", - "rustc-hash 2.1.2", + "rustc-hash 2.1.1", "unwrap_or", "widestring", - "windows 0.62.2", + "windows", "windows-sys 0.61.2", "winnow 0.6.20", "zluda_windows", ] -[[package]] -name = "zluda_server_common" -version = "0.0.0" -dependencies = [ - "bincode", - "bitcode", - "cuda_macros", - "cuda_types", - "dark_api", - "paste", - "postcard", - "rkyv", - "strum 0.28.0", - "strum_macros 0.28.0", -] - [[package]] name = "zluda_sparse" version = "0.0.0" @@ -5932,11 +4919,12 @@ dependencies = [ "libloading", "parking_lot", "paste", + "ptx", "ptx_parser", "regex", - "rustc-hash 2.1.2", + "rustc-hash 2.1.1", "unwrap_or", - "windows 0.62.2", + "windows", "zluda_common", "zluda_trace_common", "zstd-safe", @@ -6067,7 +5055,7 @@ dependencies = [ "trie-hard", "uuid", "widestring", - "windows 0.62.2", + "windows", ] [[package]] diff --git a/Cargo.toml b/Cargo.toml index 066ca9602..d199126eb 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -16,8 +16,6 @@ members = [ "ext/rocblas-sys", "format", "kernel_metadata", - "nvapi", - "nvapi_trace", "ptx_parser_macros_impl", "ptx_parser_macros", "ptx_parser", @@ -38,7 +36,6 @@ members = [ "zluda_ml", "zluda_precompile", "zluda_redirect", - "zluda_server_common", "zluda_sparse", "zluda_trace_blas", "zluda_trace_blaslt", @@ -50,8 +47,6 @@ members = [ "zluda_trace_sparse", "zluda_trace", "zluda", - "zluda32", - "zluda64_server", ] default-members = ["zluda", "zluda_ml", "zluda_inject", "zluda_redirect", "compiler"] diff --git a/cuda_check/Cargo.toml b/cuda_check/Cargo.toml index baefa150c..c0b9c3d4d 100644 --- a/cuda_check/Cargo.toml +++ b/cuda_check/Cargo.toml @@ -13,7 +13,7 @@ cuda_types = { path = "../cuda_types" } zluda_windows = { path = "../zluda_windows" } bpaf = { version = "0.9.19", features = ["derive", "bright-color"] } owo-colors = { version = "4", features = ["supports-colors"] } -rand = "0.10.1" +rand = "0.9.2" libloading = "0.8" [target.'cfg(windows)'.dependencies] diff --git a/cuda_macros/src/lib.rs b/cuda_macros/src/lib.rs index 1267860b9..769a672b9 100644 --- a/cuda_macros/src/lib.rs +++ b/cuda_macros/src/lib.rs @@ -9,7 +9,8 @@ use syn::parse::{Parse, ParseStream}; use syn::punctuated::Punctuated; use syn::visit_mut::VisitMut; use syn::{ - File, ForeignItem, ForeignItemFn, Ident, Item, PatType, Path, Signature, Token, TypeGroup, bracketed, parse_macro_input + bracketed, parse_macro_input, File, ForeignItem, ForeignItemFn, Ident, Item, Path, Signature, + Token }; const CUDA_RS: &'static str = include_str! {"cuda.rs"}; @@ -300,95 +301,6 @@ pub fn nvml_normalize_fn(tokens: TokenStream) -> TokenStream { normalize_fn_impl("nvml", None, tokens) } -#[proc_macro] -pub fn generate_input_struct(tokens: TokenStream) -> TokenStream { - let input = parse_macro_input!(tokens as FnWithFields); - let struct_name = format_ident!("{}In", input.fn_name); - let fields = input.fields.iter().filter(|pat| is_input_field(&pat.ty)).map(use_wire_object); - quote! { - #[derive(Archive, Deserialize, Serialize, Debug, PartialEq)] - #[repr(C)] - pub struct #struct_name { - #(#fields),* - } - unsafe impl Portable for #struct_name {} - }.into() -} - -#[proc_macro] -pub fn generate_output_struct(tokens: TokenStream) -> TokenStream { - let input = parse_macro_input!(tokens as FnWithFields); - let struct_name = format_ident!("{}Out", input.fn_name); - let fields = input.fields.iter().filter(|pat| !is_input_field(&pat.ty)).map(strip_mut_ptr); - quote! { - #[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] - #[repr(C)] - pub struct #struct_name { - #(#fields),* - } - unsafe impl Portable for #struct_name {} - }.into() -} - -fn is_input_field(ty: &syn::Type) -> bool { - match ty { - syn::Type::Ptr(token) if token.mutability.is_some() => false, - syn::Type::Group(TypeGroup {elem, ..}) => is_input_field(&*elem), - _ => true - } -} - -fn use_wire_object(ty: &syn::PatType) -> proc_macro2::TokenStream { - let pat = &ty.pat; - let type_ = &ty.ty; - quote! { pub #pat : <#type_ as crate::CudaEncode>::WireObject } -} - -fn strip_mut_ptr(ty: &syn::PatType) -> proc_macro2::TokenStream { - fn strip_mut_ptr_from_type(ty: &syn::Type) -> proc_macro2::TokenStream { - match ty { - syn::Type::Ptr(token) => { - let elem = &token.elem; - quote! { #elem } - }, - _ => unreachable!() - } - } - let pat = &ty.pat; - match &*ty.ty { - syn::Type::Ptr(token) => { - let type_ = strip_mut_ptr_from_type(&*token.elem); - quote! { pub #pat : <#type_ as crate::CudaEncode>::WireObject } - }, - syn::Type::Group(TypeGroup {elem, ..}) => { - let type_ = strip_mut_ptr_from_type(&*elem); - quote! { pub #pat : <#type_ as crate::CudaEncode>::WireObject } - }, - _ => unreachable!() - } -} - -struct FnWithFields { - fn_name: Ident, - fields: Punctuated, -} - -impl Parse for FnWithFields { - fn parse(input: ParseStream) -> syn::Result { - let fn_name = input.parse::()?; - let fields = if input.is_empty() { - Punctuated::new() - } else { - input.parse::()?; - input.parse_terminated(PatType::parse, Token![,])? - }; - Ok(Self { - fn_name, - fields, - }) - } -} - fn split(fn_: &str) -> Vec { let mut result = Vec::new(); let mut chars: iter::Peekable<_> = fn_.chars().peekable(); diff --git a/cuda_types/src/dark_api.rs b/cuda_types/src/dark_api.rs index c73863efc..bb7b2cfbf 100644 --- a/cuda_types/src/dark_api.rs +++ b/cuda_types/src/dark_api.rs @@ -68,8 +68,6 @@ bitflags! { pub struct FatbinFileHeaderFlags: u64 { const Is64Bit = 0x0000000000000001; const Debug = 0x0000000000000002; - const CUDA = 0x0000000000000004; - const OpenCL = 0x0000000000000008; const Linux = 0x0000000000000010; const Mac = 0x0000000000000020; const Windows = 0x0000000000000040; diff --git a/dark_api/Cargo.toml b/dark_api/Cargo.toml index c5c65bb82..f65e53827 100644 --- a/dark_api/Cargo.toml +++ b/dark_api/Cargo.toml @@ -1,15 +1,14 @@ -[package] -name = "dark_api" -version = "0.0.0" -edition = "2021" - -[dependencies] -cuda_types = { path = "../cuda_types" } -format = { path = "../format" } -uuid = "1.16" -paste = "1.0" -bit-vec = "0.8.0" -cglue = "0.3.5" -lz4-sys = "1.9" -zstd-safe = { version = "7.2.4", features = ["std"] } -rkyv = "0.8.15" +[package] +name = "dark_api" +version = "0.0.0" +edition = "2021" + +[dependencies] +cuda_types = { path = "../cuda_types" } +format = { path = "../format" } +uuid = "1.16" +paste = "1.0" +bit-vec = "0.8.0" +cglue = "0.3.5" +lz4-sys = "1.9" +zstd-safe = { version = "7.2.4", features = ["std"] } diff --git a/dark_api/src/fatbin.rs b/dark_api/src/fatbin.rs index 06a64d86f..9488499a2 100644 --- a/dark_api/src/fatbin.rs +++ b/dark_api/src/fatbin.rs @@ -196,10 +196,7 @@ impl<'a> FatbinFile<'a> { std::slice::from_raw_parts(start, self.header.compressed_size as usize) } - pub unsafe fn get_or_decompress_content( - self, - strip_trailing_zero: bool, - ) -> Result, FatbinError> { + pub unsafe fn get_or_decompress_content(self) -> Result, FatbinError> { let mut payload = if self .header .flags @@ -215,8 +212,9 @@ impl<'a> FatbinFile<'a> { } else { Cow::Borrowed(unsafe { self.get_non_compressed_payload() }) }; + // Remove trailing zeros - if strip_trailing_zero && self.header.kind == FatbinFileHeader::HEADER_KIND_PTX { + if self.header.kind == FatbinFileHeader::HEADER_KIND_PTX { match payload { Cow::Borrowed(ref mut slice) => { while slice.last() == Some(&0) { diff --git a/dark_api/src/lib.rs b/dark_api/src/lib.rs index e3eac45fb..cfd8c928e 100644 --- a/dark_api/src/lib.rs +++ b/dark_api/src/lib.rs @@ -1,8 +1,7 @@ -use cuda_types::cuda::CUuuid; -use format::CudaDisplay; -use rkyv::traits::{Archive, Deserialize, Serialize}; use std::ffi::c_void; +use cuda_types::cuda::CUuuid; + pub mod fatbin; macro_rules! dark_api_init { @@ -355,7 +354,6 @@ dark_api! { #[noformat] [0] = logged_call( fn_name: cglue::slice::CSliceRef<'static, u8>, - nvapi_interface: u32, args: crate::FnFfiRef, fn_: crate::FnFfiRef, internal_error: usize, @@ -364,54 +362,6 @@ dark_api! { } } -#[repr(C)] -#[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone, Copy)] -pub struct FunctionArgInfo { - pub size: u32, - pub align: u32, -} - -impl FunctionArgInfo { - pub fn to_layout(self) -> Option { - std::alloc::Layout::from_size_align(self.size as usize, self.align as usize).ok() - } -} - -impl CudaDisplay for FunctionArgInfo { - fn write( - &self, - _fn_name: &'static str, - _index: usize, - writer: &mut (impl std::io::Write + ?Sized), - ) -> std::io::Result<()> { - writer.write_all(b"{ size: ")?; - CudaDisplay::write(&self.size, "", 0, writer)?; - writer.write_all(b", align: ")?; - CudaDisplay::write(&self.align, "", 0, writer)?; - writer.write_all(b" }") - } -} - -// Purely for internal use by ZLUDA32 -dark_api! { - zluda32; - "{EE376A1B-B858-42EB-A52D-9A106D50D914}" => ZLUDA32_INTERNAL[2] { - [0] = get_module_globals( - names: *mut *mut u8, - initializers: *mut *const u8, - sizes: *mut u32, - alignments: *mut u32, - count: *mut u32, - module: cuda_types::cuda::CUmodule - ) -> cuda_types::cuda::CUresult, - [1] = get_function_info( - explicit_arguments: *mut crate::FunctionArgInfo, - explicit_argument_count: *mut u32, - func: cuda_types::cuda::CUfunction - ) -> cuda_types::cuda::CUresult - } -} - #[repr(C)] pub struct ByteVecFfi { ptr: *mut u8, diff --git a/kernel_metadata/src/lib.rs b/kernel_metadata/src/lib.rs index 40b817141..d4db9baf3 100644 --- a/kernel_metadata/src/lib.rs +++ b/kernel_metadata/src/lib.rs @@ -43,7 +43,7 @@ pub struct Global32Bit { #[derive(Archive, Serialize, Deserialize, Debug)] pub struct ModuleMetadata32Bit { pub globals: Vec, - pub explicit_args_size_align: Vec<(String, Vec<(u32, u32)>)>, + pub explicit_arg_count: Vec<(String, u32)>, } // If the alignment is larger than u64, then we need different padding diff --git a/llvm_zluda/src/utils.rs b/llvm_zluda/src/utils.rs index b0a2e267b..f407bbb0e 100644 --- a/llvm_zluda/src/utils.rs +++ b/llvm_zluda/src/utils.rs @@ -23,11 +23,7 @@ pub struct Context(LLVMContextRef); impl Context { pub fn new() -> Self { - let ctx = unsafe { LLVMContextCreate() }; - if !cfg!(debug_assertions) { - unsafe { LLVMContextSetDiscardValueNames(ctx, 1) }; - } - Self(ctx) + Self(unsafe { LLVMContextCreate() }) } pub fn get(&self) -> LLVMContextRef { diff --git a/nvapi/Cargo.toml b/nvapi/Cargo.toml deleted file mode 100644 index a3699b162..000000000 --- a/nvapi/Cargo.toml +++ /dev/null @@ -1,26 +0,0 @@ -[package] -name = "nvapi" -version = "0.0.0" -authors = ["Andrzej Janik "] -edition = "2021" - -[lib] -name = "nvapi64" -crate-type = ["cdylib"] - -[dependencies] -format = { path = "../format" } -dark_api = { path = "../dark_api" } -cuda_macros = { path = "../cuda_macros" } -cuda_types = { path = "../cuda_types" } -zluda_trace_common = { path = "../zluda_trace_common" } -libloading = "0.8" -paste = "1.0" -unwrap_or = "1.0.1" -cglue = "0.3.5" -rustc-hash = "2.0.0" - -[package.metadata.zluda] -windows_only = true -windows32_paths = ["nvapi.dll"] -32bit = true diff --git a/nvapi/src/lib.rs b/nvapi/src/lib.rs deleted file mode 100644 index a44cd3582..000000000 --- a/nvapi/src/lib.rs +++ /dev/null @@ -1,726 +0,0 @@ -use crate::nvapi::*; -use libloading::Library; -use rustc_hash::FxHashMap; -use std::{ - collections::hash_map, - ffi::c_void, - mem, ptr, - sync::{LazyLock, Mutex}, -}; - -#[allow(warnings)] -mod nvapi; - -macro_rules! interface_to_name { - ($({ $name:ident, $id:literal }),* $(,)?) => { - fn interface_to_fn(interface: u32) -> Option<*mut c_void> { - match interface { - $( - $id => Some($name as *mut c_void), - )* - _ => None, - } - } - }; -} - -interface_to_name!( - { NvAPI_Initialize, 0x0150e828 }, - { NvAPI_Unload, 0xd22bdd7e }, - // { NvAPI_GetErrorMessage, 0x6c2d048c }, - // { NvAPI_GetInterfaceVersionString, 0x01053fa5 }, - // { NvAPI_GPU_GetEDID, 0x37d32e69 }, - // { NvAPI_SetView, 0x0957d7b6 }, - // { NvAPI_SetViewEx, 0x06b89e68 }, - { NvAPI_GetDisplayDriverVersion, 0xf951a4d1 }, - { NvAPI_SYS_GetDriverAndBranchVersion, 0x2926aaad }, - // { NvAPI_GPU_GetMemoryInfo, 0x07f9b368 }, - // { NvAPI_GPU_GetMemoryInfoEx, 0xc0599498 }, - // { NvAPI_OGL_ExpertModeSet, 0x3805ef7a }, - // { NvAPI_OGL_ExpertModeGet, 0x22ed9516 }, - // { NvAPI_OGL_ExpertModeDefaultsSet, 0xb47a657e }, - // { NvAPI_OGL_ExpertModeDefaultsGet, 0xae921f12 }, - // { NvAPI_EnumPhysicalGPUs, 0xe5ac921f }, - // { NvAPI_EnumTCCPhysicalGPUs, 0xd9930b07 }, - // { NvAPI_EnumLogicalGPUs, 0x48b3ea59 }, - // { NvAPI_GetPhysicalGPUsFromDisplay, 0x34ef9506 }, - // { NvAPI_GetPhysicalGPUFromUnAttachedDisplay, 0x5018ed61 }, - // { NvAPI_GetLogicalGPUFromDisplay, 0xee1370cf }, - // { NvAPI_GetLogicalGPUFromPhysicalGPU, 0xadd604d1 }, - // { NvAPI_GetPhysicalGPUsFromLogicalGPU, 0xaea3fa32 }, - { NvAPI_GetPhysicalGPUFromGPUID, 0x5380ad1a }, - { NvAPI_GetGPUIDfromPhysicalGPU, 0x6533ea3e }, - // { NvAPI_GPU_GetShaderSubPipeCount, 0x0be17923 }, - // { NvAPI_GPU_GetGpuCoreCount, 0xc7026a87 }, - // { NvAPI_GPU_GetAllOutputs, 0x7d554f8e }, - // { NvAPI_GPU_GetConnectedOutputs, 0x1730bfc9 }, - // { NvAPI_GPU_GetConnectedSLIOutputs, 0x0680de09 }, - // { NvAPI_GPU_GetConnectedDisplayIds, 0x0078dba2 }, - // { NvAPI_GPU_GetAllDisplayIds, 0x785210a2 }, - // { NvAPI_GPU_GetConnectedOutputsWithLidState, 0xcf8caf39 }, - // { NvAPI_GPU_GetConnectedSLIOutputsWithLidState, 0x96043cc7 }, - // { NvAPI_GPU_GetSystemType, 0xbaaabfcc }, - // { NvAPI_GPU_GetActiveOutputs, 0xe3e89b6f }, - // { NvAPI_GPU_SetEDID, 0xe83d6456 }, - // { NvAPI_GPU_GetOutputType, 0x40a505e4 }, - // { NvAPI_GPU_ValidateOutputCombination, 0x34c9c2d4 }, - // { NvAPI_GPU_GetFullName, 0xceee8e9f }, - // { NvAPI_GPU_GetPCIIdentifiers, 0x2ddfb66e }, - // { NvAPI_GPU_GetGPUType, 0xc33baeb1 }, - // { NvAPI_GPU_GetBusType, 0x1bb18724 }, - // { NvAPI_GPU_GetBusId, 0x1be0b8e5 }, - // { NvAPI_GPU_GetBusSlotId, 0x2a0a350f }, - // { NvAPI_GPU_GetIRQ, 0xe4715417 }, - // { NvAPI_GPU_GetVbiosRevision, 0xacc3da0a }, - // { NvAPI_GPU_GetVbiosOEMRevision, 0x2d43fb31 }, - // { NvAPI_GPU_GetVbiosVersionString, 0xa561fd7d }, - // { NvAPI_GPU_GetAGPAperture, 0x6e042794 }, - // { NvAPI_GPU_GetCurrentAGPRate, 0xc74925a0 }, - // { NvAPI_GPU_GetCurrentPCIEDownstreamWidth, 0xd048c3b1 }, - // { NvAPI_GPU_GetPhysicalFrameBufferSize, 0x46fbeb03 }, - // { NvAPI_GPU_GetVirtualFrameBufferSize, 0x5a04b644 }, - // { NvAPI_GPU_GetQuadroStatus, 0xe332fa47 }, - // { NvAPI_GPU_GetBoardInfo, 0x22d54523 }, - // { NvAPI_GPU_GetRamBusWidth, 0x7975c581 }, - // { NvAPI_GPU_GetArchInfo, 0xd8265d24 }, - // { NvAPI_I2CRead, 0x2fde12c5 }, - // { NvAPI_I2CWrite, 0xe812eb07 }, - // { NvAPI_GPU_WorkstationFeatureSetup, 0x6c1f3fe4 }, - // { NvAPI_GPU_WorkstationFeatureQuery, 0x004537df }, - // { NvAPI_GPU_GetHDCPSupportStatus, 0xf089eef5 }, - { NvAPI_GPU_CudaEnumComputeCapableGpus, 0x5786cc6e }, - // { NvAPI_GPU_GetTachReading, 0x5f608315 }, - // { NvAPI_GPU_GetECCStatusInfo, 0xca1ddaf3 }, - // { NvAPI_GPU_GetECCErrorInfo, 0xc71f85a6 }, - // { NvAPI_GPU_ResetECCErrorInfo, 0xc02eec20 }, - // { NvAPI_GPU_GetECCConfigurationInfo, 0x77a796f3 }, - // { NvAPI_GPU_SetECCConfiguration, 0x1cf639d9 }, - // { NvAPI_GPU_QueryWorkstationFeatureSupport, 0x80b1abb9 }, - // { NvAPI_GPU_SetScanoutIntensity, 0xa57457a4 }, - // { NvAPI_GPU_GetScanoutIntensityState, 0xe81ce836 }, - // { NvAPI_GPU_SetScanoutWarping, 0xb34bab4f }, - // { NvAPI_GPU_GetScanoutWarpingState, 0x6f5435af }, - // { NvAPI_GPU_SetScanoutCompositionParameter, 0xf898247d }, - // { NvAPI_GPU_GetScanoutCompositionParameter, 0x58fe51e6 }, - // { NvAPI_GPU_GetScanoutConfiguration, 0x6a9f5b63 }, - // { NvAPI_GPU_GetScanoutConfigurationEx, 0xe2e1e6f0 }, - // { NvAPI_GPU_GetAdapterIdFromPhysicalGpu, 0x0ff07fde }, - // { NvAPI_GPU_GetVirtualizationInfo, 0x44e022a9 }, - // { NvAPI_GPU_GetLogicalGpuInfo, 0x842b066e }, - // { NvAPI_GPU_GetLicensableFeatures, 0x3fc596aa }, - // { NvAPI_GPU_GetEncoderStatistics, 0xf0a9aeeb }, - // { NvAPI_GPU_GetEncoderSessionsInfo, 0xd8a72ce5 }, - // { NvAPI_GPU_GetGPUInfo, 0xafd1b02c }, - // { NvAPI_GPU_GetVRReadyData, 0x81d629c5 }, - // { NvAPI_GPU_GetGspFeatures, 0x581c4391 }, - // { NvAPI_GPU_GetUUID, 0xdc95673d }, - // { NvAPI_GPU_NVLINK_GetCaps, 0xbef1119d }, - // { NvAPI_GPU_NVLINK_GetStatus, 0xc72a38e3 }, - // { NvAPI_GPU_GetPerfDecreaseInfo, 0x7f7f4600 }, - // { NvAPI_GPU_GetPstatesInfoEx, 0x843c0256 }, - // { NvAPI_GPU_GetPstates20, 0x6ff81213 }, - // { NvAPI_GPU_GetCurrentPstate, 0x927da4f6 }, - // { NvAPI_GPU_GetDynamicPstatesInfoEx, 0x60ded2ed }, - // { NvAPI_GPU_GetThermalSettings, 0xe3640a56 }, - // { NvAPI_GPU_GetAllClockFrequencies, 0xdcb616c3 }, - // { NvAPI_GPU_QueryIlluminationSupport, 0xa629da31 }, - // { NvAPI_GPU_GetIllumination, 0x9a1b9365 }, - // { NvAPI_GPU_SetIllumination, 0x0254a187 }, - // { NvAPI_GPU_ClientIllumDevicesGetInfo, 0xd4100e58 }, - // { NvAPI_GPU_ClientIllumDevicesGetControl, 0x73c01d58 }, - // { NvAPI_GPU_ClientIllumDevicesSetControl, 0x57024c62 }, - // { NvAPI_GPU_ClientIllumZonesGetInfo, 0x4b81241b }, - // { NvAPI_GPU_ClientIllumZonesGetControl, 0x3dbf5764 }, - // { NvAPI_GPU_ClientIllumZonesSetControl, 0x197d065e }, - // { NvAPI_Event_RegisterCallback, 0xe6dbea69 }, - // { NvAPI_Event_UnregisterCallback, 0xde1f9b45 }, - // { NvAPI_EnumNvidiaDisplayHandle, 0x9abdd40d }, - // { NvAPI_EnumNvidiaUnAttachedDisplayHandle, 0x20de9260 }, - // { NvAPI_CreateDisplayFromUnAttachedDisplay, 0x63f9799e }, - // { NvAPI_GetAssociatedNvidiaDisplayHandle, 0x35c29134 }, - // { NvAPI_DISP_GetAssociatedUnAttachedNvidiaDisplayHandle, 0xa70503b2 }, - // { NvAPI_GetAssociatedNvidiaDisplayName, 0x22a78b05 }, - // { NvAPI_GetUnAttachedAssociatedDisplayName, 0x4888d790 }, - // { NvAPI_EnableHWCursor, 0x2863148d }, - // { NvAPI_DisableHWCursor, 0xab163097 }, - // { NvAPI_GetVBlankCounter, 0x67b5db55 }, - // { NvAPI_SetRefreshRateOverride, 0x3092ac32 }, - // { NvAPI_GetAssociatedDisplayOutputId, 0xd995937e }, - // { NvAPI_GetDisplayPortInfo, 0xc64ff367 }, - // { NvAPI_SetDisplayPort, 0xfa13e65a }, - // { NvAPI_GetHDMISupportInfo, 0x6ae16ec3 }, - // { NvAPI_Disp_InfoFrameControl, 0x6067af3f }, - // { NvAPI_Disp_ColorControl, 0x92f9d80d }, - // { NvAPI_Disp_GetHdrCapabilities, 0x84f2a8df }, - // { NvAPI_Disp_HdrColorControl, 0x351da224 }, - // { NvAPI_Disp_SetSourceColorSpace, 0x473b6caf }, - // { NvAPI_Disp_GetSourceColorSpace, 0xceedc85b }, - // { NvAPI_Disp_SetSourceHdrMetadata, 0x905eb63b }, - // { NvAPI_Disp_GetSourceHdrMetadata, 0x0d3f52da }, - // { NvAPI_Disp_SetOutputMode, 0x98e7661a }, - // { NvAPI_Disp_GetOutputMode, 0x81fed88d }, - // { NvAPI_Disp_SetHdrToneMapping, 0xdd6da362 }, - // { NvAPI_Disp_GetHdrToneMapping, 0xfbd36e71 }, - // { NvAPI_Disp_GetColorimetry, 0x00b421ad }, - // { NvAPI_DISP_GetTiming, 0x175167e9 }, - // { NvAPI_DISP_GetMonitorCapabilities, 0x3b05c7e1 }, - // { NvAPI_DISP_GetMonitorColorCapabilities, 0x6ae4cfb5 }, - // { NvAPI_DISP_EnumCustomDisplay, 0xa2072d59 }, - // { NvAPI_DISP_TryCustomDisplay, 0x1f7db630 }, - // { NvAPI_DISP_DeleteCustomDisplay, 0x552e5b9b }, - // { NvAPI_DISP_SaveCustomDisplay, 0x49882876 }, - // { NvAPI_DISP_RevertCustomDisplayTrial, 0xcbbd40f0 }, - // { NvAPI_GetView, 0xd6b99d89 }, - // { NvAPI_GetViewEx, 0xdbbc0af4 }, - // { NvAPI_GetSupportedViews, 0x66fb7fc0 }, - // { NvAPI_DISP_GetDisplayIdByDisplayName, 0xae457190 }, - // { NvAPI_DISP_GetGDIPrimaryDisplayId, 0x1e9d8a31 }, - // { NvAPI_DISP_GetDisplayConfig, 0x11abccf8 }, - // { NvAPI_DISP_SetDisplayConfig, 0x5d8cf8de }, - // { NvAPI_DISP_GetEdidData, 0x436ced76 }, - // { NvAPI_DISP_GetAdaptiveSyncData, 0xb73d1ee9 }, - // { NvAPI_DISP_SetAdaptiveSyncData, 0x3eebba1d }, - // { NvAPI_DISP_GetVirtualRefreshRateData, 0x8c00429a }, - // { NvAPI_DISP_SetVirtualRefreshRateData, 0x5abbe6a3 }, - // { NvAPI_DISP_SetPreferredStereoDisplay, 0xc9d0e25f }, - // { NvAPI_DISP_GetPreferredStereoDisplay, 0x1f6b4666 }, - // { NvAPI_DISP_GetNvManagedDedicatedDisplays, 0xdbdf0cb2 }, - // { NvAPI_DISP_AcquireDedicatedDisplay, 0x47c917ba }, - // { NvAPI_DISP_ReleaseDedicatedDisplay, 0x1247825f }, - // { NvAPI_DISP_GetNvManagedDedicatedDisplayMetadata, 0xd645d80c }, - // { NvAPI_DISP_SetNvManagedDedicatedDisplayMetadata, 0x3d8b129a }, - // { NvAPI_Disp_GetDisplayIdInfo, 0xbae8aa5e }, - // { NvAPI_Disp_GetDisplayIdsFromTarget, 0xe7e5f89e }, - // { NvAPI_Disp_GetVRRInfo, 0xdf8fda57 }, - // { NvAPI_Mosaic_GetSupportedTopoInfo, 0xfdb63c81 }, - // { NvAPI_Mosaic_GetTopoGroup, 0xcb89381d }, - // { NvAPI_Mosaic_GetOverlapLimits, 0x989685f0 }, - // { NvAPI_Mosaic_SetCurrentTopo, 0x9b542831 }, - // { NvAPI_Mosaic_GetCurrentTopo, 0xec32944e }, - // { NvAPI_Mosaic_EnableCurrentTopo, 0x5f1aa66c }, - // { NvAPI_Mosaic_GetDisplayViewportsByResolution, 0xdc6dc8d3 }, - // { NvAPI_Mosaic_SetDisplayGrids, 0x4d959a89 }, - // { NvAPI_Mosaic_ValidateDisplayGrids, 0xcf43903d }, - // { NvAPI_Mosaic_EnumDisplayModes, 0x78db97d7 }, - // { NvAPI_Mosaic_EnumDisplayGrids, 0xdf2887af }, - // { NvAPI_GetSupportedMosaicTopologies, 0x410b5c25 }, - // { NvAPI_GetCurrentMosaicTopology, 0xf60852bd }, - // { NvAPI_SetCurrentMosaicTopology, 0xd54b8989 }, - // { NvAPI_EnableCurrentMosaicTopology, 0x74073cc9 }, - // { NvAPI_GSync_EnumSyncDevices, 0xd9639601 }, - // { NvAPI_GSync_QueryCapabilities, 0x44a3f1d1 }, - // { NvAPI_GSync_GetTopology, 0x4562bc38 }, - // { NvAPI_GSync_SetSyncStateSettings, 0x60acdfdd }, - // { NvAPI_GSync_GetControlParameters, 0x16de1c6a }, - // { NvAPI_GSync_SetControlParameters, 0x8bbff88b }, - // { NvAPI_GSync_AdjustSyncDelay, 0x2d11ff51 }, - // { NvAPI_GSync_GetSyncStatus, 0xf1f5b434 }, - // { NvAPI_GSync_GetStatusParameters, 0x70d404ec }, - // { NvAPI_D3D_GetCurrentSLIState, 0x4b708b54 }, - // { NvAPI_D3D9_RegisterResource, 0xa064bdfc }, - // { NvAPI_D3D9_UnregisterResource, 0xbb2b17aa }, - // { NvAPI_D3D9_AliasSurfaceAsTexture, 0xe5ceae41 }, - // { NvAPI_D3D9_StretchRectEx, 0x22de03aa }, - // { NvAPI_D3D9_ClearRT, 0x332d3942 }, - // { NvAPI_D3D_GetObjectHandleForResource, 0xfceac864 }, - // { NvAPI_D3D_SetResourceHint, 0x6c0ed98c }, - // { NvAPI_D3D_BeginResourceRendering, 0x91123d6a }, - // { NvAPI_D3D_EndResourceRendering, 0x37e7191c }, - // { NvAPI_D3D9_GetSurfaceHandle, 0x0f2dd3f2 }, - // { NvAPI_D3D9_VideoSetStereoInfo, 0xb852f4db }, - // { NvAPI_D3D10_SetDepthBoundsTest, 0x4eadf5d2 }, - // { NvAPI_D3D11_CreateDevice, 0x6a16d3a0 }, - // { NvAPI_D3D11_CreateDeviceAndSwapChain, 0xbb939ee5 }, - // { NvAPI_D3D11_SetDepthBoundsTest, 0x7aaf7a04 }, - // { NvAPI_D3D11_IsNvShaderExtnOpCodeSupported, 0x5f68da40 }, - // { NvAPI_D3D11_SetNvShaderExtnSlot, 0x8e90bb9f }, - // { NvAPI_D3D12_SetNvShaderExtnSlotSpace, 0xac2dfeb5 }, - // { NvAPI_D3D12_SetNvShaderExtnSlotSpaceLocalThread, 0x43d867c0 }, - // { NvAPI_D3D11_SetNvShaderExtnSlotLocalThread, 0x0e6482a0 }, - // { NvAPI_D3D11_BeginUAVOverlapEx, 0xba08208a }, - // { NvAPI_D3D11_BeginUAVOverlap, 0x65b93ca8 }, - // { NvAPI_D3D11_EndUAVOverlap, 0x2216a357 }, - // { NvAPI_D3D11_GetResourceHandle, 0x09d52986 }, - // { NvAPI_D3D_SetFPSIndicatorState, 0xa776e8db }, - // { NvAPI_D3D9_Present, 0x05650beb }, - // { NvAPI_D3D9_QueryFrameCount, 0x9083e53a }, - // { NvAPI_D3D9_ResetFrameCount, 0xfa6a0675 }, - // { NvAPI_D3D9_QueryMaxSwapGroup, 0x5995410d }, - // { NvAPI_D3D9_QuerySwapGroup, 0xeba4d232 }, - // { NvAPI_D3D9_JoinSwapGroup, 0x7d44bb54 }, - // { NvAPI_D3D9_BindSwapBarrier, 0x9c39c246 }, - // { NvAPI_D3D_SetVerticalSyncMode, 0x5526cfd1 }, - // { NvAPI_D3D1x_Present, 0x03b845a1 }, - // { NvAPI_D3D1x_QueryFrameCount, 0x9152e055 }, - // { NvAPI_D3D1x_ResetFrameCount, 0xfbbb031a }, - // { NvAPI_D3D1x_QueryMaxSwapGroup, 0x9bb9d68f }, - // { NvAPI_D3D1x_QuerySwapGroup, 0x407f67aa }, - // { NvAPI_D3D1x_JoinSwapGroup, 0x14610cd7 }, - // { NvAPI_D3D1x_BindSwapBarrier, 0x9de8c729 }, - // { NvAPI_D3D12_QueryPresentBarrierSupport, 0xa15faef7 }, - // { NvAPI_D3D12_CreatePresentBarrierClient, 0x4d815de9 }, - // { NvAPI_D3D12_RegisterPresentBarrierResources, 0xd53c9ef0 }, - // { NvAPI_DestroyPresentBarrierClient, 0x3c5c351b }, - // { NvAPI_JoinPresentBarrier, 0x17f6bf82 }, - // { NvAPI_LeavePresentBarrier, 0xc3ec5a7f }, - // { NvAPI_QueryPresentBarrierFrameStatistics, 0x61b844a1 }, - // { NvAPI_D3D12_CreateDDisplayPresentBarrierClient, 0xb5a21987 }, - // { NvAPI_D3D11_CreateRasterizerState, 0xdb8d28af }, - // { NvAPI_D3D_ConfigureAnsel, 0x341c6c7f }, - // { NvAPI_D3D11_CreateTiledTexture2DArray, 0x7886981a }, - // { NvAPI_D3D11_CheckFeatureSupport, 0x106a487e }, - // { NvAPI_D3D11_CreateImplicitMSAATexture2D, 0xb8f79632 }, - // { NvAPI_D3D12_CreateCommittedImplicitMSAATexture2D, 0x24c6a07b }, - // { NvAPI_D3D11_ResolveSubresourceRegion, 0xe6bfedd6 }, - // { NvAPI_D3D12_ResolveSubresourceRegion, 0xc24a15bf }, - // { NvAPI_D3D11_TiledTexture2DArrayGetDesc, 0xf1a2b9d5 }, - // { NvAPI_D3D11_UpdateTileMappings, 0x9a06ea07 }, - // { NvAPI_D3D11_CopyTileMappings, 0xc09ee6bc }, - // { NvAPI_D3D11_TiledResourceBarrier, 0xd6839099 }, - // { NvAPI_D3D11_AliasMSAATexture2DAsNonMSAA, 0xf1c54fc9 }, - // { NvAPI_D3D11_CreateGeometryShaderEx_2, 0x99ed5c1c }, - // { NvAPI_D3D11_CreateVertexShaderEx, 0x0beaa0b2 }, - // { NvAPI_D3D11_CreateHullShaderEx, 0xb53cab00 }, - // { NvAPI_D3D11_CreateDomainShaderEx, 0xa0d7180d }, - // { NvAPI_D3D11_CreatePixelShaderEx_2, 0x4162822b }, - // { NvAPI_D3D11_CreateFastGeometryShaderExplicit, 0x71ab7c9c }, - // { NvAPI_D3D11_CreateFastGeometryShader, 0x525d43be }, - // { NvAPI_D3D11_DecompressView, 0x3a94e822 }, - // { NvAPI_D3D12_CreateGraphicsPipelineState, 0x2fc28856 }, - // { NvAPI_D3D12_CreateComputePipelineState, 0x2762deac }, - // { NvAPI_D3D12_SetDepthBoundsTestValues, 0xb9333fe9 }, - // { NvAPI_D3D12_CreateReservedResource, 0x2c85f101 }, - // { NvAPI_D3D12_CreateHeap, 0x5cb397cf }, - // { NvAPI_D3D12_CreateHeap2, 0x924be9d6 }, - // { NvAPI_D3D12_QueryCpuVisibleVidmem, 0x26322bc3 }, - // { NvAPI_D3D12_ReservedResourceGetDesc, 0x9aa2aabb }, - // { NvAPI_D3D12_UpdateTileMappings, 0xc6017a7d }, - // { NvAPI_D3D12_CopyTileMappings, 0x47f78194 }, - // { NvAPI_D3D12_ResourceAliasingBarrier, 0xb942bab7 }, - // { NvAPI_D3D12_CaptureUAVInfo, 0x6e5ea9db }, - // { NvAPI_D3D11_GetResourceGPUVirtualAddressEx, 0xaf6d14da }, - // { NvAPI_D3D11_EnumerateMetaCommands, 0xc7453ba8 }, - // { NvAPI_D3D11_CreateMetaCommand, 0xf505fba0 }, - // { NvAPI_D3D11_InitializeMetaCommand, 0xaec629e9 }, - // { NvAPI_D3D11_ExecuteMetaCommand, 0x82236c47 }, - // { NvAPI_D3D12_EnumerateMetaCommands, 0xcd9141d8 }, - // { NvAPI_D3D12_CreateMetaCommand, 0xeb29634b }, - // { NvAPI_D3D12_InitializeMetaCommand, 0xa4125399 }, - // { NvAPI_D3D12_ExecuteMetaCommand, 0xde24fc3d }, - // { NvAPI_D3D12_CreateCommittedResource, 0x027e98ae }, - // { NvAPI_D3D12_GetCopyableFootprints, 0xf6305eb5 }, - // { NvAPI_D3D12_CopyTextureRegion, 0x82b91b25 }, - // { NvAPI_D3D12_IsNvShaderExtnOpCodeSupported, 0x3dfacec8 }, - // { NvAPI_D3D12_GetOptimalThreadCountForMesh, 0xb43995cb }, - // { NvAPI_D3D_IsGSyncCapable, 0x9c1eed78 }, - // { NvAPI_D3D_IsGSyncActive, 0xe942b0ff }, - // { NvAPI_D3D12_SetFlipConfig, 0xf3148c42 }, - // { NvAPI_D3D1x_DisableShaderDiskCache, 0xd0cbca7d }, - // { NvAPI_D3D11_MultiGPU_GetCaps, 0xd2d25687 }, - // { NvAPI_D3D11_MultiGPU_Init, 0x017be49e }, - // { NvAPI_D3D11_CreateMultiGPUDevice, 0xbdb20007 }, - // { NvAPI_D3D_QuerySinglePassStereoSupport, 0x6f5f0a6d }, - // { NvAPI_D3D_SetSinglePassStereoMode, 0xa39e6e6e }, - // { NvAPI_D3D12_QuerySinglePassStereoSupport, 0x3b03791b }, - // { NvAPI_D3D12_SetSinglePassStereoMode, 0x83556d87 }, - // { NvAPI_D3D_QueryMultiViewSupport, 0xb6e0a41c }, - // { NvAPI_D3D_SetMultiViewMode, 0x8285c8da }, - // { NvAPI_D3D_QueryModifiedWSupport, 0xcbf9f4f5 }, - // { NvAPI_D3D_SetModifiedWMode, 0x06ea4bf4 }, - // { NvAPI_D3D12_QueryModifiedWSupport, 0x51235248 }, - // { NvAPI_D3D12_SetModifiedWMode, 0xe1fdaba7 }, - // { NvAPI_D3D_CreateLateLatchObject, 0x2db27d09 }, - // { NvAPI_D3D_QueryLateLatchSupport, 0x8ceca0ec }, - // { NvAPI_D3D_RegisterDevice, 0x8c02c4d0 }, - // { NvAPI_D3D11_MultiDrawInstancedIndirect, 0xd4e26bbf }, - // { NvAPI_D3D11_MultiDrawIndexedInstancedIndirect, 0x59e890f9 }, - // { NvAPI_D3D_ImplicitSLIControl, 0x2aede111 }, - // { NvAPI_D3D12_GetNeedsAppFPBlendClamping, 0x6ef4d2d1 }, - // { NvAPI_D3D12_UseDriverHeapPriorities, 0xf0d978a8 }, - // { NvAPI_D3D12_Mosaic_GetCompanionAllocations, 0xa46022c7 }, - // { NvAPI_D3D12_Mosaic_GetViewportAndGpuPartitions, 0xb092b818 }, - // { NvAPI_D3D1x_GetGraphicsCapabilities, 0x52b1499a }, - // { NvAPI_D3D12_GetGraphicsCapabilities, 0x01e87354 }, - // { NvAPI_D3D11_RSSetExclusiveScissorRects, 0xae4d73ef }, - // { NvAPI_D3D11_RSSetViewportsPixelShadingRates, 0x34f7938f }, - // { NvAPI_D3D11_CreateShadingRateResourceView, 0x99ca2dff }, - // { NvAPI_D3D11_RSSetShadingRateResourceView, 0x1b0c2f83 }, - // { NvAPI_D3D11_RSGetPixelShadingRateSampleOrder, 0x092442a1 }, - // { NvAPI_D3D11_RSSetPixelShadingRateSampleOrder, 0xa942373a }, - // { NvAPI_D3D_InitializeVRSHelper, 0x4780d70b }, - // { NvAPI_D3D_InitializeNvGazeHandler, 0x5b3b7479 }, - // { NvAPI_D3D_InitializeSMPAssist, 0x42763d0c }, - // { NvAPI_D3D_QuerySMPAssistSupport, 0xc57921de }, - // { NvAPI_D3D_GetSleepStatus, 0xaef96ca1 }, - // { NvAPI_D3D_SetSleepMode, 0xac1ca9e0 }, - // { NvAPI_D3D_Sleep, 0x852cd1d2 }, - // { NvAPI_D3D_SetReflexSync, 0xb9f6faff }, - // { NvAPI_D3D_GetLatency, 0x1a587f9c }, - // { NvAPI_D3D_SetLatencyMarker, 0xd9984c05 }, - // { NvAPI_D3D12_SetAsyncFrameMarker, 0x13c98f73 }, - // { NvAPI_D3D11_SetAsyncFrameMarker, 0x59c2c510 }, - // { NvAPI_D3D12_NotifyOutOfBandCommandQueue, 0x03d6e8cb }, - // { NvAPI_D3D12_SetCreateCommandQueueLowLatencyHint, 0x548c224f }, - // { NvAPI_D3D12_CreateCubinComputeShaderExV2, 0x299f5fdc }, - // { NvAPI_D3D12_CreateCubinComputeShader, 0x2a2c79e8 }, - // { NvAPI_D3D12_CreateCubinComputeShaderEx, 0x3151211b }, - // { NvAPI_D3D12_CreateCubinComputeShaderWithName, 0x1dc7261f }, - // { NvAPI_D3D12_LaunchCubinShader, 0x5c52bb86 }, - // { NvAPI_D3D12_DestroyCubinComputeShader, 0x7fb785ba }, - // { NvAPI_D3D12_GetCudaMergedTextureSamplerObject, 0x329fe6e0 }, - // { NvAPI_D3D12_GetCudaIndependentDescriptorObject, 0x0ddac234 }, - // { NvAPI_D3D12_GetCudaTextureObject, 0x80403fc9 }, - // { NvAPI_D3D12_GetCudaSurfaceObject, 0x48f5b2ee }, - // { NvAPI_D3D12_IsFatbinPTXSupported, 0x70c07832 }, - // { NvAPI_D3D12_CreateCuModule, 0xad1a677d }, - // { NvAPI_D3D12_EnumFunctionsInModule, 0x7ab88d88 }, - // { NvAPI_D3D12_CreateCuFunction, 0xe2436e22 }, - // { NvAPI_D3D12_LaunchCuKernelChain, 0x24973538 }, - // { NvAPI_D3D12_LaunchCuKernelChainEx, 0x846a9bf0 }, - // { NvAPI_D3D12_DestroyCuModule, 0x41c65285 }, - // { NvAPI_D3D12_DestroyCuFunction, 0xdf295ea6 }, - // { NvAPI_D3D11_CreateCubinComputeShaderExV2, 0xf2c71d48 }, - // { NvAPI_D3D11_CreateCubinComputeShader, 0x0ed98181 }, - // { NvAPI_D3D11_CreateCubinComputeShaderEx, 0x32c2a0f6 }, - // { NvAPI_D3D11_CreateCubinComputeShaderWithName, 0xb672be19 }, - // { NvAPI_D3D11_LaunchCubinShader, 0x427e236d }, - // { NvAPI_D3D11_DestroyCubinComputeShader, 0x01682c86 }, - // { NvAPI_D3D11_IsFatbinPTXSupported, 0x6086bd93 }, - // { NvAPI_D3D11_GetCudaIndependentViewObject, 0x34d2afa8 }, - // { NvAPI_D3D11_GetCudaMergedTextureSamplerObject, 0x5d637d8f }, - // { NvAPI_D3D11_CreateUnorderedAccessView, 0x74a497a1 }, - // { NvAPI_D3D11_CreateShaderResourceView, 0x65cb431e }, - // { NvAPI_D3D11_CreateSamplerState, 0x89eca416 }, - // { NvAPI_D3D11_GetCudaTextureObject, 0x9006fa68 }, - // { NvAPI_D3D11_GetResourceGPUVirtualAddress, 0x1819b423 }, - // { NvAPI_D3D12_GetRaytracingCaps, 0x85a6c2a0 }, - // { NvAPI_D3D12_EnableRaytracingValidation, 0x1de5991b }, - // { NvAPI_D3D12_RegisterRaytracingValidationMessageCallback, 0x8554eb38 }, - // { NvAPI_D3D12_UnregisterRaytracingValidationMessageCallback, 0x26975da6 }, - // { NvAPI_D3D12_FlushRaytracingValidationMessages, 0xb8fb1fcb }, - // { NvAPI_D3D12_GetRaytracingDisplacementMicromapArrayPrebuildInfo, 0xfa99b6de }, - // { NvAPI_D3D12_GetRaytracingOpacityMicromapArrayPrebuildInfo, 0x4726d180 }, - // { NvAPI_D3D12_SetCreatePipelineStateOptions, 0x5c607a27 }, - // { NvAPI_D3D12_CheckDriverMatchingIdentifierEx, 0xafb237d4 }, - // { NvAPI_D3D12_GetRaytracingAccelerationStructurePrebuildInfoEx, 0x8d025b77 }, - // { NvAPI_D3D12_BuildRaytracingOpacityMicromapArray, 0x814f8d11 }, - // { NvAPI_D3D12_RelocateRaytracingOpacityMicromapArray, 0x0425c538 }, - // { NvAPI_D3D12_BuildRaytracingDisplacementMicromapArray, 0x066f569d }, - // { NvAPI_D3D12_RelocateRaytracingDisplacementMicromapArray, 0x1c142308 }, - // { NvAPI_D3D12_EmitRaytracingDisplacementMicromapArrayPostbuildInfo, 0x68b9a790 }, - // { NvAPI_D3D12_EmitRaytracingOpacityMicromapArrayPostbuildInfo, 0x1d9a39b6 }, - // { NvAPI_D3D12_BuildRaytracingAccelerationStructureEx, 0xe24ead45 }, - // { NvAPI_D3D12_QueryWorkstationFeatureProperties, 0xa92ea23a }, - // { NvAPI_D3D12_CreateCommittedRDMABuffer, 0xe78dcb44 }, - // { NvAPI_D3D12_ConvertCooperativeVectorMatrix, 0x0f252cb3 }, - // { NvAPI_D3D12_ConvertCooperativeVectorMatrixMultiple, 0x96ba5235 }, - // { NvAPI_D3D12_GetPhysicalDeviceCooperativeVectorProperties, 0x8f182aec }, - // { NvAPI_D3D12_GetRaytracingMultiIndirectClusterOperationRequirementsInfo, 0x5c9163f4 }, - // { NvAPI_D3D12_RaytracingExecuteMultiIndirectClusterOperation, 0x67c798af }, - // { NvAPI_D3D12_GetRaytracingPartitionedTlasIndirectPrebuildInfo, 0xcdfdc5f2 }, - // { NvAPI_D3D12_BuildRaytracingPartitionedTlasIndirect, 0x7cfc6fc3 }, - // { NvAPI_NGX_GetNGXOverrideState, 0x3fd96fba }, - // { NvAPI_NGX_SetNGXOverrideState, 0xb60fcb4e }, - // { NvAPI_DirectD3D12GraphicsCommandList_Create, 0x74a4e712 }, - // { NvAPI_DirectD3D12GraphicsCommandList_Release, 0x99da3dde }, - // { NvAPI_DirectD3D12GraphicsCommandList_Reset, 0x999c26d8 }, - // { NvAPI_VIO_GetCapabilities, 0x1dc91303 }, - // { NvAPI_VIO_Open, 0x44ee4841 }, - // { NvAPI_VIO_Close, 0xd01bd237 }, - // { NvAPI_VIO_Status, 0x0e6ce4f1 }, - // { NvAPI_VIO_SyncFormatDetect, 0x118d48a3 }, - // { NvAPI_VIO_GetConfig, 0xd34a789b }, - // { NvAPI_VIO_SetConfig, 0x0e4eec07 }, - // { NvAPI_VIO_SetCSC, 0xa1ec8d74 }, - // { NvAPI_VIO_GetCSC, 0x7b0d72a3 }, - // { NvAPI_VIO_SetGamma, 0x964bf452 }, - // { NvAPI_VIO_GetGamma, 0x51d53d06 }, - // { NvAPI_VIO_SetSyncDelay, 0x2697a8d1 }, - // { NvAPI_VIO_GetSyncDelay, 0x462214a9 }, - // { NvAPI_VIO_GetPCIInfo, 0xb981d935 }, - // { NvAPI_VIO_IsRunning, 0x96bd040e }, - // { NvAPI_VIO_Start, 0xcde8e1a3 }, - // { NvAPI_VIO_Stop, 0x6ba2a5d6 }, - // { NvAPI_VIO_IsFrameLockModeCompatible, 0x7bf0a94d }, - // { NvAPI_VIO_EnumDevices, 0xfd7c5557 }, - // { NvAPI_VIO_QueryTopology, 0x869534e2 }, - // { NvAPI_VIO_EnumSignalFormats, 0xead72fe4 }, - // { NvAPI_VIO_EnumDataFormats, 0x221fa8e8 }, - // { NvAPI_Stereo_CreateConfigurationProfileRegistryKey, 0xbe7692ec }, - // { NvAPI_Stereo_DeleteConfigurationProfileRegistryKey, 0xf117b834 }, - // { NvAPI_Stereo_SetConfigurationProfileValue, 0x24409f48 }, - // { NvAPI_Stereo_DeleteConfigurationProfileValue, 0x49bceecf }, - // { NvAPI_Stereo_Enable, 0x239c4545 }, - // { NvAPI_Stereo_Disable, 0x2ec50c2b }, - // { NvAPI_Stereo_IsEnabled, 0x348ff8e1 }, - // { NvAPI_Stereo_GetStereoSupport, 0x296c434d }, - // { NvAPI_Stereo_CreateHandleFromIUnknown, 0xac7e37f4 }, - // { NvAPI_Stereo_DestroyHandle, 0x3a153134 }, - // { NvAPI_Stereo_Activate, 0xf6a1ad68 }, - // { NvAPI_Stereo_Deactivate, 0x2d68de96 }, - // { NvAPI_Stereo_IsActivated, 0x1fb0bc30 }, - // { NvAPI_Stereo_GetSeparation, 0x451f2134 }, - // { NvAPI_Stereo_SetSeparation, 0x5c069fa3 }, - // { NvAPI_Stereo_DecreaseSeparation, 0xda044458 }, - // { NvAPI_Stereo_IncreaseSeparation, 0xc9a8ecec }, - // { NvAPI_Stereo_GetConvergence, 0x4ab00934 }, - // { NvAPI_Stereo_SetConvergence, 0x3dd6b54b }, - // { NvAPI_Stereo_DecreaseConvergence, 0x4c87e317 }, - // { NvAPI_Stereo_IncreaseConvergence, 0xa17daabe }, - // { NvAPI_Stereo_GetFrustumAdjustMode, 0xe6839b43 }, - // { NvAPI_Stereo_SetFrustumAdjustMode, 0x7be27fa2 }, - // { NvAPI_Stereo_CaptureJpegImage, 0x932cb140 }, - // { NvAPI_Stereo_InitActivation, 0xc7177702 }, - // { NvAPI_Stereo_Trigger_Activation, 0x0d6c6cd2 }, - // { NvAPI_Stereo_CapturePngImage, 0x8b7e99b5 }, - // { NvAPI_Stereo_ReverseStereoBlitControl, 0x3cd58f89 }, - // { NvAPI_Stereo_SetNotificationMessage, 0x6b9b409e }, - // { NvAPI_Stereo_SetActiveEye, 0x96eea9f8 }, - // { NvAPI_Stereo_SetDriverMode, 0x5e8f0bec }, - // { NvAPI_Stereo_GetEyeSeparation, 0xce653127 }, - // { NvAPI_Stereo_IsWindowedModeSupported, 0x40c8ed5e }, - // { NvAPI_Stereo_SetSurfaceCreationMode, 0xf5dcfcba }, - // { NvAPI_Stereo_GetSurfaceCreationMode, 0x36f1c736 }, - // { NvAPI_Stereo_Debug_WasLastDrawStereoized, 0xed4416c5 }, - // { NvAPI_Stereo_SetDefaultProfile, 0x44f0ecd1 }, - // { NvAPI_Stereo_GetDefaultProfile, 0x624e21c2 }, - // { NvAPI_D3D1x_CreateSwapChain, 0x1bc21b66 }, - // { NvAPI_D3D9_CreateSwapChain, 0x1a131e09 }, - // { NvAPI_Vulkan_InitLowLatencyDevice, 0x5c1696b6 }, - // { NvAPI_Vulkan_DestroyLowLatencyDevice, 0x11a5932b }, - // { NvAPI_Vulkan_GetSleepStatus, 0xadf966af }, - // { NvAPI_Vulkan_SetSleepMode, 0x2acfd162 }, - // { NvAPI_Vulkan_Sleep, 0x36732b1e }, - // { NvAPI_Vulkan_GetLatency, 0x3233d44a }, - // { NvAPI_Vulkan_SetLatencyMarker, 0xa17d13d6 }, - // { NvAPI_Vulkan_NotifyOutOfBandVkQueue, 0x5d6d3840 }, - // { NvAPI_DRS_CreateSession, 0x0694d52e }, - // { NvAPI_DRS_DestroySession, 0xdad9cff8 }, - // { NvAPI_DRS_LoadSettings, 0x375dbd6b }, - // { NvAPI_DRS_SaveSettings, 0xfcbc7e14 }, - // { NvAPI_DRS_LoadSettingsFromFile, 0xd3ede889 }, - // { NvAPI_DRS_SaveSettingsToFile, 0x2be25df8 }, - // { NvAPI_DRS_CreateProfile, 0xcc176068 }, - // { NvAPI_DRS_DeleteProfile, 0x17093206 }, - // { NvAPI_DRS_SetCurrentGlobalProfile, 0x1c89c5df }, - // { NvAPI_DRS_GetCurrentGlobalProfile, 0x617bff9f }, - // { NvAPI_DRS_GetProfileInfo, 0x61cd6fd6 }, - // { NvAPI_DRS_SetProfileInfo, 0x16abd3a9 }, - // { NvAPI_DRS_FindProfileByName, 0x7e4a9a0b }, - // { NvAPI_DRS_EnumProfiles, 0xbc371ee0 }, - // { NvAPI_DRS_GetNumProfiles, 0x1dae4fbc }, - // { NvAPI_DRS_CreateApplication, 0x4347a9de }, - // { NvAPI_DRS_DeleteApplicationEx, 0xc5ea85a1 }, - // { NvAPI_DRS_DeleteApplication, 0x2c694bc6 }, - // { NvAPI_DRS_GetApplicationInfo, 0xed1f8c69 }, - // { NvAPI_DRS_EnumApplications, 0x7fa2173a }, - // { NvAPI_DRS_FindApplicationByName, 0xeee566b2 }, - // { NvAPI_DRS_SetSetting, 0x577dd202 }, - // { NvAPI_DRS_GetSetting, 0x73bf8338 }, - // { NvAPI_DRS_EnumSettings, 0xae3039da }, - // { NvAPI_DRS_EnumAvailableSettingIds, 0xf020614a }, - // { NvAPI_DRS_EnumAvailableSettingValues, 0x2ec39f90 }, - // { NvAPI_DRS_GetSettingIdFromName, 0xcb7309cd }, - // { NvAPI_DRS_GetSettingNameFromId, 0xd61cbe6e }, - // { NvAPI_DRS_DeleteProfileSetting, 0xe4a26362 }, - // { NvAPI_DRS_RestoreAllDefaults, 0x5927b094 }, - // { NvAPI_DRS_RestoreProfileDefault, 0xfa5f6134 }, - // { NvAPI_DRS_RestoreProfileDefaultSetting, 0x53f0381e }, - // { NvAPI_DRS_GetBaseProfile, 0xda8466a0 }, - // { NvAPI_SYS_GetChipSetInfo, 0x53dabbca }, - // { NvAPI_SYS_GetLidAndDockInfo, 0xcda14d8a }, - // { NvAPI_SYS_GetDisplayIdFromGpuAndOutputId, 0x08f2bab4 }, - // { NvAPI_SYS_GetGpuAndOutputIdFromDisplayId, 0x112ba1a5 }, - // { NvAPI_SYS_GetPhysicalGpuFromDisplayId, 0x9ea74659 }, - // { NvAPI_SYS_GetDisplayDriverInfo, 0x721faceb }, - // { NvAPI_SYS_GetPhysicalGPUs, 0xd3b24d2d }, - // { NvAPI_SYS_GetLogicalGPUs, 0xccfffc10 }, - // { NvAPI_NGX_GetDriverFeatureSupport, 0x6194b19d }, - // { NvAPI_GPU_ClientRegisterForUtilizationSampleUpdates, 0xadeeaf67 }, - // { NvAPI_RegisterRiseCallback, 0x9cfe8f94 }, - // { NvAPI_RequestRise, 0x5047de98 }, - // { NvAPI_UninstallRise, 0xab8d09f6 }, - // Undocumented: - // Not sure what is the deal with this function, but looking at the - // implementation of NvAPI_GPU_CudaEnumComputeCapableGpus it seems to just - // call it with the same argument? - { NvAPI_Unknown_36e39e6b, 0x36e39e6b } - -); - -const NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_CAPABLE: u32 = 1 << 0; -const NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_ENABLE: u32 = 1 << 1; -// const NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_DEDICATED: u32 = 1 << 2; -const NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_RECOMMENDED: u32 = 1 << 3; -const NV_COMPUTE_GPU_TOPOLOGY_CUDA_AVAILABLE: u32 = 1 << 4; -const NV_COMPUTE_GPU_TOPOLOGY_CUDA_CAPABLE: u32 = 1 << 16; -// const NV_COMPUTE_GPU_TOPOLOGY_CUDA_DISABLED: u32 = 1 << 17; -const NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_AVAILABLE: u32 = 1 << 21; - -fn make_nvapi_version(ver: u32) -> u32 { - let size = std::mem::size_of::() as u32; - size | (ver << 16) -} - -#[no_mangle] -pub unsafe extern "C" fn nvapi_QueryInterface(interface: u32) -> *mut c_void { - interface_to_fn(interface).unwrap_or(std::ptr::null_mut()) -} - -#[allow(non_snake_case)] -unsafe extern "C" fn NvAPI_Initialize() -> i32 { - 0 -} - -#[allow(non_snake_case)] -unsafe extern "C" fn NvAPI_Unload() -> i32 { - 0 -} - -#[allow(non_snake_case)] -unsafe extern "C" fn NvAPI_GetDisplayDriverVersion( - _display: NvDisplayHandle, - version: *mut NV_DISPLAY_DRIVER_VERSION, -) -> i32 { - // return 0; - let version = version.as_mut(); - let version = unwrap_or::unwrap_some_or!(version, return _NvAPI_Status_NVAPI_INVALID_ARGUMENT); - if version.version != make_nvapi_version::(1) { - return _NvAPI_Status_NVAPI_INCOMPATIBLE_STRUCT_VERSION; - } - version.drvVersion = 99999; - version.bldChangeListNum = 0; - version.szBuildBranchString.fill(0); - version.szAdapterString.fill(0); - let device_name = b"ZLUDA Graphics Device"; - std::ptr::copy_nonoverlapping( - device_name.as_ptr() as _, - version.szAdapterString.as_mut_ptr() as _, - device_name.len(), - ); - 0 -} - -#[allow(non_snake_case)] -unsafe extern "C" fn NvAPI_GPU_CudaEnumComputeCapableGpus(version_ptr: *mut NvU32) -> i32 { - let version = version_ptr.as_mut(); - let version = unwrap_or::unwrap_some_or!(version, return _NvAPI_Status_NVAPI_INVALID_ARGUMENT); - if *version == make_nvapi_version::(1) { - NvAPI_GPU_CudaEnumComputeCapableGpus_v1( - version_ptr - .cast::() - .as_mut() - .unwrap(), - ) - } else if *version == make_nvapi_version::(2) { - NvAPI_GPU_CudaEnumComputeCapableGpus_v2( - version_ptr - .cast::() - .as_mut() - .unwrap(), - ) - } else { - _NvAPI_Status_NVAPI_INCOMPATIBLE_STRUCT_VERSION - } -} - -#[allow(non_snake_case)] -unsafe fn NvAPI_GPU_CudaEnumComputeCapableGpus_v1( - compute_topo: &mut NV_COMPUTE_GPU_TOPOLOGY_V1, -) -> i32 { - compute_topo.gpuCount = 1; - compute_topo.computeGpus[0] = NV_COMPUTE_GPU_TOPOLOGY_V1__bindgen_ty_1 { - hPhysicalGpu: 1 as _, - flags: NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_CAPABLE - | NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_ENABLE - | NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_RECOMMENDED - | NV_COMPUTE_GPU_TOPOLOGY_CUDA_AVAILABLE - | NV_COMPUTE_GPU_TOPOLOGY_CUDA_CAPABLE - | NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_AVAILABLE, - }; - 0 -} - -#[repr(transparent)] -struct NvComputeGpuSync(NV_COMPUTE_GPU); - -unsafe impl Sync for NvComputeGpuSync {} - -#[allow(non_snake_case)] -unsafe fn NvAPI_GPU_CudaEnumComputeCapableGpus_v2( - compute_topo: &mut NV_COMPUTE_GPU_TOPOLOGY_V2, -) -> i32 { - static mut FAKE_GPU: NvComputeGpuSync = NvComputeGpuSync(NV_COMPUTE_GPU { - hPhysicalGpu: 1 as _, - flags: NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_CAPABLE - | NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_ENABLE - | NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_RECOMMENDED - | NV_COMPUTE_GPU_TOPOLOGY_CUDA_AVAILABLE - | NV_COMPUTE_GPU_TOPOLOGY_CUDA_CAPABLE - | NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_AVAILABLE, - }); - compute_topo.gpuCount = 1; - compute_topo.computeGpus = (&raw mut FAKE_GPU).cast(); - 0 -} - -#[allow(non_snake_case)] -unsafe extern "C" fn NvAPI_GetGPUIDfromPhysicalGPU( - physical_gpu: NvPhysicalGpuHandle, - gpu_id: *mut NvU32, -) -> i32 { - if physical_gpu != 1 as _ { - return _NvAPI_Status_NVAPI_INVALID_ARGUMENT; - } - let gpu_id = gpu_id.as_mut(); - let gpu_id = unwrap_or::unwrap_some_or!(gpu_id, return _NvAPI_Status_NVAPI_INVALID_ARGUMENT); - *gpu_id = 1; - 0 -} - -#[allow(non_snake_case)] -unsafe extern "C" fn NvAPI_GetPhysicalGPUFromGPUID( - gpu_id: NvU32, - physical_gpu: *mut NvPhysicalGpuHandle, -) -> i32 { - if gpu_id != 1 { - return _NvAPI_Status_NVAPI_INVALID_ARGUMENT; - } - let physical_gpu = physical_gpu.as_mut(); - let physical_gpu = - unwrap_or::unwrap_some_or!(physical_gpu, return _NvAPI_Status_NVAPI_INVALID_ARGUMENT); - *physical_gpu = 1 as _; - 0 -} - -#[allow(non_snake_case)] -unsafe extern "C" fn NvAPI_SYS_GetDriverAndBranchVersion( - driver_version: *mut NvU32, - build_branch_string: *mut NvAPI_ShortString, -) -> i32 { - let driver_version = driver_version.as_mut(); - let driver_version = - unwrap_or::unwrap_some_or!(driver_version, return _NvAPI_Status_NVAPI_INVALID_ARGUMENT); - let build_branch_string = build_branch_string.as_mut(); - let build_branch_string = unwrap_or::unwrap_some_or!( - build_branch_string, - return _NvAPI_Status_NVAPI_INVALID_ARGUMENT - ); - *driver_version = 99999; - build_branch_string.fill(0); - let version_string = b"r999_99"; - std::ptr::copy_nonoverlapping( - version_string.as_ptr().cast(), - build_branch_string.as_mut_ptr(), - version_string.len(), - ); - 0 -} - -#[allow(non_snake_case)] -unsafe extern "C" fn NvAPI_Unknown_36e39e6b(compute_topo: *mut NV_COMPUTE_GPU_TOPOLOGY_V2) -> i32 { - let compute_topo = compute_topo.as_mut(); - let compute_topo = - unwrap_or::unwrap_some_or!(compute_topo, return _NvAPI_Status_NVAPI_INVALID_ARGUMENT); - NvAPI_GPU_CudaEnumComputeCapableGpus_v2(compute_topo) -} diff --git a/nvapi/src/nvapi.rs b/nvapi/src/nvapi.rs deleted file mode 100644 index 718bd0a38..000000000 --- a/nvapi/src/nvapi.rs +++ /dev/null @@ -1,19879 +0,0 @@ -// bindgen nvapi.h -o nvapi.rs --no-layout-tests --allowlist-type "Nv.*" --allowlist-type "NV_.*" -/* automatically generated by rust-bindgen 0.72.1 */ - -#[repr(C)] -#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] -pub struct __BindgenBitfieldUnit { - storage: Storage, -} -impl __BindgenBitfieldUnit { - #[inline] - pub const fn new(storage: Storage) -> Self { - Self { storage } - } -} -impl __BindgenBitfieldUnit -where - Storage: AsRef<[u8]> + AsMut<[u8]>, -{ - #[inline] - fn extract_bit(byte: u8, index: usize) -> bool { - let bit_index = if cfg!(target_endian = "big") { - 7 - (index % 8) - } else { - index % 8 - }; - let mask = 1 << bit_index; - byte & mask == mask - } - #[inline] - pub fn get_bit(&self, index: usize) -> bool { - debug_assert!(index / 8 < self.storage.as_ref().len()); - let byte_index = index / 8; - let byte = self.storage.as_ref()[byte_index]; - Self::extract_bit(byte, index) - } - #[inline] - pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { - debug_assert!(index / 8 < core::mem::size_of::()); - let byte_index = index / 8; - let byte = unsafe { - *(core::ptr::addr_of!((*this).storage) as *const u8).offset(byte_index as isize) - }; - Self::extract_bit(byte, index) - } - #[inline] - fn change_bit(byte: u8, index: usize, val: bool) -> u8 { - let bit_index = if cfg!(target_endian = "big") { - 7 - (index % 8) - } else { - index % 8 - }; - let mask = 1 << bit_index; - if val { - byte | mask - } else { - byte & !mask - } - } - #[inline] - pub fn set_bit(&mut self, index: usize, val: bool) { - debug_assert!(index / 8 < self.storage.as_ref().len()); - let byte_index = index / 8; - let byte = &mut self.storage.as_mut()[byte_index]; - *byte = Self::change_bit(*byte, index, val); - } - #[inline] - pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { - debug_assert!(index / 8 < core::mem::size_of::()); - let byte_index = index / 8; - let byte = unsafe { - (core::ptr::addr_of_mut!((*this).storage) as *mut u8).offset(byte_index as isize) - }; - unsafe { *byte = Self::change_bit(*byte, index, val) }; - } - #[inline] - pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { - debug_assert!(bit_width <= 64); - debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); - debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); - let mut val = 0; - for i in 0..(bit_width as usize) { - if self.get_bit(i + bit_offset) { - let index = if cfg!(target_endian = "big") { - bit_width as usize - 1 - i - } else { - i - }; - val |= 1 << index; - } - } - val - } - #[inline] - pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { - debug_assert!(bit_width <= 64); - debug_assert!(bit_offset / 8 < core::mem::size_of::()); - debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::()); - let mut val = 0; - for i in 0..(bit_width as usize) { - if unsafe { Self::raw_get_bit(this, i + bit_offset) } { - let index = if cfg!(target_endian = "big") { - bit_width as usize - 1 - i - } else { - i - }; - val |= 1 << index; - } - } - val - } - #[inline] - pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { - debug_assert!(bit_width <= 64); - debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); - debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); - for i in 0..(bit_width as usize) { - let mask = 1 << i; - let val_bit_is_set = val & mask == mask; - let index = if cfg!(target_endian = "big") { - bit_width as usize - 1 - i - } else { - i - }; - self.set_bit(index + bit_offset, val_bit_is_set); - } - } - #[inline] - pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { - debug_assert!(bit_width <= 64); - debug_assert!(bit_offset / 8 < core::mem::size_of::()); - debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::()); - for i in 0..(bit_width as usize) { - let mask = 1 << i; - let val_bit_is_set = val & mask == mask; - let index = if cfg!(target_endian = "big") { - bit_width as usize - 1 - i - } else { - i - }; - unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; - } - } -} -pub type DWORD = ::std::os::raw::c_ulong; -pub type ULONG_PTR = ::std::os::raw::c_ulonglong; -pub type SIZE_T = ULONG_PTR; -pub type LONG = ::std::os::raw::c_long; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _LUID { - pub LowPart: DWORD, - pub HighPart: LONG, -} -pub type LUID = _LUID; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MEMORY_RANGE { - pub BaseAddress: *mut ::std::os::raw::c_void, - pub Length: SIZE_T, -} -pub type NV_MEMORY_RANGE = _NV_MEMORY_RANGE; -pub type NvU64 = ::std::os::raw::c_ulonglong; -pub type NvS64 = ::std::os::raw::c_longlong; -pub type NvS32 = ::std::os::raw::c_int; -pub type NvU32 = ::std::os::raw::c_uint; -pub type NvS16 = ::std::os::raw::c_short; -pub type NvU16 = ::std::os::raw::c_ushort; -pub type NvU8 = ::std::os::raw::c_uchar; -pub type NvS8 = ::std::os::raw::c_schar; -pub type NvF32 = f32; -pub type NvF64 = f64; -pub type NvBool = NvU8; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_RECT { - pub left: NvU32, - pub top: NvU32, - pub right: NvU32, - pub bottom: NvU32, -} -pub type NV_RECT = _NV_RECT; -#[doc = "! \\addtogroup nvapihandles\n! NVAPI Handles - These handles are retrieved from various calls and passed in to others in NvAPI\n! These are meant to be opaque types. Do not assume they correspond to indices, HDCs,\n! display indexes or anything else.\n!\n! Most handles remain valid until a display re-configuration (display mode set) or GPU\n! reconfiguration (going into or out of SLI modes) occurs. If NVAPI_HANDLE_INVALIDATED\n! is received by an app, it should discard all handles, and re-enumerate them.\n! @{"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvLogicalGpuHandle__ { - pub unused: ::std::os::raw::c_int, -} -#[doc = "! \\addtogroup nvapihandles\n! NVAPI Handles - These handles are retrieved from various calls and passed in to others in NvAPI\n! These are meant to be opaque types. Do not assume they correspond to indices, HDCs,\n! display indexes or anything else.\n!\n! Most handles remain valid until a display re-configuration (display mode set) or GPU\n! reconfiguration (going into or out of SLI modes) occurs. If NVAPI_HANDLE_INVALIDATED\n! is received by an app, it should discard all handles, and re-enumerate them.\n! @{"] -pub type NvLogicalGpuHandle = *mut NvLogicalGpuHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvPhysicalGpuHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvPhysicalGpuHandle = *mut NvPhysicalGpuHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvDisplayHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvDisplayHandle = *mut NvDisplayHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvMonitorHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvMonitorHandle = *mut NvMonitorHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvUnAttachedDisplayHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvUnAttachedDisplayHandle = *mut NvUnAttachedDisplayHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvVisualComputingDeviceHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvVisualComputingDeviceHandle = *mut NvVisualComputingDeviceHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvEventHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvEventHandle = *mut NvEventHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvHICHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvHICHandle = *mut NvHICHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvGSyncDeviceHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvGSyncDeviceHandle = *mut NvGSyncDeviceHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvVioHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvVioHandle = *mut NvVioHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvTransitionHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvTransitionHandle = *mut NvTransitionHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvAudioHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvAudioHandle = *mut NvAudioHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Nv3DVPContextHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type Nv3DVPContextHandle = *mut Nv3DVPContextHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Nv3DVPTransceiverHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type Nv3DVPTransceiverHandle = *mut Nv3DVPTransceiverHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Nv3DVPGlassesHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type Nv3DVPGlassesHandle = *mut Nv3DVPGlassesHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvPcfClientHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvPcfClientHandle = *mut NvPcfClientHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvSourceHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvSourceHandle = *mut NvSourceHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvTargetHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvTargetHandle = *mut NvTargetHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvPresentBarrierClientHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvPresentBarrierClientHandle = *mut NvPresentBarrierClientHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvSBox { - pub sX: NvS32, - pub sY: NvS32, - pub sWidth: NvS32, - pub sHeight: NvS32, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvGUID { - pub data1: NvU32, - pub data2: NvU16, - pub data3: NvU16, - pub data4: [NvU8; 8usize], -} -pub type NvLUID = NvGUID; -pub type NvAPI_String = [::std::os::raw::c_char; 4096usize]; -pub type NvAPI_LongString = [::std::os::raw::c_char; 256usize]; -pub type NvAPI_ShortString = [::std::os::raw::c_char; 64usize]; -pub type NvAPI_UnicodeShortString = [NvU16; 64usize]; -#[doc = "!< Success. Request is completed."] -pub const _NvAPI_Status_NVAPI_OK: _NvAPI_Status = 0; -#[doc = "!< Generic error"] -pub const _NvAPI_Status_NVAPI_ERROR: _NvAPI_Status = -1; -#[doc = "!< NVAPI support library cannot be loaded."] -pub const _NvAPI_Status_NVAPI_LIBRARY_NOT_FOUND: _NvAPI_Status = -2; -#[doc = "!< not implemented in current driver installation"] -pub const _NvAPI_Status_NVAPI_NO_IMPLEMENTATION: _NvAPI_Status = -3; -#[doc = "!< NvAPI_Initialize has not been called (successfully)"] -pub const _NvAPI_Status_NVAPI_API_NOT_INITIALIZED: _NvAPI_Status = -4; -#[doc = "!< The argument/parameter value is not valid or NULL."] -pub const _NvAPI_Status_NVAPI_INVALID_ARGUMENT: _NvAPI_Status = -5; -#[doc = "!< No NVIDIA display driver, or NVIDIA GPU driving a display, was found."] -pub const _NvAPI_Status_NVAPI_NVIDIA_DEVICE_NOT_FOUND: _NvAPI_Status = -6; -#[doc = "!< No more items to enumerate"] -pub const _NvAPI_Status_NVAPI_END_ENUMERATION: _NvAPI_Status = -7; -#[doc = "!< Invalid handle"] -pub const _NvAPI_Status_NVAPI_INVALID_HANDLE: _NvAPI_Status = -8; -#[doc = "!< An argument's structure version is not supported"] -pub const _NvAPI_Status_NVAPI_INCOMPATIBLE_STRUCT_VERSION: _NvAPI_Status = -9; -#[doc = "!< The handle is no longer valid (likely due to GPU or display re-configuration)"] -pub const _NvAPI_Status_NVAPI_HANDLE_INVALIDATED: _NvAPI_Status = -10; -#[doc = "!< No NVIDIA OpenGL context is current (but needs to be)"] -pub const _NvAPI_Status_NVAPI_OPENGL_CONTEXT_NOT_CURRENT: _NvAPI_Status = -11; -#[doc = "!< An invalid pointer, usually NULL, was passed as a parameter"] -pub const _NvAPI_Status_NVAPI_INVALID_POINTER: _NvAPI_Status = -14; -#[doc = "!< OpenGL Expert is not supported by the current drivers"] -pub const _NvAPI_Status_NVAPI_NO_GL_EXPERT: _NvAPI_Status = -12; -#[doc = "!< OpenGL Expert is supported, but driver instrumentation is currently disabled"] -pub const _NvAPI_Status_NVAPI_INSTRUMENTATION_DISABLED: _NvAPI_Status = -13; -#[doc = "!< OpenGL does not support Nsight"] -pub const _NvAPI_Status_NVAPI_NO_GL_NSIGHT: _NvAPI_Status = -15; -#[doc = "!< Expected a logical GPU handle for one or more parameters"] -pub const _NvAPI_Status_NVAPI_EXPECTED_LOGICAL_GPU_HANDLE: _NvAPI_Status = -100; -#[doc = "!< Expected a physical GPU handle for one or more parameters"] -pub const _NvAPI_Status_NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE: _NvAPI_Status = -101; -#[doc = "!< Expected an NV display handle for one or more parameters"] -pub const _NvAPI_Status_NVAPI_EXPECTED_DISPLAY_HANDLE: _NvAPI_Status = -102; -#[doc = "!< The combination of parameters is not valid."] -pub const _NvAPI_Status_NVAPI_INVALID_COMBINATION: _NvAPI_Status = -103; -#[doc = "!< Requested feature is not supported in the selected GPU"] -pub const _NvAPI_Status_NVAPI_NOT_SUPPORTED: _NvAPI_Status = -104; -#[doc = "!< No port ID was found for the I2C transaction"] -pub const _NvAPI_Status_NVAPI_PORTID_NOT_FOUND: _NvAPI_Status = -105; -#[doc = "!< Expected an unattached display handle as one of the input parameters."] -pub const _NvAPI_Status_NVAPI_EXPECTED_UNATTACHED_DISPLAY_HANDLE: _NvAPI_Status = -106; -#[doc = "!< Invalid perf level"] -pub const _NvAPI_Status_NVAPI_INVALID_PERF_LEVEL: _NvAPI_Status = -107; -#[doc = "!< Device is busy; request not fulfilled"] -pub const _NvAPI_Status_NVAPI_DEVICE_BUSY: _NvAPI_Status = -108; -#[doc = "!< NV persist file is not found"] -pub const _NvAPI_Status_NVAPI_NV_PERSIST_FILE_NOT_FOUND: _NvAPI_Status = -109; -#[doc = "!< NV persist data is not found"] -pub const _NvAPI_Status_NVAPI_PERSIST_DATA_NOT_FOUND: _NvAPI_Status = -110; -#[doc = "!< Expected a TV output display"] -pub const _NvAPI_Status_NVAPI_EXPECTED_TV_DISPLAY: _NvAPI_Status = -111; -#[doc = "!< Expected a TV output on the D Connector - HDTV_EIAJ4120."] -pub const _NvAPI_Status_NVAPI_EXPECTED_TV_DISPLAY_ON_DCONNECTOR: _NvAPI_Status = -112; -#[doc = "!< SLI is not active on this device."] -pub const _NvAPI_Status_NVAPI_NO_ACTIVE_SLI_TOPOLOGY: _NvAPI_Status = -113; -#[doc = "!< Setup of SLI rendering mode is not possible right now."] -pub const _NvAPI_Status_NVAPI_SLI_RENDERING_MODE_NOTALLOWED: _NvAPI_Status = -114; -#[doc = "!< Expected a digital flat panel."] -pub const _NvAPI_Status_NVAPI_EXPECTED_DIGITAL_FLAT_PANEL: _NvAPI_Status = -115; -#[doc = "!< Argument exceeds the expected size."] -pub const _NvAPI_Status_NVAPI_ARGUMENT_EXCEED_MAX_SIZE: _NvAPI_Status = -116; -#[doc = "!< Inhibit is ON due to one of the flags in NV_GPU_DISPLAY_CHANGE_INHIBIT or SLI active."] -pub const _NvAPI_Status_NVAPI_DEVICE_SWITCHING_NOT_ALLOWED: _NvAPI_Status = -117; -#[doc = "!< Testing of clocks is not supported."] -pub const _NvAPI_Status_NVAPI_TESTING_CLOCKS_NOT_SUPPORTED: _NvAPI_Status = -118; -#[doc = "!< The specified underscan config is from an unknown source (e.g. INF)"] -pub const _NvAPI_Status_NVAPI_UNKNOWN_UNDERSCAN_CONFIG: _NvAPI_Status = -119; -#[doc = "!< Timeout while reconfiguring GPUs"] -pub const _NvAPI_Status_NVAPI_TIMEOUT_RECONFIGURING_GPU_TOPO: _NvAPI_Status = -120; -#[doc = "!< Requested data was not found"] -pub const _NvAPI_Status_NVAPI_DATA_NOT_FOUND: _NvAPI_Status = -121; -#[doc = "!< Expected an analog display"] -pub const _NvAPI_Status_NVAPI_EXPECTED_ANALOG_DISPLAY: _NvAPI_Status = -122; -#[doc = "!< No SLI video bridge is present"] -pub const _NvAPI_Status_NVAPI_NO_VIDLINK: _NvAPI_Status = -123; -#[doc = "!< NVAPI requires a reboot for the settings to take effect"] -pub const _NvAPI_Status_NVAPI_REQUIRES_REBOOT: _NvAPI_Status = -124; -#[doc = "!< The function is not supported with the current Hybrid mode."] -pub const _NvAPI_Status_NVAPI_INVALID_HYBRID_MODE: _NvAPI_Status = -125; -#[doc = "!< The target types are not all the same"] -pub const _NvAPI_Status_NVAPI_MIXED_TARGET_TYPES: _NvAPI_Status = -126; -#[doc = "!< The function is not supported from 32-bit on a 64-bit system."] -pub const _NvAPI_Status_NVAPI_SYSWOW64_NOT_SUPPORTED: _NvAPI_Status = -127; -#[doc = "!< There is no implicit GPU topology active. Use NVAPI_SetHybridMode to change topology."] -pub const _NvAPI_Status_NVAPI_IMPLICIT_SET_GPU_TOPOLOGY_CHANGE_NOT_ALLOWED: _NvAPI_Status = -128; -#[doc = "!< Prompt the user to close all non-migratable applications."] -pub const _NvAPI_Status_NVAPI_REQUEST_USER_TO_CLOSE_NON_MIGRATABLE_APPS: _NvAPI_Status = -129; -#[doc = "!< Could not allocate sufficient memory to complete the call."] -pub const _NvAPI_Status_NVAPI_OUT_OF_MEMORY: _NvAPI_Status = -130; -#[doc = "!< The previous operation that is transferring information to or from this surface is incomplete."] -pub const _NvAPI_Status_NVAPI_WAS_STILL_DRAWING: _NvAPI_Status = -131; -#[doc = "!< The file was not found."] -pub const _NvAPI_Status_NVAPI_FILE_NOT_FOUND: _NvAPI_Status = -132; -#[doc = "!< There are too many unique instances of a particular type of state object."] -pub const _NvAPI_Status_NVAPI_TOO_MANY_UNIQUE_STATE_OBJECTS: _NvAPI_Status = -133; -#[doc = "!< The method call is invalid. For example, a method's parameter may not be a valid pointer."] -pub const _NvAPI_Status_NVAPI_INVALID_CALL: _NvAPI_Status = -134; -#[doc = "!< d3d10_1.dll cannot be loaded."] -pub const _NvAPI_Status_NVAPI_D3D10_1_LIBRARY_NOT_FOUND: _NvAPI_Status = -135; -#[doc = "!< Couldn't find the function in the loaded DLL."] -pub const _NvAPI_Status_NVAPI_FUNCTION_NOT_FOUND: _NvAPI_Status = -136; -#[doc = "!< The application will require Administrator privileges to access this API.\n!< The application can be elevated to a higher permission level by selecting \"Run as Administrator\"."] -pub const _NvAPI_Status_NVAPI_INVALID_USER_PRIVILEGE: _NvAPI_Status = -137; -#[doc = "!< The handle corresponds to GDIPrimary."] -pub const _NvAPI_Status_NVAPI_EXPECTED_NON_PRIMARY_DISPLAY_HANDLE: _NvAPI_Status = -138; -#[doc = "!< Setting Physx GPU requires that the GPU is compute-capable."] -pub const _NvAPI_Status_NVAPI_EXPECTED_COMPUTE_GPU_HANDLE: _NvAPI_Status = -139; -#[doc = "!< The Stereo part of NVAPI failed to initialize completely. Check if the stereo driver is installed."] -pub const _NvAPI_Status_NVAPI_STEREO_NOT_INITIALIZED: _NvAPI_Status = -140; -#[doc = "!< Access to stereo-related registry keys or values has failed."] -pub const _NvAPI_Status_NVAPI_STEREO_REGISTRY_ACCESS_FAILED: _NvAPI_Status = -141; -#[doc = "!< The given registry profile type is not supported."] -pub const _NvAPI_Status_NVAPI_STEREO_REGISTRY_PROFILE_TYPE_NOT_SUPPORTED: _NvAPI_Status = -142; -#[doc = "!< The given registry value is not supported."] -pub const _NvAPI_Status_NVAPI_STEREO_REGISTRY_VALUE_NOT_SUPPORTED: _NvAPI_Status = -143; -#[doc = "!< Stereo is not enabled and the function needed it to execute completely."] -pub const _NvAPI_Status_NVAPI_STEREO_NOT_ENABLED: _NvAPI_Status = -144; -#[doc = "!< Stereo is not turned on and the function needed it to execute completely."] -pub const _NvAPI_Status_NVAPI_STEREO_NOT_TURNED_ON: _NvAPI_Status = -145; -#[doc = "!< Invalid device interface."] -pub const _NvAPI_Status_NVAPI_STEREO_INVALID_DEVICE_INTERFACE: _NvAPI_Status = -146; -#[doc = "!< Separation percentage or JPEG image capture quality is out of [0-100] range."] -pub const _NvAPI_Status_NVAPI_STEREO_PARAMETER_OUT_OF_RANGE: _NvAPI_Status = -147; -#[doc = "!< The given frustum adjust mode is not supported."] -pub const _NvAPI_Status_NVAPI_STEREO_FRUSTUM_ADJUST_MODE_NOT_SUPPORTED: _NvAPI_Status = -148; -#[doc = "!< The mosaic topology is not possible given the current state of the hardware."] -pub const _NvAPI_Status_NVAPI_TOPO_NOT_POSSIBLE: _NvAPI_Status = -149; -#[doc = "!< An attempt to do a display resolution mode change has failed."] -pub const _NvAPI_Status_NVAPI_MODE_CHANGE_FAILED: _NvAPI_Status = -150; -#[doc = "!< d3d11.dll/d3d11_beta.dll cannot be loaded."] -pub const _NvAPI_Status_NVAPI_D3D11_LIBRARY_NOT_FOUND: _NvAPI_Status = -151; -#[doc = "!< Address is outside of valid range."] -pub const _NvAPI_Status_NVAPI_INVALID_ADDRESS: _NvAPI_Status = -152; -#[doc = "!< The pre-allocated string is too small to hold the result."] -pub const _NvAPI_Status_NVAPI_STRING_TOO_SMALL: _NvAPI_Status = -153; -#[doc = "!< The input does not match any of the available devices."] -pub const _NvAPI_Status_NVAPI_MATCHING_DEVICE_NOT_FOUND: _NvAPI_Status = -154; -#[doc = "!< Driver is running."] -pub const _NvAPI_Status_NVAPI_DRIVER_RUNNING: _NvAPI_Status = -155; -#[doc = "!< Driver is not running."] -pub const _NvAPI_Status_NVAPI_DRIVER_NOTRUNNING: _NvAPI_Status = -156; -#[doc = "!< A driver reload is required to apply these settings."] -pub const _NvAPI_Status_NVAPI_ERROR_DRIVER_RELOAD_REQUIRED: _NvAPI_Status = -157; -#[doc = "!< Intended setting is not allowed."] -pub const _NvAPI_Status_NVAPI_SET_NOT_ALLOWED: _NvAPI_Status = -158; -#[doc = "!< Information can't be returned due to \"advanced display topology\"."] -pub const _NvAPI_Status_NVAPI_ADVANCED_DISPLAY_TOPOLOGY_REQUIRED: _NvAPI_Status = -159; -#[doc = "!< Setting is not found."] -pub const _NvAPI_Status_NVAPI_SETTING_NOT_FOUND: _NvAPI_Status = -160; -#[doc = "!< Setting size is too large."] -pub const _NvAPI_Status_NVAPI_SETTING_SIZE_TOO_LARGE: _NvAPI_Status = -161; -#[doc = "!< There are too many settings for a profile."] -pub const _NvAPI_Status_NVAPI_TOO_MANY_SETTINGS_IN_PROFILE: _NvAPI_Status = -162; -#[doc = "!< Profile is not found."] -pub const _NvAPI_Status_NVAPI_PROFILE_NOT_FOUND: _NvAPI_Status = -163; -#[doc = "!< Profile name is duplicated."] -pub const _NvAPI_Status_NVAPI_PROFILE_NAME_IN_USE: _NvAPI_Status = -164; -#[doc = "!< Profile name is empty."] -pub const _NvAPI_Status_NVAPI_PROFILE_NAME_EMPTY: _NvAPI_Status = -165; -#[doc = "!< Application not found in the Profile."] -pub const _NvAPI_Status_NVAPI_EXECUTABLE_NOT_FOUND: _NvAPI_Status = -166; -#[doc = "!< Application already exists in the other profile."] -pub const _NvAPI_Status_NVAPI_EXECUTABLE_ALREADY_IN_USE: _NvAPI_Status = -167; -#[doc = "!< Data Type mismatch"] -pub const _NvAPI_Status_NVAPI_DATATYPE_MISMATCH: _NvAPI_Status = -168; -#[doc = "!< The profile passed as parameter has been removed and is no longer valid."] -pub const _NvAPI_Status_NVAPI_PROFILE_REMOVED: _NvAPI_Status = -169; -#[doc = "!< An unregistered resource was passed as a parameter."] -pub const _NvAPI_Status_NVAPI_UNREGISTERED_RESOURCE: _NvAPI_Status = -170; -#[doc = "!< The DisplayId corresponds to a display which is not within the normal outputId range."] -pub const _NvAPI_Status_NVAPI_ID_OUT_OF_RANGE: _NvAPI_Status = -171; -#[doc = "!< Display topology is not valid so the driver cannot do a mode set on this configuration."] -pub const _NvAPI_Status_NVAPI_DISPLAYCONFIG_VALIDATION_FAILED: _NvAPI_Status = -172; -#[doc = "!< Display Port Multi-Stream topology has been changed."] -pub const _NvAPI_Status_NVAPI_DPMST_CHANGED: _NvAPI_Status = -173; -#[doc = "!< Input buffer is insufficient to hold the contents."] -pub const _NvAPI_Status_NVAPI_INSUFFICIENT_BUFFER: _NvAPI_Status = -174; -#[doc = "!< No access to the caller."] -pub const _NvAPI_Status_NVAPI_ACCESS_DENIED: _NvAPI_Status = -175; -#[doc = "!< The requested action cannot be performed without Mosaic being enabled."] -pub const _NvAPI_Status_NVAPI_MOSAIC_NOT_ACTIVE: _NvAPI_Status = -176; -#[doc = "!< The surface is relocated away from video memory."] -pub const _NvAPI_Status_NVAPI_SHARE_RESOURCE_RELOCATED: _NvAPI_Status = -177; -#[doc = "!< The user should disable DWM before calling NvAPI."] -pub const _NvAPI_Status_NVAPI_REQUEST_USER_TO_DISABLE_DWM: _NvAPI_Status = -178; -#[doc = "!< D3D device status is D3DERR_DEVICELOST or D3DERR_DEVICENOTRESET - the user has to reset the device."] -pub const _NvAPI_Status_NVAPI_D3D_DEVICE_LOST: _NvAPI_Status = -179; -#[doc = "!< The requested action cannot be performed in the current state."] -pub const _NvAPI_Status_NVAPI_INVALID_CONFIGURATION: _NvAPI_Status = -180; -#[doc = "!< Call failed as stereo handshake not completed."] -pub const _NvAPI_Status_NVAPI_STEREO_HANDSHAKE_NOT_DONE: _NvAPI_Status = -181; -#[doc = "!< The path provided was too short to determine the correct NVDRS_APPLICATION"] -pub const _NvAPI_Status_NVAPI_EXECUTABLE_PATH_IS_AMBIGUOUS: _NvAPI_Status = -182; -#[doc = "!< Default stereo profile is not currently defined"] -pub const _NvAPI_Status_NVAPI_DEFAULT_STEREO_PROFILE_IS_NOT_DEFINED: _NvAPI_Status = -183; -#[doc = "!< Default stereo profile does not exist"] -pub const _NvAPI_Status_NVAPI_DEFAULT_STEREO_PROFILE_DOES_NOT_EXIST: _NvAPI_Status = -184; -#[doc = "!< A cluster is already defined with the given configuration."] -pub const _NvAPI_Status_NVAPI_CLUSTER_ALREADY_EXISTS: _NvAPI_Status = -185; -#[doc = "!< The input display id is not that of a multi stream enabled connector or a display device in a multi stream topology"] -pub const _NvAPI_Status_NVAPI_DPMST_DISPLAY_ID_EXPECTED: _NvAPI_Status = -186; -#[doc = "!< The input display id is not valid or the monitor associated to it does not support the current operation"] -pub const _NvAPI_Status_NVAPI_INVALID_DISPLAY_ID: _NvAPI_Status = -187; -#[doc = "!< While playing secure audio stream, stream goes out of sync"] -pub const _NvAPI_Status_NVAPI_STREAM_IS_OUT_OF_SYNC: _NvAPI_Status = -188; -#[doc = "!< Older audio driver version than required"] -pub const _NvAPI_Status_NVAPI_INCOMPATIBLE_AUDIO_DRIVER: _NvAPI_Status = -189; -#[doc = "!< Value already set, setting again not allowed."] -pub const _NvAPI_Status_NVAPI_VALUE_ALREADY_SET: _NvAPI_Status = -190; -#[doc = "!< Requested operation timed out"] -pub const _NvAPI_Status_NVAPI_TIMEOUT: _NvAPI_Status = -191; -#[doc = "!< The requested workstation feature set has incomplete driver internal allocation resources"] -pub const _NvAPI_Status_NVAPI_GPU_WORKSTATION_FEATURE_INCOMPLETE: _NvAPI_Status = -192; -#[doc = "!< Call failed because InitActivation was not called."] -pub const _NvAPI_Status_NVAPI_STEREO_INIT_ACTIVATION_NOT_DONE: _NvAPI_Status = -193; -#[doc = "!< The requested action cannot be performed without Sync being enabled."] -pub const _NvAPI_Status_NVAPI_SYNC_NOT_ACTIVE: _NvAPI_Status = -194; -#[doc = "!< The requested action cannot be performed without Sync Master being enabled."] -pub const _NvAPI_Status_NVAPI_SYNC_MASTER_NOT_FOUND: _NvAPI_Status = -195; -#[doc = "!< Invalid displays passed in the NV_GSYNC_DISPLAY pointer."] -pub const _NvAPI_Status_NVAPI_INVALID_SYNC_TOPOLOGY: _NvAPI_Status = -196; -#[doc = "!< The specified signing algorithm is not supported. Either an incorrect value was entered or the current installed driver/hardware does not support the input value."] -pub const _NvAPI_Status_NVAPI_ECID_SIGN_ALGO_UNSUPPORTED: _NvAPI_Status = -197; -#[doc = "!< The encrypted public key verification has failed."] -pub const _NvAPI_Status_NVAPI_ECID_KEY_VERIFICATION_FAILED: _NvAPI_Status = -198; -#[doc = "!< The device's firmware is out of date."] -pub const _NvAPI_Status_NVAPI_FIRMWARE_OUT_OF_DATE: _NvAPI_Status = -199; -#[doc = "!< The device's firmware is not supported."] -pub const _NvAPI_Status_NVAPI_FIRMWARE_REVISION_NOT_SUPPORTED: _NvAPI_Status = -200; -#[doc = "!< The caller is not authorized to modify the License."] -pub const _NvAPI_Status_NVAPI_LICENSE_CALLER_AUTHENTICATION_FAILED: _NvAPI_Status = -201; -#[doc = "!< The user tried to use a deferred context without registering the device first"] -pub const _NvAPI_Status_NVAPI_D3D_DEVICE_NOT_REGISTERED: _NvAPI_Status = -202; -#[doc = "!< Head or SourceId was not reserved for the VR Display before doing the Modeset or the dedicated display."] -pub const _NvAPI_Status_NVAPI_RESOURCE_NOT_ACQUIRED: _NvAPI_Status = -203; -#[doc = "!< Provided timing is not supported."] -pub const _NvAPI_Status_NVAPI_TIMING_NOT_SUPPORTED: _NvAPI_Status = -204; -#[doc = "!< HDCP Encryption Failed for the device. Would be applicable when the device is HDCP Capable."] -pub const _NvAPI_Status_NVAPI_HDCP_ENCRYPTION_FAILED: _NvAPI_Status = -205; -#[doc = "!< Provided mode is over sink device pclk limitation."] -pub const _NvAPI_Status_NVAPI_PCLK_LIMITATION_FAILED: _NvAPI_Status = -206; -#[doc = "!< No connector on GPU found."] -pub const _NvAPI_Status_NVAPI_NO_CONNECTOR_FOUND: _NvAPI_Status = -207; -#[doc = "!< When a non-HDCP capable HMD is connected, we would inform user by this code."] -pub const _NvAPI_Status_NVAPI_HDCP_DISABLED: _NvAPI_Status = -208; -#[doc = "!< Atleast an API is still being called"] -pub const _NvAPI_Status_NVAPI_API_IN_USE: _NvAPI_Status = -209; -#[doc = "!< No display found on Nvidia GPU(s)."] -pub const _NvAPI_Status_NVAPI_NVIDIA_DISPLAY_NOT_FOUND: _NvAPI_Status = -210; -#[doc = "!< Priv security violation, improper access to a secured register."] -pub const _NvAPI_Status_NVAPI_PRIV_SEC_VIOLATION: _NvAPI_Status = -211; -#[doc = "!< NVAPI cannot be called by this vendor"] -pub const _NvAPI_Status_NVAPI_INCORRECT_VENDOR: _NvAPI_Status = -212; -#[doc = "!< DirectMode Display is already in use"] -pub const _NvAPI_Status_NVAPI_DISPLAY_IN_USE: _NvAPI_Status = -213; -#[doc = "!< The Config is having Non-NVidia GPU with Non-HDCP HMD connected"] -pub const _NvAPI_Status_NVAPI_UNSUPPORTED_CONFIG_NON_HDCP_HMD: _NvAPI_Status = -214; -#[doc = "!< GPU's Max Display Limit has Reached"] -pub const _NvAPI_Status_NVAPI_MAX_DISPLAY_LIMIT_REACHED: _NvAPI_Status = -215; -#[doc = "!< DirectMode not Enabled on the Display"] -pub const _NvAPI_Status_NVAPI_INVALID_DIRECT_MODE_DISPLAY: _NvAPI_Status = -216; -#[doc = "!< GPU is in debug mode, OC is NOT allowed."] -pub const _NvAPI_Status_NVAPI_GPU_IN_DEBUG_MODE: _NvAPI_Status = -217; -#[doc = "!< No NvAPI context was found for this D3D object"] -pub const _NvAPI_Status_NVAPI_D3D_CONTEXT_NOT_FOUND: _NvAPI_Status = -218; -#[doc = "!< there is version mismatch between stereo driver and dx driver"] -pub const _NvAPI_Status_NVAPI_STEREO_VERSION_MISMATCH: _NvAPI_Status = -219; -#[doc = "!< GPU is not powered and so the request cannot be completed."] -pub const _NvAPI_Status_NVAPI_GPU_NOT_POWERED: _NvAPI_Status = -220; -#[doc = "!< The display driver update in progress."] -pub const _NvAPI_Status_NVAPI_ERROR_DRIVER_RELOAD_IN_PROGRESS: _NvAPI_Status = -221; -#[doc = "!< Wait for HW resources allocation"] -pub const _NvAPI_Status_NVAPI_WAIT_FOR_HW_RESOURCE: _NvAPI_Status = -222; -#[doc = "!< operation requires further HDCP action"] -pub const _NvAPI_Status_NVAPI_REQUIRE_FURTHER_HDCP_ACTION: _NvAPI_Status = -223; -#[doc = "!< Dynamic Mux transition failure"] -pub const _NvAPI_Status_NVAPI_DISPLAY_MUX_TRANSITION_FAILED: _NvAPI_Status = -224; -#[doc = "!< Invalid DSC version"] -pub const _NvAPI_Status_NVAPI_INVALID_DSC_VERSION: _NvAPI_Status = -225; -#[doc = "!< Invalid DSC slice count"] -pub const _NvAPI_Status_NVAPI_INVALID_DSC_SLICECOUNT: _NvAPI_Status = -226; -#[doc = "!< Invalid DSC output BPP"] -pub const _NvAPI_Status_NVAPI_INVALID_DSC_OUTPUT_BPP: _NvAPI_Status = -227; -#[doc = "!< There was an error while loading nvapi.dll from the driver store."] -pub const _NvAPI_Status_NVAPI_FAILED_TO_LOAD_FROM_DRIVER_STORE: _NvAPI_Status = -228; -#[doc = "!< OpenGL does not export Vulkan fake extensions"] -pub const _NvAPI_Status_NVAPI_NO_VULKAN: _NvAPI_Status = -229; -#[doc = "!< A request for NvTOPPs telemetry CData has already been made and is pending a response."] -pub const _NvAPI_Status_NVAPI_REQUEST_PENDING: _NvAPI_Status = -230; -#[doc = "!< Operation cannot be performed because the resource is in use."] -pub const _NvAPI_Status_NVAPI_RESOURCE_IN_USE: _NvAPI_Status = -231; -#[doc = "!< Device kernel image is invalid"] -pub const _NvAPI_Status_NVAPI_INVALID_IMAGE: _NvAPI_Status = -232; -#[doc = "!< PTX JIT compilation failed"] -pub const _NvAPI_Status_NVAPI_INVALID_PTX: _NvAPI_Status = -233; -#[doc = "!< Uncorrectable NVLink error was detected during the execution"] -pub const _NvAPI_Status_NVAPI_NVLINK_UNCORRECTABLE: _NvAPI_Status = -234; -#[doc = "!< PTX JIT compiler library was not found."] -pub const _NvAPI_Status_NVAPI_JIT_COMPILER_NOT_FOUND: _NvAPI_Status = -235; -#[doc = "!< Device kernel source is invalid."] -pub const _NvAPI_Status_NVAPI_INVALID_SOURCE: _NvAPI_Status = -236; -#[doc = "!< While executing a kernel, the device encountered an illegal instruction."] -pub const _NvAPI_Status_NVAPI_ILLEGAL_INSTRUCTION: _NvAPI_Status = -237; -#[doc = "!< While executing a kernel, the device program counter wrapped its address space"] -pub const _NvAPI_Status_NVAPI_INVALID_PC: _NvAPI_Status = -238; -#[doc = "!< An exception occurred on the device while executing a kernel"] -pub const _NvAPI_Status_NVAPI_LAUNCH_FAILED: _NvAPI_Status = -239; -#[doc = "!< Attempted operation is not permitted."] -pub const _NvAPI_Status_NVAPI_NOT_PERMITTED: _NvAPI_Status = -240; -#[doc = "!< The callback function has already been registered."] -pub const _NvAPI_Status_NVAPI_CALLBACK_ALREADY_REGISTERED: _NvAPI_Status = -241; -#[doc = "!< The callback function is not found or not registered."] -pub const _NvAPI_Status_NVAPI_CALLBACK_NOT_FOUND: _NvAPI_Status = -242; -#[doc = "!< Invalid Wire Format for the VR HMD"] -pub const _NvAPI_Status_NVAPI_INVALID_OUTPUT_WIRE_FORMAT: _NvAPI_Status = -243; -#[doc = "! NvAPI Status Values\n! All NvAPI functions return one of these codes.\n! \\ingroup nvapistatus"] -pub type _NvAPI_Status = ::std::os::raw::c_int; -#[doc = "! NvAPI Status Values\n! All NvAPI functions return one of these codes.\n! \\ingroup nvapistatus"] -pub use self::_NvAPI_Status as NvAPI_Status; -#[doc = "! \\ingroup driverapi\n! Used in NvAPI_GPU_GetMemoryInfo()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_DISPLAY_DRIVER_MEMORY_INFO_V1 { - #[doc = "!< Version info"] - pub version: NvU32, - #[doc = "!< Size(in kb) of the physical framebuffer."] - pub dedicatedVideoMemory: NvU32, - #[doc = "!< Size(in kb) of the available physical framebuffer for allocating video memory surfaces."] - pub availableDedicatedVideoMemory: NvU32, - #[doc = "!< Size(in kb) of system memory the driver allocates at load time."] - pub systemVideoMemory: NvU32, - #[doc = "!< Size(in kb) of shared system memory that driver is allowed to commit for surfaces across all allocations."] - pub sharedSystemMemory: NvU32, -} -#[doc = "! \\ingroup driverapi\n! Used in NvAPI_GPU_GetMemoryInfo()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_DISPLAY_DRIVER_MEMORY_INFO_V2 { - #[doc = "!< Version info"] - pub version: NvU32, - #[doc = "!< Size(in kb) of the physical framebuffer."] - pub dedicatedVideoMemory: NvU32, - #[doc = "!< Size(in kb) of the available physical framebuffer for allocating video memory surfaces."] - pub availableDedicatedVideoMemory: NvU32, - #[doc = "!< Size(in kb) of system memory the driver allocates at load time."] - pub systemVideoMemory: NvU32, - #[doc = "!< Size(in kb) of shared system memory that driver is allowed to commit for surfaces across all allocations."] - pub sharedSystemMemory: NvU32, - #[doc = "!< Size(in kb) of the current available physical framebuffer for allocating video memory surfaces."] - pub curAvailableDedicatedVideoMemory: NvU32, -} -#[doc = "! \\ingroup driverapi\n! Used in NvAPI_GPU_GetMemoryInfo()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_DISPLAY_DRIVER_MEMORY_INFO_V3 { - #[doc = "!< Version info"] - pub version: NvU32, - #[doc = "!< Size(in kb) of the physical framebuffer."] - pub dedicatedVideoMemory: NvU32, - #[doc = "!< Size(in kb) of the available physical framebuffer for allocating video memory surfaces."] - pub availableDedicatedVideoMemory: NvU32, - #[doc = "!< Size(in kb) of system memory the driver allocates at load time."] - pub systemVideoMemory: NvU32, - #[doc = "!< Size(in kb) of shared system memory that driver is allowed to commit for surfaces across all allocations."] - pub sharedSystemMemory: NvU32, - #[doc = "!< Size(in kb) of the current available physical framebuffer for allocating video memory surfaces."] - pub curAvailableDedicatedVideoMemory: NvU32, - #[doc = "!< Size(in kb) of the total size of memory released as a result of the evictions."] - pub dedicatedVideoMemoryEvictionsSize: NvU32, - #[doc = "!< Indicates the number of eviction events that caused an allocation to be removed from dedicated video memory to free GPU\n!< video memory to make room for other allocations."] - pub dedicatedVideoMemoryEvictionCount: NvU32, -} -#[doc = "! \\ingroup driverapi"] -pub type NV_DISPLAY_DRIVER_MEMORY_INFO = NV_DISPLAY_DRIVER_MEMORY_INFO_V3; -#[doc = "! \\ingroup driverapi\n! Used in NvAPI_GPU_GetMemoryInfoEx()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_MEMORY_INFO_EX_V1 { - #[doc = "!< Structure version"] - pub version: NvU32, - #[doc = "!< Size(in bytes) of the physical framebuffer. Refers to the dedicated video memory on discrete GPUs."] - pub dedicatedVideoMemory: NvU64, - #[doc = "!< Size(in bytes) of the available physical framebuffer for allocating video memory surfaces."] - pub availableDedicatedVideoMemory: NvU64, - #[doc = "!< Size(in bytes) of system memory the driver allocates at load time. It is a substitute for dedicated video memory.\n!< Typically used with integrated GPUs that do not have dedicated video memory."] - pub systemVideoMemory: NvU64, - #[doc = "!< Size(in bytes) of shared system memory that driver is allowed to commit for surfaces across all allocations.\n!< On discrete GPUs, it is used to utilize system memory for various operations. It does not need to be reserved during boot.\n!< It may be used by both GPU and CPU, and has an \"on-demand\" type of usage."] - pub sharedSystemMemory: NvU64, - #[doc = "!< Size(in bytes) of the current available physical framebuffer for allocating video memory surfaces."] - pub curAvailableDedicatedVideoMemory: NvU64, - #[doc = "!< Size(in bytes) of the total size of memory released as a result of the evictions."] - pub dedicatedVideoMemoryEvictionsSize: NvU64, - #[doc = "!< Indicates the number of eviction events that caused an allocation to be removed from dedicated video memory to free GPU\n!< video memory to make room for other allocations."] - pub dedicatedVideoMemoryEvictionCount: NvU64, - #[doc = "!< Size(in bytes) of the total size of memory allocated as a result of the promotions."] - pub dedicatedVideoMemoryPromotionsSize: NvU64, - #[doc = "!< Indicates the number of promotion events that caused an allocation to be promoted to dedicated video memory"] - pub dedicatedVideoMemoryPromotionCount: NvU64, -} -#[doc = "! \\ingroup driverapi"] -pub type NV_GPU_MEMORY_INFO_EX = NV_GPU_MEMORY_INFO_EX_V1; -#[doc = "! \\ingroup dx\n! Used in NvAPI_D3D10_GetCurrentSLIState(), and NvAPI_D3D_GetCurrentSLIState()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GET_CURRENT_SLI_STATE_V1 { - #[doc = "!< Structure version"] - pub version: NvU32, - #[doc = "!< [OUT] The maximum possible value of numAFRGroups"] - pub maxNumAFRGroups: NvU32, - #[doc = "!< [OUT] The number of AFR groups enabled in the system"] - pub numAFRGroups: NvU32, - #[doc = "!< [OUT] The AFR group index for the frame currently being rendered"] - pub currentAFRIndex: NvU32, - #[doc = "!< [OUT] What the AFR group index will be for the next frame (i.e. after calling Present)"] - pub nextFrameAFRIndex: NvU32, - #[doc = "!< [OUT] The AFR group index that was used for the previous frame (~0 if more than one frame has not been rendered yet)"] - pub previousFrameAFRIndex: NvU32, - #[doc = "!< [OUT] Boolean: Is this frame the first time running on the current AFR group"] - pub bIsCurAFRGroupNew: NvU32, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GET_CURRENT_SLI_STATE_V2 { - #[doc = "!< Structure version"] - pub version: NvU32, - #[doc = "!< [OUT] The maximum possible value of numAFRGroups"] - pub maxNumAFRGroups: NvU32, - #[doc = "!< [OUT] The number of AFR groups enabled in the system"] - pub numAFRGroups: NvU32, - #[doc = "!< [OUT] The AFR group index for the frame currently being rendered"] - pub currentAFRIndex: NvU32, - #[doc = "!< [OUT] What the AFR group index will be for the next frame (i.e. after calling Present)"] - pub nextFrameAFRIndex: NvU32, - #[doc = "!< [OUT] The AFR group index that was used for the previous frame (~0 if more than one frame has not been rendered yet)"] - pub previousFrameAFRIndex: NvU32, - #[doc = "!< [OUT] Boolean: Is this frame the first time running on the current AFR group"] - pub bIsCurAFRGroupNew: NvU32, - #[doc = "!< [OUT] The number of GPUs used in VR-SLI. If it is 0 VR-SLI is not active"] - pub numVRSLIGpus: NvU32, -} -pub const _NV_StereoActiveEye_NVAPI_STEREO_EYE_RIGHT: _NV_StereoActiveEye = 1; -pub const _NV_StereoActiveEye_NVAPI_STEREO_EYE_LEFT: _NV_StereoActiveEye = 2; -pub const _NV_StereoActiveEye_NVAPI_STEREO_EYE_MONO: _NV_StereoActiveEye = 3; -#[doc = "! \\ingroup stereoapi"] -pub type _NV_StereoActiveEye = ::std::os::raw::c_int; -#[doc = "! \\ingroup stereoapi"] -pub use self::_NV_StereoActiveEye as NV_STEREO_ACTIVE_EYE; -pub const _NV_StereoDriverMode_NVAPI_STEREO_DRIVER_MODE_AUTOMATIC: _NV_StereoDriverMode = 0; -pub const _NV_StereoDriverMode_NVAPI_STEREO_DRIVER_MODE_DIRECT: _NV_StereoDriverMode = 2; -#[doc = "! \\ingroup stereoapi"] -pub type _NV_StereoDriverMode = ::std::os::raw::c_int; -#[doc = "! \\ingroup stereoapi"] -pub use self::_NV_StereoDriverMode as NV_STEREO_DRIVER_MODE; -pub const _NV_DP_LINK_RATE_NV_DP_1_62GBPS: _NV_DP_LINK_RATE = 6; -pub const _NV_DP_LINK_RATE_NV_DP_2_70GBPS: _NV_DP_LINK_RATE = 10; -pub const _NV_DP_LINK_RATE_NV_DP_5_40GBPS: _NV_DP_LINK_RATE = 20; -pub const _NV_DP_LINK_RATE_NV_DP_8_10GBPS: _NV_DP_LINK_RATE = 30; -pub const _NV_DP_LINK_RATE_NV_EDP_2_16GBPS: _NV_DP_LINK_RATE = 8; -pub const _NV_DP_LINK_RATE_NV_EDP_2_43GBPS: _NV_DP_LINK_RATE = 9; -pub const _NV_DP_LINK_RATE_NV_EDP_3_24GBPS: _NV_DP_LINK_RATE = 12; -pub const _NV_DP_LINK_RATE_NV_EDP_4_32GBPS: _NV_DP_LINK_RATE = 16; -#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] -pub type _NV_DP_LINK_RATE = ::std::os::raw::c_int; -#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] -pub use self::_NV_DP_LINK_RATE as NV_DP_LINK_RATE; -pub const _NV_DP2X_LINK_RATE_NV_DP2X_1_62Gbps: _NV_DP2X_LINK_RATE = 162; -pub const _NV_DP2X_LINK_RATE_NV_DP2X_2_16Gbps: _NV_DP2X_LINK_RATE = 216; -pub const _NV_DP2X_LINK_RATE_NV_DP2X_2_43Gbps: _NV_DP2X_LINK_RATE = 243; -pub const _NV_DP2X_LINK_RATE_NV_DP2X_2_50Gbps: _NV_DP2X_LINK_RATE = 250; -pub const _NV_DP2X_LINK_RATE_NV_DP2X_2_70Gbps: _NV_DP2X_LINK_RATE = 270; -pub const _NV_DP2X_LINK_RATE_NV_DP2X_3_24Gbps: _NV_DP2X_LINK_RATE = 324; -pub const _NV_DP2X_LINK_RATE_NV_DP2X_4_32Gbps: _NV_DP2X_LINK_RATE = 432; -pub const _NV_DP2X_LINK_RATE_NV_DP2X_5_40Gbps: _NV_DP2X_LINK_RATE = 540; -pub const _NV_DP2X_LINK_RATE_NV_DP2X_6_75Gbps: _NV_DP2X_LINK_RATE = 675; -pub const _NV_DP2X_LINK_RATE_NV_DP2X_8_10Gbps: _NV_DP2X_LINK_RATE = 810; -pub const _NV_DP2X_LINK_RATE_NV_DP2X_10_0Gbps: _NV_DP2X_LINK_RATE = 1000; -pub const _NV_DP2X_LINK_RATE_NV_DP2X_13_5Gbps: _NV_DP2X_LINK_RATE = 1350; -pub const _NV_DP2X_LINK_RATE_NV_DP2X_20_0Gbps: _NV_DP2X_LINK_RATE = 2000; -pub type _NV_DP2X_LINK_RATE = ::std::os::raw::c_int; -pub use self::_NV_DP2X_LINK_RATE as NV_DP2X_LINK_RATE; -pub const _NV_DP_LANE_COUNT_NV_DP_1_LANE: _NV_DP_LANE_COUNT = 1; -pub const _NV_DP_LANE_COUNT_NV_DP_2_LANE: _NV_DP_LANE_COUNT = 2; -pub const _NV_DP_LANE_COUNT_NV_DP_4_LANE: _NV_DP_LANE_COUNT = 4; -#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] -pub type _NV_DP_LANE_COUNT = ::std::os::raw::c_int; -#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] -pub use self::_NV_DP_LANE_COUNT as NV_DP_LANE_COUNT; -pub const _NV_DP_COLOR_FORMAT_NV_DP_COLOR_FORMAT_RGB: _NV_DP_COLOR_FORMAT = 0; -pub const _NV_DP_COLOR_FORMAT_NV_DP_COLOR_FORMAT_YCbCr422: _NV_DP_COLOR_FORMAT = 1; -pub const _NV_DP_COLOR_FORMAT_NV_DP_COLOR_FORMAT_YCbCr444: _NV_DP_COLOR_FORMAT = 2; -#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] -pub type _NV_DP_COLOR_FORMAT = ::std::os::raw::c_int; -#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] -pub use self::_NV_DP_COLOR_FORMAT as NV_DP_COLOR_FORMAT; -pub const _NV_DP_COLORIMETRY_NV_DP_COLORIMETRY_RGB: _NV_DP_COLORIMETRY = 0; -pub const _NV_DP_COLORIMETRY_NV_DP_COLORIMETRY_YCbCr_ITU601: _NV_DP_COLORIMETRY = 1; -pub const _NV_DP_COLORIMETRY_NV_DP_COLORIMETRY_YCbCr_ITU709: _NV_DP_COLORIMETRY = 2; -#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] -pub type _NV_DP_COLORIMETRY = ::std::os::raw::c_int; -#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] -pub use self::_NV_DP_COLORIMETRY as NV_DP_COLORIMETRY; -pub const _NV_DP_DYNAMIC_RANGE_NV_DP_DYNAMIC_RANGE_VESA: _NV_DP_DYNAMIC_RANGE = 0; -pub const _NV_DP_DYNAMIC_RANGE_NV_DP_DYNAMIC_RANGE_CEA: _NV_DP_DYNAMIC_RANGE = 1; -#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] -pub type _NV_DP_DYNAMIC_RANGE = ::std::os::raw::c_int; -#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] -pub use self::_NV_DP_DYNAMIC_RANGE as NV_DP_DYNAMIC_RANGE; -pub const _NV_DP_BPC_NV_DP_BPC_DEFAULT: _NV_DP_BPC = 0; -pub const _NV_DP_BPC_NV_DP_BPC_6: _NV_DP_BPC = 1; -pub const _NV_DP_BPC_NV_DP_BPC_8: _NV_DP_BPC = 2; -pub const _NV_DP_BPC_NV_DP_BPC_10: _NV_DP_BPC = 3; -pub const _NV_DP_BPC_NV_DP_BPC_12: _NV_DP_BPC = 4; -pub const _NV_DP_BPC_NV_DP_BPC_16: _NV_DP_BPC = 5; -#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] -pub type _NV_DP_BPC = ::std::os::raw::c_int; -#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] -pub use self::_NV_DP_BPC as NV_DP_BPC; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_EDID_V1 { - pub version: NvU32, - pub EDID_Data: [NvU8; 256usize], -} -#[doc = "! Used in NvAPI_GPU_GetEDID()"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_EDID_V2 { - #[doc = "!< Structure version"] - pub version: NvU32, - pub EDID_Data: [NvU8; 256usize], - pub sizeofEDID: NvU32, -} -#[doc = "! Used in NvAPI_GPU_GetEDID()"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_EDID_V3 { - #[doc = "!< Structure version"] - pub version: NvU32, - pub EDID_Data: [NvU8; 256usize], - pub sizeofEDID: NvU32, - #[doc = "!< ID which always returned in a monotonically increasing counter.\n!< Across a split-EDID read we need to verify that all calls returned the same edidId.\n!< This counter is incremented if we get the updated EDID."] - pub edidId: NvU32, - #[doc = "!< Which 256-byte page of the EDID we want to read. Start at 0.\n!< If the read succeeds with edidSize > NV_EDID_DATA_SIZE,\n!< call back again with offset+256 until we have read the entire buffer"] - pub offset: NvU32, -} -#[doc = "! Used in NvAPI_GPU_GetEDID()"] -pub type NV_EDID = NV_EDID_V3; -#[doc = "!< the EDID which is actively used by the driver, it could be _RAW/_COOKED/_FORCED/_INF."] -pub const NV_EDID_FLAG_NV_EDID_FLAG_DEFAULT: NV_EDID_FLAG = 0; -#[doc = "!< the EDID which is not modified by the driver. If there's no _FORCED edid engaged, it\n!< will be the unmodified monitor EDID from the I2C bus. Otherwise it is original _FORCED edid."] -pub const NV_EDID_FLAG_NV_EDID_FLAG_RAW: NV_EDID_FLAG = 1; -#[doc = "!< the EDID has been modified by the driver for compatibility"] -pub const NV_EDID_FLAG_NV_EDID_FLAG_COOKED: NV_EDID_FLAG = 2; -#[doc = "!< the EDID is forced by the end-user over s/w interface,"] -pub const NV_EDID_FLAG_NV_EDID_FLAG_FORCED: NV_EDID_FLAG = 3; -#[doc = "!< the EDID is from monitor INF"] -pub const NV_EDID_FLAG_NV_EDID_FLAG_INF: NV_EDID_FLAG = 4; -#[doc = "!< the EDID is from the monitor over I2C bus without any modification."] -pub const NV_EDID_FLAG_NV_EDID_FLAG_HW: NV_EDID_FLAG = 5; -pub type NV_EDID_FLAG = ::std::os::raw::c_int; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_VGA_15_PIN: _NV_GPU_CONNECTOR_TYPE = 0; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_TV_COMPOSITE: _NV_GPU_CONNECTOR_TYPE = 16; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_TV_SVIDEO: _NV_GPU_CONNECTOR_TYPE = 17; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_TV_HDTV_COMPONENT: _NV_GPU_CONNECTOR_TYPE = 19; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_TV_SCART: _NV_GPU_CONNECTOR_TYPE = 20; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_TV_COMPOSITE_SCART_ON_EIAJ4120: - _NV_GPU_CONNECTOR_TYPE = 22; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_TV_HDTV_EIAJ4120: _NV_GPU_CONNECTOR_TYPE = 23; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_PC_POD_HDTV_YPRPB: _NV_GPU_CONNECTOR_TYPE = 24; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_PC_POD_SVIDEO: _NV_GPU_CONNECTOR_TYPE = 25; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_PC_POD_COMPOSITE: _NV_GPU_CONNECTOR_TYPE = 26; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DVI_I_TV_SVIDEO: _NV_GPU_CONNECTOR_TYPE = 32; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DVI_I_TV_COMPOSITE: _NV_GPU_CONNECTOR_TYPE = - 33; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DVI_I: _NV_GPU_CONNECTOR_TYPE = 48; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DVI_D: _NV_GPU_CONNECTOR_TYPE = 49; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_ADC: _NV_GPU_CONNECTOR_TYPE = 50; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_LFH_DVI_I_1: _NV_GPU_CONNECTOR_TYPE = 56; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_LFH_DVI_I_2: _NV_GPU_CONNECTOR_TYPE = 57; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_SPWG: _NV_GPU_CONNECTOR_TYPE = 64; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_OEM: _NV_GPU_CONNECTOR_TYPE = 65; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DISPLAYPORT_EXTERNAL: _NV_GPU_CONNECTOR_TYPE = - 70; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DISPLAYPORT_INTERNAL: _NV_GPU_CONNECTOR_TYPE = - 71; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DISPLAYPORT_MINI_EXT: _NV_GPU_CONNECTOR_TYPE = - 72; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_HDMI_A: _NV_GPU_CONNECTOR_TYPE = 97; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_HDMI_C_MINI: _NV_GPU_CONNECTOR_TYPE = 99; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_LFH_DISPLAYPORT_1: _NV_GPU_CONNECTOR_TYPE = - 100; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_LFH_DISPLAYPORT_2: _NV_GPU_CONNECTOR_TYPE = - 101; -#[doc = "!< Deprecated."] -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_VIRTUAL_WFD: _NV_GPU_CONNECTOR_TYPE = 112; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_USB_C: _NV_GPU_CONNECTOR_TYPE = 113; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_UNKNOWN: _NV_GPU_CONNECTOR_TYPE = -1; -#[doc = "! \\ingroup gpu\n! Used in NV_GPU_CONNECTOR_DATA"] -pub type _NV_GPU_CONNECTOR_TYPE = ::std::os::raw::c_int; -#[doc = "! \\ingroup gpu\n! Used in NV_GPU_CONNECTOR_DATA"] -pub use self::_NV_GPU_CONNECTOR_TYPE as NV_GPU_CONNECTOR_TYPE; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_NONE: _NV_DISPLAY_TV_FORMAT = 0; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_NTSCM: _NV_DISPLAY_TV_FORMAT = 1; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_NTSCJ: _NV_DISPLAY_TV_FORMAT = 2; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_PALM: _NV_DISPLAY_TV_FORMAT = 4; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_PALBDGH: _NV_DISPLAY_TV_FORMAT = 8; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_PALN: _NV_DISPLAY_TV_FORMAT = 16; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_PALNC: _NV_DISPLAY_TV_FORMAT = 32; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_576i: _NV_DISPLAY_TV_FORMAT = 256; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_480i: _NV_DISPLAY_TV_FORMAT = 512; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_ED_480p: _NV_DISPLAY_TV_FORMAT = 1024; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_ED_576p: _NV_DISPLAY_TV_FORMAT = 2048; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_720p: _NV_DISPLAY_TV_FORMAT = 4096; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_1080i: _NV_DISPLAY_TV_FORMAT = 8192; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_1080p: _NV_DISPLAY_TV_FORMAT = 16384; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_720p50: _NV_DISPLAY_TV_FORMAT = 32768; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_1080p24: _NV_DISPLAY_TV_FORMAT = 65536; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_1080i50: _NV_DISPLAY_TV_FORMAT = 131072; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_1080p50: _NV_DISPLAY_TV_FORMAT = 262144; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp30: _NV_DISPLAY_TV_FORMAT = 524288; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp30_3840: _NV_DISPLAY_TV_FORMAT = 524288; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp25: _NV_DISPLAY_TV_FORMAT = 1048576; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp25_3840: _NV_DISPLAY_TV_FORMAT = - 1048576; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp24: _NV_DISPLAY_TV_FORMAT = 2097152; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp24_3840: _NV_DISPLAY_TV_FORMAT = - 2097152; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp24_SMPTE: _NV_DISPLAY_TV_FORMAT = - 4194304; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp50_3840: _NV_DISPLAY_TV_FORMAT = - 8388608; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp60_3840: _NV_DISPLAY_TV_FORMAT = - 9437184; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp30_4096: _NV_DISPLAY_TV_FORMAT = - 10485760; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp25_4096: _NV_DISPLAY_TV_FORMAT = - 11534336; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp24_4096: _NV_DISPLAY_TV_FORMAT = - 12582912; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp50_4096: _NV_DISPLAY_TV_FORMAT = - 13631488; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp60_4096: _NV_DISPLAY_TV_FORMAT = - 14680064; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp24_7680: _NV_DISPLAY_TV_FORMAT = - 16777216; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp25_7680: _NV_DISPLAY_TV_FORMAT = - 33554432; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp30_7680: _NV_DISPLAY_TV_FORMAT = - 67108864; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp48_7680: _NV_DISPLAY_TV_FORMAT = - 134217728; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp50_7680: _NV_DISPLAY_TV_FORMAT = - 150994944; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp60_7680: _NV_DISPLAY_TV_FORMAT = - 167772160; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp100_7680: _NV_DISPLAY_TV_FORMAT = - 184549376; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp120_7680: _NV_DISPLAY_TV_FORMAT = - 201326592; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp48_3840: _NV_DISPLAY_TV_FORMAT = - 218103808; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp48_4096: _NV_DISPLAY_TV_FORMAT = - 234881024; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp100_4096: _NV_DISPLAY_TV_FORMAT = - 251658240; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp100_3840: _NV_DISPLAY_TV_FORMAT = - 268435456; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp120_4096: _NV_DISPLAY_TV_FORMAT = - 285212672; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp120_3840: _NV_DISPLAY_TV_FORMAT = - 301989888; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp100_5120: _NV_DISPLAY_TV_FORMAT = - 318767104; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp120_5120: _NV_DISPLAY_TV_FORMAT = - 335544320; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp24_5120: _NV_DISPLAY_TV_FORMAT = - 352321536; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp25_5120: _NV_DISPLAY_TV_FORMAT = - 369098752; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp30_5120: _NV_DISPLAY_TV_FORMAT = - 385875968; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp48_5120: _NV_DISPLAY_TV_FORMAT = - 402653184; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp50_5120: _NV_DISPLAY_TV_FORMAT = - 419430400; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp60_5120: _NV_DISPLAY_TV_FORMAT = - 536870912; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp24_10240: _NV_DISPLAY_TV_FORMAT = - 553648128; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp25_10240: _NV_DISPLAY_TV_FORMAT = - 570425344; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp30_10240: _NV_DISPLAY_TV_FORMAT = - 587202560; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp48_10240: _NV_DISPLAY_TV_FORMAT = - 603979776; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp50_10240: _NV_DISPLAY_TV_FORMAT = - 620756992; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp60_10240: _NV_DISPLAY_TV_FORMAT = - 637534208; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp100_10240: _NV_DISPLAY_TV_FORMAT = - 654311424; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp120_10240: _NV_DISPLAY_TV_FORMAT = - 671088640; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_OTHER: _NV_DISPLAY_TV_FORMAT = 805306368; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_ED_OTHER: _NV_DISPLAY_TV_FORMAT = 1073741824; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_OTHER: _NV_DISPLAY_TV_FORMAT = 1342177280; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_ANY: _NV_DISPLAY_TV_FORMAT = -2147483648; -#[doc = "! \\ingroup tvapi\n! Used in NV_DISPLAY_TV_OUTPUT_INFO"] -pub type _NV_DISPLAY_TV_FORMAT = ::std::os::raw::c_int; -#[doc = "! \\ingroup tvapi\n! Used in NV_DISPLAY_TV_OUTPUT_INFO"] -pub use self::_NV_DISPLAY_TV_FORMAT as NV_DISPLAY_TV_FORMAT; -pub const _NV_TARGET_VIEW_MODE_NV_VIEW_MODE_STANDARD: _NV_TARGET_VIEW_MODE = 0; -pub const _NV_TARGET_VIEW_MODE_NV_VIEW_MODE_CLONE: _NV_TARGET_VIEW_MODE = 1; -pub const _NV_TARGET_VIEW_MODE_NV_VIEW_MODE_HSPAN: _NV_TARGET_VIEW_MODE = 2; -pub const _NV_TARGET_VIEW_MODE_NV_VIEW_MODE_VSPAN: _NV_TARGET_VIEW_MODE = 3; -pub const _NV_TARGET_VIEW_MODE_NV_VIEW_MODE_DUALVIEW: _NV_TARGET_VIEW_MODE = 4; -pub const _NV_TARGET_VIEW_MODE_NV_VIEW_MODE_MULTIVIEW: _NV_TARGET_VIEW_MODE = 5; -#[doc = "! Used in NvAPI_SetView()."] -pub type _NV_TARGET_VIEW_MODE = ::std::os::raw::c_int; -#[doc = "! Used in NvAPI_SetView()."] -pub use self::_NV_TARGET_VIEW_MODE as NV_TARGET_VIEW_MODE; -#[doc = "!< No change"] -pub const _NV_SCALING_NV_SCALING_DEFAULT: _NV_SCALING = 0; -#[doc = "!< Balanced - Full Screen"] -pub const _NV_SCALING_NV_SCALING_GPU_SCALING_TO_CLOSEST: _NV_SCALING = 1; -#[doc = "!< Force GPU - Full Screen"] -pub const _NV_SCALING_NV_SCALING_GPU_SCALING_TO_NATIVE: _NV_SCALING = 2; -#[doc = "!< Force GPU - Centered\\No Scaling"] -pub const _NV_SCALING_NV_SCALING_GPU_SCANOUT_TO_NATIVE: _NV_SCALING = 3; -#[doc = "!< Force GPU - Aspect Ratio"] -pub const _NV_SCALING_NV_SCALING_GPU_SCALING_TO_ASPECT_SCANOUT_TO_NATIVE: _NV_SCALING = 5; -#[doc = "!< Balanced - Aspect Ratio"] -pub const _NV_SCALING_NV_SCALING_GPU_SCALING_TO_ASPECT_SCANOUT_TO_CLOSEST: _NV_SCALING = 6; -#[doc = "!< Balanced - Centered\\No Scaling"] -pub const _NV_SCALING_NV_SCALING_GPU_SCANOUT_TO_CLOSEST: _NV_SCALING = 7; -#[doc = "!< Force GPU - Integer Scaling"] -pub const _NV_SCALING_NV_SCALING_GPU_INTEGER_ASPECT_SCALING: _NV_SCALING = 8; -pub const _NV_SCALING_NV_SCALING_MONITOR_SCALING: _NV_SCALING = 1; -pub const _NV_SCALING_NV_SCALING_ADAPTER_SCALING: _NV_SCALING = 2; -pub const _NV_SCALING_NV_SCALING_CENTERED: _NV_SCALING = 3; -pub const _NV_SCALING_NV_SCALING_ASPECT_SCALING: _NV_SCALING = 5; -#[doc = "!< For future use"] -pub const _NV_SCALING_NV_SCALING_CUSTOMIZED: _NV_SCALING = 255; -#[doc = "! Scaling modes - used in NvAPI_SetViewEx().\n! \\ingroup dispcontrol"] -pub type _NV_SCALING = ::std::os::raw::c_int; -#[doc = "! Scaling modes - used in NvAPI_SetViewEx().\n! \\ingroup dispcontrol"] -pub use self::_NV_SCALING as NV_SCALING; -pub const _NV_ROTATE_NV_ROTATE_0: _NV_ROTATE = 0; -pub const _NV_ROTATE_NV_ROTATE_90: _NV_ROTATE = 1; -pub const _NV_ROTATE_NV_ROTATE_180: _NV_ROTATE = 2; -pub const _NV_ROTATE_NV_ROTATE_270: _NV_ROTATE = 3; -pub const _NV_ROTATE_NV_ROTATE_IGNORED: _NV_ROTATE = 4; -#[doc = "! \\ingroup dispcontrol"] -pub type _NV_ROTATE = ::std::os::raw::c_int; -#[doc = "! \\ingroup dispcontrol"] -pub use self::_NV_ROTATE as NV_ROTATE; -#[doc = "!< unknown. Driver will choose one as following value."] -pub const _NV_FORMAT_NV_FORMAT_UNKNOWN: _NV_FORMAT = 0; -#[doc = "!< for 8bpp mode"] -pub const _NV_FORMAT_NV_FORMAT_P8: _NV_FORMAT = 41; -#[doc = "!< for 16bpp mode"] -pub const _NV_FORMAT_NV_FORMAT_R5G6B5: _NV_FORMAT = 23; -#[doc = "!< for 32bpp mode"] -pub const _NV_FORMAT_NV_FORMAT_A8R8G8B8: _NV_FORMAT = 21; -#[doc = "!< for 64bpp(floating point) mode."] -pub const _NV_FORMAT_NV_FORMAT_A16B16G16R16F: _NV_FORMAT = 113; -#[doc = "! Color formats- used in NvAPI_SetViewEx().\n! \\ingroup dispcontrol"] -pub type _NV_FORMAT = ::std::os::raw::c_int; -#[doc = "! Color formats- used in NvAPI_SetViewEx().\n! \\ingroup dispcontrol"] -pub use self::_NV_FORMAT as NV_FORMAT; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_VIEWPORTF { - #[doc = "!< x-coordinate of the viewport top-left point"] - pub x: f32, - #[doc = "!< y-coordinate of the viewport top-left point"] - pub y: f32, - #[doc = "!< Width of the viewport"] - pub w: f32, - #[doc = "!< Height of the viewport"] - pub h: f32, -} -#[doc = "!< get the current timing"] -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_CURRENT: _NV_TIMING_OVERRIDE = 0; -#[doc = "!< the timing the driver will use based the current policy"] -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_AUTO: _NV_TIMING_OVERRIDE = 1; -#[doc = "!< EDID timing"] -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_EDID: _NV_TIMING_OVERRIDE = 2; -#[doc = "!< VESA DMT timing"] -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_DMT: _NV_TIMING_OVERRIDE = 3; -#[doc = "!< VESA DMT timing with reduced blanking"] -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_DMT_RB: _NV_TIMING_OVERRIDE = 4; -#[doc = "!< VESA CVT timing"] -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_CVT: _NV_TIMING_OVERRIDE = 5; -#[doc = "!< VESA CVT timing with reduced blanking"] -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_CVT_RB: _NV_TIMING_OVERRIDE = 6; -#[doc = "!< VESA GTF timing"] -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_GTF: _NV_TIMING_OVERRIDE = 7; -#[doc = "!< EIA 861x pre-defined timing"] -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_EIA861: _NV_TIMING_OVERRIDE = 8; -#[doc = "!< analog SD/HDTV timing"] -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_ANALOG_TV: _NV_TIMING_OVERRIDE = 9; -#[doc = "!< NV custom timings"] -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_CUST: _NV_TIMING_OVERRIDE = 10; -#[doc = "!< NV pre-defined timing (basically the PsF timings)"] -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_NV_PREDEFINED: _NV_TIMING_OVERRIDE = 11; -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_NV_PSF: _NV_TIMING_OVERRIDE = 11; -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_NV_ASPR: _NV_TIMING_OVERRIDE = 12; -#[doc = "!< Override for SDI timing"] -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_SDI: _NV_TIMING_OVERRIDE = 13; -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVRRIDE_MAX: _NV_TIMING_OVERRIDE = 14; -#[doc = "! \\ingroup dispcontrol\n! The timing override is not supported yet; must be set to _AUTO. \\n"] -pub type _NV_TIMING_OVERRIDE = ::std::os::raw::c_int; -#[doc = "! \\ingroup dispcontrol\n! The timing override is not supported yet; must be set to _AUTO. \\n"] -pub use self::_NV_TIMING_OVERRIDE as NV_TIMING_OVERRIDE; -#[doc = "! \\ingroup dispcontrol\n! NVIDIA-specific timing extras \\n\n! Used in NV_TIMING."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct tagNV_TIMINGEXT { - #[doc = "!< Reserved for NVIDIA hardware-based enhancement, such as double-scan."] - pub flag: NvU32, - #[doc = "!< Logical refresh rate to present"] - pub rr: NvU16, - #[doc = "!< Physical vertical refresh rate in 0.001Hz"] - pub rrx1k: NvU32, - #[doc = "!< Display aspect ratio Hi(aspect):horizontal-aspect, Low(aspect):vertical-aspect"] - pub aspect: NvU32, - #[doc = "!< Bit-wise pixel repetition factor: 0x1:no pixel repetition; 0x2:each pixel repeats twice horizontally,.."] - pub rep: NvU16, - #[doc = "!< Timing standard"] - pub status: NvU32, - #[doc = "!< Timing name"] - pub name: [NvU8; 40usize], -} -#[doc = "! \\ingroup dispcontrol\n! NVIDIA-specific timing extras \\n\n! Used in NV_TIMING."] -pub type NV_TIMINGEXT = tagNV_TIMINGEXT; -#[doc = "! \\ingroup dispcontrol\n!The very basic timing structure based on the VESA standard:\n! \\code\n! |<----------------------------htotal--------------------------->|\n! ---------\"active\" video-------->|<-------blanking------>|<-----\n! |<-------hvisible-------->|<-hb->|<-hfp->|<-hsw->|<-hbp->|<-hb->|\n! --------- -+-------------------------+ | | | | |\n! A A | | | | | | |\n! : : | | | | | | |\n! : : | | | | | | |\n! :vertical| addressable video | | | | | |\n! : visible| | | | | | |\n! : : | | | | | | |\n! : : | | | | | | |\n! vertical V | | | | | | |\n! total --+-------------------------+ | | | | |\n! : vb border | | | | |\n! : -----------------------------------+ | | | |\n! : vfp front porch | | | |\n! : -------------------------------------------+ | | |\n! : vsw sync width | | |\n! : ---------------------------------------------------+ | |\n! : vbp back porch | |\n! : -----------------------------------------------------------+ |\n! V vb border |\n! ---------------------------------------------------------------------------+\n! \\endcode"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_TIMING { - #[doc = "!< horizontal visible"] - pub HVisible: NvU16, - #[doc = "!< horizontal border"] - pub HBorder: NvU16, - #[doc = "!< horizontal front porch"] - pub HFrontPorch: NvU16, - #[doc = "!< horizontal sync width"] - pub HSyncWidth: NvU16, - #[doc = "!< horizontal total"] - pub HTotal: NvU16, - #[doc = "!< horizontal sync polarity: 1-negative, 0-positive"] - pub HSyncPol: NvU8, - #[doc = "!< vertical visible"] - pub VVisible: NvU16, - #[doc = "!< vertical border"] - pub VBorder: NvU16, - #[doc = "!< vertical front porch"] - pub VFrontPorch: NvU16, - #[doc = "!< vertical sync width"] - pub VSyncWidth: NvU16, - #[doc = "!< vertical total"] - pub VTotal: NvU16, - #[doc = "!< vertical sync polarity: 1-negative, 0-positive"] - pub VSyncPol: NvU8, - #[doc = "!< 1-interlaced, 0-progressive"] - pub interlaced: NvU16, - #[doc = "!< pixel clock in 10 kHz"] - pub pclk: NvU32, - pub etc: NV_TIMINGEXT, -} -#[doc = "! \\ingroup dispcontrol\n!The very basic timing structure based on the VESA standard:\n! \\code\n! |<----------------------------htotal--------------------------->|\n! ---------\"active\" video-------->|<-------blanking------>|<-----\n! |<-------hvisible-------->|<-hb->|<-hfp->|<-hsw->|<-hbp->|<-hb->|\n! --------- -+-------------------------+ | | | | |\n! A A | | | | | | |\n! : : | | | | | | |\n! : : | | | | | | |\n! :vertical| addressable video | | | | | |\n! : visible| | | | | | |\n! : : | | | | | | |\n! : : | | | | | | |\n! vertical V | | | | | | |\n! total --+-------------------------+ | | | | |\n! : vb border | | | | |\n! : -----------------------------------+ | | | |\n! : vfp front porch | | | |\n! : -------------------------------------------+ | | |\n! : vsw sync width | | |\n! : ---------------------------------------------------+ | |\n! : vbp back porch | |\n! : -----------------------------------------------------------+ |\n! V vb border |\n! ---------------------------------------------------------------------------+\n! \\endcode"] -pub type NV_TIMING = _NV_TIMING; -#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_SetView() and NvAPI_GetView()"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_VIEW_TARGET_INFO { - #[doc = "!< (IN) structure version"] - pub version: NvU32, - #[doc = "!< (IN) target count"] - pub count: NvU32, - pub target: [NV_VIEW_TARGET_INFO__bindgen_ty_1; 2usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_VIEW_TARGET_INFO__bindgen_ty_1 { - #[doc = "!< (IN/OUT) Device mask"] - pub deviceMask: NvU32, - #[doc = "!< (IN/OUT) Source ID - values will be based on the number of heads exposed per GPU."] - pub sourceId: NvU32, - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, - pub __bindgen_padding_0: [u8; 3usize], -} -impl NV_VIEW_TARGET_INFO__bindgen_ty_1 { - #[inline] - pub fn bPrimary(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bPrimary(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bPrimary_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bPrimary_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bInterlaced(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_bInterlaced(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bInterlaced_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bInterlaced_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bGDIPrimary(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_bGDIPrimary(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bGDIPrimary_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bGDIPrimary_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bForceModeSet(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_bForceModeSet(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bForceModeSet_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bForceModeSet_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bPrimary: NvU32, - bInterlaced: NvU32, - bGDIPrimary: NvU32, - bForceModeSet: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bPrimary: u32 = unsafe { ::std::mem::transmute(bPrimary) }; - bPrimary as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let bInterlaced: u32 = unsafe { ::std::mem::transmute(bInterlaced) }; - bInterlaced as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let bGDIPrimary: u32 = unsafe { ::std::mem::transmute(bGDIPrimary) }; - bGDIPrimary as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let bForceModeSet: u32 = unsafe { ::std::mem::transmute(bForceModeSet) }; - bForceModeSet as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PATH_INFO."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_DISPLAY_PATH { - #[doc = "!< (IN) Device mask"] - pub deviceMask: NvU32, - #[doc = "!< (IN) Values will be based on the number of heads exposed per GPU(0, 1?)"] - pub sourceId: NvU32, - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, - #[doc = "!< (IN) Specify connector type. For TV only."] - pub connector: NV_GPU_CONNECTOR_TYPE, - #[doc = "!< (IN) Width of the mode"] - pub width: NvU32, - #[doc = "!< (IN) Height of the mode"] - pub height: NvU32, - #[doc = "!< (IN) Depth of the mode"] - pub depth: NvU32, - #[doc = "!< Color format if it needs to be specified. Not used now."] - pub colorFormat: NV_FORMAT, - #[doc = "!< (IN) Rotation setting."] - pub rotation: NV_ROTATE, - #[doc = "!< (IN) Scaling setting"] - pub scaling: NV_SCALING, - #[doc = "!< (IN) Refresh rate of the mode"] - pub refreshRate: NvU32, - pub _bitfield_align_2: [u8; 0], - pub _bitfield_2: __BindgenBitfieldUnit<[u8; 1usize]>, - #[doc = "!< (IN) To choose the last TV format set this value to NV_DISPLAY_TV_FORMAT_NONE"] - pub tvFormat: NV_DISPLAY_TV_FORMAT, - #[doc = "!< (IN/OUT) X-offset of this display on the Windows desktop"] - pub posx: NvU32, - #[doc = "!< (IN/OUT) Y-offset of this display on the Windows desktop"] - pub posy: NvU32, - pub _bitfield_align_3: [u32; 0], - pub _bitfield_3: __BindgenBitfieldUnit<[u8; 4usize]>, -} -impl NV_DISPLAY_PATH { - #[inline] - pub fn bPrimary(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bPrimary(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bPrimary_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bPrimary_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1(bPrimary: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bPrimary: u32 = unsafe { ::std::mem::transmute(bPrimary) }; - bPrimary as u64 - }); - __bindgen_bitfield_unit - } - #[inline] - pub fn interlaced(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_interlaced(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_2.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn interlaced_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_2), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_interlaced_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_2), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_2(interlaced: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let interlaced: u32 = unsafe { ::std::mem::transmute(interlaced) }; - interlaced as u64 - }); - __bindgen_bitfield_unit - } - #[inline] - pub fn bGDIPrimary(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_3.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bGDIPrimary(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_3.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bGDIPrimary_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_3), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bGDIPrimary_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_3), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bForceModeSet(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_3.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_bForceModeSet(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_3.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bForceModeSet_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_3), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bForceModeSet_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_3), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bFocusDisplay(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_3.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_bFocusDisplay(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_3.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bFocusDisplay_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_3), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bFocusDisplay_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_3), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn gpuId(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_3.get(3usize, 24u8) as u32) } - } - #[inline] - pub fn set_gpuId(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_3.set(3usize, 24u8, val as u64) - } - } - #[inline] - pub unsafe fn gpuId_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_3), - 3usize, - 24u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_gpuId_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_3), - 3usize, - 24u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_3( - bGDIPrimary: NvU32, - bForceModeSet: NvU32, - bFocusDisplay: NvU32, - gpuId: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bGDIPrimary: u32 = unsafe { ::std::mem::transmute(bGDIPrimary) }; - bGDIPrimary as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let bForceModeSet: u32 = unsafe { ::std::mem::transmute(bForceModeSet) }; - bForceModeSet as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let bFocusDisplay: u32 = unsafe { ::std::mem::transmute(bFocusDisplay) }; - bFocusDisplay as u64 - }); - __bindgen_bitfield_unit.set(3usize, 24u8, { - let gpuId: u32 = unsafe { ::std::mem::transmute(gpuId) }; - gpuId as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_SetViewEx() and NvAPI_GetViewEx()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_DISPLAY_PATH_INFO_V3 { - #[doc = "!< (IN) Structure version"] - pub version: NvU32, - #[doc = "!< (IN) Path count"] - pub count: NvU32, - pub path: [NV_DISPLAY_PATH; 2usize], -} -#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_SetViewEx() and NvAPI_GetViewEx()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_DISPLAY_PATH_INFO { - #[doc = "!< (IN) Structure version"] - pub version: NvU32, - #[doc = "!< (IN) Path count"] - pub count: NvU32, - pub path: [NV_DISPLAY_PATH; 4usize], -} -#[doc = "\n! \\ingroup dispcontrol"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_POSITION { - pub x: NvS32, - pub y: NvS32, -} -#[doc = "\n! \\ingroup dispcontrol"] -pub type NV_POSITION = _NV_POSITION; -#[doc = "! \\ingroup dispcontrol"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_RESOLUTION { - pub width: NvU32, - pub height: NvU32, - pub colorDepth: NvU32, -} -#[doc = "! \\ingroup dispcontrol"] -pub type NV_RESOLUTION = _NV_RESOLUTION; -#[doc = "! \\ingroup dispcontrol"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO_V1 { - pub version: NvU32, - #[doc = "!< (IN) rotation setting."] - pub rotation: NV_ROTATE, - #[doc = "!< (IN) scaling setting."] - pub scaling: NV_SCALING, - #[doc = "!< (IN) Non-interlaced Refresh Rate of the mode, multiplied by 1000, 0 = ignored\n!< This is the value which driver reports to the OS."] - pub refreshRate1K: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Specify connector type. For TV only, ignored if tvFormat == NV_DISPLAY_TV_FORMAT_NONE"] - pub connector: NV_GPU_CONNECTOR_TYPE, - #[doc = "!< (IN) to choose the last TV format set this value to NV_DISPLAY_TV_FORMAT_NONE\n!< In case of NvAPI_DISP_GetDisplayConfig(), this field will indicate the currently applied TV format;\n!< if no TV format is applied, this field will have NV_DISPLAY_TV_FORMAT_NONE value.\n!< In case of NvAPI_DISP_SetDisplayConfig(), this field should only be set in case of TVs;\n!< for other displays this field will be ignored and resolution & refresh rate specified in input will be used to apply the TV format."] - pub tvFormat: NV_DISPLAY_TV_FORMAT, - #[doc = "!< Ignored if timingOverride == NV_TIMING_OVERRIDE_CURRENT"] - pub timingOverride: NV_TIMING_OVERRIDE, - #[doc = "!< Scan out timing, valid only if timingOverride == NV_TIMING_OVERRIDE_CUST\n!< The value NV_TIMING::NV_TIMINGEXT::rrx1k is obtained from the EDID. The driver may\n!< tweak this value for HDTV, stereo, etc., before reporting it to the OS."] - pub timing: NV_TIMING, -} -impl _NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO_V1 { - #[inline] - pub fn interlaced(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_interlaced(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn interlaced_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_interlaced_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn primary(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_primary(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn primary_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_primary_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reservedBit1(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_reservedBit1(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn reservedBit1_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reservedBit1_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn disableVirtualModeSupport(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_disableVirtualModeSupport(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn disableVirtualModeSupport_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_disableVirtualModeSupport_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isPreferredUnscaledTarget(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } - } - #[inline] - pub fn set_isPreferredUnscaledTarget(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isPreferredUnscaledTarget_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isPreferredUnscaledTarget_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 27u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 27u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 27u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - interlaced: NvU32, - primary: NvU32, - reservedBit1: NvU32, - disableVirtualModeSupport: NvU32, - isPreferredUnscaledTarget: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let interlaced: u32 = unsafe { ::std::mem::transmute(interlaced) }; - interlaced as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let primary: u32 = unsafe { ::std::mem::transmute(primary) }; - primary as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let reservedBit1: u32 = unsafe { ::std::mem::transmute(reservedBit1) }; - reservedBit1 as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let disableVirtualModeSupport: u32 = - unsafe { ::std::mem::transmute(disableVirtualModeSupport) }; - disableVirtualModeSupport as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let isPreferredUnscaledTarget: u32 = - unsafe { ::std::mem::transmute(isPreferredUnscaledTarget) }; - isPreferredUnscaledTarget as u64 - }); - __bindgen_bitfield_unit.set(5usize, 27u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! \\ingroup dispcontrol"] -pub type NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO_V1 = - _NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO_V1; -#[doc = "! \\ingroup dispcontrol"] -pub type NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO = NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO_V1; -#[doc = "! \\ingroup dispcontrol"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_DISPLAYCONFIG_PATH_TARGET_INFO_V1 { - #[doc = "!< Display ID"] - pub displayId: NvU32, - #[doc = "!< May be NULL if no advanced settings are required. NULL for Non-NVIDIA Display."] - pub details: *mut NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO, -} -#[doc = "! \\ingroup dispcontrol"] -pub type NV_DISPLAYCONFIG_PATH_TARGET_INFO_V1 = _NV_DISPLAYCONFIG_PATH_TARGET_INFO_V1; -#[doc = "! \\ingroup dispcontrol"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_DISPLAYCONFIG_PATH_TARGET_INFO_V2 { - #[doc = "!< Display ID"] - pub displayId: NvU32, - #[doc = "!< May be NULL if no advanced settings are required"] - pub details: *mut NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO, - #[doc = "!< Windows CCD target ID. Must be present only for non-NVIDIA adapter, for NVIDIA adapter this parameter is ignored."] - pub targetId: NvU32, -} -#[doc = "! \\ingroup dispcontrol"] -pub type NV_DISPLAYCONFIG_PATH_TARGET_INFO_V2 = _NV_DISPLAYCONFIG_PATH_TARGET_INFO_V2; -#[doc = "! \\ingroup dispcontrol\n! As version is not defined for this structure, we will be using version of NV_DISPLAYCONFIG_PATH_INFO"] -pub type NV_DISPLAYCONFIG_PATH_TARGET_INFO = NV_DISPLAYCONFIG_PATH_TARGET_INFO_V2; -pub const _NV_DISPLAYCONFIG_SPANNING_ORIENTATION_NV_DISPLAYCONFIG_SPAN_NONE: - _NV_DISPLAYCONFIG_SPANNING_ORIENTATION = 0; -pub const _NV_DISPLAYCONFIG_SPANNING_ORIENTATION_NV_DISPLAYCONFIG_SPAN_HORIZONTAL: - _NV_DISPLAYCONFIG_SPANNING_ORIENTATION = 1; -pub const _NV_DISPLAYCONFIG_SPANNING_ORIENTATION_NV_DISPLAYCONFIG_SPAN_VERTICAL: - _NV_DISPLAYCONFIG_SPANNING_ORIENTATION = 2; -#[doc = "! \\ingroup dispcontrol"] -pub type _NV_DISPLAYCONFIG_SPANNING_ORIENTATION = ::std::os::raw::c_int; -#[doc = "! \\ingroup dispcontrol"] -pub use self::_NV_DISPLAYCONFIG_SPANNING_ORIENTATION as NV_DISPLAYCONFIG_SPANNING_ORIENTATION; -#[doc = "! \\ingroup dispcontrol"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1 { - pub resolution: NV_RESOLUTION, - #[doc = "!< Ignored at present, must be NV_FORMAT_UNKNOWN (0)"] - pub colorFormat: NV_FORMAT, - #[doc = "!< Is all positions are 0 or invalid, displays will be automatically\n!< positioned from left to right with GDI Primary at 0,0, and all\n!< other displays in the order of the path array."] - pub position: NV_POSITION, - #[doc = "!< Spanning is only supported on XP"] - pub spanningOrientation: NV_DISPLAYCONFIG_SPANNING_ORIENTATION, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, -} -impl _NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1 { - #[inline] - pub fn bGDIPrimary(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bGDIPrimary(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bGDIPrimary_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bGDIPrimary_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bSLIFocus(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_bSLIFocus(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bSLIFocus_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bSLIFocus_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 30u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 30u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 30u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bGDIPrimary: NvU32, - bSLIFocus: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bGDIPrimary: u32 = unsafe { ::std::mem::transmute(bGDIPrimary) }; - bGDIPrimary as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let bSLIFocus: u32 = unsafe { ::std::mem::transmute(bSLIFocus) }; - bSLIFocus as u64 - }); - __bindgen_bitfield_unit.set(2usize, 30u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! \\ingroup dispcontrol"] -pub type NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1 = _NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1; -#[doc = "! \\ingroup dispcontrol"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_DISPLAYCONFIG_PATH_INFO_V1 { - pub version: NvU32, - #[doc = "!< This field is reserved. There is ongoing debate if we need this field.\n!< Identifies sourceIds used by Windows. If all sourceIds are 0,\n!< these will be computed automatically."] - pub reserved_sourceId: NvU32, - #[doc = "!< Number of elements in targetInfo array"] - pub targetInfoCount: NvU32, - pub targetInfo: *mut NV_DISPLAYCONFIG_PATH_TARGET_INFO_V1, - #[doc = "!< May be NULL if mode info is not important"] - pub sourceModeInfo: *mut NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1, -} -#[doc = "! \\ingroup dispcontrol"] -pub type NV_DISPLAYCONFIG_PATH_INFO_V1 = _NV_DISPLAYCONFIG_PATH_INFO_V1; -#[doc = "! \\ingroup dispcontrol"] -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_DISPLAYCONFIG_PATH_INFO { - pub version: NvU32, - pub __bindgen_anon_1: _NV_DISPLAYCONFIG_PATH_INFO__bindgen_ty_1, - #[doc = "!< Number of elements in targetInfo array"] - pub targetInfoCount: NvU32, - pub targetInfo: *mut NV_DISPLAYCONFIG_PATH_TARGET_INFO_V2, - #[doc = "!< May be NULL if mode info is not important"] - pub sourceModeInfo: *mut NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Used by Non-NVIDIA adapter for pointer to OS Adapter of LUID\n!< type, type casted to void *."] - pub pOSAdapterID: *mut ::std::os::raw::c_void, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union _NV_DISPLAYCONFIG_PATH_INFO__bindgen_ty_1 { - #[doc = "!< Identifies sourceId used by Windows CCD. This can be optionally set."] - pub sourceId: NvU32, - #[doc = "!< Only for compatibility"] - pub reserved_sourceId: NvU32, -} -impl _NV_DISPLAYCONFIG_PATH_INFO { - #[inline] - pub fn IsNonNVIDIAAdapter(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_IsNonNVIDIAAdapter(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn IsNonNVIDIAAdapter_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_IsNonNVIDIAAdapter_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - IsNonNVIDIAAdapter: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let IsNonNVIDIAAdapter: u32 = unsafe { ::std::mem::transmute(IsNonNVIDIAAdapter) }; - IsNonNVIDIAAdapter as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! \\ingroup dispcontrol"] -pub type NV_DISPLAYCONFIG_PATH_INFO_V2 = _NV_DISPLAYCONFIG_PATH_INFO; -#[doc = "! \\ingroup dispcontrol"] -pub type NV_DISPLAYCONFIG_PATH_INFO = NV_DISPLAYCONFIG_PATH_INFO_V2; -#[doc = "! \\ingroup dispcontrol"] -pub type NV_DISPLAYCONFIG_SOURCE_MODE_INFO = NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1; -pub const _NV_DISPLAYCONFIG_FLAGS_NV_DISPLAYCONFIG_VALIDATE_ONLY: _NV_DISPLAYCONFIG_FLAGS = 1; -pub const _NV_DISPLAYCONFIG_FLAGS_NV_DISPLAYCONFIG_SAVE_TO_PERSISTENCE: _NV_DISPLAYCONFIG_FLAGS = 2; -#[doc = "!< Driver reload is permitted if necessary"] -pub const _NV_DISPLAYCONFIG_FLAGS_NV_DISPLAYCONFIG_DRIVER_RELOAD_ALLOWED: _NV_DISPLAYCONFIG_FLAGS = - 4; -#[doc = "!< Refresh OS mode list."] -pub const _NV_DISPLAYCONFIG_FLAGS_NV_DISPLAYCONFIG_FORCE_MODE_ENUMERATION: _NV_DISPLAYCONFIG_FLAGS = - 8; -#[doc = "!< Tell OS to avoid optimizing CommitVidPn call during a modeset"] -pub const _NV_DISPLAYCONFIG_FLAGS_NV_FORCE_COMMIT_VIDPN: _NV_DISPLAYCONFIG_FLAGS = 16; -#[doc = "! \\ingroup dispcontrol"] -pub type _NV_DISPLAYCONFIG_FLAGS = ::std::os::raw::c_int; -#[doc = "! \\ingroup dispcontrol"] -pub use self::_NV_DISPLAYCONFIG_FLAGS as NV_DISPLAYCONFIG_FLAGS; -pub type NvAPI_UnicodeString = [NvU16; 2048usize]; -pub type NvAPI_LPCWSTR = *const NvU16; -pub const _NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID_NVAPI_GPU_PERF_VOLTAGE_INFO_DOMAIN_CORE: - _NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID = 0; -pub const _NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID_NVAPI_GPU_PERF_VOLTAGE_INFO_DOMAIN_UNDEFINED: - _NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID = 16; -#[doc = "! \\ingroup gpuclock"] -pub type _NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID = ::std::os::raw::c_int; -#[doc = "! \\ingroup gpuclock"] -pub use self::_NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID as NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID; -pub const _NV_GPU_PUBLIC_CLOCK_ID_NVAPI_GPU_PUBLIC_CLOCK_GRAPHICS: _NV_GPU_PUBLIC_CLOCK_ID = 0; -pub const _NV_GPU_PUBLIC_CLOCK_ID_NVAPI_GPU_PUBLIC_CLOCK_MEMORY: _NV_GPU_PUBLIC_CLOCK_ID = 4; -pub const _NV_GPU_PUBLIC_CLOCK_ID_NVAPI_GPU_PUBLIC_CLOCK_PROCESSOR: _NV_GPU_PUBLIC_CLOCK_ID = 7; -pub const _NV_GPU_PUBLIC_CLOCK_ID_NVAPI_GPU_PUBLIC_CLOCK_VIDEO: _NV_GPU_PUBLIC_CLOCK_ID = 8; -pub const _NV_GPU_PUBLIC_CLOCK_ID_NVAPI_GPU_PUBLIC_CLOCK_UNDEFINED: _NV_GPU_PUBLIC_CLOCK_ID = 32; -#[doc = "! \\ingroup gpuclock"] -pub type _NV_GPU_PUBLIC_CLOCK_ID = ::std::os::raw::c_int; -#[doc = "! \\ingroup gpuclock"] -pub use self::_NV_GPU_PUBLIC_CLOCK_ID as NV_GPU_PUBLIC_CLOCK_ID; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P0: _NV_GPU_PERF_PSTATE_ID = 0; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P1: _NV_GPU_PERF_PSTATE_ID = 1; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P2: _NV_GPU_PERF_PSTATE_ID = 2; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P3: _NV_GPU_PERF_PSTATE_ID = 3; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P4: _NV_GPU_PERF_PSTATE_ID = 4; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P5: _NV_GPU_PERF_PSTATE_ID = 5; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P6: _NV_GPU_PERF_PSTATE_ID = 6; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P7: _NV_GPU_PERF_PSTATE_ID = 7; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P8: _NV_GPU_PERF_PSTATE_ID = 8; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P9: _NV_GPU_PERF_PSTATE_ID = 9; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P10: _NV_GPU_PERF_PSTATE_ID = 10; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P11: _NV_GPU_PERF_PSTATE_ID = 11; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P12: _NV_GPU_PERF_PSTATE_ID = 12; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P13: _NV_GPU_PERF_PSTATE_ID = 13; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P14: _NV_GPU_PERF_PSTATE_ID = 14; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P15: _NV_GPU_PERF_PSTATE_ID = 15; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_UNDEFINED: _NV_GPU_PERF_PSTATE_ID = 16; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_ALL: _NV_GPU_PERF_PSTATE_ID = 17; -#[doc = "! \\addtogroup gpupstate\n! @{"] -pub type _NV_GPU_PERF_PSTATE_ID = ::std::os::raw::c_int; -#[doc = "! \\addtogroup gpupstate\n! @{"] -pub use self::_NV_GPU_PERF_PSTATE_ID as NV_GPU_PERF_PSTATE_ID; -#[doc = "! Clock domains that use single frequency value within given pstate"] -pub const NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID_NVAPI_GPU_PERF_PSTATE20_CLOCK_TYPE_SINGLE: - NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID = 0; -#[doc = "! Clock domains that allow range of frequency values within given pstate"] -pub const NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID_NVAPI_GPU_PERF_PSTATE20_CLOCK_TYPE_RANGE: - NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID = 1; -#[doc = "! Used to identify clock type"] -pub type NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID = ::std::os::raw::c_int; -#[doc = "! Used to describe both voltage and frequency deltas"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_PERF_PSTATES20_PARAM_DELTA { - #[doc = "! Value of parameter delta (in respective units [kHz, uV])"] - pub value: NvS32, - pub valueRange: NV_GPU_PERF_PSTATES20_PARAM_DELTA__bindgen_ty_1, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_PERF_PSTATES20_PARAM_DELTA__bindgen_ty_1 { - #[doc = "! Min value allowed for parameter delta (in respective units [kHz, uV])"] - pub min: NvS32, - #[doc = "! Max value allowed for parameter delta (in respective units [kHz, uV])"] - pub max: NvS32, -} -#[doc = "! Used to describe single clock entry"] -#[repr(C)] -#[derive(Copy, Clone)] -pub struct NV_GPU_PSTATE20_CLOCK_ENTRY_V1 { - #[doc = "! ID of the clock domain"] - pub domainId: NV_GPU_PUBLIC_CLOCK_ID, - #[doc = "! Clock type ID"] - pub typeId: NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "! Current frequency delta from nominal settings in (kHz)"] - pub freqDelta_kHz: NV_GPU_PERF_PSTATES20_PARAM_DELTA, - pub data: NV_GPU_PSTATE20_CLOCK_ENTRY_V1__bindgen_ty_1, -} -#[doc = "! Clock domain type dependant information"] -#[repr(C)] -#[derive(Copy, Clone)] -pub union NV_GPU_PSTATE20_CLOCK_ENTRY_V1__bindgen_ty_1 { - pub single: NV_GPU_PSTATE20_CLOCK_ENTRY_V1__bindgen_ty_1__bindgen_ty_1, - pub range: NV_GPU_PSTATE20_CLOCK_ENTRY_V1__bindgen_ty_1__bindgen_ty_2, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_PSTATE20_CLOCK_ENTRY_V1__bindgen_ty_1__bindgen_ty_1 { - #[doc = "! Clock frequency within given pstate in (kHz)"] - pub freq_kHz: NvU32, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_PSTATE20_CLOCK_ENTRY_V1__bindgen_ty_1__bindgen_ty_2 { - #[doc = "! Min clock frequency within given pstate in (kHz)"] - pub minFreq_kHz: NvU32, - #[doc = "! Max clock frequency within given pstate in (kHz)"] - pub maxFreq_kHz: NvU32, - #[doc = "! Voltage domain ID and value range in (uV) required for this clock"] - pub domainId: NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID, - pub minVoltage_uV: NvU32, - pub maxVoltage_uV: NvU32, -} -impl NV_GPU_PSTATE20_CLOCK_ENTRY_V1 { - #[inline] - pub fn bIsEditable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsEditable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsEditable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsEditable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bIsEditable: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsEditable: u32 = unsafe { ::std::mem::transmute(bIsEditable) }; - bIsEditable as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! Used to describe single base voltage entry"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY_V1 { - #[doc = "! ID of the voltage domain"] - pub domainId: NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "! Current base voltage settings in [uV]"] - pub volt_uV: NvU32, - pub voltDelta_uV: NV_GPU_PERF_PSTATES20_PARAM_DELTA, -} -impl NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY_V1 { - #[inline] - pub fn bIsEditable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsEditable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsEditable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsEditable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bIsEditable: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsEditable: u32 = unsafe { ::std::mem::transmute(bIsEditable) }; - bIsEditable as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! Used in NvAPI_GPU_GetPstates20() interface call."] -#[repr(C)] -#[derive(Copy, Clone)] -pub struct NV_GPU_PERF_PSTATES20_INFO_V1 { - #[doc = "! Version info of the structure (NV_GPU_PERF_PSTATES20_INFO_VER)"] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "! Number of populated pstates"] - pub numPstates: NvU32, - #[doc = "! Number of populated clocks (per pstate)"] - pub numClocks: NvU32, - #[doc = "! Number of populated base voltages (per pstate)"] - pub numBaseVoltages: NvU32, - pub pstates: [NV_GPU_PERF_PSTATES20_INFO_V1__bindgen_ty_1; 16usize], -} -#[doc = "! Performance state (P-State) settings\n! Valid index range is 0 to numPstates-1"] -#[repr(C)] -#[derive(Copy, Clone)] -pub struct NV_GPU_PERF_PSTATES20_INFO_V1__bindgen_ty_1 { - #[doc = "! ID of the P-State"] - pub pstateId: NV_GPU_PERF_PSTATE_ID, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "! Array of clock entries\n! Valid index range is 0 to numClocks-1"] - pub clocks: [NV_GPU_PSTATE20_CLOCK_ENTRY_V1; 8usize], - #[doc = "! Array of baseVoltage entries\n! Valid index range is 0 to numBaseVoltages-1"] - pub baseVoltages: [NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY_V1; 4usize], -} -impl NV_GPU_PERF_PSTATES20_INFO_V1__bindgen_ty_1 { - #[inline] - pub fn bIsEditable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsEditable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsEditable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsEditable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bIsEditable: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsEditable: u32 = unsafe { ::std::mem::transmute(bIsEditable) }; - bIsEditable as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -impl NV_GPU_PERF_PSTATES20_INFO_V1 { - #[inline] - pub fn bIsEditable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsEditable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsEditable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsEditable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bIsEditable: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsEditable: u32 = unsafe { ::std::mem::transmute(bIsEditable) }; - bIsEditable as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! Used in NvAPI_GPU_GetPstates20() interface call."] -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_GPU_PERF_PSTATES20_INFO_V2 { - #[doc = "! Version info of the structure (NV_GPU_PERF_PSTATES20_INFO_VER)"] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "! Number of populated pstates"] - pub numPstates: NvU32, - #[doc = "! Number of populated clocks (per pstate)"] - pub numClocks: NvU32, - #[doc = "! Number of populated base voltages (per pstate)"] - pub numBaseVoltages: NvU32, - pub pstates: [_NV_GPU_PERF_PSTATES20_INFO_V2__bindgen_ty_1; 16usize], - pub ov: _NV_GPU_PERF_PSTATES20_INFO_V2__bindgen_ty_2, -} -#[doc = "! Performance state (P-State) settings\n! Valid index range is 0 to numPstates-1"] -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_GPU_PERF_PSTATES20_INFO_V2__bindgen_ty_1 { - #[doc = "! ID of the P-State"] - pub pstateId: NV_GPU_PERF_PSTATE_ID, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "! Array of clock entries\n! Valid index range is 0 to numClocks-1"] - pub clocks: [NV_GPU_PSTATE20_CLOCK_ENTRY_V1; 8usize], - #[doc = "! Array of baseVoltage entries\n! Valid index range is 0 to numBaseVoltages-1"] - pub baseVoltages: [NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY_V1; 4usize], -} -impl _NV_GPU_PERF_PSTATES20_INFO_V2__bindgen_ty_1 { - #[inline] - pub fn bIsEditable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsEditable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsEditable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsEditable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bIsEditable: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsEditable: u32 = unsafe { ::std::mem::transmute(bIsEditable) }; - bIsEditable as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! OV settings - Please refer to NVIDIA over-volting recommendation to understand impact of this functionality\n! Valid index range is 0 to numVoltages-1"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_PERF_PSTATES20_INFO_V2__bindgen_ty_2 { - #[doc = "! Number of populated voltages"] - pub numVoltages: NvU32, - #[doc = "! Array of voltage entries\n! Valid index range is 0 to numVoltages-1"] - pub voltages: [NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY_V1; 4usize], -} -impl _NV_GPU_PERF_PSTATES20_INFO_V2 { - #[inline] - pub fn bIsEditable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsEditable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsEditable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsEditable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bIsEditable: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsEditable: u32 = unsafe { ::std::mem::transmute(bIsEditable) }; - bIsEditable as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! Used in NvAPI_GPU_GetPstates20() interface call."] -pub type NV_GPU_PERF_PSTATES20_INFO_V2 = _NV_GPU_PERF_PSTATES20_INFO_V2; -#[doc = "! Used in NvAPI_GPU_GetPstates20() interface call."] -pub type NV_GPU_PERF_PSTATES20_INFO = NV_GPU_PERF_PSTATES20_INFO_V2; -#[doc = "! \\ingroup driverapi\n! Used in NvAPI_GetDisplayDriverVersion()"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_DISPLAY_DRIVER_VERSION { - pub version: NvU32, - pub drvVersion: NvU32, - pub bldChangeListNum: NvU32, - pub szBuildBranchString: NvAPI_ShortString, - pub szAdapterString: NvAPI_ShortString, -} -pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_UNINITIALIZED: NV_MONITOR_CONN_TYPE = 0; -pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_VGA: NV_MONITOR_CONN_TYPE = 1; -pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_COMPONENT: NV_MONITOR_CONN_TYPE = 2; -pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_SVIDEO: NV_MONITOR_CONN_TYPE = 3; -pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_HDMI: NV_MONITOR_CONN_TYPE = 4; -pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_DVI: NV_MONITOR_CONN_TYPE = 5; -pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_LVDS: NV_MONITOR_CONN_TYPE = 6; -pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_DP: NV_MONITOR_CONN_TYPE = 7; -pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_COMPOSITE: NV_MONITOR_CONN_TYPE = 8; -pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_UNKNOWN: NV_MONITOR_CONN_TYPE = -1; -#[doc = "! \\ingroup gpu"] -pub type NV_MONITOR_CONN_TYPE = ::std::os::raw::c_int; -#[doc = "! \\ingroup gpu"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_DISPLAYIDS { - pub version: NvU32, - #[doc = "!< out: vga, tv, dvi, hdmi and dp. This is reserved for future use and clients should not rely on this information. Instead get the\n!< GPU connector type from NvAPI_GPU_GetConnectorInfo/NvAPI_GPU_GetConnectorInfoEx"] - pub connectorType: NV_MONITOR_CONN_TYPE, - #[doc = "!< this is a unique identifier for each device"] - pub displayId: NvU32, - pub _bitfield_align_1: [u16; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, -} -impl _NV_GPU_DISPLAYIDS { - #[inline] - pub fn isDynamic(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isDynamic(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isDynamic_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isDynamic_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMultiStreamRootNode(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMultiStreamRootNode(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMultiStreamRootNode_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMultiStreamRootNode_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isActive(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_isActive(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isActive_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isActive_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isCluster(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_isCluster(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isCluster_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isCluster_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isOSVisible(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } - } - #[inline] - pub fn set_isOSVisible(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isOSVisible_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isOSVisible_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isWFD(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } - } - #[inline] - pub fn set_isWFD(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isWFD_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isWFD_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isConnected(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } - } - #[inline] - pub fn set_isConnected(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(6usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isConnected_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 6usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isConnected_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 6usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reservedInternal(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 10u8) as u32) } - } - #[inline] - pub fn set_reservedInternal(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(7usize, 10u8, val as u64) - } - } - #[inline] - pub unsafe fn reservedInternal_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 7usize, - 10u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reservedInternal_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 7usize, - 10u8, - val as u64, - ) - } - } - #[inline] - pub fn isPhysicallyConnected(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) } - } - #[inline] - pub fn set_isPhysicallyConnected(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(17usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isPhysicallyConnected_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 17usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isPhysicallyConnected_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 17usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 14u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(18usize, 14u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 18usize, - 14u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 18usize, - 14u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isDynamic: NvU32, - isMultiStreamRootNode: NvU32, - isActive: NvU32, - isCluster: NvU32, - isOSVisible: NvU32, - isWFD: NvU32, - isConnected: NvU32, - reservedInternal: NvU32, - isPhysicallyConnected: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isDynamic: u32 = unsafe { ::std::mem::transmute(isDynamic) }; - isDynamic as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let isMultiStreamRootNode: u32 = - unsafe { ::std::mem::transmute(isMultiStreamRootNode) }; - isMultiStreamRootNode as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let isActive: u32 = unsafe { ::std::mem::transmute(isActive) }; - isActive as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let isCluster: u32 = unsafe { ::std::mem::transmute(isCluster) }; - isCluster as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let isOSVisible: u32 = unsafe { ::std::mem::transmute(isOSVisible) }; - isOSVisible as u64 - }); - __bindgen_bitfield_unit.set(5usize, 1u8, { - let isWFD: u32 = unsafe { ::std::mem::transmute(isWFD) }; - isWFD as u64 - }); - __bindgen_bitfield_unit.set(6usize, 1u8, { - let isConnected: u32 = unsafe { ::std::mem::transmute(isConnected) }; - isConnected as u64 - }); - __bindgen_bitfield_unit.set(7usize, 10u8, { - let reservedInternal: u32 = unsafe { ::std::mem::transmute(reservedInternal) }; - reservedInternal as u64 - }); - __bindgen_bitfield_unit.set(17usize, 1u8, { - let isPhysicallyConnected: u32 = - unsafe { ::std::mem::transmute(isPhysicallyConnected) }; - isPhysicallyConnected as u64 - }); - __bindgen_bitfield_unit.set(18usize, 14u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! \\ingroup gpu"] -pub type NV_GPU_DISPLAYIDS = _NV_GPU_DISPLAYIDS; -pub const NV_SYSTEM_TYPE_NV_SYSTEM_TYPE_UNKNOWN: NV_SYSTEM_TYPE = 0; -pub const NV_SYSTEM_TYPE_NV_SYSTEM_TYPE_LAPTOP: NV_SYSTEM_TYPE = 1; -pub const NV_SYSTEM_TYPE_NV_SYSTEM_TYPE_DESKTOP: NV_SYSTEM_TYPE = 2; -#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetSystemType()"] -pub type NV_SYSTEM_TYPE = ::std::os::raw::c_int; -pub const _NV_GPU_OUTPUT_TYPE_NVAPI_GPU_OUTPUT_UNKNOWN: _NV_GPU_OUTPUT_TYPE = 0; -#[doc = "!< CRT display device"] -pub const _NV_GPU_OUTPUT_TYPE_NVAPI_GPU_OUTPUT_CRT: _NV_GPU_OUTPUT_TYPE = 1; -#[doc = "!< Digital Flat Panel display device"] -pub const _NV_GPU_OUTPUT_TYPE_NVAPI_GPU_OUTPUT_DFP: _NV_GPU_OUTPUT_TYPE = 2; -#[doc = "!< TV display device"] -pub const _NV_GPU_OUTPUT_TYPE_NVAPI_GPU_OUTPUT_TV: _NV_GPU_OUTPUT_TYPE = 3; -#[doc = "! \\ingroup gpu\n! used in NvAPI_GPU_GetOutputType()"] -pub type _NV_GPU_OUTPUT_TYPE = ::std::os::raw::c_int; -#[doc = "! \\ingroup gpu\n! used in NvAPI_GPU_GetOutputType()"] -pub use self::_NV_GPU_OUTPUT_TYPE as NV_GPU_OUTPUT_TYPE; -pub const _NV_GPU_TYPE_NV_SYSTEM_TYPE_GPU_UNKNOWN: _NV_GPU_TYPE = 0; -#[doc = "!< Integrated GPU"] -pub const _NV_GPU_TYPE_NV_SYSTEM_TYPE_IGPU: _NV_GPU_TYPE = 1; -#[doc = "!< Discrete GPU"] -pub const _NV_GPU_TYPE_NV_SYSTEM_TYPE_DGPU: _NV_GPU_TYPE = 2; -#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetGPUType()."] -pub type _NV_GPU_TYPE = ::std::os::raw::c_int; -#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetGPUType()."] -pub use self::_NV_GPU_TYPE as NV_GPU_TYPE; -pub const _NV_GPU_BUS_TYPE_NVAPI_GPU_BUS_TYPE_UNDEFINED: _NV_GPU_BUS_TYPE = 0; -pub const _NV_GPU_BUS_TYPE_NVAPI_GPU_BUS_TYPE_PCI: _NV_GPU_BUS_TYPE = 1; -pub const _NV_GPU_BUS_TYPE_NVAPI_GPU_BUS_TYPE_AGP: _NV_GPU_BUS_TYPE = 2; -pub const _NV_GPU_BUS_TYPE_NVAPI_GPU_BUS_TYPE_PCI_EXPRESS: _NV_GPU_BUS_TYPE = 3; -pub const _NV_GPU_BUS_TYPE_NVAPI_GPU_BUS_TYPE_FPCI: _NV_GPU_BUS_TYPE = 4; -pub const _NV_GPU_BUS_TYPE_NVAPI_GPU_BUS_TYPE_AXI: _NV_GPU_BUS_TYPE = 5; -#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetBusType()"] -pub type _NV_GPU_BUS_TYPE = ::std::os::raw::c_int; -#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetBusType()"] -pub use self::_NV_GPU_BUS_TYPE as NV_GPU_BUS_TYPE; -#[doc = "! \\ingroup gpu"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_BOARD_INFO { - #[doc = "!< structure version"] - pub version: NvU32, - #[doc = "!< Board Serial Number"] - pub BoardNum: [NvU8; 16usize], -} -#[doc = "! \\ingroup gpu"] -pub type NV_BOARD_INFO_V1 = _NV_BOARD_INFO; -#[doc = "! \\ingroup gpu"] -pub type NV_BOARD_INFO = NV_BOARD_INFO_V1; -#[doc = "! Used in NvAPI_GPU_GetArchInfo()"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_ARCH_INFO_V1 { - pub version: NvU32, - pub architecture: NvU32, - pub implementation: NvU32, - pub revision: NvU32, -} -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_T2X: _NV_GPU_ARCHITECTURE_ID = -536870880; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_T3X: _NV_GPU_ARCHITECTURE_ID = -536870864; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_T4X: _NV_GPU_ARCHITECTURE_ID = -536870848; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_T12X: _NV_GPU_ARCHITECTURE_ID = -536870848; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_NV40: _NV_GPU_ARCHITECTURE_ID = 64; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_NV50: _NV_GPU_ARCHITECTURE_ID = 80; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_G78: _NV_GPU_ARCHITECTURE_ID = 96; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_G80: _NV_GPU_ARCHITECTURE_ID = 128; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_G90: _NV_GPU_ARCHITECTURE_ID = 144; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GT200: _NV_GPU_ARCHITECTURE_ID = 160; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GF100: _NV_GPU_ARCHITECTURE_ID = 192; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GF110: _NV_GPU_ARCHITECTURE_ID = 208; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GK100: _NV_GPU_ARCHITECTURE_ID = 224; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GK110: _NV_GPU_ARCHITECTURE_ID = 240; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GK200: _NV_GPU_ARCHITECTURE_ID = 256; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GM000: _NV_GPU_ARCHITECTURE_ID = 272; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GM200: _NV_GPU_ARCHITECTURE_ID = 288; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GP100: _NV_GPU_ARCHITECTURE_ID = 304; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GV100: _NV_GPU_ARCHITECTURE_ID = 320; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GV110: _NV_GPU_ARCHITECTURE_ID = 336; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_TU100: _NV_GPU_ARCHITECTURE_ID = 352; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GA100: _NV_GPU_ARCHITECTURE_ID = 368; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_AD100: _NV_GPU_ARCHITECTURE_ID = 400; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GB200: _NV_GPU_ARCHITECTURE_ID = 432; -#[doc = "! NV_GPU_ARCH_INFO() values to identify Architecture level for the GPU."] -pub type _NV_GPU_ARCHITECTURE_ID = ::std::os::raw::c_int; -#[doc = "! NV_GPU_ARCH_INFO() values to identify Architecture level for the GPU."] -pub use self::_NV_GPU_ARCHITECTURE_ID as NV_GPU_ARCHITECTURE_ID; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_T20: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_T30: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_T35: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 5; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_T40: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_T124: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV40: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV41: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 1; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV42: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV43: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 3; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV44: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV44A: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 10; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV46: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV47: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 7; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV49: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 9; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV4B: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 11; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV4C: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 12; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV4E: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 14; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV50: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV63: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 3; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV67: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 7; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_G84: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_G86: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_G92: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_G94: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_G96: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_G98: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 8; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT200: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT212: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT214: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT215: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 3; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT216: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 5; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT218: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 8; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_MCP77: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 10; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT21C: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 11; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_MCP79: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 12; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT21A: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 13; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_MCP89: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 15; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF100: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF104: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF106: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 3; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF108: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 1; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF110: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF116: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF117: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 7; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF118: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 8; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF119: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 9; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GK104: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GK106: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GK107: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 7; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GK20A: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 10; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GK110: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GK208: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 8; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GM204: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GM206: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP100: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP000: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 1; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP102: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP104: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP106: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP107: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 7; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP108: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 8; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GV100: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GV10B: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 11; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU100: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU102: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU104: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU106: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU116: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 8; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU117: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 7; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU000: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 1; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GA100: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GA102: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GA104: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_AD102: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_AD103: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 3; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_AD104: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GB202: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; -#[doc = "! NV_GPU_ARCH_INFO() values to identify GPU Architecture Implementation."] -pub type _NV_GPU_ARCH_IMPLEMENTATION_ID = ::std::os::raw::c_int; -#[doc = "! NV_GPU_ARCH_INFO() values to identify GPU Architecture Implementation."] -pub use self::_NV_GPU_ARCH_IMPLEMENTATION_ID as NV_GPU_ARCH_IMPLEMENTATION_ID; -#[doc = "!< QT chip"] -pub const _NV_GPU_CHIP_REVISION_NV_GPU_CHIP_REV_EMULATION_QT: _NV_GPU_CHIP_REVISION = 0; -#[doc = "!< FPGA implementation of the chipset"] -pub const _NV_GPU_CHIP_REVISION_NV_GPU_CHIP_REV_EMULATION_FPGA: _NV_GPU_CHIP_REVISION = 1; -#[doc = "!< First silicon chipset revision"] -pub const _NV_GPU_CHIP_REVISION_NV_GPU_CHIP_REV_A01: _NV_GPU_CHIP_REVISION = 17; -#[doc = "!< Second Silicon chipset revision"] -pub const _NV_GPU_CHIP_REVISION_NV_GPU_CHIP_REV_A02: _NV_GPU_CHIP_REVISION = 18; -#[doc = "!< Third Silicon chipset revision"] -pub const _NV_GPU_CHIP_REVISION_NV_GPU_CHIP_REV_A03: _NV_GPU_CHIP_REVISION = 19; -#[doc = "!< Unknown chip revision"] -pub const _NV_GPU_CHIP_REVISION_NV_GPU_CHIP_REV_UNKNOWN: _NV_GPU_CHIP_REVISION = -1; -pub type _NV_GPU_CHIP_REVISION = ::std::os::raw::c_int; -pub use self::_NV_GPU_CHIP_REVISION as NV_GPU_CHIP_REVISION; -#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetArchInfo()"] -#[repr(C)] -#[derive(Copy, Clone)] -pub struct NV_GPU_ARCH_INFO_V2 { - pub version: NvU32, - pub __bindgen_anon_1: NV_GPU_ARCH_INFO_V2__bindgen_ty_1, - pub __bindgen_anon_2: NV_GPU_ARCH_INFO_V2__bindgen_ty_2, - pub __bindgen_anon_3: NV_GPU_ARCH_INFO_V2__bindgen_ty_3, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union NV_GPU_ARCH_INFO_V2__bindgen_ty_1 { - #[doc = "!< architecture and architecture_id are the same. The former is NvU32 while the latter is an enum made for readability."] - pub architecture: NvU32, - #[doc = "!< specifies the architecture level for the GPU."] - pub architecture_id: NV_GPU_ARCHITECTURE_ID, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union NV_GPU_ARCH_INFO_V2__bindgen_ty_2 { - #[doc = "!< implementation and implementation_id are the same. The former is NvU32 while the latter is an enum made for readability."] - pub implementation: NvU32, - #[doc = "!< specifies the implementation of the architecture for the GPU."] - pub implementation_id: NV_GPU_ARCH_IMPLEMENTATION_ID, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union NV_GPU_ARCH_INFO_V2__bindgen_ty_3 { - #[doc = "!< revision and revision_id are the same. The former is NvU32 while the latter is an enum made for readability."] - pub revision: NvU32, - #[doc = "!< specifies the architecture revision of the GPU."] - pub revision_id: NV_GPU_CHIP_REVISION, -} -#[doc = "! \\ingroup gpu"] -pub type NV_GPU_ARCH_INFO = NV_GPU_ARCH_INFO_V2; -#[doc = "!< Set i2cSpeedKhz to I2C_SPEED_DEFAULT if default I2C speed is to be chosen, ie.use the current frequency setting."] -pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_DEFAULT: NV_I2C_SPEED = 0; -pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_3KHZ: NV_I2C_SPEED = 1; -pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_10KHZ: NV_I2C_SPEED = 2; -pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_33KHZ: NV_I2C_SPEED = 3; -pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_100KHZ: NV_I2C_SPEED = 4; -pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_200KHZ: NV_I2C_SPEED = 5; -pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_400KHZ: NV_I2C_SPEED = 6; -pub type NV_I2C_SPEED = ::std::os::raw::c_int; -#[doc = "! Used in NvAPI_I2CRead() and NvAPI_I2CWrite()"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_I2C_INFO_V1 { - #[doc = "!< The structure version."] - pub version: NvU32, - #[doc = "!< The Display Mask of the concerned display."] - pub displayMask: NvU32, - #[doc = "!< This flag indicates either the DDC port (TRUE) or the communication port\n!< (FALSE) of the concerned display."] - pub bIsDDCPort: NvU8, - #[doc = "!< The address of the I2C slave. The address should be shifted left by one. For\n!< example, the I2C address 0x50, often used for reading EDIDs, would be stored\n!< here as 0xA0. This matches the position within the byte sent by the master, as\n!< the last bit is reserved to specify the read or write direction."] - pub i2cDevAddress: NvU8, - #[doc = "!< The I2C target register address. May be NULL, which indicates no register\n!< address should be sent."] - pub pbI2cRegAddress: *mut NvU8, - #[doc = "!< The size in bytes of target register address. If pbI2cRegAddress is NULL, this\n!< field must be 0."] - pub regAddrSize: NvU32, - #[doc = "!< The buffer of data which is to be read or written (depending on the command)."] - pub pbData: *mut NvU8, - #[doc = "!< The size of the data buffer, pbData, to be read or written."] - pub cbSize: NvU32, - #[doc = "!< The target speed of the transaction (between 28Kbps to 40Kbps; not guaranteed)."] - pub i2cSpeed: NvU32, -} -#[doc = "! Used in NvAPI_I2CRead() and NvAPI_I2CWrite()"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_I2C_INFO_V2 { - #[doc = "!< The structure version."] - pub version: NvU32, - #[doc = "!< The Display Mask of the concerned display."] - pub displayMask: NvU32, - #[doc = "!< This flag indicates either the DDC port (TRUE) or the communication port\n!< (FALSE) of the concerned display."] - pub bIsDDCPort: NvU8, - #[doc = "!< The address of the I2C slave. The address should be shifted left by one. For\n!< example, the I2C address 0x50, often used for reading EDIDs, would be stored\n!< here as 0xA0. This matches the position within the byte sent by the master, as\n!< the last bit is reserved to specify the read or write direction."] - pub i2cDevAddress: NvU8, - #[doc = "!< The I2C target register address. May be NULL, which indicates no register\n!< address should be sent."] - pub pbI2cRegAddress: *mut NvU8, - #[doc = "!< The size in bytes of target register address. If pbI2cRegAddress is NULL, this\n!< field must be 0."] - pub regAddrSize: NvU32, - #[doc = "!< The buffer of data which is to be read or written (depending on the command)."] - pub pbData: *mut NvU8, - #[doc = "!< The size of the data buffer, pbData, to be read or written."] - pub cbSize: NvU32, - #[doc = "!< Deprecated, Must be set to NVAPI_I2C_SPEED_DEPRECATED."] - pub i2cSpeed: NvU32, - #[doc = "!< The target speed of the transaction in (kHz) (Chosen from the enum NV_I2C_SPEED)."] - pub i2cSpeedKhz: NV_I2C_SPEED, -} -#[doc = "! Used in NvAPI_I2CRead() and NvAPI_I2CWrite()"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_I2C_INFO_V3 { - #[doc = "!< The structure version."] - pub version: NvU32, - #[doc = "!< The Display Mask of the concerned display."] - pub displayMask: NvU32, - #[doc = "!< This flag indicates either the DDC port (TRUE) or the communication port\n!< (FALSE) of the concerned display."] - pub bIsDDCPort: NvU8, - #[doc = "!< The address of the I2C slave. The address should be shifted left by one. For\n!< example, the I2C address 0x50, often used for reading EDIDs, would be stored\n!< here as 0xA0. This matches the position within the byte sent by the master, as\n!< the last bit is reserved to specify the read or write direction."] - pub i2cDevAddress: NvU8, - #[doc = "!< The I2C target register address. May be NULL, which indicates no register\n!< address should be sent."] - pub pbI2cRegAddress: *mut NvU8, - #[doc = "!< The size in bytes of target register address. If pbI2cRegAddress is NULL, this\n!< field must be 0."] - pub regAddrSize: NvU32, - #[doc = "!< The buffer of data which is to be read or written (depending on the command)."] - pub pbData: *mut NvU8, - #[doc = "!< The size of the data buffer, pbData, to be read or written."] - pub cbSize: NvU32, - #[doc = "!< Deprecated, Must be set to NVAPI_I2C_SPEED_DEPRECATED."] - pub i2cSpeed: NvU32, - #[doc = "!< The target speed of the transaction in (kHz) (Chosen from the enum NV_I2C_SPEED)."] - pub i2cSpeedKhz: NV_I2C_SPEED, - #[doc = "!< The portid on which device is connected (remember to set bIsPortIdSet if this value is set)\n!< Optional for pre-Kepler"] - pub portId: NvU8, - #[doc = "!< set this flag on if and only if portid value is set"] - pub bIsPortIdSet: NvU32, -} -#[doc = "! Used in NvAPI_I2CRead() and NvAPI_I2CWrite()"] -pub type NV_I2C_INFO = NV_I2C_INFO_V3; -pub const _NV_GPU_HDCP_FUSE_STATE_NV_GPU_HDCP_FUSE_STATE_UNKNOWN: _NV_GPU_HDCP_FUSE_STATE = 0; -pub const _NV_GPU_HDCP_FUSE_STATE_NV_GPU_HDCP_FUSE_STATE_DISABLED: _NV_GPU_HDCP_FUSE_STATE = 1; -pub const _NV_GPU_HDCP_FUSE_STATE_NV_GPU_HDCP_FUSE_STATE_ENABLED: _NV_GPU_HDCP_FUSE_STATE = 2; -#[doc = "! HDCP fuse states - used in NV_GPU_GET_HDCP_SUPPORT_STATUS"] -pub type _NV_GPU_HDCP_FUSE_STATE = ::std::os::raw::c_int; -#[doc = "! HDCP fuse states - used in NV_GPU_GET_HDCP_SUPPORT_STATUS"] -pub use self::_NV_GPU_HDCP_FUSE_STATE as NV_GPU_HDCP_FUSE_STATE; -pub const _NV_GPU_HDCP_KEY_SOURCE_NV_GPU_HDCP_KEY_SOURCE_UNKNOWN: _NV_GPU_HDCP_KEY_SOURCE = 0; -pub const _NV_GPU_HDCP_KEY_SOURCE_NV_GPU_HDCP_KEY_SOURCE_NONE: _NV_GPU_HDCP_KEY_SOURCE = 1; -pub const _NV_GPU_HDCP_KEY_SOURCE_NV_GPU_HDCP_KEY_SOURCE_CRYPTO_ROM: _NV_GPU_HDCP_KEY_SOURCE = 2; -pub const _NV_GPU_HDCP_KEY_SOURCE_NV_GPU_HDCP_KEY_SOURCE_SBIOS: _NV_GPU_HDCP_KEY_SOURCE = 3; -pub const _NV_GPU_HDCP_KEY_SOURCE_NV_GPU_HDCP_KEY_SOURCE_I2C_ROM: _NV_GPU_HDCP_KEY_SOURCE = 4; -pub const _NV_GPU_HDCP_KEY_SOURCE_NV_GPU_HDCP_KEY_SOURCE_FUSES: _NV_GPU_HDCP_KEY_SOURCE = 5; -#[doc = "! HDCP key sources - used in NV_GPU_GET_HDCP_SUPPORT_STATUS"] -pub type _NV_GPU_HDCP_KEY_SOURCE = ::std::os::raw::c_int; -#[doc = "! HDCP key sources - used in NV_GPU_GET_HDCP_SUPPORT_STATUS"] -pub use self::_NV_GPU_HDCP_KEY_SOURCE as NV_GPU_HDCP_KEY_SOURCE; -pub const _NV_GPU_HDCP_KEY_SOURCE_STATE_NV_GPU_HDCP_KEY_SOURCE_STATE_UNKNOWN: - _NV_GPU_HDCP_KEY_SOURCE_STATE = 0; -pub const _NV_GPU_HDCP_KEY_SOURCE_STATE_NV_GPU_HDCP_KEY_SOURCE_STATE_ABSENT: - _NV_GPU_HDCP_KEY_SOURCE_STATE = 1; -pub const _NV_GPU_HDCP_KEY_SOURCE_STATE_NV_GPU_HDCP_KEY_SOURCE_STATE_PRESENT: - _NV_GPU_HDCP_KEY_SOURCE_STATE = 2; -#[doc = "! HDCP key source states - used in NV_GPU_GET_HDCP_SUPPORT_STATUS"] -pub type _NV_GPU_HDCP_KEY_SOURCE_STATE = ::std::os::raw::c_int; -#[doc = "! HDCP key source states - used in NV_GPU_GET_HDCP_SUPPORT_STATUS"] -pub use self::_NV_GPU_HDCP_KEY_SOURCE_STATE as NV_GPU_HDCP_KEY_SOURCE_STATE; -#[doc = "! HDPC support status - used in NvAPI_GPU_GetHDCPSupportStatus()"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_GET_HDCP_SUPPORT_STATUS { - pub version: NvU32, - #[doc = "! Structure version constucted by macro #NV_GPU_GET_HDCP_SUPPORT_STATUS"] - pub hdcpFuseState: NV_GPU_HDCP_FUSE_STATE, - #[doc = "! GPU's HDCP fuse state"] - pub hdcpKeySource: NV_GPU_HDCP_KEY_SOURCE, - #[doc = "! GPU's HDCP key source"] - pub hdcpKeySourceState: NV_GPU_HDCP_KEY_SOURCE_STATE, -} -#[doc = "! @}"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_COMPUTE_GPU_TOPOLOGY_V1 { - #[doc = "!< Structure version"] - pub version: NvU32, - #[doc = "!< Total number of compute-capable GPUs"] - pub gpuCount: NvU32, - #[doc = "!< Array of compute-capable physical GPUs."] - pub computeGpus: [NV_COMPUTE_GPU_TOPOLOGY_V1__bindgen_ty_1; 8usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_COMPUTE_GPU_TOPOLOGY_V1__bindgen_ty_1 { - #[doc = "!< Compute-capable physical GPU handle"] - pub hPhysicalGpu: NvPhysicalGpuHandle, - #[doc = "!< One or more flags from \\ref nvcomp_gpu_top"] - pub flags: NvU32, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_COMPUTE_GPU { - #[doc = "!< Compute-capable physical GPU handle"] - pub hPhysicalGpu: NvPhysicalGpuHandle, - #[doc = "!< One or more flags from \\ref nvcomp_gpu_top"] - pub flags: NvU32, -} -pub type NV_COMPUTE_GPU = _NV_COMPUTE_GPU; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_COMPUTE_GPU_TOPOLOGY_V2 { - #[doc = "!< Structure version"] - pub version: NvU32, - #[doc = "!< Size of array"] - pub gpuCount: NvU32, - #[doc = "!< Array of compute-capable physical GPUs (allocate memory of size of Physical gpuCount of system)."] - pub computeGpus: *mut NV_COMPUTE_GPU, -} -pub type NV_COMPUTE_GPU_TOPOLOGY_V2 = _NV_COMPUTE_GPU_TOPOLOGY_V2; -pub type NV_COMPUTE_GPU_TOPOLOGY = NV_COMPUTE_GPU_TOPOLOGY_V2; -pub const _NV_ECC_CONFIGURATION_NV_ECC_CONFIGURATION_NOT_SUPPORTED: _NV_ECC_CONFIGURATION = 0; -#[doc = "!< Changes require a POST to take effect"] -pub const _NV_ECC_CONFIGURATION_NV_ECC_CONFIGURATION_DEFERRED: _NV_ECC_CONFIGURATION = 1; -#[doc = "!< Changes can optionally be made to take effect immediately"] -pub const _NV_ECC_CONFIGURATION_NV_ECC_CONFIGURATION_IMMEDIATE: _NV_ECC_CONFIGURATION = 2; -#[doc = "! \\addtogroup gpuecc\n! Used in NV_GPU_ECC_STATUS_INFO."] -pub type _NV_ECC_CONFIGURATION = ::std::os::raw::c_int; -#[doc = "! \\addtogroup gpuecc\n! Used in NV_GPU_ECC_STATUS_INFO."] -pub use self::_NV_ECC_CONFIGURATION as NV_ECC_CONFIGURATION; -#[doc = "! \\ingroup gpuecc\n! Used in NvAPI_GPU_GetECCStatusInfo()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_ECC_STATUS_INFO { - #[doc = "!< Structure version"] - pub version: NvU32, - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, - #[doc = "!< Supported ECC memory feature configuration options"] - pub configurationOptions: NV_ECC_CONFIGURATION, - pub _bitfield_align_2: [u8; 0], - pub _bitfield_2: __BindgenBitfieldUnit<[u8; 1usize]>, - pub __bindgen_padding_0: [u8; 3usize], -} -impl NV_GPU_ECC_STATUS_INFO { - #[inline] - pub fn isSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1(isSupported: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isSupported: u32 = unsafe { ::std::mem::transmute(isSupported) }; - isSupported as u64 - }); - __bindgen_bitfield_unit - } - #[inline] - pub fn isEnabled(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isEnabled(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_2.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isEnabled_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_2), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isEnabled_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_2), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_2(isEnabled: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isEnabled: u32 = unsafe { ::std::mem::transmute(isEnabled) }; - isEnabled as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! \\ingroup gpuecc\n! Used in NvAPI_GPU_GetECCErrorInfo()/"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_ECC_ERROR_INFO { - #[doc = "!< Structure version"] - pub version: NvU32, - pub current: NV_GPU_ECC_ERROR_INFO__bindgen_ty_1, - pub aggregate: NV_GPU_ECC_ERROR_INFO__bindgen_ty_2, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_ECC_ERROR_INFO__bindgen_ty_1 { - #[doc = "!< Number of single-bit ECC errors detected since last boot"] - pub singleBitErrors: NvU64, - #[doc = "!< Number of double-bit ECC errors detected since last boot"] - pub doubleBitErrors: NvU64, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_ECC_ERROR_INFO__bindgen_ty_2 { - #[doc = "!< Number of single-bit ECC errors detected since last counter reset"] - pub singleBitErrors: NvU64, - #[doc = "!< Number of double-bit ECC errors detected since last counter reset"] - pub doubleBitErrors: NvU64, -} -#[doc = "! \\ingroup gpuecc\n! Used in NvAPI_GPU_GetECCConfigurationInfo()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_ECC_CONFIGURATION_INFO { - pub version: NvU32, - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, - pub __bindgen_padding_0: [u8; 3usize], -} -impl NV_GPU_ECC_CONFIGURATION_INFO { - #[inline] - pub fn isEnabled(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isEnabled(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isEnabled_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isEnabled_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isEnabledByDefault(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_isEnabledByDefault(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isEnabledByDefault_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isEnabledByDefault_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isEnabled: NvU32, - isEnabledByDefault: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isEnabled: u32 = unsafe { ::std::mem::transmute(isEnabled) }; - isEnabled as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let isEnabledByDefault: u32 = unsafe { ::std::mem::transmute(isEnabledByDefault) }; - isEnabledByDefault as u64 - }); - __bindgen_bitfield_unit - } -} -pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_NONE: NV_QSYNC_EVENT = 0; -pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_SYNC_LOSS: NV_QSYNC_EVENT = 1; -pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_SYNC_GAIN: NV_QSYNC_EVENT = 2; -pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_HOUSESYNC_GAIN: NV_QSYNC_EVENT = 3; -pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_HOUSESYNC_LOSS: NV_QSYNC_EVENT = 4; -pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_RJ45_GAIN: NV_QSYNC_EVENT = 5; -pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_RJ45_LOSS: NV_QSYNC_EVENT = 6; -pub type NV_QSYNC_EVENT = ::std::os::raw::c_int; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_QSYNC_EVENT_DATA { - pub qsyncEvent: NV_QSYNC_EVENT, - pub reserved: [NvU32; 7usize], -} -#[doc = "! Callback for QSYNC event"] -pub type NVAPI_CALLBACK_QSYNCEVENT = ::std::option::Option< - unsafe extern "C" fn( - qyncEventData: NV_QSYNC_EVENT_DATA, - callbackParam: *mut ::std::os::raw::c_void, - ), ->; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_DISPLAY_OUTPUT_MODE_CHANGE_EVENT_DATA { - #[doc = "!< displayId of the display"] - pub displayId: NvU32, - #[doc = "!< display output mode"] - pub outputMode: NvU32, -} -pub type NV_DISPLAY_OUTPUT_MODE_CHANGE_EVENT_DATA = _NV_DISPLAY_OUTPUT_MODE_CHANGE_EVENT_DATA; -#[doc = "! Callback for Display Output Mode change events"] -pub type NVAPI_CALLBACK_DISPLAY_OUTPUT_MODE_CHANGE_EVENT = ::std::option::Option< - unsafe extern "C" fn( - pEventData: *mut NV_DISPLAY_OUTPUT_MODE_CHANGE_EVENT_DATA, - callbackParam: *mut ::std::os::raw::c_void, - ), ->; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_DISPLAY_COLORIMETRY_CHANGE_EVENT_DATA { - #[doc = "!< displayId of the monitor"] - pub displayId: NvU32, - #[doc = "!< min luminance, cd/m^2"] - pub min_luminance: f32, - #[doc = "!< max 100% frame luminance, cd/m^2"] - pub max_full_frame_luminance: f32, - #[doc = "!< max 10% frame luminance, cd/m^2"] - pub max_luminance: f32, - #[doc = "!< HDR brightness luminance scaling factor applied by GPU on output pixels"] - pub hdrBrightnessLuminanceScalingFactor: f32, - #[doc = "!< red primary chromaticity coordinate x"] - pub red_primary_x: f32, - #[doc = "!< red primary chromaticity coordinate y"] - pub red_primary_y: f32, - #[doc = "!< green primary chromaticity coordinate x"] - pub green_primary_x: f32, - #[doc = "!< green primary chromaticity coordinate y"] - pub green_primary_y: f32, - #[doc = "!< blue primary chromaticity coordinate x"] - pub blue_primary_x: f32, - #[doc = "!< blue primary chromaticity coordinate y"] - pub blue_primary_y: f32, - #[doc = "!< white point chromaticity coordinate x"] - pub white_point_x: f32, - #[doc = "!< white point chromaticity coordinate y"] - pub white_point_y: f32, -} -pub type NV_DISPLAY_COLORIMETRY_CHANGE_EVENT_DATA = _NV_DISPLAY_COLORIMETRY_CHANGE_EVENT_DATA; -#[doc = "! Callback for Display Colorimetry change events"] -pub type NVAPI_CALLBACK_DISPLAY_COLORIMETRY_CHANGE_EVENT = ::std::option::Option< - unsafe extern "C" fn( - pEventData: *mut NV_DISPLAY_COLORIMETRY_CHANGE_EVENT_DATA, - callbackParam: *mut ::std::os::raw::c_void, - ), ->; -pub const NV_EVENT_TYPE_NV_EVENT_TYPE_NONE: NV_EVENT_TYPE = 0; -pub const NV_EVENT_TYPE_NV_EVENT_TYPE_QSYNC: NV_EVENT_TYPE = 6; -pub const NV_EVENT_TYPE_NV_EVENT_TYPE_DISPLAY_OUTPUT_MODE_CHANGE: NV_EVENT_TYPE = 103; -pub const NV_EVENT_TYPE_NV_EVENT_TYPE_DISPLAY_COLORIMETRY_CHANGE: NV_EVENT_TYPE = 104; -#[doc = "! Enum for Event IDs"] -pub type NV_EVENT_TYPE = ::std::os::raw::c_int; -#[doc = "! Core NV_EVENT_REGISTER_CALLBACK structure declaration"] -#[repr(C)] -#[derive(Copy, Clone)] -pub struct NV_EVENT_REGISTER_CALLBACK { - #[doc = "!< version field to ensure minimum version compatibility"] - pub version: NvU32, - #[doc = "!< ID of the event being sent"] - pub eventId: NV_EVENT_TYPE, - #[doc = "!< This value will be passed back to the callback function when an event occurs"] - pub callbackParam: *mut ::std::os::raw::c_void, - pub nvCallBackFunc: NV_EVENT_REGISTER_CALLBACK__bindgen_ty_1, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union NV_EVENT_REGISTER_CALLBACK__bindgen_ty_1 { - #[doc = "!< Callback function pointer for QSYNC events"] - pub nvQSYNCEventCallback: NVAPI_CALLBACK_QSYNCEVENT, - #[doc = "!< Callback function pointer for Display Output Mode change events"] - pub nvDisplayOutputModeChangeEventCallback: NVAPI_CALLBACK_DISPLAY_OUTPUT_MODE_CHANGE_EVENT, - #[doc = "!< Callback function pointer for Display Colorimetry change events"] - pub nvDisplayColorimetryChangeEventCallback: NVAPI_CALLBACK_DISPLAY_COLORIMETRY_CHANGE_EVENT, -} -#[doc = "!< NVIDIA RTX VR Ready"] -pub const _NV_GPU_WORKSTATION_FEATURE_TYPE_NV_GPU_WORKSTATION_FEATURE_TYPE_NVIDIA_RTX_VR_READY: - _NV_GPU_WORKSTATION_FEATURE_TYPE = 1; -#[doc = "!< DEPRECATED name - do not use"] -pub const _NV_GPU_WORKSTATION_FEATURE_TYPE_NV_GPU_WORKSTATION_FEATURE_TYPE_QUADRO_VR_READY: - _NV_GPU_WORKSTATION_FEATURE_TYPE = 1; -pub const _NV_GPU_WORKSTATION_FEATURE_TYPE_NV_GPU_WORKSTATION_FEATURE_TYPE_PROVIZ: - _NV_GPU_WORKSTATION_FEATURE_TYPE = 2; -#[doc = "! \\ingroup gpu"] -pub type _NV_GPU_WORKSTATION_FEATURE_TYPE = ::std::os::raw::c_int; -#[doc = "! \\ingroup gpu"] -pub use self::_NV_GPU_WORKSTATION_FEATURE_TYPE as NV_GPU_WORKSTATION_FEATURE_TYPE; -#[doc = "! \\ingroup gpu"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_SCANOUT_INTENSITY_DATA_V1 { - #[doc = "!< version of this structure"] - pub version: NvU32, - #[doc = "!< width of the input texture"] - pub width: NvU32, - #[doc = "!< height of the input texture"] - pub height: NvU32, - #[doc = "!< array of floating values building an intensity RGB texture"] - pub blendingTexture: *mut f32, -} -#[doc = "! \\ingroup gpu"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_SCANOUT_INTENSITY_DATA_V2 { - #[doc = "!< version of this structure"] - pub version: NvU32, - #[doc = "!< width of the input texture"] - pub width: NvU32, - #[doc = "!< height of the input texture"] - pub height: NvU32, - #[doc = "!< array of floating values building an intensity RGB texture"] - pub blendingTexture: *mut f32, - #[doc = "!< array of floating values building an offset texture"] - pub offsetTexture: *mut f32, - #[doc = "!< number of channels per pixel in the offset texture"] - pub offsetTexChannels: NvU32, -} -#[doc = "! \\ingroup gpu"] -pub type NV_SCANOUT_INTENSITY_DATA = NV_SCANOUT_INTENSITY_DATA_V2; -#[doc = "! \\ingroup gpu"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_SCANOUT_INTENSITY_STATE_DATA { - #[doc = "!< version of this structure"] - pub version: NvU32, - #[doc = "!< intensity is enabled or not"] - pub bEnabled: NvU32, -} -#[doc = "! \\ingroup gpu"] -pub type NV_SCANOUT_INTENSITY_STATE_DATA = _NV_SCANOUT_INTENSITY_STATE_DATA; -pub const NV_GPU_WARPING_VERTICE_FORMAT_NV_GPU_WARPING_VERTICE_FORMAT_TRIANGLESTRIP_XYUVRQ: - NV_GPU_WARPING_VERTICE_FORMAT = 0; -pub const NV_GPU_WARPING_VERTICE_FORMAT_NV_GPU_WARPING_VERTICE_FORMAT_TRIANGLES_XYUVRQ: - NV_GPU_WARPING_VERTICE_FORMAT = 1; -#[doc = "! \\ingroup gpu"] -pub type NV_GPU_WARPING_VERTICE_FORMAT = ::std::os::raw::c_int; -#[doc = "! \\ingroup gpu"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_SCANOUT_WARPING_DATA { - #[doc = "!< version of this structure"] - pub version: NvU32, - #[doc = "!< width of the input texture"] - pub vertices: *mut f32, - #[doc = "!< format of the input vertices"] - pub vertexFormat: NV_GPU_WARPING_VERTICE_FORMAT, - #[doc = "!< number of the input vertices"] - pub numVertices: ::std::os::raw::c_int, - #[doc = "!< rectangle in desktop coordinates describing the source area for the warping"] - pub textureRect: *mut NvSBox, -} -#[doc = "! \\ingroup gpu"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_SCANOUT_WARPING_STATE_DATA { - #[doc = "!< version of this structure"] - pub version: NvU32, - #[doc = "!< warping is enabled or not"] - pub bEnabled: NvU32, -} -#[doc = "! \\ingroup gpu"] -pub type NV_SCANOUT_WARPING_STATE_DATA = _NV_SCANOUT_WARPING_STATE_DATA; -pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_WARPING_RESAMPLING_METHOD : NV_GPU_SCANOUT_COMPOSITION_PARAMETER = 0 ; -pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_SCANOUT_INTENSITY_METHOD : NV_GPU_SCANOUT_COMPOSITION_PARAMETER = 1 ; -pub type NV_GPU_SCANOUT_COMPOSITION_PARAMETER = ::std::os::raw::c_int; -pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_SET_TO_DEFAULT : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 0 ; -pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BILINEAR : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 256 ; -pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_TRIANGULAR : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 257 ; -pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_BELL_SHAPED : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 258 ; -pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_BSPLINE : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 259 ; -pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_ADAPTIVE_TRIANGULAR : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 260 ; -pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_ADAPTIVE_BELL_SHAPED : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 261 ; -pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_ADAPTIVE_BSPLINE : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 262 ; -pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_SCANOUT_INTENSITY_NO_GAMMA : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 512 ; -pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_SCANOUT_INTENSITY_COLOR_GAMMA : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 513 ; -pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_SCANOUT_INTENSITY_COLOR_AND_OFFSET_GAMMA : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 514 ; -#[doc = "! This enum defines a collection of scanout composition values that can be used to configure\n! the supported scanout composition settings"] -pub type NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = ::std::os::raw::c_int; -#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetScanoutConfigurationEx()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_SCANOUT_INFORMATION { - #[doc = "!< Structure version, needs to be initialized with NV_SCANOUT_INFORMATION_VER."] - pub version: NvU32, - #[doc = "!< Operating system display device rect in desktop coordinates displayId is scanning out from."] - pub sourceDesktopRect: NvSBox, - #[doc = "!< Area inside the sourceDesktopRect which is scanned out to the display."] - pub sourceViewportRect: NvSBox, - #[doc = "!< Area inside the rect described by targetDisplayWidth/Height sourceViewportRect is scanned out to."] - pub targetViewportRect: NvSBox, - #[doc = "!< Horizontal size of the active resolution scanned out to the display."] - pub targetDisplayWidth: NvU32, - #[doc = "!< Vertical size of the active resolution scanned out to the display."] - pub targetDisplayHeight: NvU32, - #[doc = "!< If targets are cloned views of the sourceDesktopRect the cloned targets have an importance assigned (0:primary,1 secondary,...)."] - pub cloneImportance: NvU32, - #[doc = "!< Rotation performed between the sourceViewportRect and the targetViewportRect."] - pub sourceToTargetRotation: NV_ROTATE, -} -#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetScanoutConfigurationEx()."] -pub type NV_SCANOUT_INFORMATION = _NV_SCANOUT_INFORMATION; -#[doc = "!< Represents Bare Metal GPU"] -pub const _NV_VIRTUALIZATION_MODE_NV_VIRTUALIZATION_MODE_NONE: _NV_VIRTUALIZATION_MODE = 0; -#[doc = "!< Represents GPU-Passthrough"] -pub const _NV_VIRTUALIZATION_MODE_NV_VIRTUALIZATION_MODE_NMOS: _NV_VIRTUALIZATION_MODE = 1; -#[doc = "!< Represents vGPU inside virtual machine"] -pub const _NV_VIRTUALIZATION_MODE_NV_VIRTUALIZATION_MODE_VGX: _NV_VIRTUALIZATION_MODE = 2; -#[doc = "!< Represents VGX hypervisor in vGPU mode"] -pub const _NV_VIRTUALIZATION_MODE_NV_VIRTUALIZATION_MODE_HOST_VGPU: _NV_VIRTUALIZATION_MODE = 3; -#[doc = "! \\ingroup gpu"] -pub type _NV_VIRTUALIZATION_MODE = ::std::os::raw::c_int; -#[doc = "! \\ingroup gpu"] -pub use self::_NV_VIRTUALIZATION_MODE as NV_VIRTUALIZATION_MODE; -#[doc = "! \\ingroup gpu"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_VIRTUALIZATION_INFO { - #[doc = "!< Structure version"] - pub version: NvU32, - #[doc = "!< one of NV_VIRTUALIZATION_MODE."] - pub virtualizationMode: NV_VIRTUALIZATION_MODE, - #[doc = "!< reserved for future use. Should be set to ZERO."] - pub reserved: NvU32, -} -#[doc = "! \\ingroup gpu"] -pub type NV_GPU_VIRTUALIZATION_INFO_V1 = _NV_GPU_VIRTUALIZATION_INFO; -#[doc = "! \\ingroup gpu"] -pub type NV_GPU_VIRTUALIZATION_INFO = NV_GPU_VIRTUALIZATION_INFO_V1; -#[doc = "! \\ingroup gpu"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LOGICAL_GPU_DATA_V1 { - #[doc = "!< [in] Structure version."] - pub version: NvU32, - #[doc = "!< [out] Returns OS-AdapterId. User must send memory buffer of size atleast equal to the size of LUID structure before calling the NVAPI."] - pub pOSAdapterId: *mut ::std::os::raw::c_void, - #[doc = "!< [out] Number of physical GPU handles associated with the specified logical GPU handle."] - pub physicalGpuCount: NvU32, - #[doc = "!< [out] This array will be filled with physical GPU handles associated with the given logical GPU handle.\n!< The array index refers to the Physical Gpu Index (Idx).\n!< Idx value is the same as D3D11 MultiGPUDevice GPU index, D3D12 node index, OpenGL GL_NV_gpu_multicast GPU index.\n!< When converted to a bit mask (1 << Idx), it matches:\n!< 1. Vulkan deviceNodeMask in VkPhysicalDeviceIDProperties\n!< 2. CUDA deviceNodeMask returned by cuDeviceGetLuid"] - pub physicalGpuHandles: [NvPhysicalGpuHandle; 64usize], - #[doc = "!< Reserved for future use. Should be set to ZERO."] - pub reserved: [NvU32; 8usize], -} -#[doc = "! \\ingroup gpu"] -pub type NV_LOGICAL_GPU_DATA_V1 = _NV_LOGICAL_GPU_DATA_V1; -#[doc = "! \\ingroup gpu"] -pub type NV_LOGICAL_GPU_DATA = NV_LOGICAL_GPU_DATA_V1; -#[doc = "! License string"] -pub type NvAPI_LicenseString = [::std::os::raw::c_char; 128usize]; -pub const _NV_LICENSE_FEATURE_TYPE_NV_LICENSE_FEATURE_UNKNOWN: _NV_LICENSE_FEATURE_TYPE = 0; -pub const _NV_LICENSE_FEATURE_TYPE_NV_LICENSE_FEATURE_VGPU: _NV_LICENSE_FEATURE_TYPE = 1; -pub const _NV_LICENSE_FEATURE_TYPE_NV_LICENSE_FEATURE_NVIDIA_RTX: _NV_LICENSE_FEATURE_TYPE = 2; -#[doc = "!< DEPRECATED name - do not use"] -pub const _NV_LICENSE_FEATURE_TYPE_NV_LICENSE_FEATURE_QUADRO: _NV_LICENSE_FEATURE_TYPE = 2; -pub const _NV_LICENSE_FEATURE_TYPE_NV_LICENSE_FEATURE_GAMING: _NV_LICENSE_FEATURE_TYPE = 3; -pub const _NV_LICENSE_FEATURE_TYPE_NV_LICENSE_FEATURE_COMPUTE: _NV_LICENSE_FEATURE_TYPE = 4; -#[doc = "! Used in NV_LICENSE_FEATURE_DETAILS"] -pub type _NV_LICENSE_FEATURE_TYPE = ::std::os::raw::c_int; -#[doc = "! Used in NV_LICENSE_FEATURE_DETAILS"] -pub use self::_NV_LICENSE_FEATURE_TYPE as NV_LICENSE_FEATURE_TYPE; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LICENSE_EXPIRY_DETAILS { - #[doc = "!< Year value of license expiry"] - pub year: NvU32, - #[doc = "!< Month value of license expiry"] - pub month: NvU16, - #[doc = "!< Day value of license expiry"] - pub day: NvU16, - #[doc = "!< Hour value of license expiry"] - pub hour: NvU16, - #[doc = "!< Minutes value of license expiry"] - pub min: NvU16, - #[doc = "!< Seconds value of license expiry"] - pub sec: NvU16, - #[doc = "!< License expiry status"] - pub status: NvU8, -} -pub type NV_LICENSE_EXPIRY_DETAILS = _NV_LICENSE_EXPIRY_DETAILS; -#[doc = "! Used in NV_LICENSABLE_FEATURES"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LICENSE_FEATURE_DETAILS_V1 { - #[doc = "!< IN - Structure version."] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Feature code that corresponds to the licensable feature."] - pub featureCode: NV_LICENSE_FEATURE_TYPE, - #[doc = "!< Deprecated"] - pub licenseInfo: NvAPI_LicenseString, -} -impl _NV_LICENSE_FEATURE_DETAILS_V1 { - #[inline] - pub fn isEnabled(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isEnabled(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isEnabled_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isEnabled_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isEnabled: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isEnabled: u32 = unsafe { ::std::mem::transmute(isEnabled) }; - isEnabled as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! Used in NV_LICENSABLE_FEATURES"] -pub type NV_LICENSE_FEATURE_DETAILS_V1 = _NV_LICENSE_FEATURE_DETAILS_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LICENSE_FEATURE_DETAILS_V2 { - #[doc = "!< Unused."] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Feature code that corresponds to the licensable feature."] - pub featureCode: NV_LICENSE_FEATURE_TYPE, - #[doc = "!< Deprecated"] - pub licenseInfo: NvAPI_LicenseString, - #[doc = "!< Nvidia Grid licensable product name."] - pub productName: NvAPI_LicenseString, -} -impl _NV_LICENSE_FEATURE_DETAILS_V2 { - #[inline] - pub fn isEnabled(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isEnabled(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isEnabled_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isEnabled_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isEnabled: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isEnabled: u32 = unsafe { ::std::mem::transmute(isEnabled) }; - isEnabled as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_LICENSE_FEATURE_DETAILS_V2 = _NV_LICENSE_FEATURE_DETAILS_V2; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LICENSE_FEATURE_DETAILS_V3 { - #[doc = "!< Unused."] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Feature code that corresponds to the licensable feature."] - pub featureCode: NV_LICENSE_FEATURE_TYPE, - #[doc = "!< Deprecated"] - pub licenseInfo: NvAPI_LicenseString, - #[doc = "!< Nvidia Grid licensable product name."] - pub productName: NvAPI_LicenseString, -} -impl _NV_LICENSE_FEATURE_DETAILS_V3 { - #[inline] - pub fn isEnabled(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isEnabled(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isEnabled_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isEnabled_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isFeatureEnabled(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_isFeatureEnabled(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isFeatureEnabled_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isFeatureEnabled_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 30u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 30u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 30u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isEnabled: NvU32, - isFeatureEnabled: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isEnabled: u32 = unsafe { ::std::mem::transmute(isEnabled) }; - isEnabled as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let isFeatureEnabled: u32 = unsafe { ::std::mem::transmute(isFeatureEnabled) }; - isFeatureEnabled as u64 - }); - __bindgen_bitfield_unit.set(2usize, 30u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_LICENSE_FEATURE_DETAILS_V3 = _NV_LICENSE_FEATURE_DETAILS_V3; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LICENSE_FEATURE_DETAILS_V4 { - #[doc = "!< Unused."] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Feature code that corresponds to the licensable feature."] - pub featureCode: NV_LICENSE_FEATURE_TYPE, - #[doc = "!< Deprecated"] - pub licenseInfo: NvAPI_LicenseString, - #[doc = "!< Nvidia Grid licensable product name."] - pub productName: NvAPI_LicenseString, - #[doc = "!< License expiry information."] - pub licenseExpiry: NV_LICENSE_EXPIRY_DETAILS, -} -impl _NV_LICENSE_FEATURE_DETAILS_V4 { - #[inline] - pub fn isEnabled(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isEnabled(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isEnabled_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isEnabled_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isFeatureEnabled(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_isFeatureEnabled(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isFeatureEnabled_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isFeatureEnabled_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 30u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 30u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 30u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isEnabled: NvU32, - isFeatureEnabled: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isEnabled: u32 = unsafe { ::std::mem::transmute(isEnabled) }; - isEnabled as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let isFeatureEnabled: u32 = unsafe { ::std::mem::transmute(isFeatureEnabled) }; - isFeatureEnabled as u64 - }); - __bindgen_bitfield_unit.set(2usize, 30u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_LICENSE_FEATURE_DETAILS_V4 = _NV_LICENSE_FEATURE_DETAILS_V4; -#[doc = "! Used in NV_LICENSABLE_FEATURES"] -pub type NV_LICENSE_FEATURE_DETAILS = NV_LICENSE_FEATURE_DETAILS_V1; -#[doc = "! Licensable features"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LICENSABLE_FEATURES_V1 { - #[doc = "!< IN - Structure version."] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< The number of licensable features."] - pub licensableFeatureCount: NvU32, - #[doc = "!< Dynamic signature required for Authentication of the components,\n!< signature length limited to NV_LICENSE_SIGNATURE_SIZE"] - pub signature: [NvU8; 128usize], - #[doc = "!< Array of licensable features"] - pub licenseDetails: [NV_LICENSE_FEATURE_DETAILS_V1; 3usize], -} -impl _NV_LICENSABLE_FEATURES_V1 { - #[inline] - pub fn isLicenseSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isLicenseSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isLicenseSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isLicenseSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isLicenseSupported: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isLicenseSupported: u32 = unsafe { ::std::mem::transmute(isLicenseSupported) }; - isLicenseSupported as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! Licensable features"] -pub type NV_LICENSABLE_FEATURES_V1 = _NV_LICENSABLE_FEATURES_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LICENSABLE_FEATURES_V2 { - #[doc = "!< IN - Structure version."] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< The number of licensable features."] - pub licensableFeatureCount: NvU32, - #[doc = "!< Dynamic signature required for Authentication of the components,\n!< signature length limited to NV_LICENSE_SIGNATURE_SIZE"] - pub signature: [NvU8; 128usize], - #[doc = "!< Array of licensable features"] - pub licenseDetails: [NV_LICENSE_FEATURE_DETAILS_V2; 3usize], -} -impl _NV_LICENSABLE_FEATURES_V2 { - #[inline] - pub fn isLicenseSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isLicenseSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isLicenseSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isLicenseSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isLicenseSupported: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isLicenseSupported: u32 = unsafe { ::std::mem::transmute(isLicenseSupported) }; - isLicenseSupported as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_LICENSABLE_FEATURES_V2 = _NV_LICENSABLE_FEATURES_V2; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LICENSABLE_FEATURES_V3 { - #[doc = "!< IN - Structure version."] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< The number of licensable features."] - pub licensableFeatureCount: NvU32, - #[doc = "!< Dynamic signature required for Authentication of the components,\n!< signature length limited to NV_LICENSE_SIGNATURE_SIZE"] - pub signature: [NvU8; 128usize], - #[doc = "!< Array of licensable features"] - pub licenseDetails: [NV_LICENSE_FEATURE_DETAILS_V3; 3usize], -} -impl _NV_LICENSABLE_FEATURES_V3 { - #[inline] - pub fn isLicenseSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isLicenseSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isLicenseSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isLicenseSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isLicenseSupported: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isLicenseSupported: u32 = unsafe { ::std::mem::transmute(isLicenseSupported) }; - isLicenseSupported as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_LICENSABLE_FEATURES_V3 = _NV_LICENSABLE_FEATURES_V3; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LICENSABLE_FEATURES_V4 { - #[doc = "!< IN - Structure version."] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< The number of licensable features."] - pub licensableFeatureCount: NvU32, - #[doc = "!< Dynamic signature required for Authentication of the components,\n!< signature length limited to NV_LICENSE_SIGNATURE_SIZE"] - pub signature: [NvU8; 128usize], - #[doc = "!< Array of licensable features"] - pub licenseDetails: [NV_LICENSE_FEATURE_DETAILS_V4; 3usize], -} -impl _NV_LICENSABLE_FEATURES_V4 { - #[inline] - pub fn isLicenseSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isLicenseSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isLicenseSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isLicenseSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isLicenseSupported: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isLicenseSupported: u32 = unsafe { ::std::mem::transmute(isLicenseSupported) }; - isLicenseSupported as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_LICENSABLE_FEATURES_V4 = _NV_LICENSABLE_FEATURES_V4; -pub type NV_LICENSABLE_FEATURES = NV_LICENSABLE_FEATURES_V4; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_ENCODER_STATISTICS_V1 { - #[doc = "!< [in] Structure version value."] - pub version: NvU32, - #[doc = "!< [out] Count of active encoder sessions."] - pub sessionsCount: NvU32, - #[doc = "!< [out] Trailing average FPS of all active sessions."] - pub averageFps: NvU32, - #[doc = "!< [out] Encode latency in microseconds."] - pub averageLatency: NvU32, -} -pub type NV_ENCODER_STATISTICS_V1 = _NV_ENCODER_STATISTICS_V1; -pub type NV_ENCODER_STATISTICS = NV_ENCODER_STATISTICS_V1; -pub const _NV_ENCODER_TYPE_NV_ENCODER_H264: _NV_ENCODER_TYPE = 0; -pub const _NV_ENCODER_TYPE_NV_ENCODER_HEVC: _NV_ENCODER_TYPE = 1; -pub const _NV_ENCODER_TYPE_NV_ENCODER_UNKNOWN: _NV_ENCODER_TYPE = -1; -pub type _NV_ENCODER_TYPE = ::std::os::raw::c_int; -pub use self::_NV_ENCODER_TYPE as NV_ENCODER_TYPE; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_ENCODER_PER_SESSION_INFO_V1 { - #[doc = "!< Unique session ID."] - pub sessionId: NvU32, - #[doc = "!< Owning process ID."] - pub processId: NvU32, - #[doc = "!< Owning vGPU instance ID (only valid on vGPU hosts, otherwise zero)."] - pub vgpuInstance: NvU32, - #[doc = "!< Video encoder type."] - pub codecType: NV_ENCODER_TYPE, - #[doc = "!< Current encode horizontal resolution."] - pub hResolution: NvU32, - #[doc = "!< Current encode vertical resolution."] - pub vResolution: NvU32, - #[doc = "!< Moving average encode frames per second."] - pub averageEncodeFps: NvU32, - #[doc = "!< Moving average encode latency in microseconds."] - pub averageEncodeLatency: NvU32, -} -pub type NV_ENCODER_PER_SESSION_INFO_V1 = _NV_ENCODER_PER_SESSION_INFO_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_ENCODER_SESSIONS_INFO_V1 { - #[doc = "!< [in] Structure version value."] - pub version: NvU32, - #[doc = "!< [out] Count of active encoder sessions."] - pub sessionsCount: NvU32, - #[doc = "!< [out] Array of session info. Caller should allocate memory for this field before making\n!< the NvAPI_GPU_GetEncoderSessionsInfo() call, memory allocated should be of\n!< size = sizeof(NV_ENCODER_PER_SESSION_INFO_V1) * NV_ENCODER_SESSION_INFO_MAX_ENTRIES_V1."] - pub pSessionInfo: *mut NV_ENCODER_PER_SESSION_INFO_V1, -} -pub type NV_ENCODER_SESSIONS_INFO_V1 = _NV_ENCODER_SESSIONS_INFO_V1; -pub type NV_ENCODER_SESSIONS_INFO = NV_ENCODER_SESSIONS_INFO_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_INFO_V1 { - #[doc = "!< Structure Version."] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, -} -impl _NV_GPU_INFO_V1 { - #[inline] - pub fn bIsExternalGpu(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsExternalGpu(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsExternalGpu_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsExternalGpu_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bIsExternalGpu: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsExternalGpu: u32 = unsafe { ::std::mem::transmute(bIsExternalGpu) }; - bIsExternalGpu as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_GPU_INFO_V1 = _NV_GPU_INFO_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_INFO_V2 { - #[doc = "!< Structure Version."] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Reserved for future use"] - pub reserved1: NvU64, - #[doc = "!< Number of \"Ray Tracing Cores\" supported by the GPU."] - pub rayTracingCores: NvU32, - #[doc = "!< Number of \"Tensor Cores\" supported by the GPU."] - pub tensorCores: NvU32, - #[doc = "!< Reserved for future use."] - pub reserved2: [NvU32; 14usize], -} -impl _NV_GPU_INFO_V2 { - #[inline] - pub fn bIsExternalGpu(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsExternalGpu(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsExternalGpu_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsExternalGpu_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved0(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved0(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved0_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved0_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bIsExternalGpu: NvU32, - reserved0: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsExternalGpu: u32 = unsafe { ::std::mem::transmute(bIsExternalGpu) }; - bIsExternalGpu as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved0: u32 = unsafe { ::std::mem::transmute(reserved0) }; - reserved0 as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_GPU_INFO_V2 = _NV_GPU_INFO_V2; -pub type NV_GPU_INFO = NV_GPU_INFO_V2; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_VR_READY_V1 { - #[doc = "!< Structure Version."] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, -} -impl _NV_GPU_VR_READY_V1 { - #[inline] - pub fn isVRReady(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isVRReady(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isVRReady_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isVRReady_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isVRReady: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isVRReady: u32 = unsafe { ::std::mem::transmute(isVRReady) }; - isVRReady as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_GPU_VR_READY_V1 = _NV_GPU_VR_READY_V1; -pub type NV_GPU_VR_READY = NV_GPU_VR_READY_V1; -pub const _NV_ADAPTER_TYPE_NV_ADAPTER_TYPE_UNKNOWN: _NV_ADAPTER_TYPE = 0; -pub const _NV_ADAPTER_TYPE_NV_ADAPTER_TYPE_WDDM: _NV_ADAPTER_TYPE = 1; -pub const _NV_ADAPTER_TYPE_NV_ADAPTER_TYPE_MCDM: _NV_ADAPTER_TYPE = 2; -pub const _NV_ADAPTER_TYPE_NV_ADAPTER_TYPE_TCC: _NV_ADAPTER_TYPE = 4; -pub const _NV_ADAPTER_TYPE_NV_ADAPTER_TYPE_LAST: _NV_ADAPTER_TYPE = -1; -pub type _NV_ADAPTER_TYPE = ::std::os::raw::c_int; -pub use self::_NV_ADAPTER_TYPE as NV_ADAPTER_TYPE; -#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetGspFeatures()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_GSP_INFO_V1 { - #[doc = "!< [in] Structure version"] - pub version: NvU32, - #[doc = "!< [out] Contains GSP firmware version"] - pub firmwareVersion: [NvU8; 64usize], - #[doc = "!< Reserved for future use"] - pub reserved: NvU32, -} -#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetGspFeatures()."] -pub type NV_GPU_GSP_INFO_V1 = _NV_GPU_GSP_INFO_V1; -#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetGspFeatures()."] -pub type NV_GPU_GSP_INFO = NV_GPU_GSP_INFO_V1; -#[doc = "! \\fn NvAPI_GPU_GetUUID(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_UUID *pGpuUuid)\n! DESCRIPTION: This function returns the GPU UUID for the specified physical GPU handle.\n! The UUID is returned in GUID format (16 bytes).\n!\n! SUPPORTED OS: Windows 10 and higher\n!\n!\n! TCC_SUPPORTED\n!\n! MCDM_SUPPORTED\n!\n! \\since Release: 595\n!\n! \\param [in] hPhysicalGpu Physical GPU handle to get UUID for\n! \\param [in,out] pGpuUuid Pointer to structure that will receive the GPU UUID\n!\n! \\retval NVAPI_OK Request completed successfully\n! \\return This API can return any of the error codes enumerated in #NvAPI_Status.\n!\n! \\ingroup gpu\n\n! Used in NvAPI_GPU_GetUUID()"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_UUID_V1 { - pub version: NvU32, - pub uuid: [NvU8; 16usize], -} -#[doc = "! \\fn NvAPI_GPU_GetUUID(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_UUID *pGpuUuid)\n! DESCRIPTION: This function returns the GPU UUID for the specified physical GPU handle.\n! The UUID is returned in GUID format (16 bytes).\n!\n! SUPPORTED OS: Windows 10 and higher\n!\n!\n! TCC_SUPPORTED\n!\n! MCDM_SUPPORTED\n!\n! \\since Release: 595\n!\n! \\param [in] hPhysicalGpu Physical GPU handle to get UUID for\n! \\param [in,out] pGpuUuid Pointer to structure that will receive the GPU UUID\n!\n! \\retval NVAPI_OK Request completed successfully\n! \\return This API can return any of the error codes enumerated in #NvAPI_Status.\n!\n! \\ingroup gpu\n\n! Used in NvAPI_GPU_GetUUID()"] -pub type NV_GPU_UUID_V1 = _NV_GPU_UUID_V1; -#[doc = "! \\fn NvAPI_GPU_GetUUID(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_UUID *pGpuUuid)\n! DESCRIPTION: This function returns the GPU UUID for the specified physical GPU handle.\n! The UUID is returned in GUID format (16 bytes).\n!\n! SUPPORTED OS: Windows 10 and higher\n!\n!\n! TCC_SUPPORTED\n!\n! MCDM_SUPPORTED\n!\n! \\since Release: 595\n!\n! \\param [in] hPhysicalGpu Physical GPU handle to get UUID for\n! \\param [in,out] pGpuUuid Pointer to structure that will receive the GPU UUID\n!\n! \\retval NVAPI_OK Request completed successfully\n! \\return This API can return any of the error codes enumerated in #NvAPI_Status.\n!\n! \\ingroup gpu\n\n! Used in NvAPI_GPU_GetUUID()"] -pub type NV_GPU_UUID = NV_GPU_UUID_V1; -#[doc = "! \\ingroup gpupstate\n! Used in NvAPI_GPU_GetPstatesInfoEx()"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_PERF_PSTATES_INFO_V1 { - pub version: NvU32, - #[doc = "!< - bit 0 indicates if perfmon is enabled or not\n!< - bit 1 indicates if dynamic Pstate is capable or not\n!< - bit 2 indicates if dynamic Pstate is enable or not\n!< - all other bits must be set to 0"] - pub flags: NvU32, - #[doc = "!< The number of available p-states"] - pub numPstates: NvU32, - #[doc = "!< The number of clock domains supported by each P-State"] - pub numClocks: NvU32, - pub pstates: [NV_GPU_PERF_PSTATES_INFO_V1__bindgen_ty_1; 16usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_PERF_PSTATES_INFO_V1__bindgen_ty_1 { - #[doc = "!< ID of the p-state."] - pub pstateId: NV_GPU_PERF_PSTATE_ID, - #[doc = "!< - bit 0 indicates if the PCIE limit is GEN1 or GEN2\n!< - bit 1 indicates if the Pstate is overclocked or not\n!< - bit 2 indicates if the Pstate is overclockable or not\n!< - all other bits must be set to 0"] - pub flags: NvU32, - pub clocks: [NV_GPU_PERF_PSTATES_INFO_V1__bindgen_ty_1__bindgen_ty_1; 32usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_PERF_PSTATES_INFO_V1__bindgen_ty_1__bindgen_ty_1 { - #[doc = "!< ID of the clock domain"] - pub domainId: NV_GPU_PUBLIC_CLOCK_ID, - #[doc = "!< Reserved. Must be set to 0"] - pub flags: NvU32, - #[doc = "!< Clock frequency in kHz"] - pub freq: NvU32, -} -#[doc = "! \\ingroup gpupstate"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_PERF_PSTATES_INFO_V2 { - pub version: NvU32, - #[doc = "!< - bit 0 indicates if perfmon is enabled or not\n!< - bit 1 indicates if dynamic Pstate is capable or not\n!< - bit 2 indicates if dynamic Pstate is enable or not\n!< - all other bits must be set to 0"] - pub flags: NvU32, - #[doc = "!< The number of available p-states"] - pub numPstates: NvU32, - #[doc = "!< The number of clock domains supported by each P-State"] - pub numClocks: NvU32, - pub numVoltages: NvU32, - #[doc = "!< Valid index range is 0 to numVoltages-1"] - pub pstates: [NV_GPU_PERF_PSTATES_INFO_V2__bindgen_ty_1; 16usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_PERF_PSTATES_INFO_V2__bindgen_ty_1 { - #[doc = "!< ID of the p-state."] - pub pstateId: NV_GPU_PERF_PSTATE_ID, - #[doc = "!< - bit 0 indicates if the PCIE limit is GEN1 or GEN2\n!< - bit 1 indicates if the Pstate is overclocked or not\n!< - bit 2 indicates if the Pstate is overclockable or not\n!< - all other bits must be set to 0"] - pub flags: NvU32, - pub clocks: [NV_GPU_PERF_PSTATES_INFO_V2__bindgen_ty_1__bindgen_ty_1; 32usize], - pub voltages: [NV_GPU_PERF_PSTATES_INFO_V2__bindgen_ty_1__bindgen_ty_2; 16usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_PERF_PSTATES_INFO_V2__bindgen_ty_1__bindgen_ty_1 { - pub domainId: NV_GPU_PUBLIC_CLOCK_ID, - #[doc = "!< bit 0 indicates if this clock is overclockable\n!< all other bits must be set to 0"] - pub flags: NvU32, - pub freq: NvU32, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_PERF_PSTATES_INFO_V2__bindgen_ty_1__bindgen_ty_2 { - #[doc = "!< ID of the voltage domain, containing flags and mvolt info"] - pub domainId: NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID, - #[doc = "!< Reserved for future use. Must be set to 0"] - pub flags: NvU32, - #[doc = "!< Voltage in mV"] - pub mvolt: NvU32, -} -#[doc = "! \\ingroup gpupstate"] -pub type NV_GPU_PERF_PSTATES_INFO = NV_GPU_PERF_PSTATES_INFO_V2; -#[doc = "! \\ingroup gpupstate\n! Used in NvAPI_GPU_GetDynamicPstatesInfoEx()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_DYNAMIC_PSTATES_INFO_EX { - #[doc = "!< Structure version"] - pub version: NvU32, - #[doc = "!< bit 0 indicates if the dynamic Pstate is enabled or not"] - pub flags: NvU32, - pub utilization: [NV_GPU_DYNAMIC_PSTATES_INFO_EX__bindgen_ty_1; 8usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_DYNAMIC_PSTATES_INFO_EX__bindgen_ty_1 { - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, - #[doc = "!< Percentage of time where the domain is considered busy in the last 1 second interval"] - pub percentage: NvU32, -} -impl NV_GPU_DYNAMIC_PSTATES_INFO_EX__bindgen_ty_1 { - #[inline] - pub fn bIsPresent(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsPresent(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsPresent_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsPresent_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1(bIsPresent: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsPresent: u32 = unsafe { ::std::mem::transmute(bIsPresent) }; - bIsPresent as u64 - }); - __bindgen_bitfield_unit - } -} -pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_NONE: NV_THERMAL_TARGET = 0; -#[doc = "!< GPU core temperature requires NvPhysicalGpuHandle"] -pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_GPU: NV_THERMAL_TARGET = 1; -#[doc = "!< GPU memory temperature requires NvPhysicalGpuHandle"] -pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_MEMORY: NV_THERMAL_TARGET = 2; -#[doc = "!< GPU power supply temperature requires NvPhysicalGpuHandle"] -pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_POWER_SUPPLY: NV_THERMAL_TARGET = 4; -#[doc = "!< GPU board ambient temperature requires NvPhysicalGpuHandle"] -pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_BOARD: NV_THERMAL_TARGET = 8; -#[doc = "!< Visual Computing Device Board temperature requires NvVisualComputingDeviceHandle"] -pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_VCD_BOARD: NV_THERMAL_TARGET = 9; -#[doc = "!< Visual Computing Device Inlet temperature requires NvVisualComputingDeviceHandle"] -pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_VCD_INLET: NV_THERMAL_TARGET = 10; -#[doc = "!< Visual Computing Device Outlet temperature requires NvVisualComputingDeviceHandle"] -pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_VCD_OUTLET: NV_THERMAL_TARGET = 11; -pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_ALL: NV_THERMAL_TARGET = 15; -pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_UNKNOWN: NV_THERMAL_TARGET = -1; -#[doc = "! \\ingroup gputhermal\n! Used in NV_GPU_THERMAL_SETTINGS"] -pub type NV_THERMAL_TARGET = ::std::os::raw::c_int; -pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_NONE: NV_THERMAL_CONTROLLER = 0; -pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_GPU_INTERNAL: NV_THERMAL_CONTROLLER = 1; -pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_ADM1032: NV_THERMAL_CONTROLLER = 2; -pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_MAX6649: NV_THERMAL_CONTROLLER = 3; -pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_MAX1617: NV_THERMAL_CONTROLLER = 4; -pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_LM99: NV_THERMAL_CONTROLLER = 5; -pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_LM89: NV_THERMAL_CONTROLLER = 6; -pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_LM64: NV_THERMAL_CONTROLLER = 7; -pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_ADT7473: NV_THERMAL_CONTROLLER = 8; -pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_SBMAX6649: NV_THERMAL_CONTROLLER = 9; -pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_VBIOSEVT: NV_THERMAL_CONTROLLER = 10; -pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_OS: NV_THERMAL_CONTROLLER = 11; -pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_UNKNOWN: NV_THERMAL_CONTROLLER = -1; -#[doc = "! \\ingroup gputhermal\n! Used in NV_GPU_THERMAL_SETTINGS"] -pub type NV_THERMAL_CONTROLLER = ::std::os::raw::c_int; -#[doc = "! \\ingroup gputhermal\n! Used in NvAPI_GPU_GetThermalSettings()"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_THERMAL_SETTINGS_V1 { - #[doc = "!< structure version"] - pub version: NvU32, - #[doc = "!< number of associated thermal sensors"] - pub count: NvU32, - pub sensor: [NV_GPU_THERMAL_SETTINGS_V1__bindgen_ty_1; 3usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_THERMAL_SETTINGS_V1__bindgen_ty_1 { - #[doc = "!< internal, ADM1032, MAX6649..."] - pub controller: NV_THERMAL_CONTROLLER, - #[doc = "!< The min default temperature value of the thermal sensor in degree Celsius"] - pub defaultMinTemp: NvU32, - #[doc = "!< The max default temperature value of the thermal sensor in degree Celsius"] - pub defaultMaxTemp: NvU32, - #[doc = "!< The current temperature value of the thermal sensor in degree Celsius"] - pub currentTemp: NvU32, - #[doc = "!< Thermal sensor targeted @ GPU, memory, chipset, powersupply, Visual Computing Device, etc."] - pub target: NV_THERMAL_TARGET, -} -#[doc = "! \\ingroup gputhermal"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_THERMAL_SETTINGS_V2 { - #[doc = "!< structure version"] - pub version: NvU32, - #[doc = "!< number of associated thermal sensors"] - pub count: NvU32, - pub sensor: [NV_GPU_THERMAL_SETTINGS_V2__bindgen_ty_1; 3usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_THERMAL_SETTINGS_V2__bindgen_ty_1 { - #[doc = "!< internal, ADM1032, MAX6649..."] - pub controller: NV_THERMAL_CONTROLLER, - #[doc = "!< Minimum default temperature value of the thermal sensor in degree Celsius"] - pub defaultMinTemp: NvS32, - #[doc = "!< Maximum default temperature value of the thermal sensor in degree Celsius"] - pub defaultMaxTemp: NvS32, - #[doc = "!< Current temperature value of the thermal sensor in degree Celsius"] - pub currentTemp: NvS32, - #[doc = "!< Thermal sensor targeted - GPU, memory, chipset, powersupply, Visual Computing Device, etc"] - pub target: NV_THERMAL_TARGET, -} -#[doc = "! \\ingroup gputhermal"] -pub type NV_GPU_THERMAL_SETTINGS = NV_GPU_THERMAL_SETTINGS_V2; -#[doc = "! \\ingroup gpuclock\n! Used in NvAPI_GPU_GetAllClockFrequencies()"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_CLOCK_FREQUENCIES_V1 { - #[doc = "!< Structure version"] - pub version: NvU32, - #[doc = "!< These bits are reserved for future use."] - pub reserved: NvU32, - pub domain: [NV_GPU_CLOCK_FREQUENCIES_V1__bindgen_ty_1; 32usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_CLOCK_FREQUENCIES_V1__bindgen_ty_1 { - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Clock frequency (kHz)"] - pub frequency: NvU32, -} -impl NV_GPU_CLOCK_FREQUENCIES_V1__bindgen_ty_1 { - #[inline] - pub fn bIsPresent(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsPresent(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsPresent_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsPresent_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bIsPresent: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsPresent: u32 = unsafe { ::std::mem::transmute(bIsPresent) }; - bIsPresent as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub const NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE_NV_GPU_CLOCK_FREQUENCIES_CURRENT_FREQ: - NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE = 0; -pub const NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE_NV_GPU_CLOCK_FREQUENCIES_BASE_CLOCK: - NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE = 1; -pub const NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE_NV_GPU_CLOCK_FREQUENCIES_BOOST_CLOCK: - NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE = 2; -pub const NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE_NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE_NUM: - NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE = 3; -#[doc = "! \\ingroup gpuclock\n! Used in NvAPI_GPU_GetAllClockFrequencies()"] -pub type NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE = ::std::os::raw::c_int; -#[doc = "! \\ingroup gpuclock\n! Used in NvAPI_GPU_GetAllClockFrequencies()"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_CLOCK_FREQUENCIES_V2 { - #[doc = "!< Structure version"] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - pub domain: [NV_GPU_CLOCK_FREQUENCIES_V2__bindgen_ty_1; 32usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_CLOCK_FREQUENCIES_V2__bindgen_ty_1 { - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Clock frequency (kHz)"] - pub frequency: NvU32, -} -impl NV_GPU_CLOCK_FREQUENCIES_V2__bindgen_ty_1 { - #[inline] - pub fn bIsPresent(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsPresent(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsPresent_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsPresent_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bIsPresent: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsPresent: u32 = unsafe { ::std::mem::transmute(bIsPresent) }; - bIsPresent as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -impl NV_GPU_CLOCK_FREQUENCIES_V2 { - #[inline] - pub fn ClockType(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32) } - } - #[inline] - pub fn set_ClockType(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 4u8, val as u64) - } - } - #[inline] - pub unsafe fn ClockType_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 4u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_ClockType_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 4u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 20u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 20u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 20u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 20u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved1(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u32) } - } - #[inline] - pub fn set_reserved1(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(24usize, 8u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved1_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 24usize, - 8u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved1_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 24usize, - 8u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - ClockType: NvU32, - reserved: NvU32, - reserved1: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 4u8, { - let ClockType: u32 = unsafe { ::std::mem::transmute(ClockType) }; - ClockType as u64 - }); - __bindgen_bitfield_unit.set(4usize, 20u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit.set(24usize, 8u8, { - let reserved1: u32 = unsafe { ::std::mem::transmute(reserved1) }; - reserved1 as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! \\ingroup gpuclock\n! Used in NvAPI_GPU_GetAllClockFrequencies()"] -pub type NV_GPU_CLOCK_FREQUENCIES = NV_GPU_CLOCK_FREQUENCIES_V2; -pub const _NV_GPU_ILLUMINATION_ATTRIB_NV_GPU_IA_LOGO_BRIGHTNESS: _NV_GPU_ILLUMINATION_ATTRIB = 0; -pub const _NV_GPU_ILLUMINATION_ATTRIB_NV_GPU_IA_SLI_BRIGHTNESS: _NV_GPU_ILLUMINATION_ATTRIB = 1; -#[doc = "! \\ingroup gpu"] -pub type _NV_GPU_ILLUMINATION_ATTRIB = ::std::os::raw::c_int; -#[doc = "! \\ingroup gpu"] -pub use self::_NV_GPU_ILLUMINATION_ATTRIB as NV_GPU_ILLUMINATION_ATTRIB; -#[doc = "! \\ingroup gpu"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_QUERY_ILLUMINATION_SUPPORT_PARM_V1 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< The handle of the GPU that you are checking for the specified attribute.\n!< note that this is the GPU that is managing the attribute.\n!< Only a single GPU can manage an given attribute on a given HW element,\n!< regardless of how many are attatched.\n!< I.E. only one GPU will be used to control the brightness of the LED on an SLI bridge,\n!< regardless of how many are physicaly attached.\n!< You enumerate thru the GPUs with this call to determine which GPU is managing the attribute."] - pub hPhysicalGpu: NvPhysicalGpuHandle, - #[doc = "!< An enumeration value specifying the Illumination attribute to be querried.\n!< refer to enum \\ref NV_GPU_ILLUMINATION_ATTRIB."] - pub Attribute: NV_GPU_ILLUMINATION_ATTRIB, - #[doc = "!< A boolean indicating if the attribute is supported."] - pub bSupported: NvU32, -} -#[doc = "! \\ingroup gpu"] -pub type NV_GPU_QUERY_ILLUMINATION_SUPPORT_PARM_V1 = _NV_GPU_QUERY_ILLUMINATION_SUPPORT_PARM_V1; -#[doc = "! \\ingroup gpu"] -pub type NV_GPU_QUERY_ILLUMINATION_SUPPORT_PARM = NV_GPU_QUERY_ILLUMINATION_SUPPORT_PARM_V1; -#[doc = "! \\ingroup gpu"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_GET_ILLUMINATION_PARM_V1 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< The handle of the GPU that you are checking for the specified attribute.\n!< Note that this is the GPU that is managing the attribute.\n!< Only a single GPU can manage an given attribute on a given HW element,\n!< regardless of how many are attatched.\n!< I.E. only one GPU will be used to control the brightness of the LED on an SLI bridge,\n!< regardless of how many are physicaly attached.\n!< You enumerate thru the GPUs with this call to determine which GPU is managing the attribute."] - pub hPhysicalGpu: NvPhysicalGpuHandle, - #[doc = "!< An enumeration value specifying the Illumination attribute to be querried.\n!< refer to enum \\ref NV_GPU_ILLUMINATION_ATTRIB."] - pub Attribute: NV_GPU_ILLUMINATION_ATTRIB, - #[doc = "!< A DWORD that will contain the current value of the specified attribute."] - pub Value: NvU32, -} -#[doc = "! \\ingroup gpu"] -pub type NV_GPU_GET_ILLUMINATION_PARM_V1 = _NV_GPU_GET_ILLUMINATION_PARM_V1; -#[doc = "! \\ingroup gpu"] -pub type NV_GPU_GET_ILLUMINATION_PARM = NV_GPU_GET_ILLUMINATION_PARM_V1; -#[doc = "! \\ingroup gpu"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_SET_ILLUMINATION_PARM_V1 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< The handle of the GPU that you are checking for the specified attribute.\n!< Note that this is the GPU that is managing the attribute.\n!< Only a single GPU can manage an given attribute on a given HW element,\n!< regardless of how many are attatched.\n!< I.E. only one GPU will be used to control the brightness of the LED on an SLI bridge,\n!< regardless of how many are physicaly attached.\n!< You enumerate thru the GPUs with this call to determine which GPU is managing the attribute."] - pub hPhysicalGpu: NvPhysicalGpuHandle, - #[doc = "!< An enumeration value specifying the Illumination attribute to be querried.\n!< refer to enum \\ref NV_GPU_ILLUMINATION_ATTRIB."] - pub Attribute: NV_GPU_ILLUMINATION_ATTRIB, - #[doc = "!< A DWORD containing the new value for the specified attribute.\n!< This should be specified as a percentage of the full range of the attribute\n!< (0-100; 0 = off, 100 = full brightness)\n!< If a value is specified outside this range, NVAPI_INVALID_ARGUMENT will be returned."] - pub Value: NvU32, -} -#[doc = "! \\ingroup gpu"] -pub type NV_GPU_SET_ILLUMINATION_PARM_V1 = _NV_GPU_SET_ILLUMINATION_PARM_V1; -#[doc = "! \\ingroup gpu"] -pub type NV_GPU_SET_ILLUMINATION_PARM = NV_GPU_SET_ILLUMINATION_PARM_V1; -pub const NV_GPU_CLIENT_ILLUM_CTRL_MODE_NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB: - NV_GPU_CLIENT_ILLUM_CTRL_MODE = 0; -pub const NV_GPU_CLIENT_ILLUM_CTRL_MODE_NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB: - NV_GPU_CLIENT_ILLUM_CTRL_MODE = 1; -pub const NV_GPU_CLIENT_ILLUM_CTRL_MODE_NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL: - NV_GPU_CLIENT_ILLUM_CTRL_MODE = 0; -pub const NV_GPU_CLIENT_ILLUM_CTRL_MODE_NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR: - NV_GPU_CLIENT_ILLUM_CTRL_MODE = 1; -pub const NV_GPU_CLIENT_ILLUM_CTRL_MODE_NV_GPU_CLIENT_ILLUM_CTRL_MODE_INVALID: - NV_GPU_CLIENT_ILLUM_CTRL_MODE = 255; -#[doc = " Enumeration of control modes that can be applied to Illumination Zones."] -pub type NV_GPU_CLIENT_ILLUM_CTRL_MODE = ::std::os::raw::c_int; -pub const NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_GPU_TOP_0: - NV_GPU_CLIENT_ILLUM_ZONE_LOCATION = 0; -pub const NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_GPU_FRONT_0: - NV_GPU_CLIENT_ILLUM_ZONE_LOCATION = 8; -pub const NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_GPU_BACK_0: - NV_GPU_CLIENT_ILLUM_ZONE_LOCATION = 12; -pub const NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_SLI_TOP_0: - NV_GPU_CLIENT_ILLUM_ZONE_LOCATION = 32; -pub const NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_INVALID: - NV_GPU_CLIENT_ILLUM_ZONE_LOCATION = -1; -#[doc = " Enumeration of locations where an Illumination Zone might be present.\n Encoding used -\n 1:0 - Number specifier (0)\n 4:2 - Location (TOP)\n 7:5 - Type (GPU/SLI)"] -pub type NV_GPU_CLIENT_ILLUM_ZONE_LOCATION = ::std::os::raw::c_int; -pub const NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_INVALID: - NV_GPU_CLIENT_ILLUM_DEVICE_TYPE = 0; -pub const NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_MCUV10: - NV_GPU_CLIENT_ILLUM_DEVICE_TYPE = 1; -pub const NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_GPIO_PWM_RGBW_V10: - NV_GPU_CLIENT_ILLUM_DEVICE_TYPE = 2; -pub const NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_GPIO_PWM_SINGLE_COLOR_V10 : NV_GPU_CLIENT_ILLUM_DEVICE_TYPE = 3 ; -#[doc = " Enumeration of ILLUM_DEVICEs."] -pub type NV_GPU_CLIENT_ILLUM_DEVICE_TYPE = ::std::os::raw::c_int; -pub const NV_GPU_CLIENT_ILLUM_ZONE_TYPE_NV_GPU_CLIENT_ILLUM_ZONE_TYPE_INVALID: - NV_GPU_CLIENT_ILLUM_ZONE_TYPE = 0; -pub const NV_GPU_CLIENT_ILLUM_ZONE_TYPE_NV_GPU_CLIENT_ILLUM_ZONE_TYPE_RGB: - NV_GPU_CLIENT_ILLUM_ZONE_TYPE = 1; -pub const NV_GPU_CLIENT_ILLUM_ZONE_TYPE_NV_GPU_CLIENT_ILLUM_ZONE_TYPE_COLOR_FIXED: - NV_GPU_CLIENT_ILLUM_ZONE_TYPE = 2; -pub const NV_GPU_CLIENT_ILLUM_ZONE_TYPE_NV_GPU_CLIENT_ILLUM_ZONE_TYPE_RGBW: - NV_GPU_CLIENT_ILLUM_ZONE_TYPE = 3; -pub const NV_GPU_CLIENT_ILLUM_ZONE_TYPE_NV_GPU_CLIENT_ILLUM_ZONE_TYPE_SINGLE_COLOR: - NV_GPU_CLIENT_ILLUM_ZONE_TYPE = 4; -#[doc = " Enumeration of ILLUM_ZONEs."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_TYPE = ::std::os::raw::c_int; -pub const NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE_NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_HALF_HALT : NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE = 0 ; -pub const NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE_NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_FULL_HALT : NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE = 1 ; -pub const NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE_NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_FULL_REPEAT : NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE = 2 ; -pub const NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE_NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_INVALID : NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE = 255 ; -#[doc = " Enumeration of Cycle types for piecewise linear control mode."] -pub type NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE = ::std::os::raw::c_int; -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1\n Describes the static information of illumination device type MCUV10."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_MCUV10 { - #[doc = " I2C Device Index: Pointing to the illumination device in I2C Devices Table."] - pub i2cDevIdx: NvU8, -} -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1\n Describes the static information of illumination device type MCUV10."] -pub type NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_MCUV10 = _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_MCUV10; -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1\n Describes the static information of illum device type GPIO_PWM_RGBW."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_RGBW { - #[doc = " Red drive GPIO pin."] - pub gpioPinRed: NvU8, - #[doc = " Green drive GPIO pin."] - pub gpioPinGreen: NvU8, - #[doc = " Blue drive GPIO pin."] - pub gpioPinBlue: NvU8, - #[doc = " White drive GPIO pin."] - pub gpioPinWhite: NvU8, -} -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1\n Describes the static information of illum device type GPIO_PWM_RGBW."] -pub type NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_RGBW = - _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_RGBW; -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1\n Describes the static information of illum device type GPIO_PWM_SINGLE_COLOR."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_SINGLE_COLOR { - #[doc = " Single Color GPIO pin."] - pub gpioPinSingleColor: NvU8, -} -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1\n Describes the static information of illum device type GPIO_PWM_SINGLE_COLOR."] -pub type NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_SINGLE_COLOR = - _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_SINGLE_COLOR; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1 { - #[doc = " Type of the illumination device."] - pub type_: NV_GPU_CLIENT_ILLUM_DEVICE_TYPE, - #[doc = " Supported control modes for this illumination device."] - pub ctrlModeMask: NvU32, - pub data: _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1__bindgen_ty_1, - #[doc = " Reserved for future."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Union of illumination device info data. Interpreted as per\n @ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1::type"] -#[repr(C)] -#[derive(Copy, Clone)] -pub union _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1__bindgen_ty_1 { - pub mcuv10: NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_MCUV10, - pub gpioPwmRgbwv10: NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_RGBW, - pub gpioPwmSingleColorv10: NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_SINGLE_COLOR, - #[doc = " Reserved bytes for possible future extension of this struct."] - pub rsvd: [NvU8; 64usize], -} -pub type NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1 = _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_PARAMS_V1 { - #[doc = " Version of structure. Must always be first member."] - pub version: NvU32, - #[doc = " Number of illumination devices present."] - pub numIllumDevices: NvU32, - #[doc = " Reserved bytes for possible future extension of this struct."] - pub rsvd: [NvU8; 64usize], - pub devices: [NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1; 32usize], -} -pub type NV_GPU_CLIENT_ILLUM_DEVICE_INFO_PARAMS_V1 = _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_PARAMS_V1; -pub type NV_GPU_CLIENT_ILLUM_DEVICE_INFO_PARAMS = NV_GPU_CLIENT_ILLUM_DEVICE_INFO_PARAMS_V1; -#[doc = " Structure representing the data required for synchronization."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_CLIENT_ILLUM_DEVICE_SYNC_V1 { - #[doc = " Boolean representing the need for synchronization."] - pub bSync: NvBool, - #[doc = " Time stamp value required for synchronization."] - pub timeStampms: NvU64, - #[doc = " Reserved for future."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Structure representing the device control parameters of each ILLUM_DEVICE."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_V1 { - #[doc = " Type of the illum device."] - pub type_: NV_GPU_CLIENT_ILLUM_DEVICE_TYPE, - #[doc = " Structure containing the synchronization data for the illumination device."] - pub syncData: NV_GPU_CLIENT_ILLUM_DEVICE_SYNC_V1, - #[doc = " Reserved for future."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Structure representing the device control parameters of each ILLUM_DEVICE."] -pub type NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL = NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_V1; -#[doc = " Structure representing the control parameters of ILLUM_DEVICE-s."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_PARAMS_V1 { - #[doc = " Version of structure. Must always be first member."] - pub version: NvU32, - #[doc = " Number of illumination devices present."] - pub numIllumDevices: NvU32, - #[doc = " Reserved bytes for possible future extension of this struct."] - pub rsvd: [NvU8; 64usize], - pub devices: [NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_V1; 32usize], -} -#[doc = " Structure representing the control parameters of ILLUM_DEVICE-s."] -pub type NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_PARAMS = NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_PARAMS_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGB { - pub rsvd: NvU8, -} -pub type NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGB = _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGB; -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1\n Describes the static information of illum zone type RGBW."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGBW { - pub rsvd: NvU8, -} -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1\n Describes the static information of illum zone type RGBW."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGBW = _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGBW; -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1\n Describes the static information of illum zone type SINGLE_COLOR."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_SINGLE_COLOR { - pub rsvd: NvU8, -} -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1\n Describes the static information of illum zone type SINGLE_COLOR."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_SINGLE_COLOR = - _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_SINGLE_COLOR; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1 { - pub type_: NV_GPU_CLIENT_ILLUM_ZONE_TYPE, - #[doc = " Index pointing to an Illumination Device that controls this zone."] - pub illumDeviceIdx: NvU8, - #[doc = " Provider index for representing logical to physical zone mapping."] - pub provIdx: NvU8, - #[doc = " Location of the zone on the board."] - pub zoneLocation: NV_GPU_CLIENT_ILLUM_ZONE_LOCATION, - pub data: _NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1__bindgen_ty_1, - pub rsvd: [NvU8; 64usize], -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union _NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1__bindgen_ty_1 { - pub rgb: NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGB, - pub rgbw: NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGBW, - pub singleColor: NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_SINGLE_COLOR, - #[doc = " Reserved bytes for possible future extension of this struct."] - pub rsvd: [NvU8; 64usize], -} -pub type NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1 = _NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_INFO_PARAMS_V1 { - #[doc = " Version of structure. Must always be first member."] - pub version: NvU32, - #[doc = " Number of illumination zones present."] - pub numIllumZones: NvU32, - #[doc = " Reserved bytes for possible future extension of this struct."] - pub rsvd: [NvU8; 64usize], - pub zones: [NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1; 32usize], -} -pub type NV_GPU_CLIENT_ILLUM_ZONE_INFO_PARAMS_V1 = _NV_GPU_CLIENT_ILLUM_ZONE_INFO_PARAMS_V1; -pub type NV_GPU_CLIENT_ILLUM_ZONE_INFO_PARAMS = NV_GPU_CLIENT_ILLUM_ZONE_INFO_PARAMS_V1; -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB\n Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB_PARAMS { - #[doc = " Red compenent of color applied to the zone."] - pub colorR: NvU8, - #[doc = " Green compenent of color applied to the zone."] - pub colorG: NvU8, - #[doc = " Blue compenent of color applied to the zone."] - pub colorB: NvU8, - #[doc = " Brightness perecentage value of the zone."] - pub brightnessPct: NvU8, -} -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB\n Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB_PARAMS = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB_PARAMS; -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB { - #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] - pub rgbParams: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB_PARAMS, -} -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB; -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR { - #[doc = " Type of cycle effect to apply."] - pub cycleType: NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE, - #[doc = " Number of times to repeat function within group period."] - pub grpCount: NvU8, - #[doc = " Time in ms to transition from color A to color B."] - pub riseTimems: NvU16, - #[doc = " Time in ms to transition from color B to color A."] - pub fallTimems: NvU16, - #[doc = " Time in ms to remain at color A before color A to color B transition."] - pub ATimems: NvU16, - #[doc = " Time in ms to remain at color B before color B to color A transition."] - pub BTimems: NvU16, - #[doc = " Time in ms to remain idle before next group of repeated function cycles."] - pub grpIdleTimems: NvU16, - #[doc = " Time in ms to offset the cycle relative to other zones."] - pub phaseOffsetms: NvU16, -} -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR; -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB { - #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] - pub rgbParams: [NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB_PARAMS; 2usize], - pub piecewiseLinearData: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR, -} -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB; -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illumination zone of type\n \\ref NV_GPU_CLIENT_ILLUM_ZONE_TYPE_RGB."] -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB { - pub data: _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB__bindgen_ty_1, - #[doc = " Reserved for future."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Union of illumination zone control data for zone of type NV_GPU_CLIENT_ILLUM_ZONE_TYPE_RGB.\n Interpreted as per ctrlMode."] -#[repr(C)] -#[derive(Copy, Clone)] -pub union _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB__bindgen_ty_1 { - pub manualRGB: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB, - pub piecewiseLinearRGB: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB, - #[doc = " Reserved bytes for possible future extension of this struct."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illumination zone of type\n \\ref NV_GPU_CLIENT_ILLUM_ZONE_TYPE_RGB."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB = _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB; -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED\n Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_RGB."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED_PARAMS { - #[doc = " Brightness percentage value of the zone."] - pub brightnessPct: NvU8, -} -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED\n Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_RGB."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED_PARAMS = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED_PARAMS; -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED { - #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] - pub colorFixedParams: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED_PARAMS, -} -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED; -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_COLOR_FIXED { - #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] - pub colorFixedParams: [NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED_PARAMS; 2usize], - pub piecewiseLinearData: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR, -} -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_COLOR_FIXED = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_COLOR_FIXED; -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illum zone of type\n \\ref NV_GPU_CLIENT_ILLUM_ZONE_TYPE_COLOR_FIXED."] -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED { - pub data: _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED__bindgen_ty_1, - #[doc = " Reserved for future."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Union of illum zone control data for zone of type NV_GPU_CLIENT_ILLUM_ZONE_TYPE_COLOR_FIXED.\n Interpreted as per ctrlMode."] -#[repr(C)] -#[derive(Copy, Clone)] -pub union _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED__bindgen_ty_1 { - pub manualColorFixed: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED, - pub piecewiseLinearColorFixed: - NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_COLOR_FIXED, - #[doc = " Reserved bytes for possible future extension of this struct."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illum zone of type\n \\ref NV_GPU_CLIENT_ILLUM_ZONE_TYPE_COLOR_FIXED."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED; -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW\n Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGBW."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW_PARAMS { - #[doc = " Red component of color applied to the zone."] - pub colorR: NvU8, - #[doc = " Green component of color applied to the zone."] - pub colorG: NvU8, - #[doc = " Blue component of color applied to the zone."] - pub colorB: NvU8, - #[doc = " White component of color applied to the zone."] - pub colorW: NvU8, - #[doc = " Brightness percentage value of the zone."] - pub brightnessPct: NvU8, -} -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW\n Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGBW."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW_PARAMS = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW_PARAMS; -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_RGBW\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_RGBW."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW { - #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_RGBW."] - pub rgbwParams: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW_PARAMS, -} -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_RGBW\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_RGBW."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW; -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_RGBW\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGBW."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGBW { - #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGBW."] - pub rgbwParams: [NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW_PARAMS; 2usize], - pub piecewiseLinearData: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR, -} -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_RGBW\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGBW."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGBW = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGBW; -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illum zone of type\n \\ref NV_GPU_ILLUM_ZONE_TYPE_RGBW."] -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW { - pub data: _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW__bindgen_ty_1, - #[doc = " Reserved for future."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Union of illum zone control data for zone of type NV_GPU_ILLUM_ZONE_TYPE_RGBW.\n Interpreted as per ctrlMode."] -#[repr(C)] -#[derive(Copy, Clone)] -pub union _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW__bindgen_ty_1 { - pub manualRGBW: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW, - pub piecewiseLinearRGBW: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGBW, - #[doc = " Reserved bytes for possible future extension of this struct."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illum zone of type\n \\ref NV_GPU_ILLUM_ZONE_TYPE_RGBW."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW = _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW; -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR\n Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_SINGLE_COLOR."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR_PARAMS { - #[doc = " Brightness percentage value of the zone."] - pub brightnessPct: NvU8, -} -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR\n Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_SINGLE_COLOR."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR_PARAMS = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR_PARAMS; -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_SINGLE_COLOR."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR { - #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_SINGLE_COLOR."] - pub singleColorParams: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR_PARAMS, -} -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_SINGLE_COLOR."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR; -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_SINGLE_COLOR."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_SINGLE_COLOR { - #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_SINGLE_COLOR."] - pub singleColorParams: - [NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR_PARAMS; 2usize], - pub piecewiseLinearData: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR, -} -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_SINGLE_COLOR."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_SINGLE_COLOR = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_SINGLE_COLOR; -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illum zone of type\n \\ref NV_GPU_ILLUM_ZONE_TYPE_SINGLE_COLOR."] -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR { - pub data: _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR__bindgen_ty_1, - #[doc = " Reserved for future."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Union of illum zone control data for zone of type NV_GPU_ILLUM_ZONE_TYPE_SINGLE_COLOR.\n Interpreted as per ctrlMode."] -#[repr(C)] -#[derive(Copy, Clone)] -pub union _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR__bindgen_ty_1 { - pub manualSingleColor: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR, - pub piecewiseLinearSingleColor: - NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_SINGLE_COLOR, - #[doc = " Reserved bytes for possible future extension of this struct."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illum zone of type\n \\ref NV_GPU_ILLUM_ZONE_TYPE_SINGLE_COLOR."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1 { - pub type_: NV_GPU_CLIENT_ILLUM_ZONE_TYPE, - pub ctrlMode: NV_GPU_CLIENT_ILLUM_CTRL_MODE, - pub data: _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1__bindgen_ty_1, - pub rsvd: [NvU8; 64usize], -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1__bindgen_ty_1 { - pub rgb: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB, - pub colorFixed: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED, - pub rgbw: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW, - pub singleColor: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR, - pub rsvd: [NvU8; 64usize], -} -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1 = _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS_V1 { - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = " Number of illumination zones present."] - pub numIllumZonesControl: NvU32, - #[doc = " Reserved bytes for possible future extension of this struct."] - pub rsvd: [NvU8; 64usize], - pub zones: [NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1; 32usize], -} -impl _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS_V1 { - #[inline] - pub fn bDefault(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bDefault(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bDefault_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bDefault_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn rsvdField(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_rsvdField(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn rsvdField_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_rsvdField_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bDefault: NvU32, - rsvdField: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bDefault: u32 = unsafe { ::std::mem::transmute(bDefault) }; - bDefault as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let rsvdField: u32 = unsafe { ::std::mem::transmute(rsvdField) }; - rsvdField as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS_V1 = _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS_V1; -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS = NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS_V1; -#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_GetDisplayPortInfo()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_DISPLAY_PORT_INFO_V1 { - #[doc = "!< Structure version"] - pub version: NvU32, - #[doc = "!< DPCD version of the monitor"] - pub dpcd_ver: NvU32, - #[doc = "!< Maximum supported link rate"] - pub maxLinkRate: NV_DP_LINK_RATE, - #[doc = "!< Maximum supported lane count"] - pub maxLaneCount: NV_DP_LANE_COUNT, - #[doc = "!< Current link rate"] - pub curLinkRate: NV_DP_LINK_RATE, - #[doc = "!< Current lane count"] - pub curLaneCount: NV_DP_LANE_COUNT, - #[doc = "!< Current color format"] - pub colorFormat: NV_DP_COLOR_FORMAT, - #[doc = "!< Dynamic range"] - pub dynamicRange: NV_DP_DYNAMIC_RANGE, - #[doc = "!< Ignored in RGB space"] - pub colorimetry: NV_DP_COLORIMETRY, - #[doc = "!< Current bit-per-component"] - pub bpc: NV_DP_BPC, - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, -} -impl _NV_DISPLAY_PORT_INFO_V1 { - #[inline] - pub fn isDp(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isDp(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isDp_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isDp_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isInternalDp(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_isInternalDp(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isInternalDp_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isInternalDp_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isColorCtrlSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_isColorCtrlSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isColorCtrlSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isColorCtrlSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn is6BPCSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_is6BPCSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn is6BPCSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_is6BPCSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn is8BPCSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } - } - #[inline] - pub fn set_is8BPCSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn is8BPCSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_is8BPCSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn is10BPCSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } - } - #[inline] - pub fn set_is10BPCSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn is10BPCSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_is10BPCSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn is12BPCSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } - } - #[inline] - pub fn set_is12BPCSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(6usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn is12BPCSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 6usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_is12BPCSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 6usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn is16BPCSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } - } - #[inline] - pub fn set_is16BPCSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(7usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn is16BPCSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 7usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_is16BPCSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 7usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isYCrCb420Supported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) } - } - #[inline] - pub fn set_isYCrCb420Supported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(8usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isYCrCb420Supported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 8usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isYCrCb420Supported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 8usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isYCrCb422Supported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) } - } - #[inline] - pub fn set_isYCrCb422Supported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(9usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isYCrCb422Supported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 9usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isYCrCb422Supported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 9usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isYCrCb444Supported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) } - } - #[inline] - pub fn set_isYCrCb444Supported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(10usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isYCrCb444Supported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 10usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isYCrCb444Supported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 10usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isRgb444SupportedOnCurrentMode(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) } - } - #[inline] - pub fn set_isRgb444SupportedOnCurrentMode(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(11usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isRgb444SupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 11usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isRgb444SupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 11usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isYCbCr444SupportedOnCurrentMode(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) } - } - #[inline] - pub fn set_isYCbCr444SupportedOnCurrentMode(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(12usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isYCbCr444SupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 12usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isYCbCr444SupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 12usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isYCbCr422SupportedOnCurrentMode(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) } - } - #[inline] - pub fn set_isYCbCr422SupportedOnCurrentMode(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(13usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isYCbCr422SupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 13usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isYCbCr422SupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 13usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isYCbCr420SupportedOnCurrentMode(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) } - } - #[inline] - pub fn set_isYCbCr420SupportedOnCurrentMode(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(14usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isYCbCr420SupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 14usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isYCbCr420SupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 14usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn is6BPCSupportedOnCurrentMode(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) } - } - #[inline] - pub fn set_is6BPCSupportedOnCurrentMode(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(15usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn is6BPCSupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 15usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_is6BPCSupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 15usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn is8BPCSupportedOnCurrentMode(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) } - } - #[inline] - pub fn set_is8BPCSupportedOnCurrentMode(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(16usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn is8BPCSupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 16usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_is8BPCSupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 16usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn is10BPCSupportedOnCurrentMode(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) } - } - #[inline] - pub fn set_is10BPCSupportedOnCurrentMode(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(17usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn is10BPCSupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 17usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_is10BPCSupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 17usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn is12BPCSupportedOnCurrentMode(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) } - } - #[inline] - pub fn set_is12BPCSupportedOnCurrentMode(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(18usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn is12BPCSupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 18usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_is12BPCSupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 18usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn is16BPCSupportedOnCurrentMode(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u32) } - } - #[inline] - pub fn set_is16BPCSupportedOnCurrentMode(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(19usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn is16BPCSupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 19usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_is16BPCSupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 19usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonxvYCC601Capable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonxvYCC601Capable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(20usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonxvYCC601Capable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 20usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonxvYCC601Capable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 20usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonxvYCC709Capable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonxvYCC709Capable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(21usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonxvYCC709Capable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 21usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonxvYCC709Capable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 21usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonsYCC601Capable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonsYCC601Capable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(22usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonsYCC601Capable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 22usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonsYCC601Capable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 22usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonAdobeYCC601Capable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonAdobeYCC601Capable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(23usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonAdobeYCC601Capable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 23usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonAdobeYCC601Capable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 23usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonAdobeRGBCapable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonAdobeRGBCapable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(24usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonAdobeRGBCapable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 24usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonAdobeRGBCapable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 24usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonBT2020RGBCapable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonBT2020RGBCapable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(25usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonBT2020RGBCapable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 25usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonBT2020RGBCapable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 25usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonBT2020YCCCapable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonBT2020YCCCapable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(26usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonBT2020YCCCapable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 26usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonBT2020YCCCapable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 26usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonBT2020cYCCCapable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonBT2020cYCCCapable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(27usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonBT2020cYCCCapable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 27usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonBT2020cYCCCapable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 27usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 4u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(28usize, 4u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 28usize, - 4u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 28usize, - 4u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isDp: NvU32, - isInternalDp: NvU32, - isColorCtrlSupported: NvU32, - is6BPCSupported: NvU32, - is8BPCSupported: NvU32, - is10BPCSupported: NvU32, - is12BPCSupported: NvU32, - is16BPCSupported: NvU32, - isYCrCb420Supported: NvU32, - isYCrCb422Supported: NvU32, - isYCrCb444Supported: NvU32, - isRgb444SupportedOnCurrentMode: NvU32, - isYCbCr444SupportedOnCurrentMode: NvU32, - isYCbCr422SupportedOnCurrentMode: NvU32, - isYCbCr420SupportedOnCurrentMode: NvU32, - is6BPCSupportedOnCurrentMode: NvU32, - is8BPCSupportedOnCurrentMode: NvU32, - is10BPCSupportedOnCurrentMode: NvU32, - is12BPCSupportedOnCurrentMode: NvU32, - is16BPCSupportedOnCurrentMode: NvU32, - isMonxvYCC601Capable: NvU32, - isMonxvYCC709Capable: NvU32, - isMonsYCC601Capable: NvU32, - isMonAdobeYCC601Capable: NvU32, - isMonAdobeRGBCapable: NvU32, - isMonBT2020RGBCapable: NvU32, - isMonBT2020YCCCapable: NvU32, - isMonBT2020cYCCCapable: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isDp: u32 = unsafe { ::std::mem::transmute(isDp) }; - isDp as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let isInternalDp: u32 = unsafe { ::std::mem::transmute(isInternalDp) }; - isInternalDp as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let isColorCtrlSupported: u32 = unsafe { ::std::mem::transmute(isColorCtrlSupported) }; - isColorCtrlSupported as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let is6BPCSupported: u32 = unsafe { ::std::mem::transmute(is6BPCSupported) }; - is6BPCSupported as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let is8BPCSupported: u32 = unsafe { ::std::mem::transmute(is8BPCSupported) }; - is8BPCSupported as u64 - }); - __bindgen_bitfield_unit.set(5usize, 1u8, { - let is10BPCSupported: u32 = unsafe { ::std::mem::transmute(is10BPCSupported) }; - is10BPCSupported as u64 - }); - __bindgen_bitfield_unit.set(6usize, 1u8, { - let is12BPCSupported: u32 = unsafe { ::std::mem::transmute(is12BPCSupported) }; - is12BPCSupported as u64 - }); - __bindgen_bitfield_unit.set(7usize, 1u8, { - let is16BPCSupported: u32 = unsafe { ::std::mem::transmute(is16BPCSupported) }; - is16BPCSupported as u64 - }); - __bindgen_bitfield_unit.set(8usize, 1u8, { - let isYCrCb420Supported: u32 = unsafe { ::std::mem::transmute(isYCrCb420Supported) }; - isYCrCb420Supported as u64 - }); - __bindgen_bitfield_unit.set(9usize, 1u8, { - let isYCrCb422Supported: u32 = unsafe { ::std::mem::transmute(isYCrCb422Supported) }; - isYCrCb422Supported as u64 - }); - __bindgen_bitfield_unit.set(10usize, 1u8, { - let isYCrCb444Supported: u32 = unsafe { ::std::mem::transmute(isYCrCb444Supported) }; - isYCrCb444Supported as u64 - }); - __bindgen_bitfield_unit.set(11usize, 1u8, { - let isRgb444SupportedOnCurrentMode: u32 = - unsafe { ::std::mem::transmute(isRgb444SupportedOnCurrentMode) }; - isRgb444SupportedOnCurrentMode as u64 - }); - __bindgen_bitfield_unit.set(12usize, 1u8, { - let isYCbCr444SupportedOnCurrentMode: u32 = - unsafe { ::std::mem::transmute(isYCbCr444SupportedOnCurrentMode) }; - isYCbCr444SupportedOnCurrentMode as u64 - }); - __bindgen_bitfield_unit.set(13usize, 1u8, { - let isYCbCr422SupportedOnCurrentMode: u32 = - unsafe { ::std::mem::transmute(isYCbCr422SupportedOnCurrentMode) }; - isYCbCr422SupportedOnCurrentMode as u64 - }); - __bindgen_bitfield_unit.set(14usize, 1u8, { - let isYCbCr420SupportedOnCurrentMode: u32 = - unsafe { ::std::mem::transmute(isYCbCr420SupportedOnCurrentMode) }; - isYCbCr420SupportedOnCurrentMode as u64 - }); - __bindgen_bitfield_unit.set(15usize, 1u8, { - let is6BPCSupportedOnCurrentMode: u32 = - unsafe { ::std::mem::transmute(is6BPCSupportedOnCurrentMode) }; - is6BPCSupportedOnCurrentMode as u64 - }); - __bindgen_bitfield_unit.set(16usize, 1u8, { - let is8BPCSupportedOnCurrentMode: u32 = - unsafe { ::std::mem::transmute(is8BPCSupportedOnCurrentMode) }; - is8BPCSupportedOnCurrentMode as u64 - }); - __bindgen_bitfield_unit.set(17usize, 1u8, { - let is10BPCSupportedOnCurrentMode: u32 = - unsafe { ::std::mem::transmute(is10BPCSupportedOnCurrentMode) }; - is10BPCSupportedOnCurrentMode as u64 - }); - __bindgen_bitfield_unit.set(18usize, 1u8, { - let is12BPCSupportedOnCurrentMode: u32 = - unsafe { ::std::mem::transmute(is12BPCSupportedOnCurrentMode) }; - is12BPCSupportedOnCurrentMode as u64 - }); - __bindgen_bitfield_unit.set(19usize, 1u8, { - let is16BPCSupportedOnCurrentMode: u32 = - unsafe { ::std::mem::transmute(is16BPCSupportedOnCurrentMode) }; - is16BPCSupportedOnCurrentMode as u64 - }); - __bindgen_bitfield_unit.set(20usize, 1u8, { - let isMonxvYCC601Capable: u32 = unsafe { ::std::mem::transmute(isMonxvYCC601Capable) }; - isMonxvYCC601Capable as u64 - }); - __bindgen_bitfield_unit.set(21usize, 1u8, { - let isMonxvYCC709Capable: u32 = unsafe { ::std::mem::transmute(isMonxvYCC709Capable) }; - isMonxvYCC709Capable as u64 - }); - __bindgen_bitfield_unit.set(22usize, 1u8, { - let isMonsYCC601Capable: u32 = unsafe { ::std::mem::transmute(isMonsYCC601Capable) }; - isMonsYCC601Capable as u64 - }); - __bindgen_bitfield_unit.set(23usize, 1u8, { - let isMonAdobeYCC601Capable: u32 = - unsafe { ::std::mem::transmute(isMonAdobeYCC601Capable) }; - isMonAdobeYCC601Capable as u64 - }); - __bindgen_bitfield_unit.set(24usize, 1u8, { - let isMonAdobeRGBCapable: u32 = unsafe { ::std::mem::transmute(isMonAdobeRGBCapable) }; - isMonAdobeRGBCapable as u64 - }); - __bindgen_bitfield_unit.set(25usize, 1u8, { - let isMonBT2020RGBCapable: u32 = - unsafe { ::std::mem::transmute(isMonBT2020RGBCapable) }; - isMonBT2020RGBCapable as u64 - }); - __bindgen_bitfield_unit.set(26usize, 1u8, { - let isMonBT2020YCCCapable: u32 = - unsafe { ::std::mem::transmute(isMonBT2020YCCCapable) }; - isMonBT2020YCCCapable as u64 - }); - __bindgen_bitfield_unit.set(27usize, 1u8, { - let isMonBT2020cYCCCapable: u32 = - unsafe { ::std::mem::transmute(isMonBT2020cYCCCapable) }; - isMonBT2020cYCCCapable as u64 - }); - __bindgen_bitfield_unit.set(28usize, 4u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_GetDisplayPortInfo()."] -pub type NV_DISPLAY_PORT_INFO_V1 = _NV_DISPLAY_PORT_INFO_V1; -#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_GetDisplayPortInfo()."] -pub type NV_DISPLAY_PORT_INFO = NV_DISPLAY_PORT_INFO_V1; -#[doc = "! \\ingroup dispcontrol\n! DisplayPort configuration settings - used in NvAPI_SetDisplayPort()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_DISPLAY_PORT_CONFIG { - #[doc = "!< Structure version - 2 is the latest"] - pub version: NvU32, - #[doc = "!< Link rate"] - pub linkRate: NV_DP_LINK_RATE, - #[doc = "!< Lane count"] - pub laneCount: NV_DP_LANE_COUNT, - #[doc = "!< Color format to set"] - pub colorFormat: NV_DP_COLOR_FORMAT, - #[doc = "!< Dynamic range"] - pub dynamicRange: NV_DP_DYNAMIC_RANGE, - #[doc = "!< Ignored in RGB space"] - pub colorimetry: NV_DP_COLORIMETRY, - #[doc = "!< Bit-per-component"] - pub bpc: NV_DP_BPC, - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, - pub __bindgen_padding_0: [u8; 3usize], -} -impl NV_DISPLAY_PORT_CONFIG { - #[inline] - pub fn isHPD(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isHPD(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isHPD_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isHPD_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isSetDeferred(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_isSetDeferred(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isSetDeferred_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isSetDeferred_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isChromaLpfOff(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_isChromaLpfOff(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isChromaLpfOff_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isChromaLpfOff_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isDitherOff(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_isDitherOff(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isDitherOff_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isDitherOff_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn testLinkTrain(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } - } - #[inline] - pub fn set_testLinkTrain(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn testLinkTrain_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_testLinkTrain_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn testColorChange(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } - } - #[inline] - pub fn set_testColorChange(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn testColorChange_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_testColorChange_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isHPD: NvU32, - isSetDeferred: NvU32, - isChromaLpfOff: NvU32, - isDitherOff: NvU32, - testLinkTrain: NvU32, - testColorChange: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isHPD: u32 = unsafe { ::std::mem::transmute(isHPD) }; - isHPD as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let isSetDeferred: u32 = unsafe { ::std::mem::transmute(isSetDeferred) }; - isSetDeferred as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let isChromaLpfOff: u32 = unsafe { ::std::mem::transmute(isChromaLpfOff) }; - isChromaLpfOff as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let isDitherOff: u32 = unsafe { ::std::mem::transmute(isDitherOff) }; - isDitherOff as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let testLinkTrain: u32 = unsafe { ::std::mem::transmute(testLinkTrain) }; - testLinkTrain as u64 - }); - __bindgen_bitfield_unit.set(5usize, 1u8, { - let testColorChange: u32 = unsafe { ::std::mem::transmute(testColorChange) }; - testColorChange as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_GetHDMISupportInfo()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDMI_SUPPORT_INFO_V1 { - #[doc = "!< Structure version"] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Revision number of the EDID 861 extension"] - pub EDID861ExtRev: NvU32, -} -impl _NV_HDMI_SUPPORT_INFO_V1 { - #[inline] - pub fn isGpuHDMICapable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isGpuHDMICapable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isGpuHDMICapable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isGpuHDMICapable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonUnderscanCapable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonUnderscanCapable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonUnderscanCapable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonUnderscanCapable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonBasicAudioCapable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonBasicAudioCapable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonBasicAudioCapable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonBasicAudioCapable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonYCbCr444Capable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonYCbCr444Capable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonYCbCr444Capable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonYCbCr444Capable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonYCbCr422Capable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonYCbCr422Capable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonYCbCr422Capable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonYCbCr422Capable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonxvYCC601Capable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonxvYCC601Capable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonxvYCC601Capable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonxvYCC601Capable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonxvYCC709Capable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonxvYCC709Capable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(6usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonxvYCC709Capable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 6usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonxvYCC709Capable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 6usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonHDMI(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonHDMI(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(7usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonHDMI_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 7usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonHDMI_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 7usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 24u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(8usize, 24u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 8usize, - 24u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 8usize, - 24u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isGpuHDMICapable: NvU32, - isMonUnderscanCapable: NvU32, - isMonBasicAudioCapable: NvU32, - isMonYCbCr444Capable: NvU32, - isMonYCbCr422Capable: NvU32, - isMonxvYCC601Capable: NvU32, - isMonxvYCC709Capable: NvU32, - isMonHDMI: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isGpuHDMICapable: u32 = unsafe { ::std::mem::transmute(isGpuHDMICapable) }; - isGpuHDMICapable as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let isMonUnderscanCapable: u32 = - unsafe { ::std::mem::transmute(isMonUnderscanCapable) }; - isMonUnderscanCapable as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let isMonBasicAudioCapable: u32 = - unsafe { ::std::mem::transmute(isMonBasicAudioCapable) }; - isMonBasicAudioCapable as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let isMonYCbCr444Capable: u32 = unsafe { ::std::mem::transmute(isMonYCbCr444Capable) }; - isMonYCbCr444Capable as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let isMonYCbCr422Capable: u32 = unsafe { ::std::mem::transmute(isMonYCbCr422Capable) }; - isMonYCbCr422Capable as u64 - }); - __bindgen_bitfield_unit.set(5usize, 1u8, { - let isMonxvYCC601Capable: u32 = unsafe { ::std::mem::transmute(isMonxvYCC601Capable) }; - isMonxvYCC601Capable as u64 - }); - __bindgen_bitfield_unit.set(6usize, 1u8, { - let isMonxvYCC709Capable: u32 = unsafe { ::std::mem::transmute(isMonxvYCC709Capable) }; - isMonxvYCC709Capable as u64 - }); - __bindgen_bitfield_unit.set(7usize, 1u8, { - let isMonHDMI: u32 = unsafe { ::std::mem::transmute(isMonHDMI) }; - isMonHDMI as u64 - }); - __bindgen_bitfield_unit.set(8usize, 24u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_GetHDMISupportInfo()."] -pub type NV_HDMI_SUPPORT_INFO_V1 = _NV_HDMI_SUPPORT_INFO_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDMI_SUPPORT_INFO_V2 { - #[doc = "!< Structure version"] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Revision number of the EDID 861 extension"] - pub EDID861ExtRev: NvU32, -} -impl _NV_HDMI_SUPPORT_INFO_V2 { - #[inline] - pub fn isGpuHDMICapable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isGpuHDMICapable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isGpuHDMICapable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isGpuHDMICapable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonUnderscanCapable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonUnderscanCapable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonUnderscanCapable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonUnderscanCapable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonBasicAudioCapable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonBasicAudioCapable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonBasicAudioCapable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonBasicAudioCapable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonYCbCr444Capable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonYCbCr444Capable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonYCbCr444Capable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonYCbCr444Capable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonYCbCr422Capable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonYCbCr422Capable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonYCbCr422Capable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonYCbCr422Capable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonxvYCC601Capable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonxvYCC601Capable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonxvYCC601Capable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonxvYCC601Capable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonxvYCC709Capable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonxvYCC709Capable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(6usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonxvYCC709Capable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 6usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonxvYCC709Capable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 6usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonHDMI(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonHDMI(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(7usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonHDMI_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 7usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonHDMI_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 7usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonsYCC601Capable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonsYCC601Capable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(8usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonsYCC601Capable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 8usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonsYCC601Capable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 8usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonAdobeYCC601Capable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonAdobeYCC601Capable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(9usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonAdobeYCC601Capable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 9usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonAdobeYCC601Capable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 9usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonAdobeRGBCapable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonAdobeRGBCapable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(10usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonAdobeRGBCapable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 10usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonAdobeRGBCapable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 10usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 21u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(11usize, 21u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 11usize, - 21u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 11usize, - 21u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isGpuHDMICapable: NvU32, - isMonUnderscanCapable: NvU32, - isMonBasicAudioCapable: NvU32, - isMonYCbCr444Capable: NvU32, - isMonYCbCr422Capable: NvU32, - isMonxvYCC601Capable: NvU32, - isMonxvYCC709Capable: NvU32, - isMonHDMI: NvU32, - isMonsYCC601Capable: NvU32, - isMonAdobeYCC601Capable: NvU32, - isMonAdobeRGBCapable: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isGpuHDMICapable: u32 = unsafe { ::std::mem::transmute(isGpuHDMICapable) }; - isGpuHDMICapable as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let isMonUnderscanCapable: u32 = - unsafe { ::std::mem::transmute(isMonUnderscanCapable) }; - isMonUnderscanCapable as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let isMonBasicAudioCapable: u32 = - unsafe { ::std::mem::transmute(isMonBasicAudioCapable) }; - isMonBasicAudioCapable as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let isMonYCbCr444Capable: u32 = unsafe { ::std::mem::transmute(isMonYCbCr444Capable) }; - isMonYCbCr444Capable as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let isMonYCbCr422Capable: u32 = unsafe { ::std::mem::transmute(isMonYCbCr422Capable) }; - isMonYCbCr422Capable as u64 - }); - __bindgen_bitfield_unit.set(5usize, 1u8, { - let isMonxvYCC601Capable: u32 = unsafe { ::std::mem::transmute(isMonxvYCC601Capable) }; - isMonxvYCC601Capable as u64 - }); - __bindgen_bitfield_unit.set(6usize, 1u8, { - let isMonxvYCC709Capable: u32 = unsafe { ::std::mem::transmute(isMonxvYCC709Capable) }; - isMonxvYCC709Capable as u64 - }); - __bindgen_bitfield_unit.set(7usize, 1u8, { - let isMonHDMI: u32 = unsafe { ::std::mem::transmute(isMonHDMI) }; - isMonHDMI as u64 - }); - __bindgen_bitfield_unit.set(8usize, 1u8, { - let isMonsYCC601Capable: u32 = unsafe { ::std::mem::transmute(isMonsYCC601Capable) }; - isMonsYCC601Capable as u64 - }); - __bindgen_bitfield_unit.set(9usize, 1u8, { - let isMonAdobeYCC601Capable: u32 = - unsafe { ::std::mem::transmute(isMonAdobeYCC601Capable) }; - isMonAdobeYCC601Capable as u64 - }); - __bindgen_bitfield_unit.set(10usize, 1u8, { - let isMonAdobeRGBCapable: u32 = unsafe { ::std::mem::transmute(isMonAdobeRGBCapable) }; - isMonAdobeRGBCapable as u64 - }); - __bindgen_bitfield_unit.set(11usize, 21u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_HDMI_SUPPORT_INFO_V2 = _NV_HDMI_SUPPORT_INFO_V2; -pub type NV_HDMI_SUPPORT_INFO = NV_HDMI_SUPPORT_INFO_V2; -#[doc = "!< Returns the fields in the infoframe with values set by the manufacturer - NVIDIA/OEM."] -pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_GET_DEFAULT: NV_INFOFRAME_CMD = 0; -#[doc = "!< Sets the fields in the infoframe to auto, and infoframe to the default infoframe for use in a set."] -pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_RESET: NV_INFOFRAME_CMD = 1; -#[doc = "!< Get the current infoframe state."] -pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_GET: NV_INFOFRAME_CMD = 2; -#[doc = "!< Set the current infoframe state (flushed to the monitor), the values are one time and do not persist."] -pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_SET: NV_INFOFRAME_CMD = 3; -#[doc = "!< Get the override infoframe state, non-override fields will be set to value = AUTO, overridden fields will have the current override values."] -pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_GET_OVERRIDE: NV_INFOFRAME_CMD = 4; -#[doc = "!< Set the override infoframe state, non-override fields will be set to value = AUTO, other values indicate override; persist across modeset/reboot"] -pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_SET_OVERRIDE: NV_INFOFRAME_CMD = 5; -#[doc = "!< get properties associated with infoframe (each of the infoframe type will have properties)"] -pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_GET_PROPERTY: NV_INFOFRAME_CMD = 6; -#[doc = "!< set properties associated with infoframe"] -pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_SET_PROPERTY: NV_INFOFRAME_CMD = 7; -#[doc = "! \\ingroup dispcontrol"] -pub type NV_INFOFRAME_CMD = ::std::os::raw::c_int; -#[doc = "!< Driver determines whether to send infoframes."] -pub const NV_INFOFRAME_PROPERTY_MODE_NV_INFOFRAME_PROPERTY_MODE_AUTO: NV_INFOFRAME_PROPERTY_MODE = - 0; -#[doc = "!< Driver always sends infoframe."] -pub const NV_INFOFRAME_PROPERTY_MODE_NV_INFOFRAME_PROPERTY_MODE_ENABLE: NV_INFOFRAME_PROPERTY_MODE = - 1; -#[doc = "!< Driver never sends infoframe."] -pub const NV_INFOFRAME_PROPERTY_MODE_NV_INFOFRAME_PROPERTY_MODE_DISABLE: - NV_INFOFRAME_PROPERTY_MODE = 2; -#[doc = "!< Driver only sends infoframe when client requests it via infoframe escape call."] -pub const NV_INFOFRAME_PROPERTY_MODE_NV_INFOFRAME_PROPERTY_MODE_ALLOW_OVERRIDE: - NV_INFOFRAME_PROPERTY_MODE = 3; -pub type NV_INFOFRAME_PROPERTY_MODE = ::std::os::raw::c_int; -pub const NV_INFOFRAME_PROPERTY_BLACKLIST_NV_INFOFRAME_PROPERTY_BLACKLIST_FALSE: - NV_INFOFRAME_PROPERTY_BLACKLIST = 0; -pub const NV_INFOFRAME_PROPERTY_BLACKLIST_NV_INFOFRAME_PROPERTY_BLACKLIST_TRUE: - NV_INFOFRAME_PROPERTY_BLACKLIST = 1; -#[doc = "! Returns whether the current monitor is in blacklist or force this monitor to be in blacklist."] -pub type NV_INFOFRAME_PROPERTY_BLACKLIST = ::std::os::raw::c_int; -#[repr(C)] -#[repr(align(4))] -#[derive(Debug, Copy, Clone)] -pub struct NV_INFOFRAME_PROPERTY { - pub _bitfield_align_1: [u16; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, -} -impl NV_INFOFRAME_PROPERTY { - #[inline] - pub fn mode(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32) } - } - #[inline] - pub fn set_mode(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 4u8, val as u64) - } - } - #[inline] - pub unsafe fn mode_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 4u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_mode_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 4u8, - val as u64, - ) - } - } - #[inline] - pub fn blackList(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 2u8) as u32) } - } - #[inline] - pub fn set_blackList(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn blackList_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_blackList_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 10u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(6usize, 10u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 6usize, - 10u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 6usize, - 10u8, - val as u64, - ) - } - } - #[inline] - pub fn version(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 8u8) as u32) } - } - #[inline] - pub fn set_version(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(16usize, 8u8, val as u64) - } - } - #[inline] - pub unsafe fn version_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 16usize, - 8u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_version_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 16usize, - 8u8, - val as u64, - ) - } - } - #[inline] - pub fn length(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u32) } - } - #[inline] - pub fn set_length(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(24usize, 8u8, val as u64) - } - } - #[inline] - pub unsafe fn length_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 24usize, - 8u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_length_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 24usize, - 8u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - mode: NvU32, - blackList: NvU32, - reserved: NvU32, - version: NvU32, - length: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 4u8, { - let mode: u32 = unsafe { ::std::mem::transmute(mode) }; - mode as u64 - }); - __bindgen_bitfield_unit.set(4usize, 2u8, { - let blackList: u32 = unsafe { ::std::mem::transmute(blackList) }; - blackList as u64 - }); - __bindgen_bitfield_unit.set(6usize, 10u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit.set(16usize, 8u8, { - let version: u32 = unsafe { ::std::mem::transmute(version) }; - version as u64 - }); - __bindgen_bitfield_unit.set(24usize, 8u8, { - let length: u32 = unsafe { ::std::mem::transmute(length) }; - length as u64 - }); - __bindgen_bitfield_unit - } -} -pub const NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_NODATA: - NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO = 0; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_OVERSCAN: - NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO = 1; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_UNDERSCAN: - NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO = 2; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_FUTURE: - NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO = 3; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_AUTO: - NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO = 7; -#[doc = "! Byte1 related"] -pub type NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_NOT_PRESENT: - NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA = 0; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_VERTICAL_PRESENT : NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_HORIZONTAL_PRESENT : NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_BOTH_PRESENT: - NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA = 3; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_AUTO: - NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA = 7; -pub type NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO_NV_INFOFRAME_FIELD_VALUE_AVI_AFI_ABSENT: - NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO = 0; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO_NV_INFOFRAME_FIELD_VALUE_AVI_AFI_PRESENT: - NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO = 1; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO_NV_INFOFRAME_FIELD_VALUE_AVI_AFI_AUTO: - NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO = 3; -pub type NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_RGB: - NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT = 0; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_YCbCr422 : NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_YCbCr444 : NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_FUTURE : NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_AUTO: - NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT = 7; -pub type NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_F17_NV_INFOFRAME_FIELD_VALUE_AVI_F17_FALSE: - NV_INFOFRAME_FIELD_VALUE_AVI_F17 = 0; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_F17_NV_INFOFRAME_FIELD_VALUE_AVI_F17_TRUE: - NV_INFOFRAME_FIELD_VALUE_AVI_F17 = 1; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_F17_NV_INFOFRAME_FIELD_VALUE_AVI_F17_AUTO: - NV_INFOFRAME_FIELD_VALUE_AVI_F17 = 3; -pub type NV_INFOFRAME_FIELD_VALUE_AVI_F17 = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NO_AFD : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE01 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE02 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE03 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_LETTERBOX_GT16x9 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 4 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE05 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 5 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE06 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 6 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE07 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 7 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_EQUAL_CODEDFRAME : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 8 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_CENTER_4x3 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 9 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_CENTER_16x9 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 10 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_CENTER_14x9 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 11 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE12 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 12 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_4x3_ON_14x9 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 13 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_16x9_ON_14x9 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 14 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_16x9_ON_4x3 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 15 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 31 ; -#[doc = "! Byte2 related"] -pub type NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_NO_DATA : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_4x3 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_16x9 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_FUTURE : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME = 7 ; -pub type NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_NO_DATA : NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_SMPTE_170M : NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_ITUR_BT709 : NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_USE_EXTENDED_COLORIMETRY : NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_AUTO: - NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY = 7; -pub type NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_NO_DATA : NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_HORIZONTAL : NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_VERTICAL : NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_BOTH : NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING = 7 ; -#[doc = "! Byte 3 related"] -pub type NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_DEFAULT : NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_LIMITED_RANGE : NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_FULL_RANGE : NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_RESERVED : NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION = 7 ; -pub type NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_XVYCC601 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_XVYCC709 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_SYCC601 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_ADOBEYCC601 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_ADOBERGB : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 4 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_RESERVED05 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 5 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_RESERVED06 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 6 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_RESERVED07 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 7 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 15 ; -pub type NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ITC_NV_INFOFRAME_FIELD_VALUE_AVI_ITC_VIDEO_CONTENT: - NV_INFOFRAME_FIELD_VALUE_AVI_ITC = 0; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ITC_NV_INFOFRAME_FIELD_VALUE_AVI_ITC_ITCONTENT: - NV_INFOFRAME_FIELD_VALUE_AVI_ITC = 1; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ITC_NV_INFOFRAME_FIELD_VALUE_AVI_ITC_AUTO: - NV_INFOFRAME_FIELD_VALUE_AVI_ITC = 3; -pub type NV_INFOFRAME_FIELD_VALUE_AVI_ITC = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NONE : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X02 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X03 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X04 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X05 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 4 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X06 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 5 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X07 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 6 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X08 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 7 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X09 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 8 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X10 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 9 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED10 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 10 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED11 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 11 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED12 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 12 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED13 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 13 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED14 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 14 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED15 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 15 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 31 ; -#[doc = "! Byte 4 related"] -pub type NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_GRAPHICS : NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_PHOTO : NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_CINEMA : NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_GAME: - NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE = 3; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_AUTO: - NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE = 7; -pub type NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_LIMITED_RANGE : NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_FULL_RANGE : NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_RESERVED02 : NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_RESERVED03 : NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION = 7 ; -pub type NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION = ::std::os::raw::c_int; -#[doc = "! Adding an Auto bit to each field"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_INFOFRAME_VIDEO { - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 23usize]>, -} -impl NV_INFOFRAME_VIDEO { - #[inline] - pub fn vic(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) } - } - #[inline] - pub fn set_vic(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 8u8, val as u64) - } - } - #[inline] - pub unsafe fn vic_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 8u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_vic_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 8u8, - val as u64, - ) - } - } - #[inline] - pub fn pixelRepeat(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 5u8) as u32) } - } - #[inline] - pub fn set_pixelRepeat(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(8usize, 5u8, val as u64) - } - } - #[inline] - pub unsafe fn pixelRepeat_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 8usize, - 5u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_pixelRepeat_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 8usize, - 5u8, - val as u64, - ) - } - } - #[inline] - pub fn colorSpace(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 3u8) as u32) } - } - #[inline] - pub fn set_colorSpace(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(13usize, 3u8, val as u64) - } - } - #[inline] - pub unsafe fn colorSpace_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 13usize, - 3u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_colorSpace_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 13usize, - 3u8, - val as u64, - ) - } - } - #[inline] - pub fn colorimetry(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 3u8) as u32) } - } - #[inline] - pub fn set_colorimetry(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(16usize, 3u8, val as u64) - } - } - #[inline] - pub unsafe fn colorimetry_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 16usize, - 3u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_colorimetry_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 16usize, - 3u8, - val as u64, - ) - } - } - #[inline] - pub fn extendedColorimetry(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 4u8) as u32) } - } - #[inline] - pub fn set_extendedColorimetry(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(19usize, 4u8, val as u64) - } - } - #[inline] - pub unsafe fn extendedColorimetry_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 19usize, - 4u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_extendedColorimetry_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 19usize, - 4u8, - val as u64, - ) - } - } - #[inline] - pub fn rgbQuantizationRange(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 3u8) as u32) } - } - #[inline] - pub fn set_rgbQuantizationRange(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(23usize, 3u8, val as u64) - } - } - #[inline] - pub unsafe fn rgbQuantizationRange_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 23usize, - 3u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_rgbQuantizationRange_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 23usize, - 3u8, - val as u64, - ) - } - } - #[inline] - pub fn yccQuantizationRange(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 3u8) as u32) } - } - #[inline] - pub fn set_yccQuantizationRange(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(26usize, 3u8, val as u64) - } - } - #[inline] - pub unsafe fn yccQuantizationRange_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 26usize, - 3u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_yccQuantizationRange_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 26usize, - 3u8, - val as u64, - ) - } - } - #[inline] - pub fn itContent(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 2u8) as u32) } - } - #[inline] - pub fn set_itContent(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(29usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn itContent_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 29usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_itContent_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 29usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn contentTypes(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 3u8) as u32) } - } - #[inline] - pub fn set_contentTypes(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(32usize, 3u8, val as u64) - } - } - #[inline] - pub unsafe fn contentTypes_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 32usize, - 3u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_contentTypes_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 32usize, - 3u8, - val as u64, - ) - } - } - #[inline] - pub fn scanInfo(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(35usize, 3u8) as u32) } - } - #[inline] - pub fn set_scanInfo(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(35usize, 3u8, val as u64) - } - } - #[inline] - pub unsafe fn scanInfo_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 35usize, - 3u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_scanInfo_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 35usize, - 3u8, - val as u64, - ) - } - } - #[inline] - pub fn activeFormatInfoPresent(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(38usize, 2u8) as u32) } - } - #[inline] - pub fn set_activeFormatInfoPresent(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(38usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn activeFormatInfoPresent_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 38usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_activeFormatInfoPresent_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 38usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn activeFormatAspectRatio(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(40usize, 5u8) as u32) } - } - #[inline] - pub fn set_activeFormatAspectRatio(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(40usize, 5u8, val as u64) - } - } - #[inline] - pub unsafe fn activeFormatAspectRatio_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 40usize, - 5u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_activeFormatAspectRatio_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 40usize, - 5u8, - val as u64, - ) - } - } - #[inline] - pub fn picAspectRatio(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(45usize, 3u8) as u32) } - } - #[inline] - pub fn set_picAspectRatio(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(45usize, 3u8, val as u64) - } - } - #[inline] - pub unsafe fn picAspectRatio_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 45usize, - 3u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_picAspectRatio_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 45usize, - 3u8, - val as u64, - ) - } - } - #[inline] - pub fn nonuniformScaling(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 3u8) as u32) } - } - #[inline] - pub fn set_nonuniformScaling(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(48usize, 3u8, val as u64) - } - } - #[inline] - pub unsafe fn nonuniformScaling_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 48usize, - 3u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_nonuniformScaling_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 48usize, - 3u8, - val as u64, - ) - } - } - #[inline] - pub fn barInfo(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(51usize, 3u8) as u32) } - } - #[inline] - pub fn set_barInfo(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(51usize, 3u8, val as u64) - } - } - #[inline] - pub unsafe fn barInfo_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 51usize, - 3u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_barInfo_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 51usize, - 3u8, - val as u64, - ) - } - } - #[inline] - pub fn top_bar(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(64usize, 17u8) as u32) } - } - #[inline] - pub fn set_top_bar(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(64usize, 17u8, val as u64) - } - } - #[inline] - pub unsafe fn top_bar_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 64usize, - 17u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_top_bar_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 64usize, - 17u8, - val as u64, - ) - } - } - #[inline] - pub fn bottom_bar(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(96usize, 17u8) as u32) } - } - #[inline] - pub fn set_bottom_bar(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(96usize, 17u8, val as u64) - } - } - #[inline] - pub unsafe fn bottom_bar_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 96usize, - 17u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bottom_bar_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 96usize, - 17u8, - val as u64, - ) - } - } - #[inline] - pub fn left_bar(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(128usize, 17u8) as u32) } - } - #[inline] - pub fn set_left_bar(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(128usize, 17u8, val as u64) - } - } - #[inline] - pub unsafe fn left_bar_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 128usize, - 17u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_left_bar_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 128usize, - 17u8, - val as u64, - ) - } - } - #[inline] - pub fn right_bar(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(160usize, 17u8) as u32) } - } - #[inline] - pub fn set_right_bar(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(160usize, 17u8, val as u64) - } - } - #[inline] - pub unsafe fn right_bar_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 160usize, - 17u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_right_bar_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 160usize, - 17u8, - val as u64, - ) - } - } - #[inline] - pub fn Future17(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(177usize, 2u8) as u32) } - } - #[inline] - pub fn set_Future17(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(177usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn Future17_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 177usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_Future17_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 177usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn Future47(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(179usize, 2u8) as u32) } - } - #[inline] - pub fn set_Future47(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(179usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn Future47_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 179usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_Future47_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 179usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - vic: NvU32, - pixelRepeat: NvU32, - colorSpace: NvU32, - colorimetry: NvU32, - extendedColorimetry: NvU32, - rgbQuantizationRange: NvU32, - yccQuantizationRange: NvU32, - itContent: NvU32, - contentTypes: NvU32, - scanInfo: NvU32, - activeFormatInfoPresent: NvU32, - activeFormatAspectRatio: NvU32, - picAspectRatio: NvU32, - nonuniformScaling: NvU32, - barInfo: NvU32, - top_bar: NvU32, - bottom_bar: NvU32, - left_bar: NvU32, - right_bar: NvU32, - Future17: NvU32, - Future47: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 23usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 23usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 8u8, { - let vic: u32 = unsafe { ::std::mem::transmute(vic) }; - vic as u64 - }); - __bindgen_bitfield_unit.set(8usize, 5u8, { - let pixelRepeat: u32 = unsafe { ::std::mem::transmute(pixelRepeat) }; - pixelRepeat as u64 - }); - __bindgen_bitfield_unit.set(13usize, 3u8, { - let colorSpace: u32 = unsafe { ::std::mem::transmute(colorSpace) }; - colorSpace as u64 - }); - __bindgen_bitfield_unit.set(16usize, 3u8, { - let colorimetry: u32 = unsafe { ::std::mem::transmute(colorimetry) }; - colorimetry as u64 - }); - __bindgen_bitfield_unit.set(19usize, 4u8, { - let extendedColorimetry: u32 = unsafe { ::std::mem::transmute(extendedColorimetry) }; - extendedColorimetry as u64 - }); - __bindgen_bitfield_unit.set(23usize, 3u8, { - let rgbQuantizationRange: u32 = unsafe { ::std::mem::transmute(rgbQuantizationRange) }; - rgbQuantizationRange as u64 - }); - __bindgen_bitfield_unit.set(26usize, 3u8, { - let yccQuantizationRange: u32 = unsafe { ::std::mem::transmute(yccQuantizationRange) }; - yccQuantizationRange as u64 - }); - __bindgen_bitfield_unit.set(29usize, 2u8, { - let itContent: u32 = unsafe { ::std::mem::transmute(itContent) }; - itContent as u64 - }); - __bindgen_bitfield_unit.set(32usize, 3u8, { - let contentTypes: u32 = unsafe { ::std::mem::transmute(contentTypes) }; - contentTypes as u64 - }); - __bindgen_bitfield_unit.set(35usize, 3u8, { - let scanInfo: u32 = unsafe { ::std::mem::transmute(scanInfo) }; - scanInfo as u64 - }); - __bindgen_bitfield_unit.set(38usize, 2u8, { - let activeFormatInfoPresent: u32 = - unsafe { ::std::mem::transmute(activeFormatInfoPresent) }; - activeFormatInfoPresent as u64 - }); - __bindgen_bitfield_unit.set(40usize, 5u8, { - let activeFormatAspectRatio: u32 = - unsafe { ::std::mem::transmute(activeFormatAspectRatio) }; - activeFormatAspectRatio as u64 - }); - __bindgen_bitfield_unit.set(45usize, 3u8, { - let picAspectRatio: u32 = unsafe { ::std::mem::transmute(picAspectRatio) }; - picAspectRatio as u64 - }); - __bindgen_bitfield_unit.set(48usize, 3u8, { - let nonuniformScaling: u32 = unsafe { ::std::mem::transmute(nonuniformScaling) }; - nonuniformScaling as u64 - }); - __bindgen_bitfield_unit.set(51usize, 3u8, { - let barInfo: u32 = unsafe { ::std::mem::transmute(barInfo) }; - barInfo as u64 - }); - __bindgen_bitfield_unit.set(64usize, 17u8, { - let top_bar: u32 = unsafe { ::std::mem::transmute(top_bar) }; - top_bar as u64 - }); - __bindgen_bitfield_unit.set(96usize, 17u8, { - let bottom_bar: u32 = unsafe { ::std::mem::transmute(bottom_bar) }; - bottom_bar as u64 - }); - __bindgen_bitfield_unit.set(128usize, 17u8, { - let left_bar: u32 = unsafe { ::std::mem::transmute(left_bar) }; - left_bar as u64 - }); - __bindgen_bitfield_unit.set(160usize, 17u8, { - let right_bar: u32 = unsafe { ::std::mem::transmute(right_bar) }; - right_bar as u64 - }); - __bindgen_bitfield_unit.set(177usize, 2u8, { - let Future17: u32 = unsafe { ::std::mem::transmute(Future17) }; - Future17 as u64 - }); - __bindgen_bitfield_unit.set(179usize, 2u8, { - let Future47: u32 = unsafe { ::std::mem::transmute(Future47) }; - Future47 as u64 - }); - __bindgen_bitfield_unit - } -} -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_IN_HEADER : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_2 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_3 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_4 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_5 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 4 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_6 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 5 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_7 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 6 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_8 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 7 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 15 ; -#[doc = "! Byte 1 related"] -pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_IN_HEADER : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_PCM : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_AC3 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_MPEG1 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_MP3 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 4 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_MPEG2 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 5 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_AACLC : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 6 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_DTS : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 7 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_ATRAC : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 8 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_DSD : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 9 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_EAC3 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 10 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_DTSHD : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 11 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_MLP : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 12 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_DST : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 13 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_WMAPRO : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 14 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_USE_CODING_EXTENSION_TYPE : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 15 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 31 ; -pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_IN_HEADER : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_16BITS : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_20BITS : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_24BITS : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE = 7 ; -#[doc = "! Byte 2 related"] -pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_IN_HEADER : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_32000HZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_44100HZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_48000HZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_88200KHZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 4 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_96000KHZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 5 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_176400KHZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 6 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_192000KHZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 7 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 15 ; -pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_USE_CODING_TYPE : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_HEAAC : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_HEAACV2 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_MPEGSURROUND : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE04 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 4 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE05 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 5 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE06 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 6 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE07 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 7 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE08 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 8 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE09 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 9 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE10 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 10 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE11 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 11 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE12 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 12 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE13 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 13 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE14 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 14 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE15 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 15 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE16 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 16 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE17 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 17 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE18 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 18 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE19 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 19 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE20 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 20 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE21 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 21 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE22 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 22 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE23 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 23 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE24 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 24 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE25 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 25 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE26 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 26 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE27 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 27 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE28 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 28 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE29 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 29 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE30 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 30 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE31 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 31 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 63 ; -#[doc = "! Byte 3 related"] -pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_X_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_X_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_X_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_X_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_RC_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 4 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_RC_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 5 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_RC_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 6 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_RC_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 7 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_RR_RL_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 8 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_RR_RL_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 9 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 10 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 11 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_RC_RR_RL_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 12 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_RC_RR_RL_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 13 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_RC_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 14 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_RC_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 15 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_RRC_RLC_RR_RL_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 16 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_RRC_RLC_RR_RL_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 17 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_RRC_RLC_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 18 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_RRC_RLC_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 19 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_X_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 20 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_X_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 21 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_X_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 22 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_X_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 23 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_RC_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 24 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_RC_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 25 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_RC_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 26 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_RC_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 27 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_RR_RL_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 28 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_RR_RL_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 29 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 30 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 31 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_FCH_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 32 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_FCH_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 33 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_X_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 34 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_X_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 35 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRH_FLH_RR_RL_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 36 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRH_FLH_RR_RL_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 37 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRW_FLW_RR_RL_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 38 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRW_FLW_RR_RL_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 39 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_RC_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 40 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_RC_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 41 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FCH_RC_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 42 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FCH_RC_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 43 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_FCH_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 44 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_FCH_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 45 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRH_FLH_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 46 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRH_FLH_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 47 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRW_FLW_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 48 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRW_FLW_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 49 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 511 ; -#[doc = "! Byte 4 related"] -pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_NO_DATA : NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_0DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_PLUS10DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_RESERVED03 : NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL = 7 ; -#[doc = "! Byte 5 related"] -pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_0DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_1DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_2DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_3DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_4DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 4 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_5DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 5 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_6DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 6 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_7DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 7 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_8DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 8 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_9DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 9 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_10DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 10 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_11DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 11 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_12DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 12 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_13DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 13 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_14DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 14 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_15DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 15 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 31 ; -pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_PERMITTED : NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_PROHIBITED : NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_AUTO: - NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX = 3; -pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX = ::std::os::raw::c_int; -#[repr(C)] -#[repr(align(4))] -#[derive(Debug, Copy, Clone)] -pub struct NV_INFOFRAME_AUDIO { - pub _bitfield_align_1: [u16; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 14usize]>, - pub __bindgen_padding_0: u16, -} -impl NV_INFOFRAME_AUDIO { - #[inline] - pub fn codingType(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 5u8) as u32) } - } - #[inline] - pub fn set_codingType(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 5u8, val as u64) - } - } - #[inline] - pub unsafe fn codingType_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 5u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_codingType_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 5u8, - val as u64, - ) - } - } - #[inline] - pub fn codingExtensionType(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 6u8) as u32) } - } - #[inline] - pub fn set_codingExtensionType(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 6u8, val as u64) - } - } - #[inline] - pub unsafe fn codingExtensionType_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 6u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_codingExtensionType_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 6u8, - val as u64, - ) - } - } - #[inline] - pub fn sampleSize(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 3u8) as u32) } - } - #[inline] - pub fn set_sampleSize(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(11usize, 3u8, val as u64) - } - } - #[inline] - pub unsafe fn sampleSize_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 11usize, - 3u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_sampleSize_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 11usize, - 3u8, - val as u64, - ) - } - } - #[inline] - pub fn sampleRate(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 4u8) as u32) } - } - #[inline] - pub fn set_sampleRate(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(14usize, 4u8, val as u64) - } - } - #[inline] - pub unsafe fn sampleRate_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 14usize, - 4u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_sampleRate_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 14usize, - 4u8, - val as u64, - ) - } - } - #[inline] - pub fn channelCount(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 4u8) as u32) } - } - #[inline] - pub fn set_channelCount(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(18usize, 4u8, val as u64) - } - } - #[inline] - pub unsafe fn channelCount_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 18usize, - 4u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_channelCount_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 18usize, - 4u8, - val as u64, - ) - } - } - #[inline] - pub fn speakerPlacement(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 9u8) as u32) } - } - #[inline] - pub fn set_speakerPlacement(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(22usize, 9u8, val as u64) - } - } - #[inline] - pub unsafe fn speakerPlacement_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 22usize, - 9u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_speakerPlacement_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 22usize, - 9u8, - val as u64, - ) - } - } - #[inline] - pub fn downmixInhibit(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 2u8) as u32) } - } - #[inline] - pub fn set_downmixInhibit(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(32usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn downmixInhibit_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 32usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_downmixInhibit_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 32usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn lfePlaybackLevel(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(34usize, 3u8) as u32) } - } - #[inline] - pub fn set_lfePlaybackLevel(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(34usize, 3u8, val as u64) - } - } - #[inline] - pub unsafe fn lfePlaybackLevel_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 34usize, - 3u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_lfePlaybackLevel_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 34usize, - 3u8, - val as u64, - ) - } - } - #[inline] - pub fn levelShift(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(37usize, 5u8) as u32) } - } - #[inline] - pub fn set_levelShift(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(37usize, 5u8, val as u64) - } - } - #[inline] - pub unsafe fn levelShift_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 37usize, - 5u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_levelShift_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 37usize, - 5u8, - val as u64, - ) - } - } - #[inline] - pub fn Future12(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(42usize, 2u8) as u32) } - } - #[inline] - pub fn set_Future12(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(42usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn Future12_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 42usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_Future12_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 42usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn Future2x(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(44usize, 4u8) as u32) } - } - #[inline] - pub fn set_Future2x(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(44usize, 4u8, val as u64) - } - } - #[inline] - pub unsafe fn Future2x_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 44usize, - 4u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_Future2x_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 44usize, - 4u8, - val as u64, - ) - } - } - #[inline] - pub fn Future3x(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 4u8) as u32) } - } - #[inline] - pub fn set_Future3x(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(48usize, 4u8, val as u64) - } - } - #[inline] - pub unsafe fn Future3x_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 48usize, - 4u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_Future3x_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 48usize, - 4u8, - val as u64, - ) - } - } - #[inline] - pub fn Future52(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(52usize, 2u8) as u32) } - } - #[inline] - pub fn set_Future52(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(52usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn Future52_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 52usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_Future52_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 52usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn Future6(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(54usize, 9u8) as u32) } - } - #[inline] - pub fn set_Future6(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(54usize, 9u8, val as u64) - } - } - #[inline] - pub unsafe fn Future6_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 54usize, - 9u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_Future6_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 54usize, - 9u8, - val as u64, - ) - } - } - #[inline] - pub fn Future7(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(64usize, 9u8) as u32) } - } - #[inline] - pub fn set_Future7(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(64usize, 9u8, val as u64) - } - } - #[inline] - pub unsafe fn Future7_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 64usize, - 9u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_Future7_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 64usize, - 9u8, - val as u64, - ) - } - } - #[inline] - pub fn Future8(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(73usize, 9u8) as u32) } - } - #[inline] - pub fn set_Future8(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(73usize, 9u8, val as u64) - } - } - #[inline] - pub unsafe fn Future8_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 73usize, - 9u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_Future8_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 73usize, - 9u8, - val as u64, - ) - } - } - #[inline] - pub fn Future9(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(82usize, 9u8) as u32) } - } - #[inline] - pub fn set_Future9(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(82usize, 9u8, val as u64) - } - } - #[inline] - pub unsafe fn Future9_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 82usize, - 9u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_Future9_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 82usize, - 9u8, - val as u64, - ) - } - } - #[inline] - pub fn Future10(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(96usize, 9u8) as u32) } - } - #[inline] - pub fn set_Future10(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(96usize, 9u8, val as u64) - } - } - #[inline] - pub unsafe fn Future10_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 96usize, - 9u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_Future10_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 96usize, - 9u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - codingType: NvU32, - codingExtensionType: NvU32, - sampleSize: NvU32, - sampleRate: NvU32, - channelCount: NvU32, - speakerPlacement: NvU32, - downmixInhibit: NvU32, - lfePlaybackLevel: NvU32, - levelShift: NvU32, - Future12: NvU32, - Future2x: NvU32, - Future3x: NvU32, - Future52: NvU32, - Future6: NvU32, - Future7: NvU32, - Future8: NvU32, - Future9: NvU32, - Future10: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 14usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 14usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 5u8, { - let codingType: u32 = unsafe { ::std::mem::transmute(codingType) }; - codingType as u64 - }); - __bindgen_bitfield_unit.set(5usize, 6u8, { - let codingExtensionType: u32 = unsafe { ::std::mem::transmute(codingExtensionType) }; - codingExtensionType as u64 - }); - __bindgen_bitfield_unit.set(11usize, 3u8, { - let sampleSize: u32 = unsafe { ::std::mem::transmute(sampleSize) }; - sampleSize as u64 - }); - __bindgen_bitfield_unit.set(14usize, 4u8, { - let sampleRate: u32 = unsafe { ::std::mem::transmute(sampleRate) }; - sampleRate as u64 - }); - __bindgen_bitfield_unit.set(18usize, 4u8, { - let channelCount: u32 = unsafe { ::std::mem::transmute(channelCount) }; - channelCount as u64 - }); - __bindgen_bitfield_unit.set(22usize, 9u8, { - let speakerPlacement: u32 = unsafe { ::std::mem::transmute(speakerPlacement) }; - speakerPlacement as u64 - }); - __bindgen_bitfield_unit.set(32usize, 2u8, { - let downmixInhibit: u32 = unsafe { ::std::mem::transmute(downmixInhibit) }; - downmixInhibit as u64 - }); - __bindgen_bitfield_unit.set(34usize, 3u8, { - let lfePlaybackLevel: u32 = unsafe { ::std::mem::transmute(lfePlaybackLevel) }; - lfePlaybackLevel as u64 - }); - __bindgen_bitfield_unit.set(37usize, 5u8, { - let levelShift: u32 = unsafe { ::std::mem::transmute(levelShift) }; - levelShift as u64 - }); - __bindgen_bitfield_unit.set(42usize, 2u8, { - let Future12: u32 = unsafe { ::std::mem::transmute(Future12) }; - Future12 as u64 - }); - __bindgen_bitfield_unit.set(44usize, 4u8, { - let Future2x: u32 = unsafe { ::std::mem::transmute(Future2x) }; - Future2x as u64 - }); - __bindgen_bitfield_unit.set(48usize, 4u8, { - let Future3x: u32 = unsafe { ::std::mem::transmute(Future3x) }; - Future3x as u64 - }); - __bindgen_bitfield_unit.set(52usize, 2u8, { - let Future52: u32 = unsafe { ::std::mem::transmute(Future52) }; - Future52 as u64 - }); - __bindgen_bitfield_unit.set(54usize, 9u8, { - let Future6: u32 = unsafe { ::std::mem::transmute(Future6) }; - Future6 as u64 - }); - __bindgen_bitfield_unit.set(64usize, 9u8, { - let Future7: u32 = unsafe { ::std::mem::transmute(Future7) }; - Future7 as u64 - }); - __bindgen_bitfield_unit.set(73usize, 9u8, { - let Future8: u32 = unsafe { ::std::mem::transmute(Future8) }; - Future8 as u64 - }); - __bindgen_bitfield_unit.set(82usize, 9u8, { - let Future9: u32 = unsafe { ::std::mem::transmute(Future9) }; - Future9 as u64 - }); - __bindgen_bitfield_unit.set(96usize, 9u8, { - let Future10: u32 = unsafe { ::std::mem::transmute(Future10) }; - Future10 as u64 - }); - __bindgen_bitfield_unit - } -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct NV_INFOFRAME_DATA { - #[doc = "!< version of this structure"] - pub version: NvU32, - #[doc = "!< size of this structure"] - pub size: NvU16, - #[doc = "!< The actions to perform from NV_INFOFRAME_CMD"] - pub cmd: NvU8, - #[doc = "!< type of infoframe"] - pub type_: NvU8, - pub infoframe: NV_INFOFRAME_DATA__bindgen_ty_1, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union NV_INFOFRAME_DATA__bindgen_ty_1 { - #[doc = "!< This is NVIDIA-specific and corresponds to the property cmds and associated infoframe."] - pub property: NV_INFOFRAME_PROPERTY, - pub audio: NV_INFOFRAME_AUDIO, - pub video: NV_INFOFRAME_VIDEO, -} -pub const NV_COLOR_CMD_NV_COLOR_CMD_GET: NV_COLOR_CMD = 1; -pub const NV_COLOR_CMD_NV_COLOR_CMD_SET: NV_COLOR_CMD = 2; -pub const NV_COLOR_CMD_NV_COLOR_CMD_IS_SUPPORTED_COLOR: NV_COLOR_CMD = 3; -pub const NV_COLOR_CMD_NV_COLOR_CMD_GET_DEFAULT: NV_COLOR_CMD = 4; -pub type NV_COLOR_CMD = ::std::os::raw::c_int; -pub const NV_COLOR_FORMAT_NV_COLOR_FORMAT_RGB: NV_COLOR_FORMAT = 0; -pub const NV_COLOR_FORMAT_NV_COLOR_FORMAT_YUV422: NV_COLOR_FORMAT = 1; -pub const NV_COLOR_FORMAT_NV_COLOR_FORMAT_YUV444: NV_COLOR_FORMAT = 2; -pub const NV_COLOR_FORMAT_NV_COLOR_FORMAT_YUV420: NV_COLOR_FORMAT = 3; -pub const NV_COLOR_FORMAT_NV_COLOR_FORMAT_DEFAULT: NV_COLOR_FORMAT = 254; -pub const NV_COLOR_FORMAT_NV_COLOR_FORMAT_AUTO: NV_COLOR_FORMAT = 255; -#[doc = "! See Table 14 of CEA-861E. Not all of this is supported by the GPU."] -pub type NV_COLOR_FORMAT = ::std::os::raw::c_int; -pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_RGB: NV_COLOR_COLORIMETRY = 0; -pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_YCC601: NV_COLOR_COLORIMETRY = 1; -pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_YCC709: NV_COLOR_COLORIMETRY = 2; -pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_XVYCC601: NV_COLOR_COLORIMETRY = 3; -pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_XVYCC709: NV_COLOR_COLORIMETRY = 4; -pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_SYCC601: NV_COLOR_COLORIMETRY = 5; -pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_ADOBEYCC601: NV_COLOR_COLORIMETRY = 6; -pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_ADOBERGB: NV_COLOR_COLORIMETRY = 7; -pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_BT2020RGB: NV_COLOR_COLORIMETRY = 8; -pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_BT2020YCC: NV_COLOR_COLORIMETRY = 9; -pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_BT2020cYCC: NV_COLOR_COLORIMETRY = 10; -pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_DEFAULT: NV_COLOR_COLORIMETRY = 254; -pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_AUTO: NV_COLOR_COLORIMETRY = 255; -pub type NV_COLOR_COLORIMETRY = ::std::os::raw::c_int; -pub const _NV_DYNAMIC_RANGE_NV_DYNAMIC_RANGE_VESA: _NV_DYNAMIC_RANGE = 0; -pub const _NV_DYNAMIC_RANGE_NV_DYNAMIC_RANGE_CEA: _NV_DYNAMIC_RANGE = 1; -pub const _NV_DYNAMIC_RANGE_NV_DYNAMIC_RANGE_AUTO: _NV_DYNAMIC_RANGE = 255; -pub type _NV_DYNAMIC_RANGE = ::std::os::raw::c_int; -pub use self::_NV_DYNAMIC_RANGE as NV_DYNAMIC_RANGE; -pub const _NV_BPC_NV_BPC_DEFAULT: _NV_BPC = 0; -pub const _NV_BPC_NV_BPC_6: _NV_BPC = 1; -pub const _NV_BPC_NV_BPC_8: _NV_BPC = 2; -pub const _NV_BPC_NV_BPC_10: _NV_BPC = 3; -pub const _NV_BPC_NV_BPC_12: _NV_BPC = 4; -pub const _NV_BPC_NV_BPC_16: _NV_BPC = 5; -pub type _NV_BPC = ::std::os::raw::c_int; -pub use self::_NV_BPC as NV_BPC; -#[doc = "!< app/nvcpl make decision to select the desire color format"] -pub const _NV_COLOR_SELECTION_POLICY_NV_COLOR_SELECTION_POLICY_USER: _NV_COLOR_SELECTION_POLICY = 0; -#[doc = "!< driver/ OS make decision to select the best color format"] -pub const _NV_COLOR_SELECTION_POLICY_NV_COLOR_SELECTION_POLICY_BEST_QUALITY: - _NV_COLOR_SELECTION_POLICY = 1; -pub const _NV_COLOR_SELECTION_POLICY_NV_COLOR_SELECTION_POLICY_DEFAULT: _NV_COLOR_SELECTION_POLICY = - 1; -pub const _NV_COLOR_SELECTION_POLICY_NV_COLOR_SELECTION_POLICY_UNKNOWN: _NV_COLOR_SELECTION_POLICY = - 255; -pub type _NV_COLOR_SELECTION_POLICY = ::std::os::raw::c_int; -pub use self::_NV_COLOR_SELECTION_POLICY as NV_COLOR_SELECTION_POLICY; -pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_DEFAULT: _NV_DESKTOP_COLOR_DEPTH = 0; -pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_8BPC: _NV_DESKTOP_COLOR_DEPTH = 1; -pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_10BPC: _NV_DESKTOP_COLOR_DEPTH = 2; -pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_16BPC_FLOAT: _NV_DESKTOP_COLOR_DEPTH = 3; -pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_16BPC_FLOAT_WCG: _NV_DESKTOP_COLOR_DEPTH = - 4; -pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_16BPC_FLOAT_HDR: _NV_DESKTOP_COLOR_DEPTH = - 5; -pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_MAX_VALUE: _NV_DESKTOP_COLOR_DEPTH = 5; -pub type _NV_DESKTOP_COLOR_DEPTH = ::std::os::raw::c_int; -pub use self::_NV_DESKTOP_COLOR_DEPTH as NV_DESKTOP_COLOR_DEPTH; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_COLOR_DATA_V1 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< Size of this structure"] - pub size: NvU16, - pub cmd: NvU8, - pub data: _NV_COLOR_DATA_V1__bindgen_ty_1, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_COLOR_DATA_V1__bindgen_ty_1 { - #[doc = "!< One of NV_COLOR_FORMAT enum values."] - pub colorFormat: NvU8, - #[doc = "!< One of NV_COLOR_COLORIMETRY enum values."] - pub colorimetry: NvU8, -} -pub type NV_COLOR_DATA_V1 = _NV_COLOR_DATA_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_COLOR_DATA_V2 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< Size of this structure"] - pub size: NvU16, - pub cmd: NvU8, - pub data: _NV_COLOR_DATA_V2__bindgen_ty_1, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_COLOR_DATA_V2__bindgen_ty_1 { - #[doc = "!< One of NV_COLOR_FORMAT enum values."] - pub colorFormat: NvU8, - #[doc = "!< One of NV_COLOR_COLORIMETRY enum values."] - pub colorimetry: NvU8, - #[doc = "!< One of NV_DYNAMIC_RANGE enum values."] - pub dynamicRange: NvU8, -} -pub type NV_COLOR_DATA_V2 = _NV_COLOR_DATA_V2; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_COLOR_DATA_V3 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< Size of this structure"] - pub size: NvU16, - pub cmd: NvU8, - pub data: _NV_COLOR_DATA_V3__bindgen_ty_1, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_COLOR_DATA_V3__bindgen_ty_1 { - #[doc = "!< One of NV_COLOR_FORMAT enum values."] - pub colorFormat: NvU8, - #[doc = "!< One of NV_COLOR_COLORIMETRY enum values."] - pub colorimetry: NvU8, - #[doc = "!< One of NV_DYNAMIC_RANGE enum values."] - pub dynamicRange: NvU8, - #[doc = "!< One of NV_BPC enum values."] - pub bpc: NV_BPC, -} -pub type NV_COLOR_DATA_V3 = _NV_COLOR_DATA_V3; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_COLOR_DATA_V4 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< Size of this structure"] - pub size: NvU16, - pub cmd: NvU8, - pub data: _NV_COLOR_DATA_V4__bindgen_ty_1, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_COLOR_DATA_V4__bindgen_ty_1 { - #[doc = "!< One of NV_COLOR_FORMAT enum values."] - pub colorFormat: NvU8, - #[doc = "!< One of NV_COLOR_COLORIMETRY enum values."] - pub colorimetry: NvU8, - #[doc = "!< One of NV_DYNAMIC_RANGE enum values."] - pub dynamicRange: NvU8, - #[doc = "!< One of NV_BPC enum values."] - pub bpc: NV_BPC, - #[doc = "!< One of the color selection policy"] - pub colorSelectionPolicy: NV_COLOR_SELECTION_POLICY, -} -pub type NV_COLOR_DATA_V4 = _NV_COLOR_DATA_V4; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_COLOR_DATA_V5 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< Size of this structure"] - pub size: NvU16, - pub cmd: NvU8, - pub data: _NV_COLOR_DATA_V5__bindgen_ty_1, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_COLOR_DATA_V5__bindgen_ty_1 { - #[doc = "!< One of NV_COLOR_FORMAT enum values."] - pub colorFormat: NvU8, - #[doc = "!< One of NV_COLOR_COLORIMETRY enum values."] - pub colorimetry: NvU8, - #[doc = "!< One of NV_DYNAMIC_RANGE enum values."] - pub dynamicRange: NvU8, - #[doc = "!< One of NV_BPC enum values."] - pub bpc: NV_BPC, - #[doc = "!< One of the color selection policy"] - pub colorSelectionPolicy: NV_COLOR_SELECTION_POLICY, - #[doc = "!< One of NV_DESKTOP_COLOR_DEPTH enum values."] - pub depth: NV_DESKTOP_COLOR_DEPTH, -} -pub type NV_COLOR_DATA_V5 = _NV_COLOR_DATA_V5; -pub type NV_COLOR_DATA = NV_COLOR_DATA_V5; -#[doc = "!< Tells the type of structure used to define the Static Metadata Descriptor block."] -pub const NV_STATIC_METADATA_DESCRIPTOR_ID_NV_STATIC_METADATA_TYPE_1: - NV_STATIC_METADATA_DESCRIPTOR_ID = 0; -#[doc = "! @}"] -pub type NV_STATIC_METADATA_DESCRIPTOR_ID = ::std::os::raw::c_int; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDR_CAPABILITIES_V1 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Static Metadata Descriptor Id (0 for static metadata type 1)"] - pub static_metadata_descriptor_id: NV_STATIC_METADATA_DESCRIPTOR_ID, - pub display_data: _NV_HDR_CAPABILITIES_V1__bindgen_ty_1, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDR_CAPABILITIES_V1__bindgen_ty_1 { - #[doc = "!< x coordinate of color primary 0 (e.g. Red) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x0: NvU16, - #[doc = "!< y coordinate of color primary 0 (e.g. Red) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y0: NvU16, - #[doc = "!< x coordinate of color primary 1 (e.g. Green) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x1: NvU16, - #[doc = "!< y coordinate of color primary 1 (e.g. Green) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y1: NvU16, - #[doc = "!< x coordinate of color primary 2 (e.g. Blue) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x2: NvU16, - #[doc = "!< y coordinate of color primary 2 (e.g. Blue) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y2: NvU16, - #[doc = "!< x coordinate of white point of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayWhitePoint_x: NvU16, - #[doc = "!< y coordinate of white point of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayWhitePoint_y: NvU16, - #[doc = "!< Maximum display luminance = desired max luminance of HDR content ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] - pub desired_content_max_luminance: NvU16, - #[doc = "!< Minimum display luminance = desired min luminance of HDR content ([0x0001-0xFFFF] = [1.0 - 6.55350] cd/m^2)"] - pub desired_content_min_luminance: NvU16, - #[doc = "!< Desired maximum Frame-Average Light Level (MaxFALL) of HDR content ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] - pub desired_content_max_frame_average_luminance: NvU16, -} -impl _NV_HDR_CAPABILITIES_V1 { - #[inline] - pub fn isST2084EotfSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isST2084EotfSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isST2084EotfSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isST2084EotfSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isTraditionalHdrGammaSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_isTraditionalHdrGammaSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isTraditionalHdrGammaSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isTraditionalHdrGammaSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isEdrSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_isEdrSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isEdrSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isEdrSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn driverExpandDefaultHdrParameters(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_driverExpandDefaultHdrParameters(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn driverExpandDefaultHdrParameters_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_driverExpandDefaultHdrParameters_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isTraditionalSdrGammaSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } - } - #[inline] - pub fn set_isTraditionalSdrGammaSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isTraditionalSdrGammaSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isTraditionalSdrGammaSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 27u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 27u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 27u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isST2084EotfSupported: NvU32, - isTraditionalHdrGammaSupported: NvU32, - isEdrSupported: NvU32, - driverExpandDefaultHdrParameters: NvU32, - isTraditionalSdrGammaSupported: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isST2084EotfSupported: u32 = - unsafe { ::std::mem::transmute(isST2084EotfSupported) }; - isST2084EotfSupported as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let isTraditionalHdrGammaSupported: u32 = - unsafe { ::std::mem::transmute(isTraditionalHdrGammaSupported) }; - isTraditionalHdrGammaSupported as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let isEdrSupported: u32 = unsafe { ::std::mem::transmute(isEdrSupported) }; - isEdrSupported as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let driverExpandDefaultHdrParameters: u32 = - unsafe { ::std::mem::transmute(driverExpandDefaultHdrParameters) }; - driverExpandDefaultHdrParameters as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let isTraditionalSdrGammaSupported: u32 = - unsafe { ::std::mem::transmute(isTraditionalSdrGammaSupported) }; - isTraditionalSdrGammaSupported as u64 - }); - __bindgen_bitfield_unit.set(5usize, 27u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_HDR_CAPABILITIES_V1 = _NV_HDR_CAPABILITIES_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDR_CAPABILITIES_V2 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Static Metadata Descriptor Id (0 for static metadata type 1)"] - pub static_metadata_descriptor_id: NV_STATIC_METADATA_DESCRIPTOR_ID, - pub display_data: _NV_HDR_CAPABILITIES_V2__bindgen_ty_1, - pub dv_static_metadata: _NV_HDR_CAPABILITIES_V2__bindgen_ty_2, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDR_CAPABILITIES_V2__bindgen_ty_1 { - #[doc = "!< x coordinate of color primary 0 (e.g. Red) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x0: NvU16, - #[doc = "!< y coordinate of color primary 0 (e.g. Red) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y0: NvU16, - #[doc = "!< x coordinate of color primary 1 (e.g. Green) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x1: NvU16, - #[doc = "!< y coordinate of color primary 1 (e.g. Green) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y1: NvU16, - #[doc = "!< x coordinate of color primary 2 (e.g. Blue) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x2: NvU16, - #[doc = "!< y coordinate of color primary 2 (e.g. Blue) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y2: NvU16, - #[doc = "!< x coordinate of white point of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayWhitePoint_x: NvU16, - #[doc = "!< y coordinate of white point of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayWhitePoint_y: NvU16, - #[doc = "!< Maximum display luminance = desired max luminance of HDR content ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] - pub desired_content_max_luminance: NvU16, - #[doc = "!< Minimum display luminance = desired min luminance of HDR content ([0x0001-0xFFFF] = [1.0 - 6.55350] cd/m^2)"] - pub desired_content_min_luminance: NvU16, - #[doc = "!< Desired maximum Frame-Average Light Level (MaxFALL) of HDR content ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] - pub desired_content_max_frame_average_luminance: NvU16, -} -#[repr(C)] -#[repr(align(4))] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDR_CAPABILITIES_V2__bindgen_ty_2 { - pub _bitfield_align_1: [u16; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Represents min luminance level of Sink"] - pub target_min_luminance: NvU16, - #[doc = "!< Represents max luminance level of sink"] - pub target_max_luminance: NvU16, - #[doc = "!< Red primary chromaticity coordinate x"] - pub cc_red_x: NvU16, - #[doc = "!< Red primary chromaticity coordinate y"] - pub cc_red_y: NvU16, - #[doc = "!< Green primary chromaticity coordinate x"] - pub cc_green_x: NvU16, - #[doc = "!< Green primary chromaticity coordinate Y"] - pub cc_green_y: NvU16, - #[doc = "!< Blue primary chromaticity coordinate x"] - pub cc_blue_x: NvU16, - #[doc = "!< Blue primary chromaticity coordinate y"] - pub cc_blue_y: NvU16, - #[doc = "!< White primary chromaticity coordinate x"] - pub cc_white_x: NvU16, - #[doc = "!< White primary chromaticity coordinate y"] - pub cc_white_y: NvU16, -} -impl _NV_HDR_CAPABILITIES_V2__bindgen_ty_2 { - #[inline] - pub fn VSVDB_version(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 3u8) as u32) } - } - #[inline] - pub fn set_VSVDB_version(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 3u8, val as u64) - } - } - #[inline] - pub unsafe fn VSVDB_version_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 3u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_VSVDB_version_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 3u8, - val as u64, - ) - } - } - #[inline] - pub fn dm_version(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 8u8) as u32) } - } - #[inline] - pub fn set_dm_version(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 8u8, val as u64) - } - } - #[inline] - pub unsafe fn dm_version_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 8u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_dm_version_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 8u8, - val as u64, - ) - } - } - #[inline] - pub fn supports_2160p60hz(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) } - } - #[inline] - pub fn set_supports_2160p60hz(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(11usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supports_2160p60hz_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 11usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_supports_2160p60hz_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 11usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn supports_YUV422_12bit(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) } - } - #[inline] - pub fn set_supports_YUV422_12bit(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(12usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supports_YUV422_12bit_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 12usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_supports_YUV422_12bit_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 12usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn supports_global_dimming(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) } - } - #[inline] - pub fn set_supports_global_dimming(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(13usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supports_global_dimming_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 13usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_supports_global_dimming_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 13usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn colorimetry(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) } - } - #[inline] - pub fn set_colorimetry(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(14usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn colorimetry_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 14usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_colorimetry_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 14usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn supports_backlight_control(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 2u8) as u32) } - } - #[inline] - pub fn set_supports_backlight_control(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(15usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn supports_backlight_control_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 15usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_supports_backlight_control_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 15usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn backlt_min_luma(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 2u8) as u32) } - } - #[inline] - pub fn set_backlt_min_luma(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(17usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn backlt_min_luma_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 17usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_backlt_min_luma_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 17usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn interface_supported_by_sink(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 2u8) as u32) } - } - #[inline] - pub fn set_interface_supported_by_sink(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(19usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn interface_supported_by_sink_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 19usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_interface_supported_by_sink_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 19usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn supports_10b_12b_444(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 2u8) as u32) } - } - #[inline] - pub fn set_supports_10b_12b_444(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(21usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn supports_10b_12b_444_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 21usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_supports_10b_12b_444_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 21usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 9u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(23usize, 9u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 23usize, - 9u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 23usize, - 9u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - VSVDB_version: NvU32, - dm_version: NvU32, - supports_2160p60hz: NvU32, - supports_YUV422_12bit: NvU32, - supports_global_dimming: NvU32, - colorimetry: NvU32, - supports_backlight_control: NvU32, - backlt_min_luma: NvU32, - interface_supported_by_sink: NvU32, - supports_10b_12b_444: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 3u8, { - let VSVDB_version: u32 = unsafe { ::std::mem::transmute(VSVDB_version) }; - VSVDB_version as u64 - }); - __bindgen_bitfield_unit.set(3usize, 8u8, { - let dm_version: u32 = unsafe { ::std::mem::transmute(dm_version) }; - dm_version as u64 - }); - __bindgen_bitfield_unit.set(11usize, 1u8, { - let supports_2160p60hz: u32 = unsafe { ::std::mem::transmute(supports_2160p60hz) }; - supports_2160p60hz as u64 - }); - __bindgen_bitfield_unit.set(12usize, 1u8, { - let supports_YUV422_12bit: u32 = - unsafe { ::std::mem::transmute(supports_YUV422_12bit) }; - supports_YUV422_12bit as u64 - }); - __bindgen_bitfield_unit.set(13usize, 1u8, { - let supports_global_dimming: u32 = - unsafe { ::std::mem::transmute(supports_global_dimming) }; - supports_global_dimming as u64 - }); - __bindgen_bitfield_unit.set(14usize, 1u8, { - let colorimetry: u32 = unsafe { ::std::mem::transmute(colorimetry) }; - colorimetry as u64 - }); - __bindgen_bitfield_unit.set(15usize, 2u8, { - let supports_backlight_control: u32 = - unsafe { ::std::mem::transmute(supports_backlight_control) }; - supports_backlight_control as u64 - }); - __bindgen_bitfield_unit.set(17usize, 2u8, { - let backlt_min_luma: u32 = unsafe { ::std::mem::transmute(backlt_min_luma) }; - backlt_min_luma as u64 - }); - __bindgen_bitfield_unit.set(19usize, 2u8, { - let interface_supported_by_sink: u32 = - unsafe { ::std::mem::transmute(interface_supported_by_sink) }; - interface_supported_by_sink as u64 - }); - __bindgen_bitfield_unit.set(21usize, 2u8, { - let supports_10b_12b_444: u32 = unsafe { ::std::mem::transmute(supports_10b_12b_444) }; - supports_10b_12b_444 as u64 - }); - __bindgen_bitfield_unit.set(23usize, 9u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -impl _NV_HDR_CAPABILITIES_V2 { - #[inline] - pub fn isST2084EotfSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isST2084EotfSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isST2084EotfSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isST2084EotfSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isTraditionalHdrGammaSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_isTraditionalHdrGammaSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isTraditionalHdrGammaSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isTraditionalHdrGammaSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isEdrSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_isEdrSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isEdrSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isEdrSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn driverExpandDefaultHdrParameters(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_driverExpandDefaultHdrParameters(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn driverExpandDefaultHdrParameters_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_driverExpandDefaultHdrParameters_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isTraditionalSdrGammaSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } - } - #[inline] - pub fn set_isTraditionalSdrGammaSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isTraditionalSdrGammaSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isTraditionalSdrGammaSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isDolbyVisionSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } - } - #[inline] - pub fn set_isDolbyVisionSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isDolbyVisionSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isDolbyVisionSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 26u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(6usize, 26u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 6usize, - 26u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 6usize, - 26u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isST2084EotfSupported: NvU32, - isTraditionalHdrGammaSupported: NvU32, - isEdrSupported: NvU32, - driverExpandDefaultHdrParameters: NvU32, - isTraditionalSdrGammaSupported: NvU32, - isDolbyVisionSupported: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isST2084EotfSupported: u32 = - unsafe { ::std::mem::transmute(isST2084EotfSupported) }; - isST2084EotfSupported as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let isTraditionalHdrGammaSupported: u32 = - unsafe { ::std::mem::transmute(isTraditionalHdrGammaSupported) }; - isTraditionalHdrGammaSupported as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let isEdrSupported: u32 = unsafe { ::std::mem::transmute(isEdrSupported) }; - isEdrSupported as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let driverExpandDefaultHdrParameters: u32 = - unsafe { ::std::mem::transmute(driverExpandDefaultHdrParameters) }; - driverExpandDefaultHdrParameters as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let isTraditionalSdrGammaSupported: u32 = - unsafe { ::std::mem::transmute(isTraditionalSdrGammaSupported) }; - isTraditionalSdrGammaSupported as u64 - }); - __bindgen_bitfield_unit.set(5usize, 1u8, { - let isDolbyVisionSupported: u32 = - unsafe { ::std::mem::transmute(isDolbyVisionSupported) }; - isDolbyVisionSupported as u64 - }); - __bindgen_bitfield_unit.set(6usize, 26u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_HDR_CAPABILITIES_V2 = _NV_HDR_CAPABILITIES_V2; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDR_CAPABILITIES_V3 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Static Metadata Descriptor Id (0 for static metadata type 1)"] - pub static_metadata_descriptor_id: NV_STATIC_METADATA_DESCRIPTOR_ID, - pub display_data: _NV_HDR_CAPABILITIES_V3__bindgen_ty_1, - pub dv_static_metadata: _NV_HDR_CAPABILITIES_V3__bindgen_ty_2, - pub hdr10plus_vsvdb: _NV_HDR_CAPABILITIES_V3__bindgen_ty_3, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDR_CAPABILITIES_V3__bindgen_ty_1 { - #[doc = "!< x coordinate of color primary 0 (e.g. Red) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x0: NvU16, - #[doc = "!< y coordinate of color primary 0 (e.g. Red) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y0: NvU16, - #[doc = "!< x coordinate of color primary 1 (e.g. Green) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x1: NvU16, - #[doc = "!< y coordinate of color primary 1 (e.g. Green) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y1: NvU16, - #[doc = "!< x coordinate of color primary 2 (e.g. Blue) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x2: NvU16, - #[doc = "!< y coordinate of color primary 2 (e.g. Blue) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y2: NvU16, - #[doc = "!< x coordinate of white point of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayWhitePoint_x: NvU16, - #[doc = "!< y coordinate of white point of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayWhitePoint_y: NvU16, - #[doc = "!< Maximum display luminance = desired max luminance of HDR content ([0x0000-0xFFFF] = [0.0 - 65535.0] cd/m^2, in units of 1 cd/m^2)"] - pub desired_content_max_luminance: NvU16, - #[doc = "!< Minimum display luminance = desired min luminance of HDR content ([0x0000-0xFFFF] = [0.0 - 6.55350] cd/m^2, in units of 0.0001 cd/m^2)"] - pub desired_content_min_luminance: NvU16, - #[doc = "!< Desired maximum Frame-Average Light Level (MaxFALL) of HDR content ([0x0000-0xFFFF] = [0.0 - 65535.0] cd/m^2, in units of 1 cd/m^2)"] - pub desired_content_max_frame_average_luminance: NvU16, -} -#[repr(C)] -#[repr(align(4))] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDR_CAPABILITIES_V3__bindgen_ty_2 { - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Represents min luminance level of Sink"] - pub target_min_luminance: NvU16, - #[doc = "!< Represents max luminance level of sink"] - pub target_max_luminance: NvU16, - #[doc = "!< Red primary chromaticity coordinate x"] - pub cc_red_x: NvU16, - #[doc = "!< Red primary chromaticity coordinate y"] - pub cc_red_y: NvU16, - #[doc = "!< Green primary chromaticity coordinate x"] - pub cc_green_x: NvU16, - #[doc = "!< Green primary chromaticity coordinate Y"] - pub cc_green_y: NvU16, - #[doc = "!< Blue primary chromaticity coordinate x"] - pub cc_blue_x: NvU16, - #[doc = "!< Blue primary chromaticity coordinate y"] - pub cc_blue_y: NvU16, - #[doc = "!< White primary chromaticity coordinate x"] - pub cc_white_x: NvU16, - #[doc = "!< White primary chromaticity coordinate y"] - pub cc_white_y: NvU16, -} -impl _NV_HDR_CAPABILITIES_V3__bindgen_ty_2 { - #[inline] - pub fn VSVDB_version(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 3u8) as u32) } - } - #[inline] - pub fn set_VSVDB_version(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 3u8, val as u64) - } - } - #[inline] - pub unsafe fn VSVDB_version_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 3u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_VSVDB_version_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 3u8, - val as u64, - ) - } - } - #[inline] - pub fn dm_version(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 8u8) as u32) } - } - #[inline] - pub fn set_dm_version(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 8u8, val as u64) - } - } - #[inline] - pub unsafe fn dm_version_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 8u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_dm_version_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 8u8, - val as u64, - ) - } - } - #[inline] - pub fn supports_2160p60hz(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) } - } - #[inline] - pub fn set_supports_2160p60hz(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(11usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supports_2160p60hz_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 11usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_supports_2160p60hz_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 11usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn supports_YUV422_12bit(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) } - } - #[inline] - pub fn set_supports_YUV422_12bit(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(12usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supports_YUV422_12bit_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 12usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_supports_YUV422_12bit_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 12usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn supports_global_dimming(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) } - } - #[inline] - pub fn set_supports_global_dimming(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(13usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supports_global_dimming_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 13usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_supports_global_dimming_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 13usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn colorimetry(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) } - } - #[inline] - pub fn set_colorimetry(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(14usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn colorimetry_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 14usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_colorimetry_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 14usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn supports_backlight_control(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 2u8) as u32) } - } - #[inline] - pub fn set_supports_backlight_control(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(15usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn supports_backlight_control_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 15usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_supports_backlight_control_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 15usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn backlt_min_luma(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 2u8) as u32) } - } - #[inline] - pub fn set_backlt_min_luma(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(17usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn backlt_min_luma_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 17usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_backlt_min_luma_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 17usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn interface_supported_by_sink(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 2u8) as u32) } - } - #[inline] - pub fn set_interface_supported_by_sink(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(19usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn interface_supported_by_sink_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 19usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_interface_supported_by_sink_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 19usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn supports_10b_12b_444(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 2u8) as u32) } - } - #[inline] - pub fn set_supports_10b_12b_444(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(21usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn supports_10b_12b_444_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 21usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_supports_10b_12b_444_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 21usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn parity(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u32) } - } - #[inline] - pub fn set_parity(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(23usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn parity_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 23usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_parity_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 23usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(24usize, 8u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 24usize, - 8u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 24usize, - 8u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - VSVDB_version: NvU32, - dm_version: NvU32, - supports_2160p60hz: NvU32, - supports_YUV422_12bit: NvU32, - supports_global_dimming: NvU32, - colorimetry: NvU32, - supports_backlight_control: NvU32, - backlt_min_luma: NvU32, - interface_supported_by_sink: NvU32, - supports_10b_12b_444: NvU32, - parity: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 3u8, { - let VSVDB_version: u32 = unsafe { ::std::mem::transmute(VSVDB_version) }; - VSVDB_version as u64 - }); - __bindgen_bitfield_unit.set(3usize, 8u8, { - let dm_version: u32 = unsafe { ::std::mem::transmute(dm_version) }; - dm_version as u64 - }); - __bindgen_bitfield_unit.set(11usize, 1u8, { - let supports_2160p60hz: u32 = unsafe { ::std::mem::transmute(supports_2160p60hz) }; - supports_2160p60hz as u64 - }); - __bindgen_bitfield_unit.set(12usize, 1u8, { - let supports_YUV422_12bit: u32 = - unsafe { ::std::mem::transmute(supports_YUV422_12bit) }; - supports_YUV422_12bit as u64 - }); - __bindgen_bitfield_unit.set(13usize, 1u8, { - let supports_global_dimming: u32 = - unsafe { ::std::mem::transmute(supports_global_dimming) }; - supports_global_dimming as u64 - }); - __bindgen_bitfield_unit.set(14usize, 1u8, { - let colorimetry: u32 = unsafe { ::std::mem::transmute(colorimetry) }; - colorimetry as u64 - }); - __bindgen_bitfield_unit.set(15usize, 2u8, { - let supports_backlight_control: u32 = - unsafe { ::std::mem::transmute(supports_backlight_control) }; - supports_backlight_control as u64 - }); - __bindgen_bitfield_unit.set(17usize, 2u8, { - let backlt_min_luma: u32 = unsafe { ::std::mem::transmute(backlt_min_luma) }; - backlt_min_luma as u64 - }); - __bindgen_bitfield_unit.set(19usize, 2u8, { - let interface_supported_by_sink: u32 = - unsafe { ::std::mem::transmute(interface_supported_by_sink) }; - interface_supported_by_sink as u64 - }); - __bindgen_bitfield_unit.set(21usize, 2u8, { - let supports_10b_12b_444: u32 = unsafe { ::std::mem::transmute(supports_10b_12b_444) }; - supports_10b_12b_444 as u64 - }); - __bindgen_bitfield_unit.set(23usize, 1u8, { - let parity: u32 = unsafe { ::std::mem::transmute(parity) }; - parity as u64 - }); - __bindgen_bitfield_unit.set(24usize, 8u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[repr(C)] -#[repr(align(2))] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDR_CAPABILITIES_V3__bindgen_ty_3 { - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>, -} -impl _NV_HDR_CAPABILITIES_V3__bindgen_ty_3 { - #[inline] - pub fn application_version(&self) -> NvU16 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u16) } - } - #[inline] - pub fn set_application_version(&mut self, val: NvU16) { - unsafe { - let val: u16 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn application_version_raw(this: *const Self) -> NvU16 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 2u8, - ) as u16) - } - } - #[inline] - pub unsafe fn set_application_version_raw(this: *mut Self, val: NvU16) { - unsafe { - let val: u16 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn full_frame_peak_luminance_index(&self) -> NvU16 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 2u8) as u16) } - } - #[inline] - pub fn set_full_frame_peak_luminance_index(&mut self, val: NvU16) { - unsafe { - let val: u16 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn full_frame_peak_luminance_index_raw(this: *const Self) -> NvU16 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 2u8, - ) as u16) - } - } - #[inline] - pub unsafe fn set_full_frame_peak_luminance_index_raw(this: *mut Self, val: NvU16) { - unsafe { - let val: u16 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn peak_luminance_index(&self) -> NvU16 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u16) } - } - #[inline] - pub fn set_peak_luminance_index(&mut self, val: NvU16) { - unsafe { - let val: u16 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 4u8, val as u64) - } - } - #[inline] - pub unsafe fn peak_luminance_index_raw(this: *const Self) -> NvU16 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 4u8, - ) as u16) - } - } - #[inline] - pub unsafe fn set_peak_luminance_index_raw(this: *mut Self, val: NvU16) { - unsafe { - let val: u16 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 4u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU16 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 8u8) as u16) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU16) { - unsafe { - let val: u16 = ::std::mem::transmute(val); - self._bitfield_1.set(8usize, 8u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU16 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 8usize, - 8u8, - ) as u16) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU16) { - unsafe { - let val: u16 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 8usize, - 8u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - application_version: NvU16, - full_frame_peak_luminance_index: NvU16, - peak_luminance_index: NvU16, - reserved: NvU16, - ) -> __BindgenBitfieldUnit<[u8; 2usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 2u8, { - let application_version: u16 = unsafe { ::std::mem::transmute(application_version) }; - application_version as u64 - }); - __bindgen_bitfield_unit.set(2usize, 2u8, { - let full_frame_peak_luminance_index: u16 = - unsafe { ::std::mem::transmute(full_frame_peak_luminance_index) }; - full_frame_peak_luminance_index as u64 - }); - __bindgen_bitfield_unit.set(4usize, 4u8, { - let peak_luminance_index: u16 = unsafe { ::std::mem::transmute(peak_luminance_index) }; - peak_luminance_index as u64 - }); - __bindgen_bitfield_unit.set(8usize, 8u8, { - let reserved: u16 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -impl _NV_HDR_CAPABILITIES_V3 { - #[inline] - pub fn isST2084EotfSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isST2084EotfSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isST2084EotfSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isST2084EotfSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isTraditionalHdrGammaSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_isTraditionalHdrGammaSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isTraditionalHdrGammaSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isTraditionalHdrGammaSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isEdrSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_isEdrSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isEdrSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isEdrSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn driverExpandDefaultHdrParameters(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_driverExpandDefaultHdrParameters(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn driverExpandDefaultHdrParameters_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_driverExpandDefaultHdrParameters_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isTraditionalSdrGammaSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } - } - #[inline] - pub fn set_isTraditionalSdrGammaSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isTraditionalSdrGammaSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isTraditionalSdrGammaSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isDolbyVisionSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } - } - #[inline] - pub fn set_isDolbyVisionSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isDolbyVisionSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isDolbyVisionSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isHdr10PlusSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } - } - #[inline] - pub fn set_isHdr10PlusSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(6usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isHdr10PlusSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 6usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isHdr10PlusSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 6usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isHdr10PlusGamingSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } - } - #[inline] - pub fn set_isHdr10PlusGamingSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(7usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isHdr10PlusGamingSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 7usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isHdr10PlusGamingSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 7usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isNvidiaCertifiedDisplay(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) } - } - #[inline] - pub fn set_isNvidiaCertifiedDisplay(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(8usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isNvidiaCertifiedDisplay_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 8usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isNvidiaCertifiedDisplay_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 8usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 23u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(9usize, 23u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 9usize, - 23u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 9usize, - 23u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isST2084EotfSupported: NvU32, - isTraditionalHdrGammaSupported: NvU32, - isEdrSupported: NvU32, - driverExpandDefaultHdrParameters: NvU32, - isTraditionalSdrGammaSupported: NvU32, - isDolbyVisionSupported: NvU32, - isHdr10PlusSupported: NvU32, - isHdr10PlusGamingSupported: NvU32, - isNvidiaCertifiedDisplay: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isST2084EotfSupported: u32 = - unsafe { ::std::mem::transmute(isST2084EotfSupported) }; - isST2084EotfSupported as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let isTraditionalHdrGammaSupported: u32 = - unsafe { ::std::mem::transmute(isTraditionalHdrGammaSupported) }; - isTraditionalHdrGammaSupported as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let isEdrSupported: u32 = unsafe { ::std::mem::transmute(isEdrSupported) }; - isEdrSupported as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let driverExpandDefaultHdrParameters: u32 = - unsafe { ::std::mem::transmute(driverExpandDefaultHdrParameters) }; - driverExpandDefaultHdrParameters as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let isTraditionalSdrGammaSupported: u32 = - unsafe { ::std::mem::transmute(isTraditionalSdrGammaSupported) }; - isTraditionalSdrGammaSupported as u64 - }); - __bindgen_bitfield_unit.set(5usize, 1u8, { - let isDolbyVisionSupported: u32 = - unsafe { ::std::mem::transmute(isDolbyVisionSupported) }; - isDolbyVisionSupported as u64 - }); - __bindgen_bitfield_unit.set(6usize, 1u8, { - let isHdr10PlusSupported: u32 = unsafe { ::std::mem::transmute(isHdr10PlusSupported) }; - isHdr10PlusSupported as u64 - }); - __bindgen_bitfield_unit.set(7usize, 1u8, { - let isHdr10PlusGamingSupported: u32 = - unsafe { ::std::mem::transmute(isHdr10PlusGamingSupported) }; - isHdr10PlusGamingSupported as u64 - }); - __bindgen_bitfield_unit.set(8usize, 1u8, { - let isNvidiaCertifiedDisplay: u32 = - unsafe { ::std::mem::transmute(isNvidiaCertifiedDisplay) }; - isNvidiaCertifiedDisplay as u64 - }); - __bindgen_bitfield_unit.set(9usize, 23u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_HDR_CAPABILITIES_V3 = _NV_HDR_CAPABILITIES_V3; -pub type NV_HDR_CAPABILITIES = NV_HDR_CAPABILITIES_V3; -#[doc = "!< Get current HDR output configuration"] -pub const NV_HDR_CMD_NV_HDR_CMD_GET: NV_HDR_CMD = 0; -#[doc = "!< Set HDR output configuration"] -pub const NV_HDR_CMD_NV_HDR_CMD_SET: NV_HDR_CMD = 1; -#[doc = "! @}"] -pub type NV_HDR_CMD = ::std::os::raw::c_int; -#[doc = "!< Turn off HDR"] -pub const NV_HDR_MODE_NV_HDR_MODE_OFF: NV_HDR_MODE = 0; -#[doc = "!< Source: CCCS [a.k.a FP16 scRGB, linear, sRGB primaries, [-65504,0, 65504] range, RGB(1,1,1) = 80nits] Output : UHDA HDR [a.k.a HDR10, RGB/YCC 10/12bpc ST2084(PQ) EOTF RGB(1,1,1) = 10000 nits, Rec2020 color primaries, ST2086 static HDR metadata]. This is the only supported production HDR mode."] -pub const NV_HDR_MODE_NV_HDR_MODE_UHDA: NV_HDR_MODE = 2; -#[doc = "!< Experimental mode only, not for production! Source: HDR10 RGB 10bpc Output: HDR10 RGB 10 bpc - signal UHDA HDR mode (PQ + Rec2020) to the sink but send source pixel values unmodified (no PQ or Rec2020 conversions) - assumes source is already in HDR10 format."] -pub const NV_HDR_MODE_NV_HDR_MODE_UHDA_PASSTHROUGH: NV_HDR_MODE = 5; -#[doc = "!< Experimental mode only, not for production! Source: RGB8 Dolby Vision encoded (12 bpc YCbCr422 packed into RGB8) Output: Dolby Vision encoded : Application is to encoded frames in DV format and embed DV dynamic metadata as described in Dolby Vision specification."] -pub const NV_HDR_MODE_NV_HDR_MODE_DOLBY_VISION: NV_HDR_MODE = 7; -#[doc = "!< Do not use! Internal test mode only, to be removed. Source: CCCS (a.k.a FP16 scRGB) Output : EDR (Extended Dynamic Range) - HDR content is tonemapped and gamut mapped to output on regular SDR display set to max luminance ( ~300 nits )."] -pub const NV_HDR_MODE_NV_HDR_MODE_EDR: NV_HDR_MODE = 3; -#[doc = "!< Do not use! Internal test mode only, to be removed. Source: any Output: SDR (Standard Dynamic Range), we continuously send SDR EOTF InfoFrame signaling, HDMI compliance testing."] -pub const NV_HDR_MODE_NV_HDR_MODE_SDR: NV_HDR_MODE = 4; -#[doc = "!< Do not use! Internal test mode only, to be removed. Source: CCCS (a.k.a FP16 scRGB) Output : notebook HDR"] -pub const NV_HDR_MODE_NV_HDR_MODE_UHDA_NB: NV_HDR_MODE = 6; -#[doc = "!< Do not use! Obsolete, to be removed. NV_HDR_MODE_UHDBD == NV_HDR_MODE_UHDA, reflects obsolete pre-UHDA naming convention."] -pub const NV_HDR_MODE_NV_HDR_MODE_UHDBD: NV_HDR_MODE = 2; -pub type NV_HDR_MODE = ::std::os::raw::c_int; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDR_COLOR_DATA_V1 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< Command get/set"] - pub cmd: NV_HDR_CMD, - #[doc = "!< HDR mode"] - pub hdrMode: NV_HDR_MODE, - #[doc = "!< Static Metadata Descriptor Id (0 for static metadata type 1)"] - pub static_metadata_descriptor_id: NV_STATIC_METADATA_DESCRIPTOR_ID, - pub mastering_display_data: _NV_HDR_COLOR_DATA_V1__bindgen_ty_1, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDR_COLOR_DATA_V1__bindgen_ty_1 { - #[doc = "!< x coordinate of color primary 0 (e.g. Red) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x0: NvU16, - #[doc = "!< y coordinate of color primary 0 (e.g. Red) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y0: NvU16, - #[doc = "!< x coordinate of color primary 1 (e.g. Green) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x1: NvU16, - #[doc = "!< y coordinate of color primary 1 (e.g. Green) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y1: NvU16, - #[doc = "!< x coordinate of color primary 2 (e.g. Blue) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x2: NvU16, - #[doc = "!< y coordinate of color primary 2 (e.g. Blue) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y2: NvU16, - #[doc = "!< x coordinate of white point of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayWhitePoint_x: NvU16, - #[doc = "!< y coordinate of white point of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayWhitePoint_y: NvU16, - #[doc = "!< Maximum display mastering luminance ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] - pub max_display_mastering_luminance: NvU16, - #[doc = "!< Minimum display mastering luminance ([0x0001-0xFFFF] = [1.0 - 6.55350] cd/m^2)"] - pub min_display_mastering_luminance: NvU16, - #[doc = "!< Maximum Content Light level (MaxCLL) ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] - pub max_content_light_level: NvU16, - #[doc = "!< Maximum Frame-Average Light Level (MaxFALL) ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] - pub max_frame_average_light_level: NvU16, -} -pub type NV_HDR_COLOR_DATA_V1 = _NV_HDR_COLOR_DATA_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDR_COLOR_DATA_V2 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< Command get/set"] - pub cmd: NV_HDR_CMD, - #[doc = "!< HDR mode"] - pub hdrMode: NV_HDR_MODE, - #[doc = "!< Static Metadata Descriptor Id (0 for static metadata type 1)"] - pub static_metadata_descriptor_id: NV_STATIC_METADATA_DESCRIPTOR_ID, - pub mastering_display_data: _NV_HDR_COLOR_DATA_V2__bindgen_ty_1, - #[doc = "!< Optional, One of NV_COLOR_FORMAT enum values, if set it will apply requested color format for HDR session"] - pub hdrColorFormat: NV_COLOR_FORMAT, - #[doc = "!< Optional, One of NV_DYNAMIC_RANGE enum values, if set it will apply requested dynamic range for HDR session"] - pub hdrDynamicRange: NV_DYNAMIC_RANGE, - #[doc = "!< Optional, One of NV_BPC enum values, if set it will apply requested color depth\n!< Dolby Vision mode: DV supports specific combinations of colorformat, dynamic range and bpc. Please refer Dolby Vision specification.\n!< If invalid or no combination is passed driver will force default combination of RGB format + full range + 8bpc.\n!< HDR mode: These fields are ignored in hdr mode"] - pub hdrBpc: NV_BPC, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDR_COLOR_DATA_V2__bindgen_ty_1 { - #[doc = "!< x coordinate of color primary 0 (e.g. Red) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x0: NvU16, - #[doc = "!< y coordinate of color primary 0 (e.g. Red) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y0: NvU16, - #[doc = "!< x coordinate of color primary 1 (e.g. Green) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x1: NvU16, - #[doc = "!< y coordinate of color primary 1 (e.g. Green) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y1: NvU16, - #[doc = "!< x coordinate of color primary 2 (e.g. Blue) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x2: NvU16, - #[doc = "!< y coordinate of color primary 2 (e.g. Blue) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y2: NvU16, - #[doc = "!< x coordinate of white point of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayWhitePoint_x: NvU16, - #[doc = "!< y coordinate of white point of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayWhitePoint_y: NvU16, - #[doc = "!< Maximum display mastering luminance ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] - pub max_display_mastering_luminance: NvU16, - #[doc = "!< Minimum display mastering luminance ([0x0001-0xFFFF] = [1.0 - 6.55350] cd/m^2)"] - pub min_display_mastering_luminance: NvU16, - #[doc = "!< Maximum Content Light level (MaxCLL) ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] - pub max_content_light_level: NvU16, - #[doc = "!< Maximum Frame-Average Light Level (MaxFALL) ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] - pub max_frame_average_light_level: NvU16, -} -pub type NV_HDR_COLOR_DATA_V2 = _NV_HDR_COLOR_DATA_V2; -pub type NV_HDR_COLOR_DATA = NV_HDR_COLOR_DATA_V2; -#[doc = "!< sRGB IEC 61966-2-1:1999 == DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709"] -pub const _NV_COLORSPACE_TYPE_NV_COLORSPACE_sRGB: _NV_COLORSPACE_TYPE = 0; -#[doc = "!< FP16 linear with sRGB color primaries == DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709"] -pub const _NV_COLORSPACE_TYPE_NV_COLORSPACE_xRGB: _NV_COLORSPACE_TYPE = 1; -#[doc = "!< ITU-R Rec BT.2100 (HDR10) == DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020"] -pub const _NV_COLORSPACE_TYPE_NV_COLORSPACE_REC2100: _NV_COLORSPACE_TYPE = 12; -pub type _NV_COLORSPACE_TYPE = ::std::os::raw::c_int; -pub use self::_NV_COLORSPACE_TYPE as NV_COLORSPACE_TYPE; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDR_METADATA_V1 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< x coordinate of color primary 0 (e.g. Red) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x0: NvU16, - #[doc = "!< y coordinate of color primary 0 (e.g. Red) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y0: NvU16, - #[doc = "!< x coordinate of color primary 1 (e.g. Green) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x1: NvU16, - #[doc = "!< y coordinate of color primary 1 (e.g. Green) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y1: NvU16, - #[doc = "!< x coordinate of color primary 2 (e.g. Blue) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x2: NvU16, - #[doc = "!< y coordinate of color primary 2 (e.g. Blue) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y2: NvU16, - #[doc = "!< x coordinate of white point of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayWhitePoint_x: NvU16, - #[doc = "!< y coordinate of white point of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayWhitePoint_y: NvU16, - #[doc = "!< Maximum display mastering luminance ([0x0000-0xFFFF] = [0.0 - 65535.0] cd/m^2, in units of 1 cd/m^2)"] - pub max_display_mastering_luminance: NvU16, - #[doc = "!< Minimum display mastering luminance ([0x0000-0xFFFF] = [0.0 - 6.55350] cd/m^2, in units of 0.0001 cd/m^2)"] - pub min_display_mastering_luminance: NvU16, - #[doc = "!< Maximum Content Light level (MaxCLL) ([0x0000-0xFFFF] = [0.0 - 65535.0] cd/m^2, in units of 1 cd/m^2)"] - pub max_content_light_level: NvU16, - #[doc = "!< Maximum Frame-Average Light Level (MaxFALL) ([0x0000-0xFFFF] = [0.0 - 65535.0] cd/m^2, in units of 1 cd/m^2)"] - pub max_frame_average_light_level: NvU16, -} -pub type NV_HDR_METADATA_V1 = _NV_HDR_METADATA_V1; -pub type NV_HDR_METADATA = NV_HDR_METADATA_V1; -pub const _NV_DISPLAY_OUTPUT_MODE_NV_DISPLAY_OUTPUT_MODE_SDR: _NV_DISPLAY_OUTPUT_MODE = 0; -pub const _NV_DISPLAY_OUTPUT_MODE_NV_DISPLAY_OUTPUT_MODE_HDR10: _NV_DISPLAY_OUTPUT_MODE = 1; -pub const _NV_DISPLAY_OUTPUT_MODE_NV_DISPLAY_OUTPUT_MODE_HDR10PLUS_GAMING: _NV_DISPLAY_OUTPUT_MODE = - 2; -pub type _NV_DISPLAY_OUTPUT_MODE = ::std::os::raw::c_int; -pub use self::_NV_DISPLAY_OUTPUT_MODE as NV_DISPLAY_OUTPUT_MODE; -pub const _NV_HDR_TONEMAPPING_METHOD_NV_HDR_TONEMAPPING_APP: _NV_HDR_TONEMAPPING_METHOD = 0; -pub const _NV_HDR_TONEMAPPING_METHOD_NV_HDR_TONEMAPPING_GPU: _NV_HDR_TONEMAPPING_METHOD = 1; -pub type _NV_HDR_TONEMAPPING_METHOD = ::std::os::raw::c_int; -pub use self::_NV_HDR_TONEMAPPING_METHOD as NV_HDR_TONEMAPPING_METHOD; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_DISPLAY_COLORIMETRY_V1 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< min luminance, cd/m^2"] - pub min_luminance: f32, - #[doc = "!< max 100% frame luminance, cd/m^2"] - pub max_full_frame_luminance: f32, - #[doc = "!< max 10% frame luminance, cd/m^2"] - pub max_luminance: f32, - #[doc = "!< HDR brightness luminance scaling factor applied by GPU on output pixels"] - pub hdrBrightnessLuminanceScalingFactor: f32, - #[doc = "!< red primary chromaticity coordinate x"] - pub red_primary_x: f32, - #[doc = "!< red primary chromaticity coordinate y"] - pub red_primary_y: f32, - #[doc = "!< green primary chromaticity coordinate x"] - pub green_primary_x: f32, - #[doc = "!< green primary chromaticity coordinate y"] - pub green_primary_y: f32, - #[doc = "!< blue primary chromaticity coordinate x"] - pub blue_primary_x: f32, - #[doc = "!< blue primary chromaticity coordinate y"] - pub blue_primary_y: f32, - #[doc = "!< white point chromaticity coordinate x"] - pub white_point_x: f32, - #[doc = "!< white point chromaticity coordinate y"] - pub white_point_y: f32, -} -pub type NV_DISPLAY_COLORIMETRY_V1 = _NV_DISPLAY_COLORIMETRY_V1; -pub type NV_DISPLAY_COLORIMETRY = NV_DISPLAY_COLORIMETRY_V1; -#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_DISP_GetTiming()."] -#[repr(C)] -#[repr(align(4))] -#[derive(Copy, Clone)] -pub struct NV_TIMING_FLAG { - pub _bitfield_align_1: [u16; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>, - pub __bindgen_anon_1: NV_TIMING_FLAG__bindgen_ty_1, - pub _bitfield_align_2: [u8; 0], - pub _bitfield_2: __BindgenBitfieldUnit<[u8; 1usize]>, - pub __bindgen_padding_0: [u8; 5usize], -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union NV_TIMING_FLAG__bindgen_ty_1 { - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>, -} -impl NV_TIMING_FLAG__bindgen_ty_1 { - #[inline] - pub fn tvFormat(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) } - } - #[inline] - pub fn set_tvFormat(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 8u8, val as u64) - } - } - #[inline] - pub unsafe fn tvFormat_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 8u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_tvFormat_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 8u8, - val as u64, - ) - } - } - #[inline] - pub fn ceaId(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 8u8) as u32) } - } - #[inline] - pub fn set_ceaId(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(8usize, 8u8, val as u64) - } - } - #[inline] - pub unsafe fn ceaId_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 8usize, - 8u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_ceaId_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 8usize, - 8u8, - val as u64, - ) - } - } - #[inline] - pub fn nvPsfId(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 8u8) as u32) } - } - #[inline] - pub fn set_nvPsfId(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(16usize, 8u8, val as u64) - } - } - #[inline] - pub unsafe fn nvPsfId_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 16usize, - 8u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_nvPsfId_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 16usize, - 8u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - tvFormat: NvU32, - ceaId: NvU32, - nvPsfId: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 3usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 8u8, { - let tvFormat: u32 = unsafe { ::std::mem::transmute(tvFormat) }; - tvFormat as u64 - }); - __bindgen_bitfield_unit.set(8usize, 8u8, { - let ceaId: u32 = unsafe { ::std::mem::transmute(ceaId) }; - ceaId as u64 - }); - __bindgen_bitfield_unit.set(16usize, 8u8, { - let nvPsfId: u32 = unsafe { ::std::mem::transmute(nvPsfId) }; - nvPsfId as u64 - }); - __bindgen_bitfield_unit - } -} -impl NV_TIMING_FLAG { - #[inline] - pub fn isInterlaced(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32) } - } - #[inline] - pub fn set_isInterlaced(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 4u8, val as u64) - } - } - #[inline] - pub unsafe fn isInterlaced_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 4u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isInterlaced_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 4u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved0(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 12u8) as u32) } - } - #[inline] - pub fn set_reserved0(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 12u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved0_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 12u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved0_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 12u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isInterlaced: NvU32, - reserved0: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 2usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 4u8, { - let isInterlaced: u32 = unsafe { ::std::mem::transmute(isInterlaced) }; - isInterlaced as u64 - }); - __bindgen_bitfield_unit.set(4usize, 12u8, { - let reserved0: u32 = unsafe { ::std::mem::transmute(reserved0) }; - reserved0 as u64 - }); - __bindgen_bitfield_unit - } - #[inline] - pub fn scaling(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 8u8) as u32) } - } - #[inline] - pub fn set_scaling(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_2.set(0usize, 8u8, val as u64) - } - } - #[inline] - pub unsafe fn scaling_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_2), - 0usize, - 8u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_scaling_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_2), - 0usize, - 8u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_2(scaling: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 8u8, { - let scaling: u32 = unsafe { ::std::mem::transmute(scaling) }; - scaling as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_DISP_GetTiming()."] -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_TIMING_INPUT { - #[doc = "!< (IN) structure version"] - pub version: NvU32, - #[doc = "!< Visible horizontal size"] - pub width: NvU32, - #[doc = "!< Visible vertical size"] - pub height: NvU32, - #[doc = "!< Timing refresh rate"] - pub rr: f32, - #[doc = "!< Flag containing additional info for timing calculation."] - pub flag: NV_TIMING_FLAG, - #[doc = "!< Timing type(formula) to use for calculating the timing"] - pub type_: NV_TIMING_OVERRIDE, -} -#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_DISP_GetTiming()."] -pub type NV_TIMING_INPUT = _NV_TIMING_INPUT; -pub const NV_MONITOR_CAPS_TYPE_NV_MONITOR_CAPS_TYPE_HDMI_VSDB: NV_MONITOR_CAPS_TYPE = 4096; -pub const NV_MONITOR_CAPS_TYPE_NV_MONITOR_CAPS_TYPE_HDMI_VCDB: NV_MONITOR_CAPS_TYPE = 4097; -pub const NV_MONITOR_CAPS_TYPE_NV_MONITOR_CAPS_TYPE_GENERIC: NV_MONITOR_CAPS_TYPE = 4098; -#[doc = "! HDMI-related and extended CAPs"] -pub type NV_MONITOR_CAPS_TYPE = ::std::os::raw::c_int; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MONITOR_CAPS_VCDB { - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, -} -impl _NV_MONITOR_CAPS_VCDB { - #[inline] - pub fn quantizationRangeYcc(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) } - } - #[inline] - pub fn set_quantizationRangeYcc(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn quantizationRangeYcc_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_quantizationRangeYcc_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn quantizationRangeRgb(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) } - } - #[inline] - pub fn set_quantizationRangeRgb(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn quantizationRangeRgb_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_quantizationRangeRgb_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn scanInfoPreferredVideoFormat(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 2u8) as u8) } - } - #[inline] - pub fn set_scanInfoPreferredVideoFormat(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn scanInfoPreferredVideoFormat_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 2u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_scanInfoPreferredVideoFormat_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn scanInfoITVideoFormats(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 2u8) as u8) } - } - #[inline] - pub fn set_scanInfoITVideoFormats(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn scanInfoITVideoFormats_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 2u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_scanInfoITVideoFormats_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn scanInfoCEVideoFormats(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 2u8) as u8) } - } - #[inline] - pub fn set_scanInfoCEVideoFormats(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(6usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn scanInfoCEVideoFormats_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 6usize, - 2u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_scanInfoCEVideoFormats_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 6usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - quantizationRangeYcc: NvU8, - quantizationRangeRgb: NvU8, - scanInfoPreferredVideoFormat: NvU8, - scanInfoITVideoFormats: NvU8, - scanInfoCEVideoFormats: NvU8, - ) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let quantizationRangeYcc: u8 = unsafe { ::std::mem::transmute(quantizationRangeYcc) }; - quantizationRangeYcc as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let quantizationRangeRgb: u8 = unsafe { ::std::mem::transmute(quantizationRangeRgb) }; - quantizationRangeRgb as u64 - }); - __bindgen_bitfield_unit.set(2usize, 2u8, { - let scanInfoPreferredVideoFormat: u8 = - unsafe { ::std::mem::transmute(scanInfoPreferredVideoFormat) }; - scanInfoPreferredVideoFormat as u64 - }); - __bindgen_bitfield_unit.set(4usize, 2u8, { - let scanInfoITVideoFormats: u8 = - unsafe { ::std::mem::transmute(scanInfoITVideoFormats) }; - scanInfoITVideoFormats as u64 - }); - __bindgen_bitfield_unit.set(6usize, 2u8, { - let scanInfoCEVideoFormats: u8 = - unsafe { ::std::mem::transmute(scanInfoCEVideoFormats) }; - scanInfoCEVideoFormats as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_MONITOR_CAPS_VCDB = _NV_MONITOR_CAPS_VCDB; -#[doc = "! See NvAPI_DISP_GetMonitorCapabilities()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MONITOR_CAPS_VSDB { - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>, - #[doc = "!< Bye 4"] - pub maxTmdsClock: NvU8, - pub _bitfield_align_2: [u8; 0], - pub _bitfield_2: __BindgenBitfieldUnit<[u8; 1usize]>, - #[doc = "!< Byte 6"] - pub videoLatency: NvU8, - #[doc = "!< Byte 7"] - pub audioLatency: NvU8, - #[doc = "!< Byte 8"] - pub interlacedVideoLatency: NvU8, - #[doc = "!< Byte 9"] - pub interlacedAudioLatency: NvU8, - pub _bitfield_align_3: [u8; 0], - pub _bitfield_3: __BindgenBitfieldUnit<[u8; 2usize]>, - #[doc = "!< Keeping maximum length for 3 bits"] - pub hdmi_vic: [NvU8; 7usize], - #[doc = "!< Keeping maximum length for 5 bits"] - pub hdmi_3d: [NvU8; 31usize], -} -impl _NV_MONITOR_CAPS_VSDB { - #[inline] - pub fn sourcePhysicalAddressB(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u8) } - } - #[inline] - pub fn set_sourcePhysicalAddressB(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 4u8, val as u64) - } - } - #[inline] - pub unsafe fn sourcePhysicalAddressB_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 4u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_sourcePhysicalAddressB_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 4u8, - val as u64, - ) - } - } - #[inline] - pub fn sourcePhysicalAddressA(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u8) } - } - #[inline] - pub fn set_sourcePhysicalAddressA(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 4u8, val as u64) - } - } - #[inline] - pub unsafe fn sourcePhysicalAddressA_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 4u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_sourcePhysicalAddressA_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 4u8, - val as u64, - ) - } - } - #[inline] - pub fn sourcePhysicalAddressD(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 4u8) as u8) } - } - #[inline] - pub fn set_sourcePhysicalAddressD(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(8usize, 4u8, val as u64) - } - } - #[inline] - pub unsafe fn sourcePhysicalAddressD_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 8usize, - 4u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_sourcePhysicalAddressD_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 8usize, - 4u8, - val as u64, - ) - } - } - #[inline] - pub fn sourcePhysicalAddressC(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 4u8) as u8) } - } - #[inline] - pub fn set_sourcePhysicalAddressC(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(12usize, 4u8, val as u64) - } - } - #[inline] - pub unsafe fn sourcePhysicalAddressC_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 12usize, - 4u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_sourcePhysicalAddressC_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 12usize, - 4u8, - val as u64, - ) - } - } - #[inline] - pub fn supportDualDviOperation(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u8) } - } - #[inline] - pub fn set_supportDualDviOperation(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(16usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supportDualDviOperation_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 16usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_supportDualDviOperation_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 16usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved6(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 2u8) as u8) } - } - #[inline] - pub fn set_reserved6(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(17usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved6_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 17usize, - 2u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_reserved6_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 17usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn supportDeepColorYCbCr444(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u8) } - } - #[inline] - pub fn set_supportDeepColorYCbCr444(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(19usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supportDeepColorYCbCr444_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 19usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_supportDeepColorYCbCr444_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 19usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn supportDeepColor30bits(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u8) } - } - #[inline] - pub fn set_supportDeepColor30bits(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(20usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supportDeepColor30bits_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 20usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_supportDeepColor30bits_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 20usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn supportDeepColor36bits(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u8) } - } - #[inline] - pub fn set_supportDeepColor36bits(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(21usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supportDeepColor36bits_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 21usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_supportDeepColor36bits_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 21usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn supportDeepColor48bits(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u8) } - } - #[inline] - pub fn set_supportDeepColor48bits(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(22usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supportDeepColor48bits_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 22usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_supportDeepColor48bits_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 22usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn supportAI(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u8) } - } - #[inline] - pub fn set_supportAI(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(23usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supportAI_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 23usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_supportAI_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 23usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - sourcePhysicalAddressB: NvU8, - sourcePhysicalAddressA: NvU8, - sourcePhysicalAddressD: NvU8, - sourcePhysicalAddressC: NvU8, - supportDualDviOperation: NvU8, - reserved6: NvU8, - supportDeepColorYCbCr444: NvU8, - supportDeepColor30bits: NvU8, - supportDeepColor36bits: NvU8, - supportDeepColor48bits: NvU8, - supportAI: NvU8, - ) -> __BindgenBitfieldUnit<[u8; 3usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 4u8, { - let sourcePhysicalAddressB: u8 = - unsafe { ::std::mem::transmute(sourcePhysicalAddressB) }; - sourcePhysicalAddressB as u64 - }); - __bindgen_bitfield_unit.set(4usize, 4u8, { - let sourcePhysicalAddressA: u8 = - unsafe { ::std::mem::transmute(sourcePhysicalAddressA) }; - sourcePhysicalAddressA as u64 - }); - __bindgen_bitfield_unit.set(8usize, 4u8, { - let sourcePhysicalAddressD: u8 = - unsafe { ::std::mem::transmute(sourcePhysicalAddressD) }; - sourcePhysicalAddressD as u64 - }); - __bindgen_bitfield_unit.set(12usize, 4u8, { - let sourcePhysicalAddressC: u8 = - unsafe { ::std::mem::transmute(sourcePhysicalAddressC) }; - sourcePhysicalAddressC as u64 - }); - __bindgen_bitfield_unit.set(16usize, 1u8, { - let supportDualDviOperation: u8 = - unsafe { ::std::mem::transmute(supportDualDviOperation) }; - supportDualDviOperation as u64 - }); - __bindgen_bitfield_unit.set(17usize, 2u8, { - let reserved6: u8 = unsafe { ::std::mem::transmute(reserved6) }; - reserved6 as u64 - }); - __bindgen_bitfield_unit.set(19usize, 1u8, { - let supportDeepColorYCbCr444: u8 = - unsafe { ::std::mem::transmute(supportDeepColorYCbCr444) }; - supportDeepColorYCbCr444 as u64 - }); - __bindgen_bitfield_unit.set(20usize, 1u8, { - let supportDeepColor30bits: u8 = - unsafe { ::std::mem::transmute(supportDeepColor30bits) }; - supportDeepColor30bits as u64 - }); - __bindgen_bitfield_unit.set(21usize, 1u8, { - let supportDeepColor36bits: u8 = - unsafe { ::std::mem::transmute(supportDeepColor36bits) }; - supportDeepColor36bits as u64 - }); - __bindgen_bitfield_unit.set(22usize, 1u8, { - let supportDeepColor48bits: u8 = - unsafe { ::std::mem::transmute(supportDeepColor48bits) }; - supportDeepColor48bits as u64 - }); - __bindgen_bitfield_unit.set(23usize, 1u8, { - let supportAI: u8 = unsafe { ::std::mem::transmute(supportAI) }; - supportAI as u64 - }); - __bindgen_bitfield_unit - } - #[inline] - pub fn cnc0SupportGraphicsTextContent(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 1u8) as u8) } - } - #[inline] - pub fn set_cnc0SupportGraphicsTextContent(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_2.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn cnc0SupportGraphicsTextContent_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_2), - 0usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_cnc0SupportGraphicsTextContent_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_2), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn cnc1SupportPhotoContent(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_2.get(1usize, 1u8) as u8) } - } - #[inline] - pub fn set_cnc1SupportPhotoContent(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_2.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn cnc1SupportPhotoContent_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_2), - 1usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_cnc1SupportPhotoContent_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_2), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn cnc2SupportCinemaContent(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_2.get(2usize, 1u8) as u8) } - } - #[inline] - pub fn set_cnc2SupportCinemaContent(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_2.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn cnc2SupportCinemaContent_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_2), - 2usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_cnc2SupportCinemaContent_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_2), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn cnc3SupportGameContent(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_2.get(3usize, 1u8) as u8) } - } - #[inline] - pub fn set_cnc3SupportGameContent(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_2.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn cnc3SupportGameContent_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_2), - 3usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_cnc3SupportGameContent_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_2), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved8(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_2.get(4usize, 1u8) as u8) } - } - #[inline] - pub fn set_reserved8(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_2.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved8_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_2), - 4usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_reserved8_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_2), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn hasVicEntries(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_2.get(5usize, 1u8) as u8) } - } - #[inline] - pub fn set_hasVicEntries(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_2.set(5usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn hasVicEntries_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_2), - 5usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_hasVicEntries_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_2), - 5usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn hasInterlacedLatencyField(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_2.get(6usize, 1u8) as u8) } - } - #[inline] - pub fn set_hasInterlacedLatencyField(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_2.set(6usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn hasInterlacedLatencyField_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_2), - 6usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_hasInterlacedLatencyField_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_2), - 6usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn hasLatencyField(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_2.get(7usize, 1u8) as u8) } - } - #[inline] - pub fn set_hasLatencyField(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_2.set(7usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn hasLatencyField_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_2), - 7usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_hasLatencyField_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_2), - 7usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_2( - cnc0SupportGraphicsTextContent: NvU8, - cnc1SupportPhotoContent: NvU8, - cnc2SupportCinemaContent: NvU8, - cnc3SupportGameContent: NvU8, - reserved8: NvU8, - hasVicEntries: NvU8, - hasInterlacedLatencyField: NvU8, - hasLatencyField: NvU8, - ) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let cnc0SupportGraphicsTextContent: u8 = - unsafe { ::std::mem::transmute(cnc0SupportGraphicsTextContent) }; - cnc0SupportGraphicsTextContent as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let cnc1SupportPhotoContent: u8 = - unsafe { ::std::mem::transmute(cnc1SupportPhotoContent) }; - cnc1SupportPhotoContent as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let cnc2SupportCinemaContent: u8 = - unsafe { ::std::mem::transmute(cnc2SupportCinemaContent) }; - cnc2SupportCinemaContent as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let cnc3SupportGameContent: u8 = - unsafe { ::std::mem::transmute(cnc3SupportGameContent) }; - cnc3SupportGameContent as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let reserved8: u8 = unsafe { ::std::mem::transmute(reserved8) }; - reserved8 as u64 - }); - __bindgen_bitfield_unit.set(5usize, 1u8, { - let hasVicEntries: u8 = unsafe { ::std::mem::transmute(hasVicEntries) }; - hasVicEntries as u64 - }); - __bindgen_bitfield_unit.set(6usize, 1u8, { - let hasInterlacedLatencyField: u8 = - unsafe { ::std::mem::transmute(hasInterlacedLatencyField) }; - hasInterlacedLatencyField as u64 - }); - __bindgen_bitfield_unit.set(7usize, 1u8, { - let hasLatencyField: u8 = unsafe { ::std::mem::transmute(hasLatencyField) }; - hasLatencyField as u64 - }); - __bindgen_bitfield_unit - } - #[inline] - pub fn reserved13(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_3.get(0usize, 7u8) as u8) } - } - #[inline] - pub fn set_reserved13(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_3.set(0usize, 7u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved13_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_3), - 0usize, - 7u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_reserved13_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_3), - 0usize, - 7u8, - val as u64, - ) - } - } - #[inline] - pub fn has3dEntries(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_3.get(7usize, 1u8) as u8) } - } - #[inline] - pub fn set_has3dEntries(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_3.set(7usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn has3dEntries_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_3), - 7usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_has3dEntries_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_3), - 7usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn hdmi3dLength(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_3.get(8usize, 5u8) as u8) } - } - #[inline] - pub fn set_hdmi3dLength(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_3.set(8usize, 5u8, val as u64) - } - } - #[inline] - pub unsafe fn hdmi3dLength_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_3), - 8usize, - 5u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_hdmi3dLength_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_3), - 8usize, - 5u8, - val as u64, - ) - } - } - #[inline] - pub fn hdmiVicLength(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_3.get(13usize, 3u8) as u8) } - } - #[inline] - pub fn set_hdmiVicLength(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_3.set(13usize, 3u8, val as u64) - } - } - #[inline] - pub unsafe fn hdmiVicLength_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_3), - 13usize, - 3u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_hdmiVicLength_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_3), - 13usize, - 3u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_3( - reserved13: NvU8, - has3dEntries: NvU8, - hdmi3dLength: NvU8, - hdmiVicLength: NvU8, - ) -> __BindgenBitfieldUnit<[u8; 2usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 7u8, { - let reserved13: u8 = unsafe { ::std::mem::transmute(reserved13) }; - reserved13 as u64 - }); - __bindgen_bitfield_unit.set(7usize, 1u8, { - let has3dEntries: u8 = unsafe { ::std::mem::transmute(has3dEntries) }; - has3dEntries as u64 - }); - __bindgen_bitfield_unit.set(8usize, 5u8, { - let hdmi3dLength: u8 = unsafe { ::std::mem::transmute(hdmi3dLength) }; - hdmi3dLength as u64 - }); - __bindgen_bitfield_unit.set(13usize, 3u8, { - let hdmiVicLength: u8 = unsafe { ::std::mem::transmute(hdmiVicLength) }; - hdmiVicLength as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! See NvAPI_DISP_GetMonitorCapabilities()."] -pub type NV_MONITOR_CAPS_VSDB = _NV_MONITOR_CAPS_VSDB; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MONITOR_CAPS_GENERIC { - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, -} -impl _NV_MONITOR_CAPS_GENERIC { - #[inline] - pub fn supportVRR(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) } - } - #[inline] - pub fn set_supportVRR(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supportVRR_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_supportVRR_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn supportULMB(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) } - } - #[inline] - pub fn set_supportULMB(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supportULMB_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_supportULMB_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isTrueGsync(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) } - } - #[inline] - pub fn set_isTrueGsync(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isTrueGsync_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_isTrueGsync_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isRLACapable(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) } - } - #[inline] - pub fn set_isRLACapable(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isRLACapable_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_isRLACapable_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn currentlyCapableOfVRR(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) } - } - #[inline] - pub fn set_currentlyCapableOfVRR(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn currentlyCapableOfVRR_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_currentlyCapableOfVRR_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isBasicVRR(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) } - } - #[inline] - pub fn set_isBasicVRR(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isBasicVRR_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_isBasicVRR_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 2u8) as u8) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(6usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 6usize, - 2u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 6usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - supportVRR: NvU8, - supportULMB: NvU8, - isTrueGsync: NvU8, - isRLACapable: NvU8, - currentlyCapableOfVRR: NvU8, - isBasicVRR: NvU8, - reserved: NvU8, - ) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let supportVRR: u8 = unsafe { ::std::mem::transmute(supportVRR) }; - supportVRR as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let supportULMB: u8 = unsafe { ::std::mem::transmute(supportULMB) }; - supportULMB as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let isTrueGsync: u8 = unsafe { ::std::mem::transmute(isTrueGsync) }; - isTrueGsync as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let isRLACapable: u8 = unsafe { ::std::mem::transmute(isRLACapable) }; - isRLACapable as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let currentlyCapableOfVRR: u8 = unsafe { ::std::mem::transmute(currentlyCapableOfVRR) }; - currentlyCapableOfVRR as u64 - }); - __bindgen_bitfield_unit.set(5usize, 1u8, { - let isBasicVRR: u8 = unsafe { ::std::mem::transmute(isBasicVRR) }; - isBasicVRR as u64 - }); - __bindgen_bitfield_unit.set(6usize, 2u8, { - let reserved: u8 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_MONITOR_CAPS_GENERIC = _NV_MONITOR_CAPS_GENERIC; -#[doc = "! See NvAPI_DISP_GetMonitorCapabilities()."] -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_MONITOR_CAPABILITIES_V1 { - pub version: NvU32, - pub size: NvU16, - pub infoType: NvU32, - #[doc = "!< Out: VGA, TV, DVI, HDMI, DP"] - pub connectorType: NvU32, - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, - pub data: _NV_MONITOR_CAPABILITIES_V1__bindgen_ty_1, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union _NV_MONITOR_CAPABILITIES_V1__bindgen_ty_1 { - pub vsdb: NV_MONITOR_CAPS_VSDB, - pub vcdb: NV_MONITOR_CAPS_VCDB, - pub caps: NV_MONITOR_CAPS_GENERIC, -} -impl _NV_MONITOR_CAPABILITIES_V1 { - #[inline] - pub fn bIsValidInfo(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) } - } - #[inline] - pub fn set_bIsValidInfo(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsValidInfo_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_bIsValidInfo_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1(bIsValidInfo: NvU8) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsValidInfo: u8 = unsafe { ::std::mem::transmute(bIsValidInfo) }; - bIsValidInfo as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! See NvAPI_DISP_GetMonitorCapabilities()."] -pub type NV_MONITOR_CAPABILITIES_V1 = _NV_MONITOR_CAPABILITIES_V1; -#[doc = "! See NvAPI_DISP_GetMonitorCapabilities()."] -pub type NV_MONITOR_CAPABILITIES = NV_MONITOR_CAPABILITIES_V1; -#[doc = "! \\ingroup dispcontrol"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MONITOR_COLOR_DATA { - pub version: NvU32, - #[doc = "!< One of the supported color formats"] - pub colorFormat: NV_DP_COLOR_FORMAT, - #[doc = "!< One of the supported bit depths"] - pub backendBitDepths: NV_DP_BPC, -} -#[doc = "! \\ingroup dispcontrol"] -pub type NV_MONITOR_COLOR_CAPS_V1 = _NV_MONITOR_COLOR_DATA; -#[doc = "! \\ingroup dispcontrol"] -pub type NV_MONITOR_COLOR_CAPS = NV_MONITOR_COLOR_CAPS_V1; -#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_DISP_EnumCustomDisplay() and NvAPI_DISP_TryCustomDisplay()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_CUSTOM_DISPLAY { - pub version: NvU32, - #[doc = "!< Source surface(source mode) width"] - pub width: NvU32, - #[doc = "!< Source surface(source mode) height"] - pub height: NvU32, - #[doc = "!< Source surface color depth.\"0\" means all 8/16/32bpp"] - pub depth: NvU32, - #[doc = "!< Color format (optional)"] - pub colorFormat: NV_FORMAT, - #[doc = "!< For multimon support, should be set to (0,0,1.0,1.0) for now."] - pub srcPartition: NV_VIEWPORTF, - #[doc = "!< Horizontal scaling ratio"] - pub xRatio: f32, - #[doc = "!< Vertical scaling ratio"] - pub yRatio: f32, - #[doc = "!< Timing used to program TMDS/DAC/LVDS/HDMI/TVEncoder, etc."] - pub timing: NV_TIMING, - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, - pub __bindgen_padding_0: [u8; 3usize], -} -impl NV_CUSTOM_DISPLAY { - #[inline] - pub fn hwModeSetOnly(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_hwModeSetOnly(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn hwModeSetOnly_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_hwModeSetOnly_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1(hwModeSetOnly: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let hwModeSetOnly: u32 = unsafe { ::std::mem::transmute(hwModeSetOnly) }; - hwModeSetOnly as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! \\ingroup dispcontrol\n! @{"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_EDID_DATA_V1 { - #[doc = "!< Structure version."] - pub version: NvU32, - #[doc = "!< Pointer to EDID data."] - pub pEDID: *mut NvU8, - #[doc = "!< Size of EDID data."] - pub sizeOfEDID: NvU32, -} -#[doc = "! \\ingroup dispcontrol\n! @{"] -pub type NV_EDID_DATA_V1 = _NV_EDID_DATA_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_EDID_DATA_V2 { - #[doc = "!< Structure version."] - pub version: NvU32, - #[doc = "!< Pointer to EDID data."] - pub pEDID: *mut NvU8, - #[doc = "!< Size of EDID data."] - pub sizeOfEDID: NvU32, - #[doc = "!< Reserved for future use."] - pub reserved: [NvU32; 8usize], -} -pub type NV_EDID_DATA_V2 = _NV_EDID_DATA_V2; -pub type NV_EDID_DATA = NV_EDID_DATA_V2; -#[doc = "! @}"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GET_ADAPTIVE_SYNC_DATA_V1 { - #[doc = "!< [in] structure version"] - pub version: NvU32, - #[doc = "!< [out] maximum frame interval in micro seconds as set previously using NvAPI_DISP_SetAdaptiveSyncData function."] - pub maxFrameInterval: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< [out] Number of times the last flip was shown on the screen"] - pub lastFlipRefreshCount: NvU32, - #[doc = "!< [out] Timestamp for the lastest flip on the screen"] - pub lastFlipTimeStamp: NvU64, - #[doc = "!< reserved for future use."] - pub reservedEx: [NvU32; 4usize], -} -impl _NV_GET_ADAPTIVE_SYNC_DATA_V1 { - #[inline] - pub fn bDisableAdaptiveSync(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bDisableAdaptiveSync(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bDisableAdaptiveSync_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bDisableAdaptiveSync_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bDisableFrameSplitting(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_bDisableFrameSplitting(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bDisableFrameSplitting_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bDisableFrameSplitting_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 30u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 30u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 30u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bDisableAdaptiveSync: NvU32, - bDisableFrameSplitting: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bDisableAdaptiveSync: u32 = unsafe { ::std::mem::transmute(bDisableAdaptiveSync) }; - bDisableAdaptiveSync as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let bDisableFrameSplitting: u32 = - unsafe { ::std::mem::transmute(bDisableFrameSplitting) }; - bDisableFrameSplitting as u64 - }); - __bindgen_bitfield_unit.set(2usize, 30u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! @}"] -pub type NV_GET_ADAPTIVE_SYNC_DATA_V1 = _NV_GET_ADAPTIVE_SYNC_DATA_V1; -#[doc = "! @}"] -pub type NV_GET_ADAPTIVE_SYNC_DATA = NV_GET_ADAPTIVE_SYNC_DATA_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_SET_ADAPTIVE_SYNC_DATA_V1 { - #[doc = "!< [in] structure version"] - pub version: NvU32, - #[doc = "!< [in] deprecated, please use maxFrameIntervalNs instead\n!< If maxFrameInterval is sent as 0, default values from EDID will be used."] - pub maxFrameInterval: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Ensure the alignment is 8 bytes and reserve it for future use."] - pub reserved1: NvU32, - #[doc = "!< [in] maximum frame interval in nano seconds.\n!< If maxFrameIntervalNs is sent as 0, default values from EDID will be used."] - pub maxFrameIntervalNs: NvU64, - #[doc = "!< reserved for future use."] - pub reservedEx: [NvU32; 4usize], -} -impl _NV_SET_ADAPTIVE_SYNC_DATA_V1 { - #[inline] - pub fn bDisableAdaptiveSync(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bDisableAdaptiveSync(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bDisableAdaptiveSync_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bDisableAdaptiveSync_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bDisableFrameSplitting(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_bDisableFrameSplitting(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bDisableFrameSplitting_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bDisableFrameSplitting_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 30u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 30u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 30u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bDisableAdaptiveSync: NvU32, - bDisableFrameSplitting: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bDisableAdaptiveSync: u32 = unsafe { ::std::mem::transmute(bDisableAdaptiveSync) }; - bDisableAdaptiveSync as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let bDisableFrameSplitting: u32 = - unsafe { ::std::mem::transmute(bDisableFrameSplitting) }; - bDisableFrameSplitting as u64 - }); - __bindgen_bitfield_unit.set(2usize, 30u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_SET_ADAPTIVE_SYNC_DATA_V1 = _NV_SET_ADAPTIVE_SYNC_DATA_V1; -pub type NV_SET_ADAPTIVE_SYNC_DATA = NV_SET_ADAPTIVE_SYNC_DATA_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GET_VIRTUAL_REFRESH_RATE_DATA_V1 { - #[doc = "!< [in] structure version"] - pub version: NvU32, - #[doc = "!< [out] frame interval in micro seconds if Virtual RR is currently applied"] - pub frameIntervalUs: NvU32, - #[doc = "!< [out] Refresh Rate * 1000"] - pub rrx1k: NvU32, - #[doc = "!< [out] If the content is Gaming"] - pub bIsGamingVrr: NvU32, - #[doc = "!< reserved for future use."] - pub reservedEx: [NvU32; 6usize], -} -pub type NV_GET_VIRTUAL_REFRESH_RATE_DATA_V1 = _NV_GET_VIRTUAL_REFRESH_RATE_DATA_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GET_VIRTUAL_REFRESH_RATE_DATA_V2 { - #[doc = "!< [in] structure version"] - pub version: NvU32, - #[doc = "!< [out] frame interval in micro seconds if Virtual RR is currently applied. This variable is deprecated in V2 and should not be used."] - pub frameIntervalUs: NvU32, - #[doc = "!< [out] Refresh Rate * 1000"] - pub rrx1k: NvU32, - #[doc = "!< [out] If the content is Gaming"] - pub bIsGamingVrr: NvU32, - #[doc = "!< [out] frame interval in nano seconds if Virtual RR is currently applied"] - pub frameIntervalNs: NvU64, - #[doc = "!< reserved for future use."] - pub reservedEx: [NvU32; 4usize], -} -pub type NV_GET_VIRTUAL_REFRESH_RATE_DATA_V2 = _NV_GET_VIRTUAL_REFRESH_RATE_DATA_V2; -pub type NV_GET_VIRTUAL_REFRESH_RATE_DATA = NV_GET_VIRTUAL_REFRESH_RATE_DATA_V2; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_SET_VIRTUAL_REFRESH_RATE_DATA_V1 { - #[doc = "!< [in] structure version"] - pub version: NvU32, - #[doc = "!< [in] frame interval in micro seconds if Virtual RR is currently applied"] - pub frameIntervalUs: NvU32, - #[doc = "!< [in] Refresh Rate * 1000"] - pub rrx1k: NvU32, - #[doc = "!< [in] If the content is Gaming"] - pub bIsGamingVrr: NvU32, - #[doc = "!< reserved for future use."] - pub reservedEx: [NvU32; 6usize], -} -pub type NV_SET_VIRTUAL_REFRESH_RATE_DATA_V1 = _NV_SET_VIRTUAL_REFRESH_RATE_DATA_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_SET_VIRTUAL_REFRESH_RATE_DATA_V2 { - #[doc = "!< [in] structure version"] - pub version: NvU32, - #[doc = "!< [in] frame interval in micro seconds if Virtual RR is currently applied. This variable is deprecated in V2 and should not be used."] - pub frameIntervalUs: NvU32, - #[doc = "!< [in] Refresh Rate * 1000"] - pub rrx1k: NvU32, - #[doc = "!< [in] If the content is Gaming"] - pub bIsGamingVrr: NvU32, - #[doc = "!< [in] frame interval in nano seconds if Virtual RR is currently applied"] - pub frameIntervalNs: NvU64, - #[doc = "!< reserved for future use."] - pub reservedEx: [NvU32; 4usize], -} -pub type NV_SET_VIRTUAL_REFRESH_RATE_DATA_V2 = _NV_SET_VIRTUAL_REFRESH_RATE_DATA_V2; -pub type NV_SET_VIRTUAL_REFRESH_RATE_DATA = NV_SET_VIRTUAL_REFRESH_RATE_DATA_V2; -#[doc = "! \\ingroup dispcontrol"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_SET_PREFERRED_STEREO_DISPLAY_V1 { - #[doc = "!< [in] Structure version"] - pub version: NvU32, - #[doc = "!< [in] Monitor Identifier to be set"] - pub displayId: NvU32, - #[doc = "!< Reserved for future use without adding versioning"] - pub reserved: NvU32, -} -#[doc = "! \\ingroup dispcontrol"] -pub type NV_SET_PREFERRED_STEREO_DISPLAY = NV_SET_PREFERRED_STEREO_DISPLAY_V1; -#[doc = "! \\ingroup dispcontrol"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GET_PREFERRED_STEREO_DISPLAY_V1 { - #[doc = "!< [in] Structure version"] - pub version: NvU32, - #[doc = "!< [out] The queried stereo display"] - pub displayId: NvU32, - #[doc = "!< Reserved for future use without adding versioning"] - pub reserved: NvU32, -} -#[doc = "! \\ingroup dispcontrol"] -pub type NV_GET_PREFERRED_STEREO_DISPLAY = NV_GET_PREFERRED_STEREO_DISPLAY_V1; -#[doc = "! \\ingroup dispcontrol"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_DISPLAY_ID_INFO_DATA_V1 { - #[doc = "!< [in] Structure version"] - pub version: NvU32, - #[doc = "!< [out] Locally unique ID (LUID) of the display adapter on which the given display is present."] - pub adapterId: LUID, - #[doc = "!< [out] The target identifier of the given display. This is also called AdapterRelativeId."] - pub targetId: NvU32, - #[doc = "!< Reserved for future use."] - pub reserved: [NvU32; 4usize], -} -#[doc = "! \\ingroup dispcontrol"] -pub type NV_DISPLAY_ID_INFO_DATA_V1 = _NV_DISPLAY_ID_INFO_DATA_V1; -#[doc = "! \\ingroup dispcontrol"] -pub type NV_DISPLAY_ID_INFO_DATA = NV_DISPLAY_ID_INFO_DATA_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_TARGET_INFO_DATA_V1 { - #[doc = "!< [in] Structure version"] - pub version: NvU32, - #[doc = "!< [in] Locally unique ID (LUID) of the display adapter on which the target is present."] - pub adapterId: LUID, - #[doc = "!< [in] The target identifier. This is also called AdapterRelativeId."] - pub targetId: NvU32, - #[doc = "!< [out] An array of displayIds corresponding to the input adapterId and targetId.\n!< If the input (targetId, adapterId) pair is a display grid (Mosaic/Surround),\n!< then the output contains the displayId of every display that is part of the display grid.\n!< Otherwise, it contains exactly one displayId.\n!< These displayId values are unique to this (targetId, adapterId) pair."] - pub displayId: [NvU32; 128usize], - #[doc = "!< [out] The number of displays returned in displayId array."] - pub displayIdCount: NvU32, - #[doc = "!< Reserved for future use."] - pub reserved: [NvU32; 4usize], -} -pub type NV_TARGET_INFO_DATA_V1 = _NV_TARGET_INFO_DATA_V1; -pub type NV_TARGET_INFO_DATA = NV_TARGET_INFO_DATA_V1; -#[doc = "! \\ingroup dispcontrol"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GET_VRR_INFO_V1 { - #[doc = "!< [in] Structure version"] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Reserved for future use"] - pub reservedEx: [NvU32; 4usize], -} -impl _NV_GET_VRR_INFO_V1 { - #[inline] - pub fn bIsVRREnabled(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsVRREnabled(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsVRREnabled_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsVRREnabled_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bIsVRRPossible(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsVRRPossible(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsVRRPossible_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsVRRPossible_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bIsVRRRequested(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsVRRRequested(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsVRRRequested_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsVRRRequested_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bIsVRRIndicatorEnabled(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsVRRIndicatorEnabled(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsVRRIndicatorEnabled_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsVRRIndicatorEnabled_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bIsDisplayInVRRMode(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsDisplayInVRRMode(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsDisplayInVRRMode_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsDisplayInVRRMode_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 27u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 27u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 27u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bIsVRREnabled: NvU32, - bIsVRRPossible: NvU32, - bIsVRRRequested: NvU32, - bIsVRRIndicatorEnabled: NvU32, - bIsDisplayInVRRMode: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsVRREnabled: u32 = unsafe { ::std::mem::transmute(bIsVRREnabled) }; - bIsVRREnabled as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let bIsVRRPossible: u32 = unsafe { ::std::mem::transmute(bIsVRRPossible) }; - bIsVRRPossible as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let bIsVRRRequested: u32 = unsafe { ::std::mem::transmute(bIsVRRRequested) }; - bIsVRRRequested as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let bIsVRRIndicatorEnabled: u32 = - unsafe { ::std::mem::transmute(bIsVRRIndicatorEnabled) }; - bIsVRRIndicatorEnabled as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let bIsDisplayInVRRMode: u32 = unsafe { ::std::mem::transmute(bIsDisplayInVRRMode) }; - bIsDisplayInVRRMode as u64 - }); - __bindgen_bitfield_unit.set(5usize, 27u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! \\ingroup dispcontrol"] -pub type NV_GET_VRR_INFO_V1 = _NV_GET_VRR_INFO_V1; -#[doc = "! \\ingroup dispcontrol"] -pub type NV_GET_VRR_INFO = NV_GET_VRR_INFO_V1; -#[doc = "! This structure defines the topology details."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_MOSAIC_TOPO_DETAILS { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< Logical GPU for this topology"] - pub hLogicalGPU: NvLogicalGpuHandle, - #[doc = "!< 0 means topology is valid with the current hardware."] - pub validityMask: NvU32, - #[doc = "!< Number of displays in a row"] - pub rowCount: NvU32, - #[doc = "!< Number of displays in a column"] - pub colCount: NvU32, - pub gpuLayout: [[NV_MOSAIC_TOPO_DETAILS__bindgen_ty_1; 8usize]; 8usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_MOSAIC_TOPO_DETAILS__bindgen_ty_1 { - #[doc = "!< Physical GPU to be used in the topology (0 if GPU missing)"] - pub hPhysicalGPU: NvPhysicalGpuHandle, - #[doc = "!< Connected display target (0 if no display connected)"] - pub displayOutputId: NvU32, - #[doc = "!< Pixels of overlap on left of target: (+overlap, -gap)"] - pub overlapX: NvS32, - #[doc = "!< Pixels of overlap on top of target: (+overlap, -gap)"] - pub overlapY: NvS32, -} -#[doc = "!< All mosaic topologies"] -pub const NV_MOSAIC_TOPO_TYPE_NV_MOSAIC_TOPO_TYPE_ALL: NV_MOSAIC_TOPO_TYPE = 0; -#[doc = "!< Basic Mosaic topologies"] -pub const NV_MOSAIC_TOPO_TYPE_NV_MOSAIC_TOPO_TYPE_BASIC: NV_MOSAIC_TOPO_TYPE = 1; -#[doc = "!< Passive Stereo topologies"] -pub const NV_MOSAIC_TOPO_TYPE_NV_MOSAIC_TOPO_TYPE_PASSIVE_STEREO: NV_MOSAIC_TOPO_TYPE = 2; -#[doc = "!< Not supported at this time"] -pub const NV_MOSAIC_TOPO_TYPE_NV_MOSAIC_TOPO_TYPE_SCALED_CLONE: NV_MOSAIC_TOPO_TYPE = 3; -#[doc = "!< Not supported at this time"] -pub const NV_MOSAIC_TOPO_TYPE_NV_MOSAIC_TOPO_TYPE_PASSIVE_STEREO_SCALED_CLONE: NV_MOSAIC_TOPO_TYPE = - 4; -#[doc = "!< Always leave this at end of the enum"] -pub const NV_MOSAIC_TOPO_TYPE_NV_MOSAIC_TOPO_TYPE_MAX: NV_MOSAIC_TOPO_TYPE = 5; -#[doc = "! These values refer to the different types of Mosaic topologies that are possible. When\n! getting the supported Mosaic topologies, you can specify one of these types to narrow down\n! the returned list to only those that match the given type."] -pub type NV_MOSAIC_TOPO_TYPE = ::std::os::raw::c_int; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_NONE: NV_MOSAIC_TOPO = 0; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_BEGIN_BASIC: NV_MOSAIC_TOPO = 1; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x2_BASIC: NV_MOSAIC_TOPO = 1; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_2x1_BASIC: NV_MOSAIC_TOPO = 2; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x3_BASIC: NV_MOSAIC_TOPO = 3; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_3x1_BASIC: NV_MOSAIC_TOPO = 4; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x4_BASIC: NV_MOSAIC_TOPO = 5; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_4x1_BASIC: NV_MOSAIC_TOPO = 6; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_2x2_BASIC: NV_MOSAIC_TOPO = 7; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_2x3_BASIC: NV_MOSAIC_TOPO = 8; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_2x4_BASIC: NV_MOSAIC_TOPO = 9; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_3x2_BASIC: NV_MOSAIC_TOPO = 10; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_4x2_BASIC: NV_MOSAIC_TOPO = 11; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x5_BASIC: NV_MOSAIC_TOPO = 12; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x6_BASIC: NV_MOSAIC_TOPO = 13; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_7x1_BASIC: NV_MOSAIC_TOPO = 14; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_END_BASIC: NV_MOSAIC_TOPO = 23; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_BEGIN_PASSIVE_STEREO: NV_MOSAIC_TOPO = 24; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x2_PASSIVE_STEREO: NV_MOSAIC_TOPO = 24; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_2x1_PASSIVE_STEREO: NV_MOSAIC_TOPO = 25; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x3_PASSIVE_STEREO: NV_MOSAIC_TOPO = 26; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_3x1_PASSIVE_STEREO: NV_MOSAIC_TOPO = 27; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x4_PASSIVE_STEREO: NV_MOSAIC_TOPO = 28; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_4x1_PASSIVE_STEREO: NV_MOSAIC_TOPO = 29; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_2x2_PASSIVE_STEREO: NV_MOSAIC_TOPO = 30; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_END_PASSIVE_STEREO: NV_MOSAIC_TOPO = 34; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_MAX: NV_MOSAIC_TOPO = 35; -#[doc = "! This is a complete list of supported Mosaic topologies.\n!\n! Using a \"Basic\" topology combines multiple monitors to create a single desktop.\n!\n! Using a \"Passive\" topology combines multiples monitors to create a passive stereo desktop.\n! In passive stereo, two identical topologies combine - one topology is used for the right eye and the other identical //! topology (targeting different displays) is used for the left eye. \\n\n! NOTE: common\\inc\\nvEscDef.h shadows a couple PASSIVE_STEREO enums. If this\n! enum list changes and effects the value of NV_MOSAIC_TOPO_BEGIN_PASSIVE_STEREO\n! please update the corresponding value in nvEscDef.h"] -pub type NV_MOSAIC_TOPO = ::std::os::raw::c_int; -#[doc = "! This is a \"topology brief\" structure. It tells you what you need to know about\n! a topology at a high level. A list of these is returned when you query for the\n! supported Mosaic information.\n!\n! If you need more detailed information about the topology, call\n! NvAPI_Mosaic_GetTopoGroup() with the topology value from this structure."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_MOSAIC_TOPO_BRIEF { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< The topology"] - pub topo: NV_MOSAIC_TOPO, - #[doc = "!< 1 if topo is enabled, else 0"] - pub enabled: NvU32, - #[doc = "!< 1 if topo *can* be enabled, else 0"] - pub isPossible: NvU32, -} -#[doc = "! Basic per-display settings that are used in setting/getting the Mosaic mode"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MOSAIC_DISPLAY_SETTING_V1 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< Per-display width"] - pub width: NvU32, - #[doc = "!< Per-display height"] - pub height: NvU32, - #[doc = "!< Bits per pixel"] - pub bpp: NvU32, - #[doc = "!< Display frequency"] - pub freq: NvU32, -} -#[doc = "! Basic per-display settings that are used in setting/getting the Mosaic mode"] -pub type NV_MOSAIC_DISPLAY_SETTING_V1 = _NV_MOSAIC_DISPLAY_SETTING_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_MOSAIC_DISPLAY_SETTING_V2 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< Per-display width"] - pub width: NvU32, - #[doc = "!< Per-display height"] - pub height: NvU32, - #[doc = "!< Bits per pixel"] - pub bpp: NvU32, - #[doc = "!< Display frequency"] - pub freq: NvU32, - #[doc = "!< Display frequency in x1k"] - pub rrx1k: NvU32, -} -pub type NV_MOSAIC_DISPLAY_SETTING = NV_MOSAIC_DISPLAY_SETTING_V2; -#[doc = "! This structure is used to contain a list of supported Mosaic topologies\n! along with the display settings that can be used."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MOSAIC_SUPPORTED_TOPO_INFO_V1 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< Number of topologies in below array"] - pub topoBriefsCount: NvU32, - #[doc = "!< List of supported topologies with only brief details"] - pub topoBriefs: [NV_MOSAIC_TOPO_BRIEF; 35usize], - #[doc = "!< Number of display settings in below array"] - pub displaySettingsCount: NvU32, - #[doc = "!< List of per display settings possible"] - pub displaySettings: [NV_MOSAIC_DISPLAY_SETTING_V1; 40usize], -} -#[doc = "! This structure is used to contain a list of supported Mosaic topologies\n! along with the display settings that can be used."] -pub type NV_MOSAIC_SUPPORTED_TOPO_INFO_V1 = _NV_MOSAIC_SUPPORTED_TOPO_INFO_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MOSAIC_SUPPORTED_TOPO_INFO_V2 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< Number of topologies in below array"] - pub topoBriefsCount: NvU32, - #[doc = "!< List of supported topologies with only brief details"] - pub topoBriefs: [NV_MOSAIC_TOPO_BRIEF; 35usize], - #[doc = "!< Number of display settings in below array"] - pub displaySettingsCount: NvU32, - #[doc = "!< List of per display settings possible"] - pub displaySettings: [NV_MOSAIC_DISPLAY_SETTING_V2; 40usize], -} -pub type NV_MOSAIC_SUPPORTED_TOPO_INFO_V2 = _NV_MOSAIC_SUPPORTED_TOPO_INFO_V2; -pub type NV_MOSAIC_SUPPORTED_TOPO_INFO = NV_MOSAIC_SUPPORTED_TOPO_INFO_V2; -#[doc = "! This structure defines a group of topologies that work together to create one\n! overall layout. All of the supported topologies are represented with this\n! structure.\n!\n! For example, a 'Passive Stereo' topology would be represented with this\n! structure, and would have separate topology details for the left and right eyes.\n! The count would be 2. A 'Basic' topology is also represented by this structure,\n! with a count of 1.\n!\n! The structure is primarily used internally, but is exposed to applications in a\n! read-only fashion because there are some details in it that might be useful\n! (like the number of rows/cols, or connected display information). A user can\n! get the filled-in structure by calling NvAPI_Mosaic_GetTopoGroup().\n!\n! You can then look at the detailed values within the structure. There are no\n! entrypoints which take this structure as input (effectively making it read-only)."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_MOSAIC_TOPO_GROUP { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< The brief details of this topo"] - pub brief: NV_MOSAIC_TOPO_BRIEF, - #[doc = "!< Number of topos in array below"] - pub count: NvU32, - pub topos: [NV_MOSAIC_TOPO_DETAILS; 2usize], -} -#[doc = "! \\ingroup mosaicapi\n! @{"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MOSAIC_GRID_TOPO_DISPLAY_V1 { - #[doc = "!< DisplayID of the display"] - pub displayId: NvU32, - #[doc = "!< (+overlap, -gap)"] - pub overlapX: NvS32, - #[doc = "!< (+overlap, -gap)"] - pub overlapY: NvS32, - #[doc = "!< Rotation of display"] - pub rotation: NV_ROTATE, - #[doc = "!< Reserved, must be 0"] - pub cloneGroup: NvU32, -} -#[doc = "! \\ingroup mosaicapi\n! @{"] -pub type NV_MOSAIC_GRID_TOPO_DISPLAY_V1 = _NV_MOSAIC_GRID_TOPO_DISPLAY_V1; -#[doc = "!< No pixel shift will be applied to this display."] -pub const _NV_PIXEL_SHIFT_TYPE_NV_PIXEL_SHIFT_TYPE_NO_PIXEL_SHIFT: _NV_PIXEL_SHIFT_TYPE = 0; -#[doc = "!< This display will be used to scanout top left pixels in 2x2 PixelShift configuration"] -pub const _NV_PIXEL_SHIFT_TYPE_NV_PIXEL_SHIFT_TYPE_2x2_TOP_LEFT_PIXELS: _NV_PIXEL_SHIFT_TYPE = 1; -#[doc = "!< This display will be used to scanout bottom right pixels in 2x2 PixelShift configuration"] -pub const _NV_PIXEL_SHIFT_TYPE_NV_PIXEL_SHIFT_TYPE_2x2_BOTTOM_RIGHT_PIXELS: _NV_PIXEL_SHIFT_TYPE = - 2; -#[doc = "!< This display will be used to scanout top right pixels in 2x2 PixelShift configuration"] -pub const _NV_PIXEL_SHIFT_TYPE_NV_PIXEL_SHIFT_TYPE_2x2_TOP_RIGHT_PIXELS: _NV_PIXEL_SHIFT_TYPE = 4; -#[doc = "!< This display will be used to scanout bottom left pixels in 2x2 PixelShift configuration"] -pub const _NV_PIXEL_SHIFT_TYPE_NV_PIXEL_SHIFT_TYPE_2x2_BOTTOM_LEFT_PIXELS: _NV_PIXEL_SHIFT_TYPE = 8; -pub type _NV_PIXEL_SHIFT_TYPE = ::std::os::raw::c_int; -pub use self::_NV_PIXEL_SHIFT_TYPE as NV_PIXEL_SHIFT_TYPE; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MOSAIC_GRID_TOPO_DISPLAY_V2 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< DisplayID of the display"] - pub displayId: NvU32, - #[doc = "!< (+overlap, -gap)"] - pub overlapX: NvS32, - #[doc = "!< (+overlap, -gap)"] - pub overlapY: NvS32, - #[doc = "!< Rotation of display"] - pub rotation: NV_ROTATE, - #[doc = "!< Reserved, must be 0"] - pub cloneGroup: NvU32, - #[doc = "!< Type of the pixel shift enabled display"] - pub pixelShiftType: NV_PIXEL_SHIFT_TYPE, -} -pub type NV_MOSAIC_GRID_TOPO_DISPLAY_V2 = _NV_MOSAIC_GRID_TOPO_DISPLAY_V2; -#[doc = "! \\ingroup mosaicapi\n! @{"] -pub type NV_MOSAIC_GRID_TOPO_DISPLAY = NV_MOSAIC_GRID_TOPO_DISPLAY_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MOSAIC_GRID_TOPO_V1 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< Number of rows"] - pub rows: NvU32, - #[doc = "!< Number of columns"] - pub columns: NvU32, - #[doc = "!< Number of display details"] - pub displayCount: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Displays are done as [(row * columns) + column]"] - pub displays: [NV_MOSAIC_GRID_TOPO_DISPLAY_V1; 64usize], - #[doc = "!< Display settings"] - pub displaySettings: NV_MOSAIC_DISPLAY_SETTING_V1, -} -impl _NV_MOSAIC_GRID_TOPO_V1 { - #[inline] - pub fn applyWithBezelCorrect(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_applyWithBezelCorrect(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn applyWithBezelCorrect_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_applyWithBezelCorrect_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn immersiveGaming(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_immersiveGaming(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn immersiveGaming_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_immersiveGaming_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn baseMosaic(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_baseMosaic(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn baseMosaic_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_baseMosaic_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn driverReloadAllowed(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_driverReloadAllowed(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn driverReloadAllowed_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_driverReloadAllowed_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn acceleratePrimaryDisplay(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } - } - #[inline] - pub fn set_acceleratePrimaryDisplay(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn acceleratePrimaryDisplay_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_acceleratePrimaryDisplay_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 27u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 27u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 27u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - applyWithBezelCorrect: NvU32, - immersiveGaming: NvU32, - baseMosaic: NvU32, - driverReloadAllowed: NvU32, - acceleratePrimaryDisplay: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let applyWithBezelCorrect: u32 = - unsafe { ::std::mem::transmute(applyWithBezelCorrect) }; - applyWithBezelCorrect as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let immersiveGaming: u32 = unsafe { ::std::mem::transmute(immersiveGaming) }; - immersiveGaming as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let baseMosaic: u32 = unsafe { ::std::mem::transmute(baseMosaic) }; - baseMosaic as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let driverReloadAllowed: u32 = unsafe { ::std::mem::transmute(driverReloadAllowed) }; - driverReloadAllowed as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let acceleratePrimaryDisplay: u32 = - unsafe { ::std::mem::transmute(acceleratePrimaryDisplay) }; - acceleratePrimaryDisplay as u64 - }); - __bindgen_bitfield_unit.set(5usize, 27u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_MOSAIC_GRID_TOPO_V1 = _NV_MOSAIC_GRID_TOPO_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MOSAIC_GRID_TOPO_V2 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< Number of rows"] - pub rows: NvU32, - #[doc = "!< Number of columns"] - pub columns: NvU32, - #[doc = "!< Number of display details"] - pub displayCount: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Displays are done as [(row * columns) + column]"] - pub displays: [NV_MOSAIC_GRID_TOPO_DISPLAY_V2; 64usize], - #[doc = "!< Display settings"] - pub displaySettings: NV_MOSAIC_DISPLAY_SETTING_V1, -} -impl _NV_MOSAIC_GRID_TOPO_V2 { - #[inline] - pub fn applyWithBezelCorrect(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_applyWithBezelCorrect(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn applyWithBezelCorrect_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_applyWithBezelCorrect_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn immersiveGaming(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_immersiveGaming(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn immersiveGaming_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_immersiveGaming_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn baseMosaic(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_baseMosaic(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn baseMosaic_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_baseMosaic_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn driverReloadAllowed(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_driverReloadAllowed(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn driverReloadAllowed_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_driverReloadAllowed_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn acceleratePrimaryDisplay(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } - } - #[inline] - pub fn set_acceleratePrimaryDisplay(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn acceleratePrimaryDisplay_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_acceleratePrimaryDisplay_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn pixelShift(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } - } - #[inline] - pub fn set_pixelShift(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn pixelShift_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_pixelShift_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 26u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(6usize, 26u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 6usize, - 26u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 6usize, - 26u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - applyWithBezelCorrect: NvU32, - immersiveGaming: NvU32, - baseMosaic: NvU32, - driverReloadAllowed: NvU32, - acceleratePrimaryDisplay: NvU32, - pixelShift: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let applyWithBezelCorrect: u32 = - unsafe { ::std::mem::transmute(applyWithBezelCorrect) }; - applyWithBezelCorrect as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let immersiveGaming: u32 = unsafe { ::std::mem::transmute(immersiveGaming) }; - immersiveGaming as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let baseMosaic: u32 = unsafe { ::std::mem::transmute(baseMosaic) }; - baseMosaic as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let driverReloadAllowed: u32 = unsafe { ::std::mem::transmute(driverReloadAllowed) }; - driverReloadAllowed as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let acceleratePrimaryDisplay: u32 = - unsafe { ::std::mem::transmute(acceleratePrimaryDisplay) }; - acceleratePrimaryDisplay as u64 - }); - __bindgen_bitfield_unit.set(5usize, 1u8, { - let pixelShift: u32 = unsafe { ::std::mem::transmute(pixelShift) }; - pixelShift as u64 - }); - __bindgen_bitfield_unit.set(6usize, 26u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_MOSAIC_GRID_TOPO_V2 = _NV_MOSAIC_GRID_TOPO_V2; -pub type NV_MOSAIC_GRID_TOPO = NV_MOSAIC_GRID_TOPO_V2; -#[doc = "! \\ingroup mosaicapi"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_MOSAIC_DISPLAY_TOPO_STATUS { - pub version: NvU32, - #[doc = "!< (OUT) Any of the NV_MOSAIC_DISPLAYTOPO_ERROR_* flags."] - pub errorFlags: NvU32, - #[doc = "!< (OUT) Any of the NV_MOSAIC_DISPLAYTOPO_WARNING_* flags."] - pub warningFlags: NvU32, - #[doc = "!< (OUT) The number of valid entries in the displays array."] - pub displayCount: NvU32, - pub displays: [NV_MOSAIC_DISPLAY_TOPO_STATUS__bindgen_ty_1; 128usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_MOSAIC_DISPLAY_TOPO_STATUS__bindgen_ty_1 { - #[doc = "!< (OUT) The DisplayID of this display."] - pub displayId: NvU32, - #[doc = "!< (OUT) Any of the NV_MOSAIC_DISPLAYCAPS_PROBLEM_* flags."] - pub errorFlags: NvU32, - #[doc = "!< (OUT) Any of the NV_MOSAIC_DISPLAYTOPO_WARNING_* flags."] - pub warningFlags: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, -} -impl NV_MOSAIC_DISPLAY_TOPO_STATUS__bindgen_ty_1 { - #[inline] - pub fn supportsRotation(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_supportsRotation(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supportsRotation_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_supportsRotation_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - supportsRotation: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let supportsRotation: u32 = unsafe { ::std::mem::transmute(supportsRotation) }; - supportsRotation as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! Used in NvAPI_GetCurrentMosaicTopology() and NvAPI_SetCurrentMosaicTopology()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_MOSAIC_TOPOLOGY { - #[doc = "!< Version number of the mosaic topology"] - pub version: NvU32, - #[doc = "!< Horizontal display count"] - pub rowCount: NvU32, - #[doc = "!< Vertical display count"] - pub colCount: NvU32, - pub gpuLayout: [[NV_MOSAIC_TOPOLOGY__bindgen_ty_1; 8usize]; 8usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_MOSAIC_TOPOLOGY__bindgen_ty_1 { - #[doc = "!< Physical GPU to be used in the topology"] - pub hPhysicalGPU: NvPhysicalGpuHandle, - #[doc = "!< Connected display target"] - pub displayOutputId: NvU32, - #[doc = "!< Pixels of overlap on the left of target: (+overlap, -gap)"] - pub overlapX: NvS32, - #[doc = "!< Pixels of overlap on the top of target: (+overlap, -gap)"] - pub overlapY: NvS32, -} -#[doc = "! Used in NvAPI_GetSupportedMosaicTopologies()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_MOSAIC_SUPPORTED_TOPOLOGIES { - pub version: NvU32, - #[doc = "!< Count of valid topologies"] - pub totalCount: NvU32, - #[doc = "!< Maximum number of topologies"] - pub topos: [NV_MOSAIC_TOPOLOGY; 16usize], -} -#[doc = "! Used in NvAPI_GSync_QueryCapabilities()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GSYNC_CAPABILITIES_V1 { - #[doc = "!< Version of the structure"] - pub version: NvU32, - #[doc = "!< Board ID"] - pub boardId: NvU32, - #[doc = "!< FPGA Revision"] - pub revision: NvU32, - #[doc = "!< Capabilities of the Sync board. Reserved for future use"] - pub capFlags: NvU32, -} -#[doc = "! Used in NvAPI_GSync_QueryCapabilities()."] -pub type NV_GSYNC_CAPABILITIES_V1 = _NV_GSYNC_CAPABILITIES_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GSYNC_CAPABILITIES_V2 { - #[doc = "!< Version of the structure"] - pub version: NvU32, - #[doc = "!< Board ID"] - pub boardId: NvU32, - #[doc = "!< FPGA major revision"] - pub revision: NvU32, - #[doc = "!< Capabilities of the Sync board. Reserved for future use"] - pub capFlags: NvU32, - #[doc = "!< FPGA minor revision"] - pub extendedRevision: NvU32, -} -pub type NV_GSYNC_CAPABILITIES_V2 = _NV_GSYNC_CAPABILITIES_V2; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GSYNC_CAPABILITIES_V3 { - #[doc = "!< Version of the structure"] - pub version: NvU32, - #[doc = "!< Board ID"] - pub boardId: NvU32, - #[doc = "!< FPGA major revision"] - pub revision: NvU32, - #[doc = "!< Capabilities of the Sync board. Reserved for future use"] - pub capFlags: NvU32, - #[doc = "!< FPGA minor revision"] - pub extendedRevision: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< This parameter returns the maximum possible value that can be programmed\n!< for multiplying / dividing house sync. Only valid if bIsMulDivSupported is set to 1."] - pub maxMulDivValue: NvU32, -} -impl _NV_GSYNC_CAPABILITIES_V3 { - #[inline] - pub fn bIsMulDivSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsMulDivSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsMulDivSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsMulDivSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bIsMulDivSupported: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsMulDivSupported: u32 = unsafe { ::std::mem::transmute(bIsMulDivSupported) }; - bIsMulDivSupported as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_GSYNC_CAPABILITIES_V3 = _NV_GSYNC_CAPABILITIES_V3; -pub type NV_GSYNC_CAPABILITIES = NV_GSYNC_CAPABILITIES_V3; -pub const _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_NONE: - _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR = 0; -pub const _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_PRIMARY: - _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR = 1; -pub const _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_SECONDARY: - _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR = 2; -pub const _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_TERTIARY: - _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR = 3; -pub const _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_QUARTERNARY: - _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR = 4; -#[doc = "! Connector values for a GPU. Used in NV_GSYNC_GPU."] -pub type _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR = ::std::os::raw::c_int; -#[doc = "! Connector values for a GPU. Used in NV_GSYNC_GPU."] -pub use self::_NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR as NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR; -pub const _NVAPI_GSYNC_DISPLAY_SYNC_STATE_NVAPI_GSYNC_DISPLAY_SYNC_STATE_UNSYNCED: - _NVAPI_GSYNC_DISPLAY_SYNC_STATE = 0; -pub const _NVAPI_GSYNC_DISPLAY_SYNC_STATE_NVAPI_GSYNC_DISPLAY_SYNC_STATE_SLAVE: - _NVAPI_GSYNC_DISPLAY_SYNC_STATE = 1; -pub const _NVAPI_GSYNC_DISPLAY_SYNC_STATE_NVAPI_GSYNC_DISPLAY_SYNC_STATE_MASTER: - _NVAPI_GSYNC_DISPLAY_SYNC_STATE = 2; -#[doc = "! Display sync states. Used in NV_GSYNC_DISPLAY."] -pub type _NVAPI_GSYNC_DISPLAY_SYNC_STATE = ::std::os::raw::c_int; -#[doc = "! Display sync states. Used in NV_GSYNC_DISPLAY."] -pub use self::_NVAPI_GSYNC_DISPLAY_SYNC_STATE as NVAPI_GSYNC_DISPLAY_SYNC_STATE; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GSYNC_GPU { - #[doc = "!< Version of the structure"] - pub version: NvU32, - #[doc = "!< GPU handle"] - pub hPhysicalGpu: NvPhysicalGpuHandle, - #[doc = "!< Indicates which connector on the device the GPU is connected to."] - pub connector: NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR, - #[doc = "!< GPU through which hPhysicalGpu is connected to the Sync device (if not directly connected)\n!< - this is NULL otherwise"] - pub hProxyPhysicalGpu: NvPhysicalGpuHandle, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - pub __bindgen_padding_0: u32, -} -impl _NV_GSYNC_GPU { - #[inline] - pub fn isSynced(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isSynced(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isSynced_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isSynced_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1(isSynced: NvU32, reserved: NvU32) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isSynced: u32 = unsafe { ::std::mem::transmute(isSynced) }; - isSynced as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_GSYNC_GPU = _NV_GSYNC_GPU; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GSYNC_DISPLAY { - #[doc = "!< Version of the structure"] - pub version: NvU32, - #[doc = "!< display identifier for displays.The GPU to which it is connected, can be retireved from NvAPI_SYS_GetPhysicalGpuFromDisplayId"] - pub displayId: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Is this display slave/master\n!< (Retrieved with topology or set by caller for enable/disable sync)"] - pub syncState: NVAPI_GSYNC_DISPLAY_SYNC_STATE, -} -impl _NV_GSYNC_DISPLAY { - #[inline] - pub fn isMasterable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMasterable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMasterable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMasterable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isMasterable: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isMasterable: u32 = unsafe { ::std::mem::transmute(isMasterable) }; - isMasterable as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_GSYNC_DISPLAY = _NV_GSYNC_DISPLAY; -pub const _NVAPI_GSYNC_POLARITY_NVAPI_GSYNC_POLARITY_RISING_EDGE: _NVAPI_GSYNC_POLARITY = 0; -pub const _NVAPI_GSYNC_POLARITY_NVAPI_GSYNC_POLARITY_FALLING_EDGE: _NVAPI_GSYNC_POLARITY = 1; -pub const _NVAPI_GSYNC_POLARITY_NVAPI_GSYNC_POLARITY_BOTH_EDGES: _NVAPI_GSYNC_POLARITY = 2; -#[doc = "! Source signal edge to be used for output pulse. See NV_GSYNC_CONTROL_PARAMS."] -pub type _NVAPI_GSYNC_POLARITY = ::std::os::raw::c_int; -#[doc = "! Source signal edge to be used for output pulse. See NV_GSYNC_CONTROL_PARAMS."] -pub use self::_NVAPI_GSYNC_POLARITY as NVAPI_GSYNC_POLARITY; -pub const _NVAPI_GSYNC_VIDEO_MODE_NVAPI_GSYNC_VIDEO_MODE_NONE: _NVAPI_GSYNC_VIDEO_MODE = 0; -pub const _NVAPI_GSYNC_VIDEO_MODE_NVAPI_GSYNC_VIDEO_MODE_TTL: _NVAPI_GSYNC_VIDEO_MODE = 1; -pub const _NVAPI_GSYNC_VIDEO_MODE_NVAPI_GSYNC_VIDEO_MODE_NTSCPALSECAM: _NVAPI_GSYNC_VIDEO_MODE = 2; -pub const _NVAPI_GSYNC_VIDEO_MODE_NVAPI_GSYNC_VIDEO_MODE_HDTV: _NVAPI_GSYNC_VIDEO_MODE = 3; -pub const _NVAPI_GSYNC_VIDEO_MODE_NVAPI_GSYNC_VIDEO_MODE_COMPOSITE: _NVAPI_GSYNC_VIDEO_MODE = 4; -#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] -pub type _NVAPI_GSYNC_VIDEO_MODE = ::std::os::raw::c_int; -#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] -pub use self::_NVAPI_GSYNC_VIDEO_MODE as NVAPI_GSYNC_VIDEO_MODE; -pub const _NVAPI_GSYNC_SYNC_SOURCE_NVAPI_GSYNC_SYNC_SOURCE_VSYNC: _NVAPI_GSYNC_SYNC_SOURCE = 0; -pub const _NVAPI_GSYNC_SYNC_SOURCE_NVAPI_GSYNC_SYNC_SOURCE_HOUSESYNC: _NVAPI_GSYNC_SYNC_SOURCE = 1; -#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] -pub type _NVAPI_GSYNC_SYNC_SOURCE = ::std::os::raw::c_int; -#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] -pub use self::_NVAPI_GSYNC_SYNC_SOURCE as NVAPI_GSYNC_SYNC_SOURCE; -#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GSYNC_DELAY { - #[doc = "!< Version of the structure"] - pub version: NvU32, - #[doc = "!< delay to be induced in number of horizontal lines."] - pub numLines: NvU32, - #[doc = "!< delay to be induced in number of pixels."] - pub numPixels: NvU32, - #[doc = "!< maximum number of lines supported at current display mode to induce delay. Updated by NvAPI_GSync_GetControlParameters(). Read only."] - pub maxLines: NvU32, - #[doc = "!< minimum number of pixels required at current display mode to induce delay. Updated by NvAPI_GSync_GetControlParameters(). Read only."] - pub minPixels: NvU32, -} -#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] -pub type NV_GSYNC_DELAY = _NV_GSYNC_DELAY; -#[doc = "! Used in NvAPI_GSync_GetControlParameters() and NvAPI_GSync_SetControlParameters()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GSYNC_CONTROL_PARAMS_V1 { - #[doc = "!< Version of the structure"] - pub version: NvU32, - #[doc = "!< Leading edge / Falling edge / both"] - pub polarity: NVAPI_GSYNC_POLARITY, - #[doc = "!< None, TTL, NTSCPALSECAM, HDTV"] - pub vmode: NVAPI_GSYNC_VIDEO_MODE, - #[doc = "!< Number of pulses to wait between framelock signal generation"] - pub interval: NvU32, - #[doc = "!< VSync/House sync"] - pub source: NVAPI_GSYNC_SYNC_SOURCE, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< The time delay between the frame sync signal and the GPUs signal."] - pub syncSkew: NV_GSYNC_DELAY, - #[doc = "!< Sync start delay for master."] - pub startupDelay: NV_GSYNC_DELAY, -} -impl _NV_GSYNC_CONTROL_PARAMS_V1 { - #[inline] - pub fn interlaceMode(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_interlaceMode(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn interlaceMode_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_interlaceMode_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn syncSourceIsOutput(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_syncSourceIsOutput(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn syncSourceIsOutput_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_syncSourceIsOutput_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 30u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 30u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 30u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - interlaceMode: NvU32, - syncSourceIsOutput: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let interlaceMode: u32 = unsafe { ::std::mem::transmute(interlaceMode) }; - interlaceMode as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let syncSourceIsOutput: u32 = unsafe { ::std::mem::transmute(syncSourceIsOutput) }; - syncSourceIsOutput as u64 - }); - __bindgen_bitfield_unit.set(2usize, 30u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! Used in NvAPI_GSync_GetControlParameters() and NvAPI_GSync_SetControlParameters()."] -pub type NV_GSYNC_CONTROL_PARAMS_V1 = _NV_GSYNC_CONTROL_PARAMS_V1; -pub const _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE_NVAPI_GSYNC_UNDEFINED_MODE: - _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE = 0; -pub const _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE_NVAPI_GSYNC_MULTIPLY_MODE: - _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE = 1; -pub const _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE_NVAPI_GSYNC_DIVIDE_MODE: - _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE = 2; -#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] -pub type _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE = ::std::os::raw::c_int; -#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] -pub use self::_NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE as NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GSYNC_CONTROL_PARAMS_V2 { - #[doc = "!< Version of the structure"] - pub version: NvU32, - #[doc = "!< Leading edge / Falling edge / both"] - pub polarity: NVAPI_GSYNC_POLARITY, - #[doc = "!< None, TTL, NTSCPALSECAM, HDTV"] - pub vmode: NVAPI_GSYNC_VIDEO_MODE, - #[doc = "!< Number of pulses to wait between framelock signal generation"] - pub interval: NvU32, - #[doc = "!< VSync/House sync"] - pub source: NVAPI_GSYNC_SYNC_SOURCE, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< The time delay between the frame sync signal and the GPUs signal."] - pub syncSkew: NV_GSYNC_DELAY, - #[doc = "!< Sync start delay for master."] - pub startupDelay: NV_GSYNC_DELAY, - #[doc = "!< Indicates multiplier/divider mode for the housesync signal.\n!< While setting multiplyDivideMode, source needs to be set as NVAPI_GSYNC_SYNC_SOURCE_HOUSESYNC."] - pub multiplyDivideMode: NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE, - #[doc = "!< Indicates the multiplier/divider value for the housesync signal. Only supported if bIsMulDivSupported field of the structure NV_GSYNC_CAPABILITIES is set to 1.\n!< The maximum supported value for this field can be obtained from maxMulDivValue field of the structure NV_GSYNC_CAPABILITIES."] - pub multiplyDivideValue: NvU8, -} -impl _NV_GSYNC_CONTROL_PARAMS_V2 { - #[inline] - pub fn interlaceMode(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_interlaceMode(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn interlaceMode_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_interlaceMode_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn syncSourceIsOutput(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_syncSourceIsOutput(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn syncSourceIsOutput_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_syncSourceIsOutput_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 30u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 30u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 30u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - interlaceMode: NvU32, - syncSourceIsOutput: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let interlaceMode: u32 = unsafe { ::std::mem::transmute(interlaceMode) }; - interlaceMode as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let syncSourceIsOutput: u32 = unsafe { ::std::mem::transmute(syncSourceIsOutput) }; - syncSourceIsOutput as u64 - }); - __bindgen_bitfield_unit.set(2usize, 30u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_GSYNC_CONTROL_PARAMS_V2 = _NV_GSYNC_CONTROL_PARAMS_V2; -pub type NV_GSYNC_CONTROL_PARAMS = NV_GSYNC_CONTROL_PARAMS_V2; -#[doc = "! Used in NvAPI_GSync_GetSyncStatus()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GSYNC_STATUS { - #[doc = "!< Version of the structure"] - pub version: NvU32, - #[doc = "!< Is timing in sync?"] - pub bIsSynced: NvU32, - #[doc = "!< Does the phase of the timing signal from the GPU = the phase of the master sync signal?"] - pub bIsStereoSynced: NvU32, - #[doc = "!< Is the sync signal available?"] - pub bIsSyncSignalAvailable: NvU32, -} -#[doc = "! Used in NvAPI_GSync_GetSyncStatus()."] -pub type NV_GSYNC_STATUS = _NV_GSYNC_STATUS; -pub const _NVAPI_GSYNC_RJ45_IO_NVAPI_GSYNC_RJ45_OUTPUT: _NVAPI_GSYNC_RJ45_IO = 0; -pub const _NVAPI_GSYNC_RJ45_IO_NVAPI_GSYNC_RJ45_INPUT: _NVAPI_GSYNC_RJ45_IO = 1; -#[doc = "!< This field is used to notify that the framelock is not actually present."] -pub const _NVAPI_GSYNC_RJ45_IO_NVAPI_GSYNC_RJ45_UNUSED: _NVAPI_GSYNC_RJ45_IO = 2; -#[doc = "! Used in NV_GSYNC_STATUS_PARAMS."] -pub type _NVAPI_GSYNC_RJ45_IO = ::std::os::raw::c_int; -#[doc = "! Used in NV_GSYNC_STATUS_PARAMS."] -pub use self::_NVAPI_GSYNC_RJ45_IO as NVAPI_GSYNC_RJ45_IO; -#[doc = "! \\ingroup gsyncapi\n! Used in NvAPI_GSync_GetStatusParameters()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GSYNC_STATUS_PARAMS_V1 { - pub version: NvU32, - #[doc = "!< The refresh rate"] - pub refreshRate: NvU32, - #[doc = "!< Configured as input / output"] - pub RJ45_IO: [NVAPI_GSYNC_RJ45_IO; 2usize], - #[doc = "!< Connected to ethernet hub? [ERRONEOUSLY CONNECTED!]"] - pub RJ45_Ethernet: [NvU32; 2usize], - #[doc = "!< Incoming house sync frequency in Hz"] - pub houseSyncIncoming: NvU32, - #[doc = "!< Is house sync connected?"] - pub bHouseSync: NvU32, -} -#[doc = "! \\ingroup gsyncapi\n! Used in NvAPI_GSync_GetStatusParameters()."] -pub type NV_GSYNC_STATUS_PARAMS_V1 = _NV_GSYNC_STATUS_PARAMS_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GSYNC_STATUS_PARAMS_V2 { - pub version: NvU32, - #[doc = "!< The refresh rate"] - pub refreshRate: NvU32, - #[doc = "!< Configured as input / output"] - pub RJ45_IO: [NVAPI_GSYNC_RJ45_IO; 2usize], - #[doc = "!< Connected to ethernet hub? [ERRONEOUSLY CONNECTED!]"] - pub RJ45_Ethernet: [NvU32; 2usize], - #[doc = "!< Incoming house sync frequency in Hz"] - pub houseSyncIncoming: NvU32, - #[doc = "!< Is house sync connected?"] - pub bHouseSync: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, -} -impl _NV_GSYNC_STATUS_PARAMS_V2 { - #[inline] - pub fn bInternalSlave(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bInternalSlave(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bInternalSlave_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bInternalSlave_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bInternalSlave: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bInternalSlave: u32 = unsafe { ::std::mem::transmute(bInternalSlave) }; - bInternalSlave as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_GSYNC_STATUS_PARAMS_V2 = _NV_GSYNC_STATUS_PARAMS_V2; -pub type NV_GSYNC_STATUS_PARAMS = NV_GSYNC_STATUS_PARAMS_V2; -pub const _NV_RESOLVE_MODE_NV_RESOLVE_MODE_SAMPLE_0: _NV_RESOLVE_MODE = 0; -#[doc = "! \\ingroup dx\n! Valid modes for NvAPI_D3D11_ResolveSubresourceRegion() and NvAPI_D3D12_ResolveSubresourceRegion"] -pub type _NV_RESOLVE_MODE = ::std::os::raw::c_int; -#[doc = "! \\ingroup dx\n! Valid modes for NvAPI_D3D11_ResolveSubresourceRegion() and NvAPI_D3D12_ResolveSubresourceRegion"] -pub use self::_NV_RESOLVE_MODE as NV_RESOLVE_MODE; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of Single Pass Stereo HW feature\n! \\ingroup dx"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V1 { - pub version: NvU32, - pub bSinglePassStereoSupported: NvU32, -} -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of Single Pass Stereo HW feature\n! \\ingroup dx"] -pub type NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V1 = - _NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V2 { - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, -} -impl _NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V2 { - #[inline] - pub fn bSinglePassStereoSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bSinglePassStereoSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bSinglePassStereoSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bSinglePassStereoSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bSinglePassStereoXYZWSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_bSinglePassStereoXYZWSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bSinglePassStereoXYZWSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bSinglePassStereoXYZWSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 30u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 30u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 30u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bSinglePassStereoSupported: NvU32, - bSinglePassStereoXYZWSupported: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bSinglePassStereoSupported: u32 = - unsafe { ::std::mem::transmute(bSinglePassStereoSupported) }; - bSinglePassStereoSupported as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let bSinglePassStereoXYZWSupported: u32 = - unsafe { ::std::mem::transmute(bSinglePassStereoXYZWSupported) }; - bSinglePassStereoXYZWSupported as u64 - }); - __bindgen_bitfield_unit.set(2usize, 30u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V2 = - _NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V2; -pub type NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS = NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V2; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of MultiView HW feature\n! \\ingroup dx"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_QUERY_MULTIVIEW_SUPPORT_PARAMS_V1 { - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, -} -impl _NV_QUERY_MULTIVIEW_SUPPORT_PARAMS_V1 { - #[inline] - pub fn bMultiViewSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bMultiViewSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bMultiViewSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bMultiViewSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bSinglePassStereoSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_bSinglePassStereoSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bSinglePassStereoSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bSinglePassStereoSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bSinglePassStereoXYZWSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_bSinglePassStereoXYZWSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bSinglePassStereoXYZWSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bSinglePassStereoXYZWSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 29u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 29u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 29u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 29u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bMultiViewSupported: NvU32, - bSinglePassStereoSupported: NvU32, - bSinglePassStereoXYZWSupported: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bMultiViewSupported: u32 = unsafe { ::std::mem::transmute(bMultiViewSupported) }; - bMultiViewSupported as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let bSinglePassStereoSupported: u32 = - unsafe { ::std::mem::transmute(bSinglePassStereoSupported) }; - bSinglePassStereoSupported as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let bSinglePassStereoXYZWSupported: u32 = - unsafe { ::std::mem::transmute(bSinglePassStereoXYZWSupported) }; - bSinglePassStereoXYZWSupported as u64 - }); - __bindgen_bitfield_unit.set(3usize, 29u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of MultiView HW feature\n! \\ingroup dx"] -pub type NV_QUERY_MULTIVIEW_SUPPORT_PARAMS_V1 = _NV_QUERY_MULTIVIEW_SUPPORT_PARAMS_V1; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of MultiView HW feature\n! \\ingroup dx"] -pub type NV_QUERY_MULTIVIEW_SUPPORT_PARAMS = NV_QUERY_MULTIVIEW_SUPPORT_PARAMS_V1; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used for setting the Mode for MultiView HW Feature.\n! \\ingroup dx"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MULTIVIEW_PARAMS_V1 { - pub version: NvU32, - pub numViews: NvU32, - pub renderTargetIndexOffset: [NvU32; 4usize], - pub independentViewportMaskEnable: NvU8, -} -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used for setting the Mode for MultiView HW Feature.\n! \\ingroup dx"] -pub type NV_MULTIVIEW_PARAMS_V1 = _NV_MULTIVIEW_PARAMS_V1; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used for setting the Mode for MultiView HW Feature.\n! \\ingroup dx"] -pub type NV_MULTIVIEW_PARAMS = NV_MULTIVIEW_PARAMS_V1; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of Lens Matched Shading HW feature\n! \\ingroup dx"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_QUERY_MODIFIED_W_SUPPORT_PARAMS { - pub version: NvU32, - pub bModifiedWSupported: NvU32, -} -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of Lens Matched Shading HW feature\n! \\ingroup dx"] -pub type NV_QUERY_MODIFIED_W_SUPPORT_PARAMS_V1 = _NV_QUERY_MODIFIED_W_SUPPORT_PARAMS; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of Lens Matched Shading HW feature\n! \\ingroup dx"] -pub type NV_QUERY_MODIFIED_W_SUPPORT_PARAMS = NV_QUERY_MODIFIED_W_SUPPORT_PARAMS_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MODIFIED_W_COEFFICIENTS { - pub fA: f32, - pub fB: f32, - pub fAReserved: f32, - pub fBReserved: f32, - pub fReserved: [f32; 2usize], -} -pub type NV_MODIFIED_W_COEFFICIENTS = _NV_MODIFIED_W_COEFFICIENTS; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MODIFIED_W_PARAMS { - pub version: NvU32, - pub numEntries: NvU32, - pub modifiedWCoefficients: [NV_MODIFIED_W_COEFFICIENTS; 16usize], - pub id: NvU32, - pub reserved: [NvU32; 16usize], -} -pub type NV_MODIFIED_W_PARAMS_V1 = _NV_MODIFIED_W_PARAMS; -pub type NV_MODIFIED_W_PARAMS = NV_MODIFIED_W_PARAMS_V1; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to get sleep status\n! \\ingroup dx"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GET_SLEEP_STATUS_PARAMS { - #[doc = "!< (IN) Structure version"] - pub version: NvU32, - #[doc = "!< (OUT) Is low latency mode enabled?"] - pub bLowLatencyMode: NvBool, - #[doc = "!< (OUT) Is fullscreen VRR enabled?"] - pub bFsVrr: NvBool, - #[doc = "!< (OUT) Is Control Panel overriding VSYNC ON?"] - pub bCplVsyncOn: NvBool, - #[doc = "!< (OUT) Latest sleep interval in microseconds."] - pub sleepIntervalUs: NvU32, - #[doc = "!< (OUT) Is NvAPI_D3D_Sleep() being called?"] - pub bUseGameSleep: NvBool, - #[doc = "!< (OUT) Is in fullscreen/iFlip mode?"] - pub bFullscreenIFlip: NvBool, - #[doc = "!< (OUT) Latest Frame Generation multiplier used."] - pub fgMultiplier: NvU8, - #[doc = "!< (IN) Reserved. Must be set to 0s."] - pub rsvd: [NvU8; 119usize], -} -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to get sleep status\n! \\ingroup dx"] -pub type NV_GET_SLEEP_STATUS_PARAMS_V1 = _NV_GET_SLEEP_STATUS_PARAMS; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to get sleep status\n! \\ingroup dx"] -pub type NV_GET_SLEEP_STATUS_PARAMS = NV_GET_SLEEP_STATUS_PARAMS_V1; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to set sleep mode\n! \\ingroup dx"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_SET_SLEEP_MODE_PARAMS { - #[doc = "!< (IN) Structure version"] - pub version: NvU32, - #[doc = "!< (IN) Low latency mode enable/disable."] - pub bLowLatencyMode: NvBool, - #[doc = "!< (IN) Request maximum GPU clock frequency regardless of workload."] - pub bLowLatencyBoost: NvBool, - #[doc = "!< (IN) Minimum frame interval in microseconds. 0 = no frame rate limit."] - pub minimumIntervalUs: NvU32, - #[doc = "!< (IN) Allow latency markers to be used for runtime optimizations."] - pub bUseMarkersToOptimize: NvBool, - #[doc = "!< (IN) Consider all submission overlaps (both in between frames and within each frame)."] - pub bUseMinQueueTime: NvBool, - #[doc = "!< (IN) Reserved. Must be set to 0s."] - pub rsvd: [NvU8; 30usize], -} -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to set sleep mode\n! \\ingroup dx"] -pub type NV_SET_SLEEP_MODE_PARAMS_V1 = _NV_SET_SLEEP_MODE_PARAMS; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to set sleep mode\n! \\ingroup dx"] -pub type NV_SET_SLEEP_MODE_PARAMS = NV_SET_SLEEP_MODE_PARAMS_V1; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to send Reflex Sync data to UMD\n! \\ingroup dx"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_SET_REFLEX_SYNC_PARAMS { - #[doc = "!< (IN) Structure version"] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< (IN) Interval between VBLANKs in microseconds. (0 means N/A)"] - pub vblankIntervalUs: NvU32, - #[doc = "!< (IN) Amount of time in the completed frame queue. Can be negative. (0 means N/A)"] - pub timeInQueueUs: NvS32, - #[doc = "!< (IN) Target amount of time in the completed frame queue. (0 means N/A)"] - pub timeInQueueUsTarget: NvU32, - #[doc = "!< (IN) Specify the frame generation multipler to use. (0 means driver should auto-detect)"] - pub fgMultiplier: NvU8, - #[doc = "!< (IN) Reserved. Must be set to 0s."] - pub rsvd: [NvU8; 27usize], -} -impl _NV_SET_REFLEX_SYNC_PARAMS { - #[inline] - pub fn bEnable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bEnable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bEnable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bEnable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bDisable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_bDisable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bDisable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bDisable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn flagsRsvd(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } - } - #[inline] - pub fn set_flagsRsvd(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 30u8, val as u64) - } - } - #[inline] - pub unsafe fn flagsRsvd_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 30u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_flagsRsvd_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 30u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bEnable: NvU32, - bDisable: NvU32, - flagsRsvd: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bEnable: u32 = unsafe { ::std::mem::transmute(bEnable) }; - bEnable as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let bDisable: u32 = unsafe { ::std::mem::transmute(bDisable) }; - bDisable as u64 - }); - __bindgen_bitfield_unit.set(2usize, 30u8, { - let flagsRsvd: u32 = unsafe { ::std::mem::transmute(flagsRsvd) }; - flagsRsvd as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to send Reflex Sync data to UMD\n! \\ingroup dx"] -pub type NV_SET_REFLEX_SYNC_PARAMS_V1 = _NV_SET_REFLEX_SYNC_PARAMS; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to send Reflex Sync data to UMD\n! \\ingroup dx"] -pub type NV_SET_REFLEX_SYNC_PARAMS = NV_SET_REFLEX_SYNC_PARAMS_V1; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to get latency report.\n! \\ingroup dx"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LATENCY_RESULT_PARAMS { - #[doc = "!< (IN) Structure version"] - pub version: NvU32, - pub frameReport: [_NV_LATENCY_RESULT_PARAMS_FrameReport; 64usize], - pub rsvd: [NvU8; 32usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LATENCY_RESULT_PARAMS_FrameReport { - #[doc = "!< (OUT)"] - pub frameID: NvU64, - #[doc = "!< (OUT)"] - pub inputSampleTime: NvU64, - #[doc = "!< (OUT)"] - pub simStartTime: NvU64, - #[doc = "!< (OUT)"] - pub simEndTime: NvU64, - #[doc = "!< (OUT)"] - pub renderSubmitStartTime: NvU64, - #[doc = "!< (OUT)"] - pub renderSubmitEndTime: NvU64, - #[doc = "!< (OUT)"] - pub presentStartTime: NvU64, - #[doc = "!< (OUT)"] - pub presentEndTime: NvU64, - #[doc = "!< (OUT)"] - pub driverStartTime: NvU64, - #[doc = "!< (OUT)"] - pub driverEndTime: NvU64, - #[doc = "!< (OUT)"] - pub osRenderQueueStartTime: NvU64, - #[doc = "!< (OUT)"] - pub osRenderQueueEndTime: NvU64, - #[doc = "!< (OUT)"] - pub gpuRenderStartTime: NvU64, - #[doc = "!< (OUT)"] - pub gpuRenderEndTime: NvU64, - #[doc = "!< (OUT) Difference between gpuRenderStartTime and gpuRenderEndTime, excluding the idles in between, in microseconds."] - pub gpuActiveRenderTimeUs: NvU32, - #[doc = "!< (OUT) Difference between previous and current frame's gpuRenderEndTime, in microseconds."] - pub gpuFrameTimeUs: NvU32, - #[doc = "!< (OUT)"] - pub cameraConstructedTime: NvU64, - #[doc = "!< (OUT) Cross adapter copy time in microseconds."] - pub crossAdapterCopyTimeUs: NvU32, - #[doc = "!< (OUT) Frame generation time in microseconds."] - pub aiFrameTimeUs: NvU32, - pub rsvd: [NvU8; 104usize], -} -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to get latency report.\n! \\ingroup dx"] -pub type NV_LATENCY_RESULT_PARAMS_V1 = _NV_LATENCY_RESULT_PARAMS; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to get latency report.\n! \\ingroup dx"] -pub type NV_LATENCY_RESULT_PARAMS = NV_LATENCY_RESULT_PARAMS_V1; -pub const NV_LATENCY_MARKER_TYPE_SIMULATION_START: NV_LATENCY_MARKER_TYPE = 0; -pub const NV_LATENCY_MARKER_TYPE_SIMULATION_END: NV_LATENCY_MARKER_TYPE = 1; -pub const NV_LATENCY_MARKER_TYPE_RENDERSUBMIT_START: NV_LATENCY_MARKER_TYPE = 2; -pub const NV_LATENCY_MARKER_TYPE_RENDERSUBMIT_END: NV_LATENCY_MARKER_TYPE = 3; -pub const NV_LATENCY_MARKER_TYPE_PRESENT_START: NV_LATENCY_MARKER_TYPE = 4; -pub const NV_LATENCY_MARKER_TYPE_PRESENT_END: NV_LATENCY_MARKER_TYPE = 5; -pub const NV_LATENCY_MARKER_TYPE_INPUT_SAMPLE: NV_LATENCY_MARKER_TYPE = 6; -pub const NV_LATENCY_MARKER_TYPE_TRIGGER_FLASH: NV_LATENCY_MARKER_TYPE = 7; -pub const NV_LATENCY_MARKER_TYPE_PC_LATENCY_PING: NV_LATENCY_MARKER_TYPE = 8; -pub const NV_LATENCY_MARKER_TYPE_OUT_OF_BAND_RENDERSUBMIT_START: NV_LATENCY_MARKER_TYPE = 9; -pub const NV_LATENCY_MARKER_TYPE_OUT_OF_BAND_RENDERSUBMIT_END: NV_LATENCY_MARKER_TYPE = 10; -pub const NV_LATENCY_MARKER_TYPE_OUT_OF_BAND_PRESENT_START: NV_LATENCY_MARKER_TYPE = 11; -pub const NV_LATENCY_MARKER_TYPE_OUT_OF_BAND_PRESENT_END: NV_LATENCY_MARKER_TYPE = 12; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used define latency marker type\n! \\ingroup dx"] -pub type NV_LATENCY_MARKER_TYPE = ::std::os::raw::c_int; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used set latency markers\n! \\ingroup dx"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LATENCY_MARKER_PARAMS { - #[doc = "!< (IN) Structure version"] - pub version: NvU32, - pub frameID: NvU64, - pub markerType: NV_LATENCY_MARKER_TYPE, - pub rsvd0: NvU64, - pub rsvd: [NvU8; 56usize], -} -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used set latency markers\n! \\ingroup dx"] -pub type NV_LATENCY_MARKER_PARAMS_V1 = _NV_LATENCY_MARKER_PARAMS; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used set latency markers\n! \\ingroup dx"] -pub type NV_LATENCY_MARKER_PARAMS = NV_LATENCY_MARKER_PARAMS_V1; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used in NvAPI_D3D12_SetAsyncFrameMarker and NvAPI_D3D11_SetAsyncFrameMarker\n! \\ingroup dx"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_ASYNC_FRAME_MARKER_PARAMS_V1 { - #[doc = "!< (IN) Structure version"] - pub version: NvU32, - pub frameID: NvU64, - pub markerType: NV_LATENCY_MARKER_TYPE, - pub presentFrameID: NvU64, - pub vendorInternal: NvBool, - pub rsvd: [NvU8; 55usize], -} -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used in NvAPI_D3D12_SetAsyncFrameMarker and NvAPI_D3D11_SetAsyncFrameMarker\n! \\ingroup dx"] -pub type NV_ASYNC_FRAME_MARKER_PARAMS_V1 = _NV_ASYNC_FRAME_MARKER_PARAMS_V1; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used in NvAPI_D3D12_SetAsyncFrameMarker and NvAPI_D3D11_SetAsyncFrameMarker\n! \\ingroup dx"] -pub type NV_ASYNC_FRAME_MARKER_PARAMS = NV_ASYNC_FRAME_MARKER_PARAMS_V1; -pub const NV_OUT_OF_BAND_CQ_TYPE_OUT_OF_BAND_RENDER: NV_OUT_OF_BAND_CQ_TYPE = 0; -pub const NV_OUT_OF_BAND_CQ_TYPE_OUT_OF_BAND_PRESENT: NV_OUT_OF_BAND_CQ_TYPE = 1; -pub const NV_OUT_OF_BAND_CQ_TYPE_OUT_OF_BAND_IGNORE: NV_OUT_OF_BAND_CQ_TYPE = 2; -pub const NV_OUT_OF_BAND_CQ_TYPE_OUT_OF_BAND_RENDER_PRESENT: NV_OUT_OF_BAND_CQ_TYPE = 3; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used in NvAPI_D3D12_NotifyOutOfBandCommandQueue\n! \\ingroup dx"] -pub type NV_OUT_OF_BAND_CQ_TYPE = ::std::os::raw::c_int; -pub const _NV_D3D12_WORKSTATION_FEATURE_TYPE_NV_D3D12_WORKSTATION_FEATURE_TYPE_PRESENT_BARRIER: - _NV_D3D12_WORKSTATION_FEATURE_TYPE = 1; -pub const _NV_D3D12_WORKSTATION_FEATURE_TYPE_NV_D3D12_WORKSTATION_FEATURE_TYPE_RDMA_BAR1_SUPPORT: - _NV_D3D12_WORKSTATION_FEATURE_TYPE = 2; -#[doc = "! \\ingroup DX"] -pub type _NV_D3D12_WORKSTATION_FEATURE_TYPE = ::std::os::raw::c_int; -#[doc = "! \\ingroup DX"] -pub use self::_NV_D3D12_WORKSTATION_FEATURE_TYPE as NV_D3D12_WORKSTATION_FEATURE_TYPE; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_D3D12_WORKSTATION_FEATURE_RDMA_PROPERTIES { - pub rdmaHeapSize: NvU64, -} -pub type NV_D3D12_WORKSTATION_FEATURE_RDMA_PROPERTIES = - _NV_D3D12_WORKSTATION_FEATURE_RDMA_PROPERTIES; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_INITIALIZED: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 1; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_ENABLED: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 2; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_DLL_EXISTS: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 4; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_DLL_LOADED: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 8; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_DLL_SELECTED: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 16; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_PRESET: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 32; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_PERF_MODE: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 64; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_SCALING_RATIO: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 128; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_OPTIMAL_SETTINGS: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 256; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_CREATED: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 512; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_EVALUATE: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 1024; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_FG_MODE: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 8192; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_SR_DLAA_MODE: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 16384; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_FG_MULTI_FRAME: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 32768; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_ERR_FAILED: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 65536; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_ERR_DENIED: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 131072; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_ERR_DRS: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 262144; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_ERR_NOT_FOUND: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 524288; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_ERR_DLL_LOAD: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 1048576; -pub type NV_NGX_DLSS_OVERRIDE_BITFIELD = ::std::os::raw::c_int; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_NGX_DLSS_OVERRIDE_GET_STATE_PARAMS_V1 { - #[doc = "!< [in] Structure version"] - pub version: NvU32, - #[doc = "!< [in] Process Identifier"] - pub processIdentifier: NvU32, - #[doc = "!< [out] Feedback bits for Super Resolution"] - pub feedbackMaskSR: NvU64, - #[doc = "!< [out] Feedback bits for Ray Reconstruction"] - pub feedbackMaskRR: NvU64, - #[doc = "!< [out] Feedback bits for Frame Generation"] - pub feedbackMaskFG: NvU64, - #[doc = "!< [out] Scaling Ratio"] - pub scalingRatio: NvF32, - #[doc = "!< [out] Performance Mode"] - pub performanceMode: NvU32, - #[doc = "!< [out] Render Preset for SR/RR"] - pub renderPreset: NvU32, - #[doc = "!< [out] FG Override Frame Count Target"] - pub frameGenerationCount: NvU32, - #[doc = "!< [out] Render Preset for FG"] - pub frameGenerationPreset: NvU32, - #[doc = "!< [out] Frame Generation Mode"] - pub frameGenerationMode: NvU32, - #[doc = "!< Reserved for future use. Must be zero."] - pub reserved: [NvU32; 2usize], -} -pub type NV_NGX_DLSS_OVERRIDE_GET_STATE_PARAMS_V1 = _NV_NGX_DLSS_OVERRIDE_GET_STATE_PARAMS_V1; -pub type NV_NGX_DLSS_OVERRIDE_GET_STATE_PARAMS = NV_NGX_DLSS_OVERRIDE_GET_STATE_PARAMS_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_NGX_DLSS_OVERRIDE_SET_STATE_PARAMS_V1 { - #[doc = "!< [in] Structure version"] - pub version: NvU32, - #[doc = "!< [in] Process identifier of caller"] - pub processIdentifier: NvU32, - #[doc = "!< [in] DLSS feature ID"] - pub feature: NvU32, - #[doc = "!< [in] Feedback bits for DLSS feature"] - pub feedbackMask: NvU64, - #[doc = "!< Reserved for future use. Must be zero."] - pub reserved: [NvU64; 4usize], -} -pub type NV_NGX_DLSS_OVERRIDE_SET_STATE_PARAMS_V1 = _NV_NGX_DLSS_OVERRIDE_SET_STATE_PARAMS_V1; -pub type NV_NGX_DLSS_OVERRIDE_SET_STATE_PARAMS = NV_NGX_DLSS_OVERRIDE_SET_STATE_PARAMS_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NVVIOTOPOLOGYTARGET { - #[doc = "!< Handle to Physical GPU (This could be NULL for GVI device if its not binded)"] - pub hPhysicalGpu: NvPhysicalGpuHandle, - #[doc = "!, -} -impl _NV_DISPLAY_DRIVER_INFO { - #[inline] - pub fn bIsDCHDriver(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsDCHDriver(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsDCHDriver_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsDCHDriver_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bIsNVIDIAStudioPackage(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsNVIDIAStudioPackage(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsNVIDIAStudioPackage_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsNVIDIAStudioPackage_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bIsNVIDIAGameReadyPackage(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsNVIDIAGameReadyPackage(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsNVIDIAGameReadyPackage_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsNVIDIAGameReadyPackage_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bIsNVIDIARTXProductionBranchPackage(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsNVIDIARTXProductionBranchPackage(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsNVIDIARTXProductionBranchPackage_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsNVIDIARTXProductionBranchPackage_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bIsNVIDIARTXNewFeatureBranchPackage(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsNVIDIARTXNewFeatureBranchPackage(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsNVIDIARTXNewFeatureBranchPackage_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsNVIDIARTXNewFeatureBranchPackage_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 27u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 27u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 27u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bIsDCHDriver: NvU32, - bIsNVIDIAStudioPackage: NvU32, - bIsNVIDIAGameReadyPackage: NvU32, - bIsNVIDIARTXProductionBranchPackage: NvU32, - bIsNVIDIARTXNewFeatureBranchPackage: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsDCHDriver: u32 = unsafe { ::std::mem::transmute(bIsDCHDriver) }; - bIsDCHDriver as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let bIsNVIDIAStudioPackage: u32 = - unsafe { ::std::mem::transmute(bIsNVIDIAStudioPackage) }; - bIsNVIDIAStudioPackage as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let bIsNVIDIAGameReadyPackage: u32 = - unsafe { ::std::mem::transmute(bIsNVIDIAGameReadyPackage) }; - bIsNVIDIAGameReadyPackage as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let bIsNVIDIARTXProductionBranchPackage: u32 = - unsafe { ::std::mem::transmute(bIsNVIDIARTXProductionBranchPackage) }; - bIsNVIDIARTXProductionBranchPackage as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let bIsNVIDIARTXNewFeatureBranchPackage: u32 = - unsafe { ::std::mem::transmute(bIsNVIDIARTXNewFeatureBranchPackage) }; - bIsNVIDIARTXNewFeatureBranchPackage as u64 - }); - __bindgen_bitfield_unit.set(5usize, 27u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_DISPLAY_DRIVER_INFO_V1 = _NV_DISPLAY_DRIVER_INFO; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_DISPLAY_DRIVER_INFO_V2 { - #[doc = "!< Structure Version."] - pub version: NvU32, - #[doc = "!< Contains the driver version after successful return."] - pub driverVersion: NvU32, - #[doc = "!< Contains the driver-branch string after successful return."] - pub szBuildBranch: NvAPI_ShortString, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< (OUT) Contains the driver base branch string after successful return."] - pub szBuildBaseBranch: NvAPI_ShortString, - #[doc = "!< Reserved for future use"] - pub reservedEx: NvU32, -} -impl _NV_DISPLAY_DRIVER_INFO_V2 { - #[inline] - pub fn bIsDCHDriver(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsDCHDriver(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsDCHDriver_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsDCHDriver_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bIsNVIDIAStudioPackage(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsNVIDIAStudioPackage(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsNVIDIAStudioPackage_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsNVIDIAStudioPackage_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bIsNVIDIAGameReadyPackage(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsNVIDIAGameReadyPackage(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsNVIDIAGameReadyPackage_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsNVIDIAGameReadyPackage_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bIsNVIDIARTXProductionBranchPackage(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsNVIDIARTXProductionBranchPackage(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsNVIDIARTXProductionBranchPackage_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsNVIDIARTXProductionBranchPackage_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bIsNVIDIARTXNewFeatureBranchPackage(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsNVIDIARTXNewFeatureBranchPackage(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsNVIDIARTXNewFeatureBranchPackage_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsNVIDIARTXNewFeatureBranchPackage_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 27u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 27u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 27u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bIsDCHDriver: NvU32, - bIsNVIDIAStudioPackage: NvU32, - bIsNVIDIAGameReadyPackage: NvU32, - bIsNVIDIARTXProductionBranchPackage: NvU32, - bIsNVIDIARTXNewFeatureBranchPackage: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsDCHDriver: u32 = unsafe { ::std::mem::transmute(bIsDCHDriver) }; - bIsDCHDriver as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let bIsNVIDIAStudioPackage: u32 = - unsafe { ::std::mem::transmute(bIsNVIDIAStudioPackage) }; - bIsNVIDIAStudioPackage as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let bIsNVIDIAGameReadyPackage: u32 = - unsafe { ::std::mem::transmute(bIsNVIDIAGameReadyPackage) }; - bIsNVIDIAGameReadyPackage as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let bIsNVIDIARTXProductionBranchPackage: u32 = - unsafe { ::std::mem::transmute(bIsNVIDIARTXProductionBranchPackage) }; - bIsNVIDIARTXProductionBranchPackage as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let bIsNVIDIARTXNewFeatureBranchPackage: u32 = - unsafe { ::std::mem::transmute(bIsNVIDIARTXNewFeatureBranchPackage) }; - bIsNVIDIARTXNewFeatureBranchPackage as u64 - }); - __bindgen_bitfield_unit.set(5usize, 27u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_DISPLAY_DRIVER_INFO_V2 = _NV_DISPLAY_DRIVER_INFO_V2; -pub type NV_DISPLAY_DRIVER_INFO = NV_DISPLAY_DRIVER_INFO_V2; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_PHYSICAL_GPU_HANDLE_DATA { - pub hPhysicalGpu: NvPhysicalGpuHandle, - pub adapterType: NV_ADAPTER_TYPE, - pub reserved2: [NvU32; 4usize], -} -pub type NV_PHYSICAL_GPU_HANDLE_DATA = _NV_PHYSICAL_GPU_HANDLE_DATA; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_PHYSICAL_GPUS { - pub version: NvU32, - pub gpuHandleData: [NV_PHYSICAL_GPU_HANDLE_DATA; 64usize], - pub gpuHandleCount: NvU32, - pub reserved: [NvU32; 4usize], -} -pub type NV_PHYSICAL_GPUS_V1 = _NV_PHYSICAL_GPUS; -pub type NV_PHYSICAL_GPUS = NV_PHYSICAL_GPUS_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LOGICAL_GPU_HANDLE_DATA { - pub hLogicalGpu: NvLogicalGpuHandle, - pub adapterType: NV_ADAPTER_TYPE, - pub reserved: [NvU32; 4usize], -} -pub type NV_LOGICAL_GPU_HANDLE_DATA = _NV_LOGICAL_GPU_HANDLE_DATA; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LOGICAL_GPUS { - pub version: NvU32, - pub gpuHandleData: [NV_LOGICAL_GPU_HANDLE_DATA; 64usize], - pub gpuHandleCount: NvU32, - pub reserved: [NvU32; 4usize], -} -pub type NV_LOGICAL_GPUS_V1 = _NV_LOGICAL_GPUS; -pub type NV_LOGICAL_GPUS = NV_LOGICAL_GPUS_V1; -pub const _NV_NGX_DRIVER_FEATURE_ID_NV_NGX_DRIVER_FEATURE_ID_SET_FLIP_CONFIG_V2: - _NV_NGX_DRIVER_FEATURE_ID = 3423695; -pub type _NV_NGX_DRIVER_FEATURE_ID = ::std::os::raw::c_int; -pub use self::_NV_NGX_DRIVER_FEATURE_ID as NV_NGX_DRIVER_FEATURE_ID; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_NGX_DRIVER_FEATURE_SUPPORT_INFO { - #[doc = "!< [IN] Feature ID to query"] - pub featureId: NV_NGX_DRIVER_FEATURE_ID, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Reserved for future use"] - pub reserved2: [NvU32; 2usize], -} -impl _NV_NGX_DRIVER_FEATURE_SUPPORT_INFO { - #[inline] - pub fn bSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved1(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved1(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved1_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved1_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bSupported: NvU32, - reserved1: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bSupported: u32 = unsafe { ::std::mem::transmute(bSupported) }; - bSupported as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved1: u32 = unsafe { ::std::mem::transmute(reserved1) }; - reserved1 as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_NGX_DRIVER_FEATURE_SUPPORT_INFO = _NV_NGX_DRIVER_FEATURE_SUPPORT_INFO; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_NGX_GET_DRIVER_FEATURE_SUPPORT_PARAMS_V1 { - #[doc = "!< [IN] Structure version"] - pub version: NvU32, - #[doc = "!< [IN] Number of features to query (must be <= NVAPI_MAX_NGX_FEATURES_PER_QUERY)"] - pub featureCount: NvU32, - #[doc = "!< [INOUT] Feature query array"] - pub featureSupportInfo: [NV_NGX_DRIVER_FEATURE_SUPPORT_INFO; 16usize], - #[doc = "!< Reserved for future use"] - pub reserved: [NvU32; 6usize], -} -pub type NV_NGX_GET_DRIVER_FEATURE_SUPPORT_PARAMS_V1 = _NV_NGX_GET_DRIVER_FEATURE_SUPPORT_PARAMS_V1; -pub type NV_NGX_GET_DRIVER_FEATURE_SUPPORT_PARAMS = NV_NGX_GET_DRIVER_FEATURE_SUPPORT_PARAMS_V1; -#[doc = " Callback settings common to all client callbacks."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1 { - #[doc = " [in] Generic callback parameter which will be passed to the callback."] - pub pCallbackParam: *mut ::std::os::raw::c_void, - #[doc = " Reserved bytes for future expansion."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Callback settings common to all client callbacks."] -pub type NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1 = _NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1; -#[doc = " Callback settings common to all client callbacks."] -pub type NV_GPU_CLIENT_CALLBACK_SETTINGS_SUPER_V1 = NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1; -#[doc = " Callback settings common to all periodic client callbacks."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_PERIODIC_CALLBACK_SETTINGS_SUPER_V1 { - #[doc = " [in] Super class data."] - pub super_: NV_GPU_CLIENT_CALLBACK_SETTINGS_SUPER_V1, - #[doc = " [in] Minimum interval at which callback will be called.\n\n The callback may be invoked slower than this interval if underlying\n sampling rate does not align precisely to the provided period."] - pub callbackPeriodms: NvU32, - #[doc = " Reserved bytes for future expansion."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Callback settings common to all periodic client callbacks."] -pub type NV_GPU_CLIENT_PERIODIC_CALLBACK_SETTINGS_SUPER_V1 = - _NV_GPU_CLIENT_PERIODIC_CALLBACK_SETTINGS_SUPER_V1; -#[doc = " Callback data common to all client callbacks."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_CALLBACK_DATA_SUPER_V1 { - #[doc = " [out] Generic callback parameter which was passed in at registration time."] - pub pCallbackParam: *mut ::std::os::raw::c_void, - #[doc = " Reserved bytes for future expansion."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Callback data common to all client callbacks."] -pub type NV_GPU_CLIENT_CALLBACK_DATA_SUPER_V1 = _NV_GPU_CLIENT_CALLBACK_DATA_SUPER_V1; -pub const _NV_GPU_CLIENT_UTIL_DOMAIN_ID_NV_GPU_CLIENT_UTIL_DOMAIN_GRAPHICS: - _NV_GPU_CLIENT_UTIL_DOMAIN_ID = 0; -pub const _NV_GPU_CLIENT_UTIL_DOMAIN_ID_NV_GPU_CLIENT_UTIL_DOMAIN_FRAME_BUFFER: - _NV_GPU_CLIENT_UTIL_DOMAIN_ID = 1; -pub const _NV_GPU_CLIENT_UTIL_DOMAIN_ID_NV_GPU_CLIENT_UTIL_DOMAIN_VIDEO: - _NV_GPU_CLIENT_UTIL_DOMAIN_ID = 2; -#[doc = " Reserved for future use."] -pub const _NV_GPU_CLIENT_UTIL_DOMAIN_ID_NV_GPU_CLIENT_UTIL_DOMAIN_RSVD: - _NV_GPU_CLIENT_UTIL_DOMAIN_ID = 3; -#[doc = " Enumeration of different utilization domains"] -pub type _NV_GPU_CLIENT_UTIL_DOMAIN_ID = ::std::os::raw::c_int; -#[doc = " Enumeration of different utilization domains"] -pub use self::_NV_GPU_CLIENT_UTIL_DOMAIN_ID as NV_GPU_CLIENT_UTIL_DOMAIN_ID; -#[doc = " Data specific to a single utilization domain."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_UTILIZATION_DATA_V1 { - #[doc = " [out] Utilization domain identifier."] - pub utilId: NV_GPU_CLIENT_UTIL_DOMAIN_ID, - #[doc = " [out] Percentage of time where the domain is considered busy since the\n last sample. Units of percent*100; i.e. 5000 = 50%."] - pub utilizationPercent: NvU32, - #[doc = " Reserved bytes for future expansion."] - pub rsvd: [NvU8; 61usize], -} -#[doc = " Data specific to a single utilization domain."] -pub type NV_GPU_CLIENT_UTILIZATION_DATA_V1 = _NV_GPU_CLIENT_UTILIZATION_DATA_V1; -#[doc = " Data passed back to callback registered with\n @ref NvAPI_GPU_ClientRegisterForUtilizationSampleUpdates."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_CALLBACK_UTILIZATION_DATA_V1 { - #[doc = " [out] Super struct."] - pub super_: NV_GPU_CLIENT_CALLBACK_DATA_SUPER_V1, - #[doc = " [out] Number of valid entries in `utils` array."] - pub numUtils: NvU32, - #[doc = " [out] Time at which data was collected. Represented as elapsed\n microseconds since 00:00:00 UTC on January 1, 1970."] - pub timestamp: NvU64, - #[doc = " Reserved bytes for future expansion."] - pub rsvd: [NvU8; 64usize], - #[doc = " [out] Status data for each utilization domain."] - pub utils: [NV_GPU_CLIENT_UTILIZATION_DATA_V1; 4usize], -} -#[doc = " Data passed back to callback registered with\n @ref NvAPI_GPU_ClientRegisterForUtilizationSampleUpdates."] -pub type NV_GPU_CLIENT_CALLBACK_UTILIZATION_DATA_V1 = _NV_GPU_CLIENT_CALLBACK_UTILIZATION_DATA_V1; -#[doc = " Function prototype for a periodic utilization data callback that will be registered with NvAPI."] -pub type NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_V1 = ::std::option::Option< - unsafe extern "C" fn( - hPhysicalGpu: NvPhysicalGpuHandle, - pData: *mut NV_GPU_CLIENT_CALLBACK_UTILIZATION_DATA_V1, - ), ->; -#[doc = " Data required to register a periodic callback for utilization data."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_SETTINGS_V1 { - #[doc = " [in] Structure Version, must always be first."] - pub version: NvU32, - #[doc = " [in] Generic callback settings. Some data within will be passed to the\n callback when invoked."] - pub super_: NV_GPU_CLIENT_PERIODIC_CALLBACK_SETTINGS_SUPER_V1, - #[doc = " [in] Callback. Pass in NULL or nullptr to indicate request to unregister."] - pub callback: NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_V1, - #[doc = " Reserved bytes for future expansion."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Data required to register a periodic callback for utilization data."] -pub type NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_SETTINGS_V1 = - _NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_SETTINGS_V1; -#[doc = " Data required to register a periodic callback for utilization data."] -pub type NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_SETTINGS = - NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_SETTINGS_V1; -pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_INVALID: _NV_RISE_CONTENT_TYPE = 0; -pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_TEXT: _NV_RISE_CONTENT_TYPE = 1; -pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_GRAPH: _NV_RISE_CONTENT_TYPE = 2; -pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_CUSTOM_BEHAVIOR: _NV_RISE_CONTENT_TYPE = 3; -pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_CUSTOM_BEHAVIOR_RESULT: _NV_RISE_CONTENT_TYPE = - 4; -pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_INSTALLING: _NV_RISE_CONTENT_TYPE = 5; -pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_PROGRESS_UPDATE: _NV_RISE_CONTENT_TYPE = 6; -pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_READY: _NV_RISE_CONTENT_TYPE = 7; -pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_DOWNLOAD_REQUEST: _NV_RISE_CONTENT_TYPE = 8; -pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_UPDATE_INFO: _NV_RISE_CONTENT_TYPE = 9; -#[doc = " Enumeration of different RISE content types."] -pub type _NV_RISE_CONTENT_TYPE = ::std::os::raw::c_int; -#[doc = " Enumeration of different RISE content types."] -pub use self::_NV_RISE_CONTENT_TYPE as NV_RISE_CONTENT_TYPE; -#[doc = " Data passed back to callback."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_RISE_CALLBACK_DATA_V1 { - #[doc = " Super struct."] - pub super_: NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1, - #[doc = " RISE type of content"] - pub contentType: NV_RISE_CONTENT_TYPE, - #[doc = " RISE content."] - pub content: NvAPI_String, - #[doc = " Is this the last in the batch?"] - pub completed: NvBool, -} -#[doc = " Data passed back to callback."] -pub type NV_RISE_CALLBACK_DATA_V1 = _NV_RISE_CALLBACK_DATA_V1; -#[doc = " Callback for RISE update callbacks."] -pub type NV_RISE_CALLBACK_V1 = - ::std::option::Option; -#[doc = " Data required to register an update callback from the RISE."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_RISE_CALLBACK_SETTINGS_V1 { - #[doc = " [in] Structure Version, must always be first."] - pub version: NvU32, - #[doc = " [in] Generic callback parameter which will be passed to the callback."] - pub super_: NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1, - #[doc = " [in] Callback. Pass in NULL or nullptr to indicate request to unregister."] - pub callback: NV_RISE_CALLBACK_V1, - #[doc = " Reserved, must be set to zero by client."] - pub reserved: [NvU8; 32usize], -} -#[doc = " Data required to register an update callback from the RISE."] -pub type NV_RISE_CALLBACK_SETTINGS_V1 = _NV_RISE_CALLBACK_SETTINGS_V1; -#[doc = " Data required to register an update callback from the RISE."] -pub type NV_RISE_CALLBACK_SETTINGS = NV_RISE_CALLBACK_SETTINGS_V1; -#[doc = " Request contents sent to RISE."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_REQUEST_RISE_SETTINGS_V1 { - #[doc = " [in] Structure Version, must always be first."] - pub version: NvU32, - #[doc = " RISE type of content"] - pub contentType: NV_RISE_CONTENT_TYPE, - #[doc = " RISE request content."] - pub content: NvAPI_String, - #[doc = " Is the request fully sent?"] - pub completed: NvBool, - #[doc = " Reserved, must be set to zero by client."] - pub reserved: [NvU8; 32usize], -} -#[doc = " Request contents sent to RISE."] -pub type NV_REQUEST_RISE_SETTINGS_V1 = _NV_REQUEST_RISE_SETTINGS_V1; -#[doc = " Request contents sent to RISE."] -pub type NV_REQUEST_RISE_SETTINGS = NV_REQUEST_RISE_SETTINGS_V1; -#[doc = " Request contents sent to RISE."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_UNINSTALL_RISE_SETTINGS_V1 { - #[doc = " [in] Structure Version, must always be first."] - pub version: NvU32, - #[doc = " Reserved, must be set to zero by client."] - pub reserved: [NvU8; 32usize], -} -#[doc = " Request contents sent to RISE."] -pub type NV_UNINSTALL_RISE_SETTINGS_V1 = _NV_UNINSTALL_RISE_SETTINGS_V1; -#[doc = " Request contents sent to RISE."] -pub type NV_UNINSTALL_RISE_SETTINGS = NV_UNINSTALL_RISE_SETTINGS_V1; diff --git a/nvapi_trace/Cargo.toml b/nvapi_trace/Cargo.toml deleted file mode 100644 index ed86c5453..000000000 --- a/nvapi_trace/Cargo.toml +++ /dev/null @@ -1,29 +0,0 @@ -[package] -name = "nvapi_trace" -version = "0.0.0" -authors = ["Andrzej Janik "] -edition = "2021" - -[lib] -name = "nvapi_trace" -crate-type = ["cdylib"] - -[dependencies] -format = { path = "../format" } -dark_api = { path = "../dark_api" } -cuda_macros = { path = "../cuda_macros" } -cuda_types = { path = "../cuda_types" } -zluda_trace_common = { path = "../zluda_trace_common" } -libloading = "0.8" -paste = "1.0" -unwrap_or = "1.0.1" -cglue = "0.3.5" -dynasm = "5.0" -dynasmrt = "5.0" -rustc-hash = "2.0.0" - -[package.metadata.zluda] -windows_only = true -windows_paths = ["trace/nvapi64.dll"] -windows32_paths = ["trace/nvapi.dll"] -32bit = true diff --git a/nvapi_trace/src/lib.rs b/nvapi_trace/src/lib.rs deleted file mode 100644 index 9fcc8dd06..000000000 --- a/nvapi_trace/src/lib.rs +++ /dev/null @@ -1,704 +0,0 @@ -use libloading::Library; -use rustc_hash::FxHashMap; -use std::{ - collections::hash_map, - ffi::c_void, - mem, ptr, - sync::{LazyLock, Mutex}, -}; -use zluda_trace_common::ReprUsize; - -static GLOBAL_STATE: LazyLock)>> = - LazyLock::new(get_global_state); - -fn get_global_state() -> Option<(Library, Mutex)> { - let cuda_lib = std::env::var("ZLUDA_NVAPI_LIB").ok().unwrap_or_else(|| { - if cfg!(target_pointer_width = "64") { - r"C:\Windows\System32\nvapi64.dll".to_string() - } else { - r"C:\Windows\System32\nvapi.dll".to_string() - } - }); - let lib = zluda_trace_common::dlopen_local_noredirect(cuda_lib).ok()?; - Some((Library::from(lib), Mutex::new(GlobalState::new()))) -} - -struct GlobalState { - thunks: FxHashMap, -} - -impl GlobalState { - fn new() -> Self { - GlobalState { - thunks: FxHashMap::default(), - } - } - - fn get_thunk( - &mut self, - original: *mut c_void, - report_fn: unsafe extern "C" fn(i32, u32), - interface: u32, - ) -> *mut c_void { - match self.thunks.entry(interface) { - hash_map::Entry::Occupied(entry) => *entry.get() as *mut c_void, - hash_map::Entry::Vacant(entry) => { - let thunk = get_thunk(original, report_fn, interface); - entry.insert(thunk as usize); - thunk - } - } - } -} - -macro_rules! interface_to_name { - ($({ $name:literal, $id:literal }),* $(,)?) => { - fn interface_to_name(interface: u32) -> Option<&'static str> { - match interface { - $( - $id => Some($name), - )* - _ => None, - } - } - }; -} - -interface_to_name!( - { "NvAPI_Initialize", 0x0150e828 }, - { "NvAPI_Unload", 0xd22bdd7e }, - { "NvAPI_GetErrorMessage", 0x6c2d048c }, - { "NvAPI_GetInterfaceVersionString", 0x01053fa5 }, - { "NvAPI_GPU_GetEDID", 0x37d32e69 }, - { "NvAPI_SetView", 0x0957d7b6 }, - { "NvAPI_SetViewEx", 0x06b89e68 }, - { "NvAPI_GetDisplayDriverVersion", 0xf951a4d1 }, - { "NvAPI_SYS_GetDriverAndBranchVersion", 0x2926aaad }, - { "NvAPI_GPU_GetMemoryInfo", 0x07f9b368 }, - { "NvAPI_GPU_GetMemoryInfoEx", 0xc0599498 }, - { "NvAPI_OGL_ExpertModeSet", 0x3805ef7a }, - { "NvAPI_OGL_ExpertModeGet", 0x22ed9516 }, - { "NvAPI_OGL_ExpertModeDefaultsSet", 0xb47a657e }, - { "NvAPI_OGL_ExpertModeDefaultsGet", 0xae921f12 }, - { "NvAPI_EnumPhysicalGPUs", 0xe5ac921f }, - { "NvAPI_EnumTCCPhysicalGPUs", 0xd9930b07 }, - { "NvAPI_EnumLogicalGPUs", 0x48b3ea59 }, - { "NvAPI_GetPhysicalGPUsFromDisplay", 0x34ef9506 }, - { "NvAPI_GetPhysicalGPUFromUnAttachedDisplay", 0x5018ed61 }, - { "NvAPI_GetLogicalGPUFromDisplay", 0xee1370cf }, - { "NvAPI_GetLogicalGPUFromPhysicalGPU", 0xadd604d1 }, - { "NvAPI_GetPhysicalGPUsFromLogicalGPU", 0xaea3fa32 }, - { "NvAPI_GetPhysicalGPUFromGPUID", 0x5380ad1a }, - { "NvAPI_GetGPUIDfromPhysicalGPU", 0x6533ea3e }, - { "NvAPI_GPU_GetShaderSubPipeCount", 0x0be17923 }, - { "NvAPI_GPU_GetGpuCoreCount", 0xc7026a87 }, - { "NvAPI_GPU_GetAllOutputs", 0x7d554f8e }, - { "NvAPI_GPU_GetConnectedOutputs", 0x1730bfc9 }, - { "NvAPI_GPU_GetConnectedSLIOutputs", 0x0680de09 }, - { "NvAPI_GPU_GetConnectedDisplayIds", 0x0078dba2 }, - { "NvAPI_GPU_GetAllDisplayIds", 0x785210a2 }, - { "NvAPI_GPU_GetConnectedOutputsWithLidState", 0xcf8caf39 }, - { "NvAPI_GPU_GetConnectedSLIOutputsWithLidState", 0x96043cc7 }, - { "NvAPI_GPU_GetSystemType", 0xbaaabfcc }, - { "NvAPI_GPU_GetActiveOutputs", 0xe3e89b6f }, - { "NvAPI_GPU_SetEDID", 0xe83d6456 }, - { "NvAPI_GPU_GetOutputType", 0x40a505e4 }, - { "NvAPI_GPU_ValidateOutputCombination", 0x34c9c2d4 }, - { "NvAPI_GPU_GetFullName", 0xceee8e9f }, - { "NvAPI_GPU_GetPCIIdentifiers", 0x2ddfb66e }, - { "NvAPI_GPU_GetGPUType", 0xc33baeb1 }, - { "NvAPI_GPU_GetBusType", 0x1bb18724 }, - { "NvAPI_GPU_GetBusId", 0x1be0b8e5 }, - { "NvAPI_GPU_GetBusSlotId", 0x2a0a350f }, - { "NvAPI_GPU_GetIRQ", 0xe4715417 }, - { "NvAPI_GPU_GetVbiosRevision", 0xacc3da0a }, - { "NvAPI_GPU_GetVbiosOEMRevision", 0x2d43fb31 }, - { "NvAPI_GPU_GetVbiosVersionString", 0xa561fd7d }, - { "NvAPI_GPU_GetAGPAperture", 0x6e042794 }, - { "NvAPI_GPU_GetCurrentAGPRate", 0xc74925a0 }, - { "NvAPI_GPU_GetCurrentPCIEDownstreamWidth", 0xd048c3b1 }, - { "NvAPI_GPU_GetPhysicalFrameBufferSize", 0x46fbeb03 }, - { "NvAPI_GPU_GetVirtualFrameBufferSize", 0x5a04b644 }, - { "NvAPI_GPU_GetQuadroStatus", 0xe332fa47 }, - { "NvAPI_GPU_GetBoardInfo", 0x22d54523 }, - { "NvAPI_GPU_GetRamBusWidth", 0x7975c581 }, - { "NvAPI_GPU_GetArchInfo", 0xd8265d24 }, - { "NvAPI_I2CRead", 0x2fde12c5 }, - { "NvAPI_I2CWrite", 0xe812eb07 }, - { "NvAPI_GPU_WorkstationFeatureSetup", 0x6c1f3fe4 }, - { "NvAPI_GPU_WorkstationFeatureQuery", 0x004537df }, - { "NvAPI_GPU_GetHDCPSupportStatus", 0xf089eef5 }, - { "NvAPI_GPU_CudaEnumComputeCapableGpus", 0x5786cc6e }, - { "NvAPI_GPU_GetTachReading", 0x5f608315 }, - { "NvAPI_GPU_GetECCStatusInfo", 0xca1ddaf3 }, - { "NvAPI_GPU_GetECCErrorInfo", 0xc71f85a6 }, - { "NvAPI_GPU_ResetECCErrorInfo", 0xc02eec20 }, - { "NvAPI_GPU_GetECCConfigurationInfo", 0x77a796f3 }, - { "NvAPI_GPU_SetECCConfiguration", 0x1cf639d9 }, - { "NvAPI_GPU_QueryWorkstationFeatureSupport", 0x80b1abb9 }, - { "NvAPI_GPU_SetScanoutIntensity", 0xa57457a4 }, - { "NvAPI_GPU_GetScanoutIntensityState", 0xe81ce836 }, - { "NvAPI_GPU_SetScanoutWarping", 0xb34bab4f }, - { "NvAPI_GPU_GetScanoutWarpingState", 0x6f5435af }, - { "NvAPI_GPU_SetScanoutCompositionParameter", 0xf898247d }, - { "NvAPI_GPU_GetScanoutCompositionParameter", 0x58fe51e6 }, - { "NvAPI_GPU_GetScanoutConfiguration", 0x6a9f5b63 }, - { "NvAPI_GPU_GetScanoutConfigurationEx", 0xe2e1e6f0 }, - { "NvAPI_GPU_GetAdapterIdFromPhysicalGpu", 0x0ff07fde }, - { "NvAPI_GPU_GetVirtualizationInfo", 0x44e022a9 }, - { "NvAPI_GPU_GetLogicalGpuInfo", 0x842b066e }, - { "NvAPI_GPU_GetLicensableFeatures", 0x3fc596aa }, - { "NvAPI_GPU_GetEncoderStatistics", 0xf0a9aeeb }, - { "NvAPI_GPU_GetEncoderSessionsInfo", 0xd8a72ce5 }, - { "NvAPI_GPU_GetGPUInfo", 0xafd1b02c }, - { "NvAPI_GPU_GetVRReadyData", 0x81d629c5 }, - { "NvAPI_GPU_GetGspFeatures", 0x581c4391 }, - { "NvAPI_GPU_GetUUID", 0xdc95673d }, - { "NvAPI_GPU_NVLINK_GetCaps", 0xbef1119d }, - { "NvAPI_GPU_NVLINK_GetStatus", 0xc72a38e3 }, - { "NvAPI_GPU_GetPerfDecreaseInfo", 0x7f7f4600 }, - { "NvAPI_GPU_GetPstatesInfoEx", 0x843c0256 }, - { "NvAPI_GPU_GetPstates20", 0x6ff81213 }, - { "NvAPI_GPU_GetCurrentPstate", 0x927da4f6 }, - { "NvAPI_GPU_GetDynamicPstatesInfoEx", 0x60ded2ed }, - { "NvAPI_GPU_GetThermalSettings", 0xe3640a56 }, - { "NvAPI_GPU_GetAllClockFrequencies", 0xdcb616c3 }, - { "NvAPI_GPU_QueryIlluminationSupport", 0xa629da31 }, - { "NvAPI_GPU_GetIllumination", 0x9a1b9365 }, - { "NvAPI_GPU_SetIllumination", 0x0254a187 }, - { "NvAPI_GPU_ClientIllumDevicesGetInfo", 0xd4100e58 }, - { "NvAPI_GPU_ClientIllumDevicesGetControl", 0x73c01d58 }, - { "NvAPI_GPU_ClientIllumDevicesSetControl", 0x57024c62 }, - { "NvAPI_GPU_ClientIllumZonesGetInfo", 0x4b81241b }, - { "NvAPI_GPU_ClientIllumZonesGetControl", 0x3dbf5764 }, - { "NvAPI_GPU_ClientIllumZonesSetControl", 0x197d065e }, - { "NvAPI_Event_RegisterCallback", 0xe6dbea69 }, - { "NvAPI_Event_UnregisterCallback", 0xde1f9b45 }, - { "NvAPI_EnumNvidiaDisplayHandle", 0x9abdd40d }, - { "NvAPI_EnumNvidiaUnAttachedDisplayHandle", 0x20de9260 }, - { "NvAPI_CreateDisplayFromUnAttachedDisplay", 0x63f9799e }, - { "NvAPI_GetAssociatedNvidiaDisplayHandle", 0x35c29134 }, - { "NvAPI_DISP_GetAssociatedUnAttachedNvidiaDisplayHandle", 0xa70503b2 }, - { "NvAPI_GetAssociatedNvidiaDisplayName", 0x22a78b05 }, - { "NvAPI_GetUnAttachedAssociatedDisplayName", 0x4888d790 }, - { "NvAPI_EnableHWCursor", 0x2863148d }, - { "NvAPI_DisableHWCursor", 0xab163097 }, - { "NvAPI_GetVBlankCounter", 0x67b5db55 }, - { "NvAPI_SetRefreshRateOverride", 0x3092ac32 }, - { "NvAPI_GetAssociatedDisplayOutputId", 0xd995937e }, - { "NvAPI_GetDisplayPortInfo", 0xc64ff367 }, - { "NvAPI_SetDisplayPort", 0xfa13e65a }, - { "NvAPI_GetHDMISupportInfo", 0x6ae16ec3 }, - { "NvAPI_Disp_InfoFrameControl", 0x6067af3f }, - { "NvAPI_Disp_ColorControl", 0x92f9d80d }, - { "NvAPI_Disp_GetHdrCapabilities", 0x84f2a8df }, - { "NvAPI_Disp_HdrColorControl", 0x351da224 }, - { "NvAPI_Disp_SetSourceColorSpace", 0x473b6caf }, - { "NvAPI_Disp_GetSourceColorSpace", 0xceedc85b }, - { "NvAPI_Disp_SetSourceHdrMetadata", 0x905eb63b }, - { "NvAPI_Disp_GetSourceHdrMetadata", 0x0d3f52da }, - { "NvAPI_Disp_SetOutputMode", 0x98e7661a }, - { "NvAPI_Disp_GetOutputMode", 0x81fed88d }, - { "NvAPI_Disp_SetHdrToneMapping", 0xdd6da362 }, - { "NvAPI_Disp_GetHdrToneMapping", 0xfbd36e71 }, - { "NvAPI_Disp_GetColorimetry", 0x00b421ad }, - { "NvAPI_DISP_GetTiming", 0x175167e9 }, - { "NvAPI_DISP_GetMonitorCapabilities", 0x3b05c7e1 }, - { "NvAPI_DISP_GetMonitorColorCapabilities", 0x6ae4cfb5 }, - { "NvAPI_DISP_EnumCustomDisplay", 0xa2072d59 }, - { "NvAPI_DISP_TryCustomDisplay", 0x1f7db630 }, - { "NvAPI_DISP_DeleteCustomDisplay", 0x552e5b9b }, - { "NvAPI_DISP_SaveCustomDisplay", 0x49882876 }, - { "NvAPI_DISP_RevertCustomDisplayTrial", 0xcbbd40f0 }, - { "NvAPI_GetView", 0xd6b99d89 }, - { "NvAPI_GetViewEx", 0xdbbc0af4 }, - { "NvAPI_GetSupportedViews", 0x66fb7fc0 }, - { "NvAPI_DISP_GetDisplayIdByDisplayName", 0xae457190 }, - { "NvAPI_DISP_GetGDIPrimaryDisplayId", 0x1e9d8a31 }, - { "NvAPI_DISP_GetDisplayConfig", 0x11abccf8 }, - { "NvAPI_DISP_SetDisplayConfig", 0x5d8cf8de }, - { "NvAPI_DISP_GetEdidData", 0x436ced76 }, - { "NvAPI_DISP_GetAdaptiveSyncData", 0xb73d1ee9 }, - { "NvAPI_DISP_SetAdaptiveSyncData", 0x3eebba1d }, - { "NvAPI_DISP_GetVirtualRefreshRateData", 0x8c00429a }, - { "NvAPI_DISP_SetVirtualRefreshRateData", 0x5abbe6a3 }, - { "NvAPI_DISP_SetPreferredStereoDisplay", 0xc9d0e25f }, - { "NvAPI_DISP_GetPreferredStereoDisplay", 0x1f6b4666 }, - { "NvAPI_DISP_GetNvManagedDedicatedDisplays", 0xdbdf0cb2 }, - { "NvAPI_DISP_AcquireDedicatedDisplay", 0x47c917ba }, - { "NvAPI_DISP_ReleaseDedicatedDisplay", 0x1247825f }, - { "NvAPI_DISP_GetNvManagedDedicatedDisplayMetadata", 0xd645d80c }, - { "NvAPI_DISP_SetNvManagedDedicatedDisplayMetadata", 0x3d8b129a }, - { "NvAPI_Disp_GetDisplayIdInfo", 0xbae8aa5e }, - { "NvAPI_Disp_GetDisplayIdsFromTarget", 0xe7e5f89e }, - { "NvAPI_Disp_GetVRRInfo", 0xdf8fda57 }, - { "NvAPI_Mosaic_GetSupportedTopoInfo", 0xfdb63c81 }, - { "NvAPI_Mosaic_GetTopoGroup", 0xcb89381d }, - { "NvAPI_Mosaic_GetOverlapLimits", 0x989685f0 }, - { "NvAPI_Mosaic_SetCurrentTopo", 0x9b542831 }, - { "NvAPI_Mosaic_GetCurrentTopo", 0xec32944e }, - { "NvAPI_Mosaic_EnableCurrentTopo", 0x5f1aa66c }, - { "NvAPI_Mosaic_GetDisplayViewportsByResolution", 0xdc6dc8d3 }, - { "NvAPI_Mosaic_SetDisplayGrids", 0x4d959a89 }, - { "NvAPI_Mosaic_ValidateDisplayGrids", 0xcf43903d }, - { "NvAPI_Mosaic_EnumDisplayModes", 0x78db97d7 }, - { "NvAPI_Mosaic_EnumDisplayGrids", 0xdf2887af }, - { "NvAPI_GetSupportedMosaicTopologies", 0x410b5c25 }, - { "NvAPI_GetCurrentMosaicTopology", 0xf60852bd }, - { "NvAPI_SetCurrentMosaicTopology", 0xd54b8989 }, - { "NvAPI_EnableCurrentMosaicTopology", 0x74073cc9 }, - { "NvAPI_GSync_EnumSyncDevices", 0xd9639601 }, - { "NvAPI_GSync_QueryCapabilities", 0x44a3f1d1 }, - { "NvAPI_GSync_GetTopology", 0x4562bc38 }, - { "NvAPI_GSync_SetSyncStateSettings", 0x60acdfdd }, - { "NvAPI_GSync_GetControlParameters", 0x16de1c6a }, - { "NvAPI_GSync_SetControlParameters", 0x8bbff88b }, - { "NvAPI_GSync_AdjustSyncDelay", 0x2d11ff51 }, - { "NvAPI_GSync_GetSyncStatus", 0xf1f5b434 }, - { "NvAPI_GSync_GetStatusParameters", 0x70d404ec }, - { "NvAPI_D3D_GetCurrentSLIState", 0x4b708b54 }, - { "NvAPI_D3D9_RegisterResource", 0xa064bdfc }, - { "NvAPI_D3D9_UnregisterResource", 0xbb2b17aa }, - { "NvAPI_D3D9_AliasSurfaceAsTexture", 0xe5ceae41 }, - { "NvAPI_D3D9_StretchRectEx", 0x22de03aa }, - { "NvAPI_D3D9_ClearRT", 0x332d3942 }, - { "NvAPI_D3D_GetObjectHandleForResource", 0xfceac864 }, - { "NvAPI_D3D_SetResourceHint", 0x6c0ed98c }, - { "NvAPI_D3D_BeginResourceRendering", 0x91123d6a }, - { "NvAPI_D3D_EndResourceRendering", 0x37e7191c }, - { "NvAPI_D3D9_GetSurfaceHandle", 0x0f2dd3f2 }, - { "NvAPI_D3D9_VideoSetStereoInfo", 0xb852f4db }, - { "NvAPI_D3D10_SetDepthBoundsTest", 0x4eadf5d2 }, - { "NvAPI_D3D11_CreateDevice", 0x6a16d3a0 }, - { "NvAPI_D3D11_CreateDeviceAndSwapChain", 0xbb939ee5 }, - { "NvAPI_D3D11_SetDepthBoundsTest", 0x7aaf7a04 }, - { "NvAPI_D3D11_IsNvShaderExtnOpCodeSupported", 0x5f68da40 }, - { "NvAPI_D3D11_SetNvShaderExtnSlot", 0x8e90bb9f }, - { "NvAPI_D3D12_SetNvShaderExtnSlotSpace", 0xac2dfeb5 }, - { "NvAPI_D3D12_SetNvShaderExtnSlotSpaceLocalThread", 0x43d867c0 }, - { "NvAPI_D3D11_SetNvShaderExtnSlotLocalThread", 0x0e6482a0 }, - { "NvAPI_D3D11_BeginUAVOverlapEx", 0xba08208a }, - { "NvAPI_D3D11_BeginUAVOverlap", 0x65b93ca8 }, - { "NvAPI_D3D11_EndUAVOverlap", 0x2216a357 }, - { "NvAPI_D3D11_GetResourceHandle", 0x09d52986 }, - { "NvAPI_D3D_SetFPSIndicatorState", 0xa776e8db }, - { "NvAPI_D3D9_Present", 0x05650beb }, - { "NvAPI_D3D9_QueryFrameCount", 0x9083e53a }, - { "NvAPI_D3D9_ResetFrameCount", 0xfa6a0675 }, - { "NvAPI_D3D9_QueryMaxSwapGroup", 0x5995410d }, - { "NvAPI_D3D9_QuerySwapGroup", 0xeba4d232 }, - { "NvAPI_D3D9_JoinSwapGroup", 0x7d44bb54 }, - { "NvAPI_D3D9_BindSwapBarrier", 0x9c39c246 }, - { "NvAPI_D3D_SetVerticalSyncMode", 0x5526cfd1 }, - { "NvAPI_D3D1x_Present", 0x03b845a1 }, - { "NvAPI_D3D1x_QueryFrameCount", 0x9152e055 }, - { "NvAPI_D3D1x_ResetFrameCount", 0xfbbb031a }, - { "NvAPI_D3D1x_QueryMaxSwapGroup", 0x9bb9d68f }, - { "NvAPI_D3D1x_QuerySwapGroup", 0x407f67aa }, - { "NvAPI_D3D1x_JoinSwapGroup", 0x14610cd7 }, - { "NvAPI_D3D1x_BindSwapBarrier", 0x9de8c729 }, - { "NvAPI_D3D12_QueryPresentBarrierSupport", 0xa15faef7 }, - { "NvAPI_D3D12_CreatePresentBarrierClient", 0x4d815de9 }, - { "NvAPI_D3D12_RegisterPresentBarrierResources", 0xd53c9ef0 }, - { "NvAPI_DestroyPresentBarrierClient", 0x3c5c351b }, - { "NvAPI_JoinPresentBarrier", 0x17f6bf82 }, - { "NvAPI_LeavePresentBarrier", 0xc3ec5a7f }, - { "NvAPI_QueryPresentBarrierFrameStatistics", 0x61b844a1 }, - { "NvAPI_D3D12_CreateDDisplayPresentBarrierClient", 0xb5a21987 }, - { "NvAPI_D3D11_CreateRasterizerState", 0xdb8d28af }, - { "NvAPI_D3D_ConfigureAnsel", 0x341c6c7f }, - { "NvAPI_D3D11_CreateTiledTexture2DArray", 0x7886981a }, - { "NvAPI_D3D11_CheckFeatureSupport", 0x106a487e }, - { "NvAPI_D3D11_CreateImplicitMSAATexture2D", 0xb8f79632 }, - { "NvAPI_D3D12_CreateCommittedImplicitMSAATexture2D", 0x24c6a07b }, - { "NvAPI_D3D11_ResolveSubresourceRegion", 0xe6bfedd6 }, - { "NvAPI_D3D12_ResolveSubresourceRegion", 0xc24a15bf }, - { "NvAPI_D3D11_TiledTexture2DArrayGetDesc", 0xf1a2b9d5 }, - { "NvAPI_D3D11_UpdateTileMappings", 0x9a06ea07 }, - { "NvAPI_D3D11_CopyTileMappings", 0xc09ee6bc }, - { "NvAPI_D3D11_TiledResourceBarrier", 0xd6839099 }, - { "NvAPI_D3D11_AliasMSAATexture2DAsNonMSAA", 0xf1c54fc9 }, - { "NvAPI_D3D11_CreateGeometryShaderEx_2", 0x99ed5c1c }, - { "NvAPI_D3D11_CreateVertexShaderEx", 0x0beaa0b2 }, - { "NvAPI_D3D11_CreateHullShaderEx", 0xb53cab00 }, - { "NvAPI_D3D11_CreateDomainShaderEx", 0xa0d7180d }, - { "NvAPI_D3D11_CreatePixelShaderEx_2", 0x4162822b }, - { "NvAPI_D3D11_CreateFastGeometryShaderExplicit", 0x71ab7c9c }, - { "NvAPI_D3D11_CreateFastGeometryShader", 0x525d43be }, - { "NvAPI_D3D11_DecompressView", 0x3a94e822 }, - { "NvAPI_D3D12_CreateGraphicsPipelineState", 0x2fc28856 }, - { "NvAPI_D3D12_CreateComputePipelineState", 0x2762deac }, - { "NvAPI_D3D12_SetDepthBoundsTestValues", 0xb9333fe9 }, - { "NvAPI_D3D12_CreateReservedResource", 0x2c85f101 }, - { "NvAPI_D3D12_CreateHeap", 0x5cb397cf }, - { "NvAPI_D3D12_CreateHeap2", 0x924be9d6 }, - { "NvAPI_D3D12_QueryCpuVisibleVidmem", 0x26322bc3 }, - { "NvAPI_D3D12_ReservedResourceGetDesc", 0x9aa2aabb }, - { "NvAPI_D3D12_UpdateTileMappings", 0xc6017a7d }, - { "NvAPI_D3D12_CopyTileMappings", 0x47f78194 }, - { "NvAPI_D3D12_ResourceAliasingBarrier", 0xb942bab7 }, - { "NvAPI_D3D12_CaptureUAVInfo", 0x6e5ea9db }, - { "NvAPI_D3D11_GetResourceGPUVirtualAddressEx", 0xaf6d14da }, - { "NvAPI_D3D11_EnumerateMetaCommands", 0xc7453ba8 }, - { "NvAPI_D3D11_CreateMetaCommand", 0xf505fba0 }, - { "NvAPI_D3D11_InitializeMetaCommand", 0xaec629e9 }, - { "NvAPI_D3D11_ExecuteMetaCommand", 0x82236c47 }, - { "NvAPI_D3D12_EnumerateMetaCommands", 0xcd9141d8 }, - { "NvAPI_D3D12_CreateMetaCommand", 0xeb29634b }, - { "NvAPI_D3D12_InitializeMetaCommand", 0xa4125399 }, - { "NvAPI_D3D12_ExecuteMetaCommand", 0xde24fc3d }, - { "NvAPI_D3D12_CreateCommittedResource", 0x027e98ae }, - { "NvAPI_D3D12_GetCopyableFootprints", 0xf6305eb5 }, - { "NvAPI_D3D12_CopyTextureRegion", 0x82b91b25 }, - { "NvAPI_D3D12_IsNvShaderExtnOpCodeSupported", 0x3dfacec8 }, - { "NvAPI_D3D12_GetOptimalThreadCountForMesh", 0xb43995cb }, - { "NvAPI_D3D_IsGSyncCapable", 0x9c1eed78 }, - { "NvAPI_D3D_IsGSyncActive", 0xe942b0ff }, - { "NvAPI_D3D12_SetFlipConfig", 0xf3148c42 }, - { "NvAPI_D3D1x_DisableShaderDiskCache", 0xd0cbca7d }, - { "NvAPI_D3D11_MultiGPU_GetCaps", 0xd2d25687 }, - { "NvAPI_D3D11_MultiGPU_Init", 0x017be49e }, - { "NvAPI_D3D11_CreateMultiGPUDevice", 0xbdb20007 }, - { "NvAPI_D3D_QuerySinglePassStereoSupport", 0x6f5f0a6d }, - { "NvAPI_D3D_SetSinglePassStereoMode", 0xa39e6e6e }, - { "NvAPI_D3D12_QuerySinglePassStereoSupport", 0x3b03791b }, - { "NvAPI_D3D12_SetSinglePassStereoMode", 0x83556d87 }, - { "NvAPI_D3D_QueryMultiViewSupport", 0xb6e0a41c }, - { "NvAPI_D3D_SetMultiViewMode", 0x8285c8da }, - { "NvAPI_D3D_QueryModifiedWSupport", 0xcbf9f4f5 }, - { "NvAPI_D3D_SetModifiedWMode", 0x06ea4bf4 }, - { "NvAPI_D3D12_QueryModifiedWSupport", 0x51235248 }, - { "NvAPI_D3D12_SetModifiedWMode", 0xe1fdaba7 }, - { "NvAPI_D3D_CreateLateLatchObject", 0x2db27d09 }, - { "NvAPI_D3D_QueryLateLatchSupport", 0x8ceca0ec }, - { "NvAPI_D3D_RegisterDevice", 0x8c02c4d0 }, - { "NvAPI_D3D11_MultiDrawInstancedIndirect", 0xd4e26bbf }, - { "NvAPI_D3D11_MultiDrawIndexedInstancedIndirect", 0x59e890f9 }, - { "NvAPI_D3D_ImplicitSLIControl", 0x2aede111 }, - { "NvAPI_D3D12_GetNeedsAppFPBlendClamping", 0x6ef4d2d1 }, - { "NvAPI_D3D12_UseDriverHeapPriorities", 0xf0d978a8 }, - { "NvAPI_D3D12_Mosaic_GetCompanionAllocations", 0xa46022c7 }, - { "NvAPI_D3D12_Mosaic_GetViewportAndGpuPartitions", 0xb092b818 }, - { "NvAPI_D3D1x_GetGraphicsCapabilities", 0x52b1499a }, - { "NvAPI_D3D12_GetGraphicsCapabilities", 0x01e87354 }, - { "NvAPI_D3D11_RSSetExclusiveScissorRects", 0xae4d73ef }, - { "NvAPI_D3D11_RSSetViewportsPixelShadingRates", 0x34f7938f }, - { "NvAPI_D3D11_CreateShadingRateResourceView", 0x99ca2dff }, - { "NvAPI_D3D11_RSSetShadingRateResourceView", 0x1b0c2f83 }, - { "NvAPI_D3D11_RSGetPixelShadingRateSampleOrder", 0x092442a1 }, - { "NvAPI_D3D11_RSSetPixelShadingRateSampleOrder", 0xa942373a }, - { "NvAPI_D3D_InitializeVRSHelper", 0x4780d70b }, - { "NvAPI_D3D_InitializeNvGazeHandler", 0x5b3b7479 }, - { "NvAPI_D3D_InitializeSMPAssist", 0x42763d0c }, - { "NvAPI_D3D_QuerySMPAssistSupport", 0xc57921de }, - { "NvAPI_D3D_GetSleepStatus", 0xaef96ca1 }, - { "NvAPI_D3D_SetSleepMode", 0xac1ca9e0 }, - { "NvAPI_D3D_Sleep", 0x852cd1d2 }, - { "NvAPI_D3D_SetReflexSync", 0xb9f6faff }, - { "NvAPI_D3D_GetLatency", 0x1a587f9c }, - { "NvAPI_D3D_SetLatencyMarker", 0xd9984c05 }, - { "NvAPI_D3D12_SetAsyncFrameMarker", 0x13c98f73 }, - { "NvAPI_D3D11_SetAsyncFrameMarker", 0x59c2c510 }, - { "NvAPI_D3D12_NotifyOutOfBandCommandQueue", 0x03d6e8cb }, - { "NvAPI_D3D12_SetCreateCommandQueueLowLatencyHint", 0x548c224f }, - { "NvAPI_D3D12_CreateCubinComputeShaderExV2", 0x299f5fdc }, - { "NvAPI_D3D12_CreateCubinComputeShader", 0x2a2c79e8 }, - { "NvAPI_D3D12_CreateCubinComputeShaderEx", 0x3151211b }, - { "NvAPI_D3D12_CreateCubinComputeShaderWithName", 0x1dc7261f }, - { "NvAPI_D3D12_LaunchCubinShader", 0x5c52bb86 }, - { "NvAPI_D3D12_DestroyCubinComputeShader", 0x7fb785ba }, - { "NvAPI_D3D12_GetCudaMergedTextureSamplerObject", 0x329fe6e0 }, - { "NvAPI_D3D12_GetCudaIndependentDescriptorObject", 0x0ddac234 }, - { "NvAPI_D3D12_GetCudaTextureObject", 0x80403fc9 }, - { "NvAPI_D3D12_GetCudaSurfaceObject", 0x48f5b2ee }, - { "NvAPI_D3D12_IsFatbinPTXSupported", 0x70c07832 }, - { "NvAPI_D3D12_CreateCuModule", 0xad1a677d }, - { "NvAPI_D3D12_EnumFunctionsInModule", 0x7ab88d88 }, - { "NvAPI_D3D12_CreateCuFunction", 0xe2436e22 }, - { "NvAPI_D3D12_LaunchCuKernelChain", 0x24973538 }, - { "NvAPI_D3D12_LaunchCuKernelChainEx", 0x846a9bf0 }, - { "NvAPI_D3D12_DestroyCuModule", 0x41c65285 }, - { "NvAPI_D3D12_DestroyCuFunction", 0xdf295ea6 }, - { "NvAPI_D3D11_CreateCubinComputeShaderExV2", 0xf2c71d48 }, - { "NvAPI_D3D11_CreateCubinComputeShader", 0x0ed98181 }, - { "NvAPI_D3D11_CreateCubinComputeShaderEx", 0x32c2a0f6 }, - { "NvAPI_D3D11_CreateCubinComputeShaderWithName", 0xb672be19 }, - { "NvAPI_D3D11_LaunchCubinShader", 0x427e236d }, - { "NvAPI_D3D11_DestroyCubinComputeShader", 0x01682c86 }, - { "NvAPI_D3D11_IsFatbinPTXSupported", 0x6086bd93 }, - { "NvAPI_D3D11_GetCudaIndependentViewObject", 0x34d2afa8 }, - { "NvAPI_D3D11_GetCudaMergedTextureSamplerObject", 0x5d637d8f }, - { "NvAPI_D3D11_CreateUnorderedAccessView", 0x74a497a1 }, - { "NvAPI_D3D11_CreateShaderResourceView", 0x65cb431e }, - { "NvAPI_D3D11_CreateSamplerState", 0x89eca416 }, - { "NvAPI_D3D11_GetCudaTextureObject", 0x9006fa68 }, - { "NvAPI_D3D11_GetResourceGPUVirtualAddress", 0x1819b423 }, - { "NvAPI_D3D12_GetRaytracingCaps", 0x85a6c2a0 }, - { "NvAPI_D3D12_EnableRaytracingValidation", 0x1de5991b }, - { "NvAPI_D3D12_RegisterRaytracingValidationMessageCallback", 0x8554eb38 }, - { "NvAPI_D3D12_UnregisterRaytracingValidationMessageCallback", 0x26975da6 }, - { "NvAPI_D3D12_FlushRaytracingValidationMessages", 0xb8fb1fcb }, - { "NvAPI_D3D12_GetRaytracingDisplacementMicromapArrayPrebuildInfo", 0xfa99b6de }, - { "NvAPI_D3D12_GetRaytracingOpacityMicromapArrayPrebuildInfo", 0x4726d180 }, - { "NvAPI_D3D12_SetCreatePipelineStateOptions", 0x5c607a27 }, - { "NvAPI_D3D12_CheckDriverMatchingIdentifierEx", 0xafb237d4 }, - { "NvAPI_D3D12_GetRaytracingAccelerationStructurePrebuildInfoEx", 0x8d025b77 }, - { "NvAPI_D3D12_BuildRaytracingOpacityMicromapArray", 0x814f8d11 }, - { "NvAPI_D3D12_RelocateRaytracingOpacityMicromapArray", 0x0425c538 }, - { "NvAPI_D3D12_BuildRaytracingDisplacementMicromapArray", 0x066f569d }, - { "NvAPI_D3D12_RelocateRaytracingDisplacementMicromapArray", 0x1c142308 }, - { "NvAPI_D3D12_EmitRaytracingDisplacementMicromapArrayPostbuildInfo", 0x68b9a790 }, - { "NvAPI_D3D12_EmitRaytracingOpacityMicromapArrayPostbuildInfo", 0x1d9a39b6 }, - { "NvAPI_D3D12_BuildRaytracingAccelerationStructureEx", 0xe24ead45 }, - { "NvAPI_D3D12_QueryWorkstationFeatureProperties", 0xa92ea23a }, - { "NvAPI_D3D12_CreateCommittedRDMABuffer", 0xe78dcb44 }, - { "NvAPI_D3D12_ConvertCooperativeVectorMatrix", 0x0f252cb3 }, - { "NvAPI_D3D12_ConvertCooperativeVectorMatrixMultiple", 0x96ba5235 }, - { "NvAPI_D3D12_GetPhysicalDeviceCooperativeVectorProperties", 0x8f182aec }, - { "NvAPI_D3D12_GetRaytracingMultiIndirectClusterOperationRequirementsInfo", 0x5c9163f4 }, - { "NvAPI_D3D12_RaytracingExecuteMultiIndirectClusterOperation", 0x67c798af }, - { "NvAPI_D3D12_GetRaytracingPartitionedTlasIndirectPrebuildInfo", 0xcdfdc5f2 }, - { "NvAPI_D3D12_BuildRaytracingPartitionedTlasIndirect", 0x7cfc6fc3 }, - { "NvAPI_NGX_GetNGXOverrideState", 0x3fd96fba }, - { "NvAPI_NGX_SetNGXOverrideState", 0xb60fcb4e }, - { "NvAPI_DirectD3D12GraphicsCommandList_Create", 0x74a4e712 }, - { "NvAPI_DirectD3D12GraphicsCommandList_Release", 0x99da3dde }, - { "NvAPI_DirectD3D12GraphicsCommandList_Reset", 0x999c26d8 }, - { "NvAPI_VIO_GetCapabilities", 0x1dc91303 }, - { "NvAPI_VIO_Open", 0x44ee4841 }, - { "NvAPI_VIO_Close", 0xd01bd237 }, - { "NvAPI_VIO_Status", 0x0e6ce4f1 }, - { "NvAPI_VIO_SyncFormatDetect", 0x118d48a3 }, - { "NvAPI_VIO_GetConfig", 0xd34a789b }, - { "NvAPI_VIO_SetConfig", 0x0e4eec07 }, - { "NvAPI_VIO_SetCSC", 0xa1ec8d74 }, - { "NvAPI_VIO_GetCSC", 0x7b0d72a3 }, - { "NvAPI_VIO_SetGamma", 0x964bf452 }, - { "NvAPI_VIO_GetGamma", 0x51d53d06 }, - { "NvAPI_VIO_SetSyncDelay", 0x2697a8d1 }, - { "NvAPI_VIO_GetSyncDelay", 0x462214a9 }, - { "NvAPI_VIO_GetPCIInfo", 0xb981d935 }, - { "NvAPI_VIO_IsRunning", 0x96bd040e }, - { "NvAPI_VIO_Start", 0xcde8e1a3 }, - { "NvAPI_VIO_Stop", 0x6ba2a5d6 }, - { "NvAPI_VIO_IsFrameLockModeCompatible", 0x7bf0a94d }, - { "NvAPI_VIO_EnumDevices", 0xfd7c5557 }, - { "NvAPI_VIO_QueryTopology", 0x869534e2 }, - { "NvAPI_VIO_EnumSignalFormats", 0xead72fe4 }, - { "NvAPI_VIO_EnumDataFormats", 0x221fa8e8 }, - { "NvAPI_Stereo_CreateConfigurationProfileRegistryKey", 0xbe7692ec }, - { "NvAPI_Stereo_DeleteConfigurationProfileRegistryKey", 0xf117b834 }, - { "NvAPI_Stereo_SetConfigurationProfileValue", 0x24409f48 }, - { "NvAPI_Stereo_DeleteConfigurationProfileValue", 0x49bceecf }, - { "NvAPI_Stereo_Enable", 0x239c4545 }, - { "NvAPI_Stereo_Disable", 0x2ec50c2b }, - { "NvAPI_Stereo_IsEnabled", 0x348ff8e1 }, - { "NvAPI_Stereo_GetStereoSupport", 0x296c434d }, - { "NvAPI_Stereo_CreateHandleFromIUnknown", 0xac7e37f4 }, - { "NvAPI_Stereo_DestroyHandle", 0x3a153134 }, - { "NvAPI_Stereo_Activate", 0xf6a1ad68 }, - { "NvAPI_Stereo_Deactivate", 0x2d68de96 }, - { "NvAPI_Stereo_IsActivated", 0x1fb0bc30 }, - { "NvAPI_Stereo_GetSeparation", 0x451f2134 }, - { "NvAPI_Stereo_SetSeparation", 0x5c069fa3 }, - { "NvAPI_Stereo_DecreaseSeparation", 0xda044458 }, - { "NvAPI_Stereo_IncreaseSeparation", 0xc9a8ecec }, - { "NvAPI_Stereo_GetConvergence", 0x4ab00934 }, - { "NvAPI_Stereo_SetConvergence", 0x3dd6b54b }, - { "NvAPI_Stereo_DecreaseConvergence", 0x4c87e317 }, - { "NvAPI_Stereo_IncreaseConvergence", 0xa17daabe }, - { "NvAPI_Stereo_GetFrustumAdjustMode", 0xe6839b43 }, - { "NvAPI_Stereo_SetFrustumAdjustMode", 0x7be27fa2 }, - { "NvAPI_Stereo_CaptureJpegImage", 0x932cb140 }, - { "NvAPI_Stereo_InitActivation", 0xc7177702 }, - { "NvAPI_Stereo_Trigger_Activation", 0x0d6c6cd2 }, - { "NvAPI_Stereo_CapturePngImage", 0x8b7e99b5 }, - { "NvAPI_Stereo_ReverseStereoBlitControl", 0x3cd58f89 }, - { "NvAPI_Stereo_SetNotificationMessage", 0x6b9b409e }, - { "NvAPI_Stereo_SetActiveEye", 0x96eea9f8 }, - { "NvAPI_Stereo_SetDriverMode", 0x5e8f0bec }, - { "NvAPI_Stereo_GetEyeSeparation", 0xce653127 }, - { "NvAPI_Stereo_IsWindowedModeSupported", 0x40c8ed5e }, - { "NvAPI_Stereo_SetSurfaceCreationMode", 0xf5dcfcba }, - { "NvAPI_Stereo_GetSurfaceCreationMode", 0x36f1c736 }, - { "NvAPI_Stereo_Debug_WasLastDrawStereoized", 0xed4416c5 }, - { "NvAPI_Stereo_SetDefaultProfile", 0x44f0ecd1 }, - { "NvAPI_Stereo_GetDefaultProfile", 0x624e21c2 }, - { "NvAPI_D3D1x_CreateSwapChain", 0x1bc21b66 }, - { "NvAPI_D3D9_CreateSwapChain", 0x1a131e09 }, - { "NvAPI_Vulkan_InitLowLatencyDevice", 0x5c1696b6 }, - { "NvAPI_Vulkan_DestroyLowLatencyDevice", 0x11a5932b }, - { "NvAPI_Vulkan_GetSleepStatus", 0xadf966af }, - { "NvAPI_Vulkan_SetSleepMode", 0x2acfd162 }, - { "NvAPI_Vulkan_Sleep", 0x36732b1e }, - { "NvAPI_Vulkan_GetLatency", 0x3233d44a }, - { "NvAPI_Vulkan_SetLatencyMarker", 0xa17d13d6 }, - { "NvAPI_Vulkan_NotifyOutOfBandVkQueue", 0x5d6d3840 }, - { "NvAPI_DRS_CreateSession", 0x0694d52e }, - { "NvAPI_DRS_DestroySession", 0xdad9cff8 }, - { "NvAPI_DRS_LoadSettings", 0x375dbd6b }, - { "NvAPI_DRS_SaveSettings", 0xfcbc7e14 }, - { "NvAPI_DRS_LoadSettingsFromFile", 0xd3ede889 }, - { "NvAPI_DRS_SaveSettingsToFile", 0x2be25df8 }, - { "NvAPI_DRS_CreateProfile", 0xcc176068 }, - { "NvAPI_DRS_DeleteProfile", 0x17093206 }, - { "NvAPI_DRS_SetCurrentGlobalProfile", 0x1c89c5df }, - { "NvAPI_DRS_GetCurrentGlobalProfile", 0x617bff9f }, - { "NvAPI_DRS_GetProfileInfo", 0x61cd6fd6 }, - { "NvAPI_DRS_SetProfileInfo", 0x16abd3a9 }, - { "NvAPI_DRS_FindProfileByName", 0x7e4a9a0b }, - { "NvAPI_DRS_EnumProfiles", 0xbc371ee0 }, - { "NvAPI_DRS_GetNumProfiles", 0x1dae4fbc }, - { "NvAPI_DRS_CreateApplication", 0x4347a9de }, - { "NvAPI_DRS_DeleteApplicationEx", 0xc5ea85a1 }, - { "NvAPI_DRS_DeleteApplication", 0x2c694bc6 }, - { "NvAPI_DRS_GetApplicationInfo", 0xed1f8c69 }, - { "NvAPI_DRS_EnumApplications", 0x7fa2173a }, - { "NvAPI_DRS_FindApplicationByName", 0xeee566b2 }, - { "NvAPI_DRS_SetSetting", 0x577dd202 }, - { "NvAPI_DRS_GetSetting", 0x73bf8338 }, - { "NvAPI_DRS_EnumSettings", 0xae3039da }, - { "NvAPI_DRS_EnumAvailableSettingIds", 0xf020614a }, - { "NvAPI_DRS_EnumAvailableSettingValues", 0x2ec39f90 }, - { "NvAPI_DRS_GetSettingIdFromName", 0xcb7309cd }, - { "NvAPI_DRS_GetSettingNameFromId", 0xd61cbe6e }, - { "NvAPI_DRS_DeleteProfileSetting", 0xe4a26362 }, - { "NvAPI_DRS_RestoreAllDefaults", 0x5927b094 }, - { "NvAPI_DRS_RestoreProfileDefault", 0xfa5f6134 }, - { "NvAPI_DRS_RestoreProfileDefaultSetting", 0x53f0381e }, - { "NvAPI_DRS_GetBaseProfile", 0xda8466a0 }, - { "NvAPI_SYS_GetChipSetInfo", 0x53dabbca }, - { "NvAPI_SYS_GetLidAndDockInfo", 0xcda14d8a }, - { "NvAPI_SYS_GetDisplayIdFromGpuAndOutputId", 0x08f2bab4 }, - { "NvAPI_SYS_GetGpuAndOutputIdFromDisplayId", 0x112ba1a5 }, - { "NvAPI_SYS_GetPhysicalGpuFromDisplayId", 0x9ea74659 }, - { "NvAPI_SYS_GetDisplayDriverInfo", 0x721faceb }, - { "NvAPI_SYS_GetPhysicalGPUs", 0xd3b24d2d }, - { "NvAPI_SYS_GetLogicalGPUs", 0xccfffc10 }, - { "NvAPI_NGX_GetDriverFeatureSupport", 0x6194b19d }, - { "NvAPI_GPU_ClientRegisterForUtilizationSampleUpdates", 0xadeeaf67 }, - { "NvAPI_RegisterRiseCallback", 0x9cfe8f94 }, - { "NvAPI_RequestRise", 0x5047de98 }, - { "NvAPI_UninstallRise", 0xab8d09f6 }, -); - -#[no_mangle] -pub unsafe extern "C" fn nvapi_QueryInterface(interface: u32) -> *mut c_void { - let maybe_fn_ptr_global = (&*GLOBAL_STATE).as_ref().and_then(|(lib, state)| { - let fn_ptr = lib - .get:: *mut c_void>(b"nvapi_QueryInterface\0") - .ok()?; - Some((fn_ptr, state)) - }); - let (fn_ptr, global_state) = - unwrap_or::unwrap_some_or!(maybe_fn_ptr_global, return ptr::null_mut()); - let export_table = unwrap_or::unwrap_some_or!( - ::zluda_trace_common::get_export_table(), - return ptr::null_mut() - ); - let format_args = dark_api::FnFfiWrapper(|| { - use std::io::Write; - let mut writer = Vec::new(); - let name = interface_to_name(interface); - match name { - Some(name) => write!(&mut writer, "(interface: {})", name).ok(), - None => write!(&mut writer, "(interface: {:#010x})", interface).ok(), - }; - dark_api::ByteVecFfi::new(writer) - }); - let underlying_fn = dark_api::FnFfiWrapper(|| { - let result = fn_ptr(interface); - result as usize - }); - let original: *mut c_void = ReprUsize::from_usize(export_table.logged_call( - cglue::slice::CSliceRef::from_str("nvapi_QueryInterface"), - 0, - cglue::trait_obj!(&format_args as dark_api::FnFfi), - cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), - ptr::null_mut::() as usize, - <*mut c_void as ReprUsize>::format_status, - )); - if cfg!(target_pointer_width = "32") && !original.is_null() { - global_state - .lock() - .ok() - .map(|mut state| state.get_thunk(original, report_fn, interface)) - .unwrap_or_else(|| get_thunk(original, report_fn, interface)) - } else { - original - } -} - -unsafe extern "C" fn report_fn(result: i32, interface: u32) { - let export_table = unwrap_or::unwrap_some_or!(::zluda_trace_common::get_export_table(), return); - let format_args = - dark_api::FnFfiWrapper(|| dark_api::ByteVecFfi::new("(...)".as_bytes().to_vec())); - let underlying_fn = dark_api::FnFfiWrapper(|| ReprUsize::to_usize(result)); - let (fn_name, interface) = match interface_to_name(interface) { - Some(name) => (name, 0), - None => ("", interface), - }; - export_table.logged_call( - cglue::slice::CSliceRef::from_str(fn_name), - interface, - cglue::trait_obj!(&format_args as dark_api::FnFfi), - cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), - ::INTERNAL_ERROR, - ::format_status, - ); -} - -#[cfg(target_arch = "x86")] -pub fn get_thunk( - original_fn: *mut c_void, - report_fn: unsafe extern "C" fn(i32, u32), - interface: u32, -) -> *mut c_void { - use dynasmrt::{dynasm, DynasmApi}; - let mut ops = dynasmrt::x86::Assembler::new().unwrap(); - let start = ops.offset(); - dynasm!(ops - ; .arch x86 - ; push ebp - ; mov ebp, esp - ; push DWORD [ebp+68] - ; push DWORD [ebp+64] - ; push DWORD [ebp+60] - ; push DWORD [ebp+56] - ; push DWORD [ebp+52] - ; push DWORD [ebp+48] - ; push DWORD [ebp+44] - ; push DWORD [ebp+40] - ; push DWORD [ebp+36] - ; push DWORD [ebp+32] - ; push DWORD [ebp+28] - ; push DWORD [ebp+24] - ; push DWORD [ebp+20] - ; push DWORD [ebp+16] - ; push DWORD [ebp+12] - ; push DWORD [ebp+8] - ; mov eax, original_fn as i32 - ; call eax - ; push interface as i32 - ; push eax - ; mov eax, report_fn as i32 - ; call eax - ; pop eax - ; leave - ; ret - ; int 3 - ); - let exe_buf = ops.finalize().unwrap(); - let result_fn = exe_buf.ptr(start); - std::mem::forget(exe_buf); - result_fn as *mut _ -} - -#[cfg(target_arch = "x86_64")] -pub fn get_thunk( - _original_fn: *mut c_void, - _report_fn: unsafe extern "C" fn(i32, u32), - _interface: u32, -) -> *mut c_void { - todo!() -} diff --git a/ptx/lib/zluda_ptx_impl.bc b/ptx/lib/zluda_ptx_impl.bc index 4e3e75df4..f6e7ca246 100644 --- a/ptx/lib/zluda_ptx_impl.bc +++ b/ptx/lib/zluda_ptx_impl.bc @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:cc872660a9289e0796b6f8de1cb0a51bf62c895d9ac0f2eaf680d7a46628d470 -size 45052 +oid sha256:04a280e445b8566fcddc9257efd426d7fd37d12a80be53b4be5116ab7fecb7cf +size 45728 diff --git a/ptx/lib/zluda_ptx_impl.cpp b/ptx/lib/zluda_ptx_impl.cpp index 96c41ec44..2b293f91f 100644 --- a/ptx/lib/zluda_ptx_impl.cpp +++ b/ptx/lib/zluda_ptx_impl.cpp @@ -16,6 +16,7 @@ ninja clang llvm-dis llvm-as then cd to the directory with this file and run this simple command: ../../ext/llvm-project/build/bin/clang \ + -DHIP_ENABLE_WARP_SYNC_BUILTINS \ -std=c++20 \ -Xclang -fdenormal-fp-math=dynamic \ -Wall -Wextra -Wsign-compare -Wconversion \ @@ -48,9 +49,9 @@ then cd to the directory with this file and run this simple command: #include #include #include +#include #include -#define GLOBAL_SPACE __attribute__((address_space(1))) #define SHARED_SPACE __attribute__((address_space(3))) #define CONSTANT_SPACE __attribute__((address_space(4))) @@ -653,6 +654,16 @@ extern "C" return ballot(value, true); } + uint32_t FUNC(match_any_sync_b32)(uint32_t value, uint32_t membermask __attribute__((unused))) + { + return uint32_t(__match_any(value)); + } + + uint32_t FUNC(match_any_sync_b64)(uint64_t value, uint32_t membermask __attribute__((unused))) + { + return uint32_t(__match_any(value)); + } + #define REDUX_SYNC_TYPE_IMPL(reducer, ptx_type, amd_type, cpp_type) \ cpp_type __ockl_wfred_##reducer##_##amd_type(cpp_type) __device__; \ cpp_type FUNC(redux_sync_##reducer##_##ptx_type)(cpp_type src, uint32_t membermask __attribute__((unused))) \ @@ -1035,25 +1046,25 @@ extern "C" c; } - static std::pair get_image_and_sampler(uint64_t texobj) __device__ + static std::pair get_image_and_sampler(uint64_t texobj) __device__ { - unsigned int GLOBAL_SPACE *image = (unsigned int GLOBAL_SPACE *)texobj; - unsigned int GLOBAL_SPACE *sampler = image + HIP_SAMPLER_OBJECT_OFFSET_DWORD; + unsigned int CONSTANT_SPACE *image = (unsigned int CONSTANT_SPACE *)texobj; + unsigned int ADDRESS_SPACE_CONSTANT *sampler = image + HIP_SAMPLER_OBJECT_OFFSET_DWORD; return {image, sampler}; } - static v4f32 sample_1D(GLOBAL_SPACE void *image, GLOBAL_SPACE void *sampler, float coord) __device__ + static v4f32 sample_1D(CONSTANT_SPACE void *image, CONSTANT_SPACE void *sampler, float coord) __device__ { __device__ v4f32 __llvm_amdgcn_image_sample_lz_1d_v4f32_f32(uint32_t, float, v8s32, v4s32, bool, int, int) __asm("llvm.amdgcn.image.sample.lz.1d.v4f32.f32"); - GLOBAL_SPACE v8s32 *image_typed = (GLOBAL_SPACE v8s32 *)image; - GLOBAL_SPACE v4s32 *sampler_typed = (GLOBAL_SPACE v4s32 *)sampler; + CONSTANT_SPACE v8s32 *image_typed = (CONSTANT_SPACE v8s32 *)image; + CONSTANT_SPACE v4s32 *sampler_typed = (CONSTANT_SPACE v4s32 *)sampler; return __llvm_amdgcn_image_sample_lz_1d_v4f32_f32(0xf, coord, *image_typed, *sampler_typed, false, 0, 0); } - static v4f32 sample_1Db(GLOBAL_SPACE void *image, s32 coord) __device__ + static v4f32 sample_1Db(CONSTANT_SPACE void *image, s32 coord) __device__ { __device__ v4f32 __llvm_amdgcn_struct_buffer_load_format_v4f32(v4s32, int, int, int, int) __asm("llvm.amdgcn.struct.buffer.load.format.v4f32"); - GLOBAL_SPACE v4s32 *image_typed = (GLOBAL_SPACE v4s32 *)image; + CONSTANT_SPACE v4s32 *image_typed = (CONSTANT_SPACE v4s32 *)image; return __llvm_amdgcn_struct_buffer_load_format_v4f32(*image_typed, coord, 0, 0, 0); } #define tex_1d(RETURN_TYPE) \ @@ -1063,7 +1074,7 @@ extern "C" auto result = sample_1D(i, s, coord.x); \ return v4##RETURN_TYPE{std::bit_cast(result.x), std::bit_cast(result.y), std::bit_cast(result.z), std::bit_cast(result.w)}; \ } \ - v4##RETURN_TYPE FUNC(texref_1d_v4_##RETURN_TYPE##_f32)(struct textureReference GLOBAL_SPACE * texref, v1f32 coord) \ + v4##RETURN_TYPE FUNC(texref_1d_v4_##RETURN_TYPE##_f32)(struct textureReference CONSTANT_SPACE * texref, v1f32 coord) \ { \ return FUNC_CALL(texobj_1d_v4_##RETURN_TYPE##_f32)(uint64_t(texref->textureObject), coord); \ } @@ -1074,7 +1085,7 @@ extern "C" auto result = sample_1Db(i, coord.x); \ return v4##RETURN_TYPE{std::bit_cast(result.x), std::bit_cast(result.y), std::bit_cast(result.z), std::bit_cast(result.w)}; \ } \ - v4##RETURN_TYPE FUNC(texref_1d_v4_##RETURN_TYPE##_s32)(struct textureReference GLOBAL_SPACE * texref, v1s32 coord) \ + v4##RETURN_TYPE FUNC(texref_1d_v4_##RETURN_TYPE##_s32)(struct textureReference CONSTANT_SPACE * texref, v1s32 coord) \ { \ return FUNC_CALL(texobj_1d_v4_##RETURN_TYPE##_s32)(uint64_t(texref->textureObject), coord); \ } @@ -1084,11 +1095,11 @@ extern "C" tex_1db(s32); tex_1db(f32); - static v4f32 sample_2D(GLOBAL_SPACE void *image, GLOBAL_SPACE void *sampler, v2f32 coord) __device__ + static v4f32 sample_2D(CONSTANT_SPACE void *image, CONSTANT_SPACE void *sampler, v2f32 coord) __device__ { __device__ v4f32 __llvm_amdgcn_image_sample_lz_2d_v4f32_f32(uint32_t, float, float, v8s32, v4s32, bool, int, int) __asm("llvm.amdgcn.image.sample.lz.2d.v4f32.f32"); - GLOBAL_SPACE v8s32 *image_typed = (GLOBAL_SPACE v8s32 *)image; - GLOBAL_SPACE v4s32 *sampler_typed = (GLOBAL_SPACE v4s32 *)sampler; + CONSTANT_SPACE v8s32 *image_typed = (CONSTANT_SPACE v8s32 *)image; + CONSTANT_SPACE v4s32 *sampler_typed = (CONSTANT_SPACE v4s32 *)sampler; return __llvm_amdgcn_image_sample_lz_2d_v4f32_f32(0xf, coord.x, coord.y, *image_typed, *sampler_typed, false, 0, 0); } #define tex_2d(RETURN_TYPE, COORD_TYPE) \ @@ -1098,7 +1109,7 @@ extern "C" auto result = sample_2D(i, s, v2f32{float(coord.x), float(coord.y)}); \ return v4##RETURN_TYPE{std::bit_cast(result.x), std::bit_cast(result.y), std::bit_cast(result.z), std::bit_cast(result.w)}; \ } \ - v4##RETURN_TYPE FUNC(texref_2d_v4_##RETURN_TYPE##_##COORD_TYPE)(struct textureReference GLOBAL_SPACE * texref, v2##COORD_TYPE coord) \ + v4##RETURN_TYPE FUNC(texref_2d_v4_##RETURN_TYPE##_##COORD_TYPE)(struct textureReference CONSTANT_SPACE * texref, v2##COORD_TYPE coord) \ { \ return FUNC_CALL(texobj_2d_v4_##RETURN_TYPE##_##COORD_TYPE)(uint64_t(texref->textureObject), coord); \ } @@ -1108,21 +1119,21 @@ extern "C" tex_2d(f32, s32); tex_2d(s32, f32); - static v4f32 sample_3D(GLOBAL_SPACE void *image, GLOBAL_SPACE void *sampler, v4f32 coord) __device__ + static v4f32 sample_3D(CONSTANT_SPACE void *image, CONSTANT_SPACE void *sampler, v4f32 coord) __device__ { __device__ v4f32 __llvm_amdgcn_image_sample_lz_3d_v4f32_f32(uint32_t, float, float, float, v8s32, v4s32, bool, int, int) __asm("llvm.amdgcn.image.sample.lz.3d.v4f32.f32"); - GLOBAL_SPACE v8s32 *image_typed = (GLOBAL_SPACE v8s32 *)image; - GLOBAL_SPACE v4s32 *sampler_typed = (GLOBAL_SPACE v4s32 *)sampler; + CONSTANT_SPACE v8s32 *image_typed = (CONSTANT_SPACE v8s32 *)image; + CONSTANT_SPACE v4s32 *sampler_typed = (CONSTANT_SPACE v4s32 *)sampler; return __llvm_amdgcn_image_sample_lz_3d_v4f32_f32(0xf, coord.x, coord.y, coord.z, *image_typed, *sampler_typed, false, 0, 0); } #define tex_3d(RETURN_TYPE, COORD_TYPE) \ v4##RETURN_TYPE FUNC(texobj_3d_v4_##RETURN_TYPE##_##COORD_TYPE)(uint64_t texobj, v4##COORD_TYPE coord) \ { \ auto [i, s] = get_image_and_sampler(texobj); \ - auto result = sample_3D(i, s, v4f32{float(coord.x), float(coord.y), float(coord.z), float(coord.w)}); \ + auto result = sample_3D(i, s, v4f32{float(coord.x), float(coord.y), float(coord.z), float(coord.w)}); \ return v4##RETURN_TYPE{std::bit_cast(result.x), std::bit_cast(result.y), std::bit_cast(result.z), std::bit_cast(result.w)}; \ } \ - v4##RETURN_TYPE FUNC(texref_3d_v4_##RETURN_TYPE##_##COORD_TYPE)(struct textureReference GLOBAL_SPACE * texref, v4##COORD_TYPE coord) \ + v4##RETURN_TYPE FUNC(texref_3d_v4_##RETURN_TYPE##_##COORD_TYPE)(struct textureReference CONSTANT_SPACE * texref, v4##COORD_TYPE coord) \ { \ return FUNC_CALL(texobj_3d_v4_##RETURN_TYPE##_##COORD_TYPE)(uint64_t(texref->textureObject), coord); \ } diff --git a/ptx/src/pass/convert_32bit_to_64bit.rs b/ptx/src/pass/convert_32bit_to_64bit.rs index 6ebc7f582..9760b0da8 100644 --- a/ptx/src/pass/convert_32bit_to_64bit.rs +++ b/ptx/src/pass/convert_32bit_to_64bit.rs @@ -31,24 +31,18 @@ pub(super) fn run<'input>( TranslateError, > { let (global_ids, globals) = collect_globals(resolver, &directives)?; - let mut explicit_args_size_align = Vec::new(); + let mut explicit_arg_count = Vec::new(); let directives = directives .into_iter() .filter_map(|directive| { - run_directive( - resolver, - directive, - &global_ids, - &mut explicit_args_size_align, - ) - .transpose() + run_directive(resolver, directive, &global_ids, &mut explicit_arg_count).transpose() }) .collect::, _>>()?; Ok(( directives, ModuleMetadata32Bit { globals, - explicit_args_size_align, + explicit_arg_count, }, )) } @@ -142,7 +136,7 @@ fn run_directive<'input>( resolver: &mut GlobalStringIdentResolver2<'input>, directive: Directive2, SpirvWord>, globals_ids: &[SpirvWord], - explicit_args_size_align: &mut Vec<(String, Vec<(u32, u32)>)>, + explicit_arg_count: &mut Vec<(String, u32)>, ) -> Result, SpirvWord>>, TranslateError> { Ok(match directive { Directive2::Variable(linking, varinfo) if pass_through_variable(&varinfo) => { @@ -152,7 +146,7 @@ fn run_directive<'input>( resolver, method, globals_ids, - explicit_args_size_align, + explicit_arg_count, )?)), _ => None, }) @@ -162,7 +156,7 @@ fn run_method<'input>( resolver: &mut GlobalStringIdentResolver2<'input>, mut method: Function, SpirvWord>, globals_ids: &[SpirvWord], - explicit_args_size_align: &mut Vec<(String, Vec<(u32, u32)>)>, + explicit_arg_count: &mut Vec<(String, u32)>, ) -> Result, SpirvWord>, TranslateError> { let is_kernel = method.is_kernel(); if let Some(ref mut body) = method.body { @@ -187,17 +181,7 @@ fn run_method<'input>( }) .ok_or_else(error_unreachable)? .to_string(); - let argument_sizes = method - .input_arguments - .iter() - .map(|arg| { - let layout = arg.info.v_type.layout().unwrap(); - let size = layout.size() as u32; - let align = layout.align() as u32; - (size, align) - }) - .collect(); - explicit_args_size_align.push((text_name, argument_sizes)); + explicit_arg_count.push((text_name, method.input_arguments.len() as u32)); let implicit_memory_ptr = add_hidden_argument( resolver, ast::ScalarType::B64, diff --git a/ptx/src/pass/insert_post_saturation.rs b/ptx/src/pass/insert_post_saturation.rs index 1a7e7fbf6..32c3bb60c 100644 --- a/ptx/src/pass/insert_post_saturation.rs +++ b/ptx/src/pass/insert_post_saturation.rs @@ -181,6 +181,7 @@ fn run_instruction<'input>( | ast::Instruction::Setp { .. } | ast::Instruction::SetpBool { .. } | ast::Instruction::ShflSync { .. } + | ast::Instruction::MatchSync { .. } | ast::Instruction::Shf { .. } | ast::Instruction::Shl { .. } | ast::Instruction::Shr { .. } diff --git a/ptx/src/pass/instruction_mode_to_global_mode/mod.rs b/ptx/src/pass/instruction_mode_to_global_mode/mod.rs index 899e8824c..005c42ce7 100644 --- a/ptx/src/pass/instruction_mode_to_global_mode/mod.rs +++ b/ptx/src/pass/instruction_mode_to_global_mode/mod.rs @@ -2143,6 +2143,7 @@ fn get_modes(inst: &ast::Instruction) -> InstructionModes { | ast::Instruction::Bmsk { .. } | ast::Instruction::Shr { .. } | ast::Instruction::ShflSync { .. } + | ast::Instruction::MatchSync { .. } | ast::Instruction::CpAsync { .. } | ast::Instruction::CpAsyncCommitGroup { .. } | ast::Instruction::CpAsyncWaitGroup { .. } diff --git a/ptx/src/pass/llvm/attributes.rs b/ptx/src/pass/llvm/attributes.rs index 1b60584ed..ffde4c6c9 100644 --- a/ptx/src/pass/llvm/attributes.rs +++ b/ptx/src/pass/llvm/attributes.rs @@ -38,7 +38,7 @@ fn emit_attribute( module.get(), attribute_type, name.as_ptr(), - get_state_space(ast::StateSpace::Const, false)?, + get_state_space(ast::StateSpace::Const)?, ) }; unsafe { LLVMSetLinkage(global, llvm_zluda::LLVMLinkage::LLVMExternalLinkage) }; diff --git a/ptx/src/pass/llvm/emit.rs b/ptx/src/pass/llvm/emit.rs index f21f48f26..2250b01de 100644 --- a/ptx/src/pass/llvm/emit.rs +++ b/ptx/src/pass/llvm/emit.rs @@ -66,10 +66,9 @@ pub(crate) fn run<'input>( context: &Context, id_defs: GlobalStringIdentResolver2<'input>, directives: Vec, SpirvWord>>, - is_32bit: bool, ) -> Result { let module = llvm::Module::new(context, LLVM_UNNAMED); - let mut emit_ctx = ModuleEmitContext::new(context, &module, &id_defs, is_32bit); + let mut emit_ctx = ModuleEmitContext::new(context, &module, &id_defs); for directive in directives { match directive { Directive2::Variable(linking, variable) => emit_ctx.emit_global(linking, variable)?, @@ -84,223 +83,12 @@ pub(crate) fn run<'input>( Ok(module) } -#[derive(Debug, Clone, Copy)] -struct ZludaTypeToLLVM { - context: LLVMContextRef, - is_32bit: bool, -} - -impl ZludaTypeToLLVM { - fn get_state_space(&self, space: ast::StateSpace) -> Result { - get_state_space(space, self.is_32bit) - } - - fn get_input_argument_type( - &self, - v_type: &ast::Type, - state_space: ast::StateSpace, - ) -> Result { - match state_space { - ast::StateSpace::ParamEntry | ast::StateSpace::Shared => Ok(unsafe { - LLVMPointerTypeInContext(self.context, self.get_state_space(state_space)?) - }), - ast::StateSpace::Reg => self.get_type(v_type), - ast::StateSpace::Global | ast::StateSpace::Const - if matches!(v_type, ast::Type::Texref) => - { - Ok(unsafe { - LLVMPointerTypeInContext(self.context, self.get_state_space(state_space)?) - }) - } - _ => return Err(error_unreachable()), - } - } - - fn get_pointer_type<'ctx>( - &self, - to_space: ast::StateSpace, - ) -> Result { - Ok(unsafe { LLVMPointerTypeInContext(self.context, self.get_state_space(to_space)?) }) - } - - fn get_type(&self, type_: &ast::Type) -> Result { - Ok(match type_ { - ast::Type::Scalar(scalar) => get_scalar_type(self.context, *scalar), - ast::Type::Vector(size, scalar) => { - let base_type = get_scalar_type(self.context, *scalar); - unsafe { LLVMVectorType(base_type, *size as u32) } - } - ast::Type::Array(vec, scalar, dimensions) => { - let mut underlying_type = get_scalar_type(self.context, *scalar); - if let Some(size) = vec { - underlying_type = unsafe { LLVMVectorType(underlying_type, size.get() as u32) }; - } - if dimensions.is_empty() { - return Ok(unsafe { LLVMArrayType2(underlying_type, 0) }); - } - dimensions - .iter() - .rfold(underlying_type, |result, dimension| unsafe { - LLVMArrayType2(result, *dimension as u64) - }) - } - ast::Type::Texref => { - // Definitions taken from ROCm LLVM output - let format_desc = unsafe { - LLVMStructCreateNamed(self.context, c"struct.hipChannelFormatDesc".as_ptr()) - }; - let llvm_i32 = get_scalar_type(self.context, ast::ScalarType::B32); - let mut format_desc_fields = [llvm_i32, llvm_i32, llvm_i32, llvm_i32, llvm_i32]; - unsafe { - LLVMStructSetBody( - format_desc, - format_desc_fields.as_mut_ptr(), - format_desc_fields.len() as u32, - 0, - ) - }; - let texture_reference = unsafe { - LLVMStructCreateNamed(self.context, c"struct.textureReference".as_ptr()) - }; - let llvm_a3i32 = unsafe { LLVMArrayType2(llvm_i32, 3) }; - let llvm_float = get_scalar_type(self.context, ast::ScalarType::F32); - let llvm_ptr = self.get_pointer_type(ast::StateSpace::Generic)?; - let mut texture_reference_fields = [ - llvm_i32, - llvm_i32, - llvm_i32, - llvm_a3i32, - format_desc, - llvm_i32, - llvm_i32, - llvm_i32, - llvm_float, - llvm_float, - llvm_float, - llvm_ptr, - llvm_i32, - llvm_i32, - ]; - unsafe { - LLVMStructSetBody( - texture_reference, - texture_reference_fields.as_mut_ptr(), - texture_reference_fields.len() as u32, - 0, - ) - }; - let texture = - unsafe { LLVMStructCreateNamed(self.context, c"struct.texture".as_ptr()) }; - let mut texture_fields = [texture_reference]; - unsafe { - LLVMStructSetBody( - texture, - texture_fields.as_mut_ptr(), - texture_fields.len() as u32, - 0, - ) - }; - texture - } - }) - } - - fn get_anonymous_struct_type<'a>( - &self, - elem_types: impl Iterator, - ) -> Result { - let mut elem_types = elem_types - .map(|t| self.get_type(t)) - .collect::, _>>()?; - Ok(unsafe { - LLVMStructTypeInContext( - self.context, - elem_types.as_mut_ptr(), - elem_types.len() as u32, - 0, - ) - }) - } - - fn get_function_type_impl<'a>( - &self, - mut return_args: impl DoubleEndedIterator - + ExactSizeIterator, - input_args: impl Iterator>, - struct_kind: StructKind, - ) -> Result { - let mut input_args = input_args.collect::, _>>()?; - let return_type = match return_args.len() { - 0 => unsafe { LLVMVoidTypeInContext(self.context) }, - 1 => self.get_type(&return_args.next().unwrap())?, - _ => match struct_kind { - StructKind::Named => self.get_or_create_struct_type(return_args)?, - StructKind::Anonymous => self.get_anonymous_struct_type(return_args)?, - }, - }; - - Ok(unsafe { - LLVMFunctionType( - return_type, - input_args.as_mut_ptr(), - input_args.len() as u32, - 0, - ) - }) - } - - fn get_function_type<'a>( - &self, - return_args: impl DoubleEndedIterator - + ExactSizeIterator, - input_args: impl Iterator>, - ) -> Result { - self.get_function_type_impl(return_args, input_args, StructKind::Named) - } - - fn get_intrinsic_type<'a>( - &self, - return_args: impl DoubleEndedIterator - + ExactSizeIterator, - input_args: impl Iterator>, - ) -> Result { - self.get_function_type_impl(return_args, input_args, StructKind::Anonymous) - } - - fn get_or_create_struct_type<'a>( - &self, - mut elem_types: impl Iterator, - ) -> Result { - use std::fmt::Write; - let (mut name, types) = elem_types.try_fold( - ("struct".to_string(), Vec::new()), - |(mut name, mut types), t| { - name.push('.'); - if let ast::Type::Scalar(scalar) = t { - write!(name, "{}", LLVMTypeDisplay(*scalar)).ok(); - } else { - return Err(error_unreachable()); - } - types.push(self.get_type(t)?); - Ok((name, types)) - }, - )?; - name.push('\0'); - let mut struct_type = unsafe { LLVMGetTypeByName2(self.context, name.as_ptr().cast()) }; - if struct_type.is_null() { - struct_type = create_struct_type(self.context, name, types); - } - Ok(struct_type) - } -} - struct ModuleEmitContext<'a, 'input> { context: LLVMContextRef, module: LLVMModuleRef, builder: Builder, id_defs: &'a GlobalStringIdentResolver2<'input>, resolver: ResolveIdent, - llvm_types: ZludaTypeToLLVM, } impl<'a, 'input> ModuleEmitContext<'a, 'input> { @@ -308,7 +96,6 @@ impl<'a, 'input> ModuleEmitContext<'a, 'input> { context: &Context, module: &llvm::Module, id_defs: &'a GlobalStringIdentResolver2<'input>, - is_32bit: bool, ) -> Self { ModuleEmitContext { context: context.get(), @@ -316,10 +103,6 @@ impl<'a, 'input> ModuleEmitContext<'a, 'input> { builder: Builder::new(context), id_defs, resolver: ResolveIdent::new(&id_defs), - llvm_types: ZludaTypeToLLVM { - context: context.get(), - is_32bit, - }, } } @@ -343,11 +126,11 @@ impl<'a, 'input> ModuleEmitContext<'a, 'input> { let name = CString::new(name).map_err(|_| error_unreachable())?; let mut fn_ = unsafe { LLVMGetNamedFunction(self.module, name.as_ptr()) }; if fn_ == ptr::null_mut() { - let fn_type = self.llvm_types.get_function_type( + let fn_type = get_function_type( + self.context, method.return_arguments.iter().map(|v| &v.info.v_type), method.input_arguments.iter().map(|v| { - self.llvm_types - .get_input_argument_type(&v.info.v_type, v.info.state_space) + get_input_argument_type(self.context, &v.info.v_type, v.info.state_space) }), )?; fn_ = unsafe { LLVMAddFunction(self.module, name.as_ptr(), fn_type) }; @@ -393,7 +176,7 @@ impl<'a, 'input> ModuleEmitContext<'a, 'input> { LLVMCreateTypeAttribute( self.context, attr_kind, - self.llvm_types.get_type(¶m.info.v_type)?, + get_type(self.context, ¶m.info.v_type)?, ) }; unsafe { LLVMAddAttributeAtIndex(fn_, i as u32 + 1, attr) }; @@ -429,13 +212,8 @@ impl<'a, 'input> ModuleEmitContext<'a, 'input> { unsafe { LLVMAppendBasicBlockInContext(self.context, fn_, LLVM_UNNAMED.as_ptr()) }; unsafe { LLVMPositionBuilderAtEnd(self.builder.get(), real_bb) }; let base_32bit_memory = method.kernel_meta32.as_ref().map(|m| m.implicit_memory_ptr); - let mut method_emitter: MethodEmitContext<'_> = MethodEmitContext::new( - self, - fn_, - variables_builder, - self.llvm_types, - base_32bit_memory, - ); + let mut method_emitter = + MethodEmitContext::new(self, fn_, variables_builder, base_32bit_memory); for var in method.return_arguments { method_emitter.emit_variable(var)?; } @@ -478,13 +256,13 @@ impl<'a, 'input> ModuleEmitContext<'a, 'input> { .transpose() .map_err(|_| error_unreachable())? .unwrap_or(Cow::Borrowed(LLVM_UNNAMED)); - let llvm_type = self.llvm_types.get_type(&var.info.v_type)?; + let llvm_type = get_type(self.context, &var.info.v_type)?; let global = unsafe { LLVMAddGlobalInAddressSpace( self.module, llvm_type, name.as_ptr(), - self.llvm_types.get_state_space(var.info.state_space)?, + get_state_space(var.info.state_space)?, ) }; if matches!(var.info.v_type, ast::Type::Texref) { @@ -662,6 +440,23 @@ fn llvm_ftz(ftz: bool) -> &'static str { } } +fn get_input_argument_type( + context: LLVMContextRef, + v_type: &ast::Type, + state_space: ast::StateSpace, +) -> Result { + match state_space { + ast::StateSpace::ParamEntry | ast::StateSpace::Shared => { + Ok(unsafe { LLVMPointerTypeInContext(context, get_state_space(state_space)?) }) + } + ast::StateSpace::Reg => get_type(context, v_type), + ast::StateSpace::Global | ast::StateSpace::Const if matches!(v_type, ast::Type::Texref) => { + Ok(unsafe { LLVMPointerTypeInContext(context, get_state_space(state_space)?) }) + } + _ => return Err(error_unreachable()), + } +} + struct MethodEmitContext<'a> { context: LLVMContextRef, module: LLVMModuleRef, @@ -670,7 +465,6 @@ struct MethodEmitContext<'a> { variables_builder: Builder, resolver: &'a mut ResolveIdent, carry_flag: Option, - llvm_types: ZludaTypeToLLVM, base_32bit_memory: Option, } @@ -679,7 +473,6 @@ impl<'a> MethodEmitContext<'a> { parent: &'a mut ModuleEmitContext, method: LLVMValueRef, variables_builder: Builder, - llvm_types: ZludaTypeToLLVM, base_32bit_memory: Option, ) -> MethodEmitContext<'a> { MethodEmitContext { @@ -690,7 +483,6 @@ impl<'a> MethodEmitContext<'a> { resolver: &mut parent.resolver, method, carry_flag: None, - llvm_types, base_32bit_memory: base_32bit_memory, } } @@ -747,8 +539,8 @@ impl<'a> MethodEmitContext<'a> { let alloca = unsafe { LLVMZludaBuildAlloca( self.variables_builder.get(), - self.llvm_types.get_type(&var.info.v_type)?, - self.llvm_types.get_state_space(var.info.state_space)?, + get_type(self.context, &var.info.v_type)?, + get_state_space(var.info.state_space)?, self.resolver.get_or_add_raw(var.name), ) }; @@ -869,6 +661,7 @@ impl<'a> MethodEmitContext<'a> { | ast::Instruction::Bmsk { .. } | ast::Instruction::Activemask { .. } | ast::Instruction::ShflSync { .. } + | ast::Instruction::MatchSync { .. } | ast::Instruction::Vote { .. } | ast::Instruction::Nanosleep { .. } | ast::Instruction::ReduxSync { .. } @@ -886,7 +679,7 @@ impl<'a> MethodEmitContext<'a> { arguments: ast::LdArgs, ) -> Result<(), TranslateError> { let builder = self.builder; - let underlying_type = self.llvm_types.get_type(&data.typ)?; + let underlying_type = get_type(self.context, &data.typ)?; let needs_cast = not_supported_by_atomics(data.qualifier, underlying_type); let op_type = if needs_cast { unsafe { @@ -930,7 +723,7 @@ impl<'a> MethodEmitContext<'a> { ), ConversionKind::SignExtend => { let src = self.resolver.value(conversion.src)?; - let type_ = self.llvm_types.get_type(&conversion.to_type)?; + let type_ = get_type(self.context, &conversion.to_type)?; self.resolver.with_result(conversion.dst, |dst| unsafe { LLVMBuildSExt(builder, src, type_, dst) }); @@ -938,7 +731,7 @@ impl<'a> MethodEmitContext<'a> { } ConversionKind::BitToPtr => { let src = self.resolver.value(conversion.src)?; - let ptr_type = self.llvm_types.get_pointer_type(conversion.to_space)?; + let ptr_type = get_pointer_type(self.context, conversion.to_space)?; if let ( Some(base32), ast::StateSpace::Global | ast::StateSpace::Generic | ast::StateSpace::Const, @@ -970,18 +763,8 @@ impl<'a> MethodEmitContext<'a> { Ok(()) } ConversionKind::PtrToPtr => { - if conversion.from_space == conversion.to_space { - // With opaque pointers it's meaningless - return self.emit_mov(ast::MovArgs { - dst: conversion.dst, - src: conversion.src, - }); - } - if self.base_32bit_memory.is_some() { - return Err(error_todo()); - } let src = self.resolver.value(conversion.src)?; - let dst_type = self.llvm_types.get_pointer_type(conversion.to_space)?; + let dst_type = get_pointer_type(self.context, conversion.to_space)?; self.resolver.with_result(conversion.dst, |dst| unsafe { LLVMBuildAddrSpaceCast(builder, src, dst_type, dst) }); @@ -989,7 +772,7 @@ impl<'a> MethodEmitContext<'a> { } ConversionKind::AddressOf => { let src = self.resolver.value(conversion.src)?; - let dst_type = self.llvm_types.get_type(&conversion.to_type)?; + let dst_type = get_type(self.context, &conversion.to_type)?; if let ( Some(_), ast::StateSpace::Global | ast::StateSpace::Generic | ast::StateSpace::Const, @@ -1021,7 +804,7 @@ impl<'a> MethodEmitContext<'a> { let from_layout = from_type.layout(); let to_layout = to_type.layout().ok_or_else(error_unreachable)?; if from_layout.size() == to_layout.size() { - let dst_type = self.llvm_types.get_type(&to_type)?; + let dst_type = get_type(self.context, &to_type)?; if from_type.kind() != ast::ScalarKind::Float && to_type_scalar.kind() != ast::ScalarKind::Float { @@ -1107,7 +890,7 @@ impl<'a> MethodEmitContext<'a> { | (ast::Type::Scalar(..), ast::Type::Vector(..)) | (ast::Type::Scalar(..), ast::Type::Array(..)) | (ast::Type::Array(..), ast::Type::Scalar(..)) => { - let dst_type = self.llvm_types.get_type(to_type)?; + let dst_type = get_type(self.context, to_type)?; self.resolver.with_result(dst, |dst| unsafe { LLVMBuildBitCast(self.builder, src, dst_type, dst) }); @@ -1192,7 +975,7 @@ impl<'a> MethodEmitContext<'a> { LLVMZludaBuildAlloca( self.variables_builder.get(), LLVMIntTypeInContext(self.context, 1), - self.llvm_types.get_state_space(ast::StateSpace::Reg)?, + get_state_space(ast::StateSpace::Reg)?, c"__ZLUDA_REG_CC_CF".as_ptr(), ) }; @@ -1356,7 +1139,7 @@ impl<'a> MethodEmitContext<'a> { arguments: ast::StArgs, ) -> Result<(), TranslateError> { let ptr = self.resolver.value(arguments.src1)?; - let underlying_type = self.llvm_types.get_type(&data.typ)?; + let underlying_type = get_type(self.context, &data.typ)?; let needs_cast = not_supported_by_atomics(data.qualifier, underlying_type); let mut value = self.resolver.value(arguments.src2)?; if needs_cast { @@ -1403,11 +1186,12 @@ impl<'a> MethodEmitContext<'a> { [dst] => self.resolver.get_or_add_raw(*dst), _ => LLVM_UNNAMED.as_ptr(), }; - let type_ = self.llvm_types.get_function_type( + let type_ = get_function_type( + self.context, data.return_arguments.iter().map(|(type_, ..)| type_), data.input_arguments .iter() - .map(|(type_, space)| self.llvm_types.get_input_argument_type(&type_, *space)), + .map(|(type_, space)| get_input_argument_type(self.context, &type_, *space)), )?; let mut input_arguments = arguments .input_arguments @@ -1568,7 +1352,7 @@ impl<'a> MethodEmitContext<'a> { .iter() .map(|(value, type_)| { let value = self.resolver.value(*value)?; - let lowered_type = self.llvm_types.get_type(type_)?; + let lowered_type = get_type(self.context, type_)?; let load = unsafe { LLVMBuildLoad2(self.builder, lowered_type, value, LLVM_UNNAMED.as_ptr()) }; @@ -1585,9 +1369,8 @@ impl<'a> MethodEmitContext<'a> { [] => unsafe { LLVMBuildRetVoid(self.builder) }, [(value, _)] => unsafe { LLVMBuildRet(self.builder, *value) }, loads => { - let struct_type = self - .llvm_types - .get_or_create_struct_type(loads.iter().map(|(_, type_)| *type_))?; + let struct_type = + get_or_create_struct_type(self.context, loads.iter().map(|(_, type_)| *type_))?; let mut value = unsafe { LLVMGetUndef(struct_type) }; for (i, (load, _)) in loads.iter().enumerate() { value = unsafe { @@ -1798,9 +1581,10 @@ impl<'a> MethodEmitContext<'a> { }); } } else { - let vector_type = self - .llvm_types - .get_type(&ast::Type::Vector(repack.unpacked.len() as u8, repack.typ))?; + let vector_type = get_type( + self.context, + &ast::Type::Vector(repack.unpacked.len() as u8, repack.typ), + )?; let mut temp_vec = unsafe { LLVMGetUndef(vector_type) }; for (index, src_id) in repack.unpacked.iter().enumerate() { let dst = if index == repack.unpacked.len() - 1 { @@ -1906,19 +1690,8 @@ impl<'a> MethodEmitContext<'a> { (data.state_space, ast::StateSpace::Generic) } }; - if self.base_32bit_memory.is_some() - && matches!( - data.state_space, - ast::StateSpace::Global | ast::StateSpace::Generic | ast::StateSpace::Const - ) - { - return self.emit_mov(ast::MovArgs { - dst: arguments.dst, - src: arguments.src, - }); - } - let from_type = self.llvm_types.get_pointer_type(from_space)?; - let dest_type = self.llvm_types.get_pointer_type(to_space)?; + let from_type = get_pointer_type(self.context, from_space)?; + let dest_type = get_pointer_type(self.context, to_space)?; let src = self.resolver.value(arguments.src)?; let temp_ptr = unsafe { LLVMBuildIntToPtr(self.builder, src, from_type, LLVM_UNNAMED.as_ptr()) }; @@ -2006,7 +1779,8 @@ impl<'a> MethodEmitContext<'a> { return_types: Vec<&ast::Type>, arguments: Vec<(LLVMValueRef, LLVMTypeRef)>, ) -> Result { - let fn_type = self.llvm_types.get_intrinsic_type( + let fn_type = get_intrinsic_type( + self.context, return_types.iter().copied(), arguments.iter().map(|(_, type_)| Ok(*type_)), )?; @@ -2955,12 +2729,16 @@ impl<'a> MethodEmitContext<'a> { _ => return Err(error_unreachable()), }; let llvm_type = get_scalar_type(self.context, type_); - self.emit_intrinsic( + let population = self.emit_intrinsic( intrinsic, - Some(arguments.dst), + None, vec![&type_.into()], vec![(self.resolver.value(arguments.src)?, llvm_type)], )?; + let i32_llvm = get_scalar_type(self.context, ast::ScalarType::B32); + self.resolver.with_result(arguments.dst, |dst_name| unsafe { + LLVMBuildTruncOrBitCast(self.builder, population, i32_llvm, dst_name) + }); Ok(()) } @@ -3455,10 +3233,10 @@ impl<'a> MethodEmitContext<'a> { let vector_result = unsafe { LLVMBuildInsertElement( self.builder, - LLVMGetPoison( - self.llvm_types - .get_type(&ast::Type::Vector(2, ast::ScalarType::U16))?, - ), + LLVMGetPoison(get_type( + self.context, + &ast::Type::Vector(2, ast::ScalarType::U16), + )?), setp_result_0, zero, LLVM_UNNAMED.as_ptr(), @@ -3488,10 +3266,10 @@ impl<'a> MethodEmitContext<'a> { let vector_result = unsafe { LLVMBuildInsertElement( self.builder, - LLVMGetPoison( - self.llvm_types - .get_type(&ast::Type::Vector(2, ast::ScalarType::F16))?, - ), + LLVMGetPoison(get_type( + self.context, + &ast::Type::Vector(2, ast::ScalarType::F16), + )?), setp_result_0, zero, LLVM_UNNAMED.as_ptr(), @@ -3874,6 +3652,13 @@ fn apply_qualifier( Ok(()) } +fn get_pointer_type<'ctx>( + context: LLVMContextRef, + to_space: ast::StateSpace, +) -> Result { + Ok(unsafe { LLVMPointerTypeInContext(context, get_state_space(to_space)?) }) +} + // https://llvm.org/docs/AMDGPUUsage.html#memory-scopes fn get_scope(scope: ast::MemScope) -> Result<*const i8, TranslateError> { Ok(match scope { @@ -3914,6 +3699,111 @@ fn get_ordering_failure(semantics: ast::AtomSemantics) -> LLVMAtomicOrdering { } } +fn get_type(context: LLVMContextRef, type_: &ast::Type) -> Result { + Ok(match type_ { + ast::Type::Scalar(scalar) => get_scalar_type(context, *scalar), + ast::Type::Vector(size, scalar) => { + let base_type = get_scalar_type(context, *scalar); + unsafe { LLVMVectorType(base_type, *size as u32) } + } + ast::Type::Array(vec, scalar, dimensions) => { + let mut underlying_type = get_scalar_type(context, *scalar); + if let Some(size) = vec { + underlying_type = unsafe { LLVMVectorType(underlying_type, size.get() as u32) }; + } + if dimensions.is_empty() { + return Ok(unsafe { LLVMArrayType2(underlying_type, 0) }); + } + dimensions + .iter() + .rfold(underlying_type, |result, dimension| unsafe { + LLVMArrayType2(result, *dimension as u64) + }) + } + ast::Type::Texref => { + // Definitions taken from ROCm LLVM output + let format_desc = + unsafe { LLVMStructCreateNamed(context, c"struct.hipChannelFormatDesc".as_ptr()) }; + let llvm_i32 = get_scalar_type(context, ast::ScalarType::B32); + let mut format_desc_fields = [llvm_i32, llvm_i32, llvm_i32, llvm_i32, llvm_i32]; + unsafe { + LLVMStructSetBody( + format_desc, + format_desc_fields.as_mut_ptr(), + format_desc_fields.len() as u32, + 0, + ) + }; + let texture_reference = + unsafe { LLVMStructCreateNamed(context, c"struct.textureReference".as_ptr()) }; + let llvm_a3i32 = unsafe { LLVMArrayType2(llvm_i32, 3) }; + let llvm_float = get_scalar_type(context, ast::ScalarType::F32); + let llvm_ptr = get_pointer_type(context, ast::StateSpace::Generic)?; + let mut texture_reference_fields = [ + llvm_i32, + llvm_i32, + llvm_i32, + llvm_a3i32, + format_desc, + llvm_i32, + llvm_i32, + llvm_i32, + llvm_float, + llvm_float, + llvm_float, + llvm_ptr, + llvm_i32, + llvm_i32, + ]; + unsafe { + LLVMStructSetBody( + texture_reference, + texture_reference_fields.as_mut_ptr(), + texture_reference_fields.len() as u32, + 0, + ) + }; + let texture = unsafe { LLVMStructCreateNamed(context, c"struct.texture".as_ptr()) }; + let mut texture_fields = [texture_reference]; + unsafe { + LLVMStructSetBody( + texture, + texture_fields.as_mut_ptr(), + texture_fields.len() as u32, + 0, + ) + }; + texture + } + }) +} + +fn get_or_create_struct_type<'a>( + context: LLVMContextRef, + mut elem_types: impl Iterator, +) -> Result { + use std::fmt::Write; + let (mut name, types) = elem_types.try_fold( + ("struct".to_string(), Vec::new()), + |(mut name, mut types), t| { + name.push('.'); + if let ast::Type::Scalar(scalar) = t { + write!(name, "{}", LLVMTypeDisplay(*scalar)).ok(); + } else { + return Err(error_unreachable()); + } + types.push(get_type(context, t)?); + Ok((name, types)) + }, + )?; + name.push('\0'); + let mut struct_type = unsafe { LLVMGetTypeByName2(context, name.as_ptr().cast()) }; + if struct_type.is_null() { + struct_type = create_struct_type(context, name, types); + } + Ok(struct_type) +} + fn create_struct_type( context: LLVMContextRef, name: String, @@ -3931,11 +3821,68 @@ fn create_struct_type( llvm_type } +fn get_anonymous_struct_type<'a>( + context: LLVMContextRef, + elem_types: impl Iterator, +) -> Result { + let mut elem_types = elem_types + .map(|t| get_type(context, t)) + .collect::, _>>()?; + Ok(unsafe { + LLVMStructTypeInContext(context, elem_types.as_mut_ptr(), elem_types.len() as u32, 0) + }) +} + enum StructKind { Named, Anonymous, } +fn get_function_type_impl<'a>( + context: LLVMContextRef, + mut return_args: impl DoubleEndedIterator + + ExactSizeIterator, + input_args: impl Iterator>, + struct_kind: StructKind, +) -> Result { + let mut input_args = input_args.collect::, _>>()?; + let return_type = match return_args.len() { + 0 => unsafe { LLVMVoidTypeInContext(context) }, + 1 => get_type(context, &return_args.next().unwrap())?, + _ => match struct_kind { + StructKind::Named => get_or_create_struct_type(context, return_args)?, + StructKind::Anonymous => get_anonymous_struct_type(context, return_args)?, + }, + }; + + Ok(unsafe { + LLVMFunctionType( + return_type, + input_args.as_mut_ptr(), + input_args.len() as u32, + 0, + ) + }) +} + +fn get_function_type<'a>( + context: LLVMContextRef, + return_args: impl DoubleEndedIterator + + ExactSizeIterator, + input_args: impl Iterator>, +) -> Result { + get_function_type_impl(context, return_args, input_args, StructKind::Named) +} + +fn get_intrinsic_type<'a>( + context: LLVMContextRef, + return_args: impl DoubleEndedIterator + + ExactSizeIterator, + input_args: impl Iterator>, +) -> Result { + get_function_type_impl(context, return_args, input_args, StructKind::Anonymous) +} + struct ResolveIdent { words: HashMap, values: HashMap, diff --git a/ptx/src/pass/llvm/mod.rs b/ptx/src/pass/llvm/mod.rs index 6fc3556a7..ebfe86dcb 100644 --- a/ptx/src/pass/llvm/mod.rs +++ b/ptx/src/pass/llvm/mod.rs @@ -46,7 +46,7 @@ fn get_scalar_type(context: LLVMContextRef, type_: ast::ScalarType) -> LLVMTypeR } } -fn get_state_space(space: ast::StateSpace, is_32bit: bool) -> Result { +fn get_state_space(space: ast::StateSpace) -> Result { match space { ast::StateSpace::Reg => Ok(PRIVATE_ADDRESS_SPACE), ast::StateSpace::Generic => Ok(GENERIC_ADDRESS_SPACE), @@ -58,14 +58,7 @@ fn get_state_space(space: ast::StateSpace, is_32bit: bool) -> Result Err(error_todo()), ast::StateSpace::Local => Ok(PRIVATE_ADDRESS_SPACE), ast::StateSpace::Global => Ok(GLOBAL_ADDRESS_SPACE), - ast::StateSpace::Const => Ok(if is_32bit { - // FIXME: This is probably incorrect, but when using constant or - // global address space, we get incorrect codegen. Might be a bug - // in LLVM, might be a bug in ZLUDA - GENERIC_ADDRESS_SPACE - } else { - CONSTANT_ADDRESS_SPACE - }), + ast::StateSpace::Const => Ok(CONSTANT_ADDRESS_SPACE), ast::StateSpace::Shared => Ok(SHARED_ADDRESS_SPACE), ast::StateSpace::SharedCta => Err(error_todo()), ast::StateSpace::SharedCluster => Err(error_todo()), diff --git a/ptx/src/pass/mod.rs b/ptx/src/pass/mod.rs index 530490e31..77f00bf6e 100644 --- a/ptx/src/pass/mod.rs +++ b/ptx/src/pass/mod.rs @@ -112,7 +112,7 @@ pub fn to_llvm_module<'input>( let directives = hoist_globals::run(directives)?; on_pass_end("hoist_globals"); let context = llvm_zluda::utils::Context::new(); - let llvm_ir = llvm::emit::run(&context, flat_resolver, directives, ast.address_size == 32)?; + let llvm_ir = llvm::emit::run(&context, flat_resolver, directives)?; let attributes_ir = llvm::attributes::run(&context, attributes)?; on_pass_end("emit_llvm"); Ok(Module { diff --git a/ptx/src/pass/replace_instructions_with_functions.rs b/ptx/src/pass/replace_instructions_with_functions.rs index 8b13547d9..413fcec66 100644 --- a/ptx/src/pass/replace_instructions_with_functions.rs +++ b/ptx/src/pass/replace_instructions_with_functions.rs @@ -301,11 +301,6 @@ fn run_instruction<'input>( }, .. } => { - let dtype = match dtype { - // For 32 bit - ast::ScalarType::U32 => ast::ScalarType::S32, - t => t, - }; let prefix = match type_ { ast::TexType::Texref => "texref", ast::TexType::Texobj => "texobj", @@ -569,6 +564,10 @@ fn run_instruction<'input>( i @ ptx_parser::Instruction::Prmt { .. } => { to_call(resolver, fn_declarations, "prmt_b32".into(), i)? } + i @ ast::Instruction::MatchSync { data, .. } => { + let name = format!("match_any_sync_{}", scalar_to_ptx_name(data)); + to_call(resolver, fn_declarations, name.into(), i)? + } i => i, }) } diff --git a/ptx/src/test/ll/match_sync.ll b/ptx/src/test/ll/match_sync.ll new file mode 100644 index 000000000..41c9a06ca --- /dev/null +++ b/ptx/src/test/ll/match_sync.ll @@ -0,0 +1,45 @@ +declare hidden i32 @__zluda_ptx_impl_match_any_sync_b32(i32, i32) #0 + +declare hidden i32 @__zluda_ptx_impl_sreg_tid(i8) #0 + +define amdgpu_kernel void @match_sync(ptr addrspace(4) byref(i64) %"46") #1 { + %"47" = alloca i64, align 8, addrspace(5) + %"48" = alloca i64, align 8, addrspace(5) + %"49" = alloca i32, align 4, addrspace(5) + %"50" = alloca i32, align 4, addrspace(5) + %"51" = alloca i32, align 4, addrspace(5) + br label %1 + +1: ; preds = %0 + br label %"44" + +"44": ; preds = %1 + %2 = load i64, ptr addrspace(4) %"46", align 8 + store i64 %2, ptr addrspace(5) %"47", align 8 + %"40" = call i32 @__zluda_ptx_impl_sreg_tid(i8 0) + store i32 %"40", ptr addrspace(5) %"49", align 4 + %3 = load i32, ptr addrspace(5) %"49", align 4 + %"67" = and i32 %3, 1 + store i32 %"67", ptr addrspace(5) %"50", align 4 + %4 = load i32, ptr addrspace(5) %"50", align 4 + %"69" = call i32 @__zluda_ptx_impl_match_any_sync_b32(i32 %4, i32 -1) + store i32 %"69", ptr addrspace(5) %"51", align 4 + %5 = load i32, ptr addrspace(5) %"49", align 4 + %6 = zext i32 %5 to i64 + store i64 %6, ptr addrspace(5) %"48", align 8 + %7 = load i64, ptr addrspace(5) %"48", align 8 + %"60" = mul i64 %7, 4 + store i64 %"60", ptr addrspace(5) %"48", align 8 + %8 = load i64, ptr addrspace(5) %"47", align 8 + %9 = load i64, ptr addrspace(5) %"48", align 8 + %"62" = add i64 %8, %9 + store i64 %"62", ptr addrspace(5) %"47", align 8 + %10 = load i64, ptr addrspace(5) %"47", align 8 + %11 = load i32, ptr addrspace(5) %"51", align 4 + %"71" = inttoptr i64 %10 to ptr + store i32 %11, ptr %"71", align 4 + ret void +} + +attributes #0 = { "amdgpu-ieee"="false" "amdgpu-unsafe-fp-atomics"="true" "denormal-fp-math"="dynamic" "denormal-fp-math-f32"="dynamic" "no-trapping-math"="true" "target-features"="+wavefrontsize32,-wavefrontsize64,+cumode,+precise-memory" "uniform-work-group-size"="true" } +attributes #1 = { "amdgpu-ieee"="false" "amdgpu-unsafe-fp-atomics"="true" "denormal-fp-math"="preserve-sign" "denormal-fp-math-f32"="preserve-sign" "no-trapping-math"="true" "target-features"="+wavefrontsize32,-wavefrontsize64,+cumode,+precise-memory" "uniform-work-group-size"="true" } diff --git a/ptx/src/test/ll/popc.ll b/ptx/src/test/ll/popc.ll index 87a3d74a6..c5c341a03 100644 --- a/ptx/src/test/ll/popc.ll +++ b/ptx/src/test/ll/popc.ll @@ -17,12 +17,12 @@ define amdgpu_kernel void @popc(ptr addrspace(4) byref(i64) %"39", ptr addrspace %5 = load i32, ptr %"52", align 4 store i32 %5, ptr addrspace(5) %"43", align 4 %6 = load i32, ptr addrspace(5) %"43", align 4 - %"53" = call i32 @llvm.ctpop.i32(i32 %6) - store i32 %"53", ptr addrspace(5) %"43", align 4 - %7 = load i64, ptr addrspace(5) %"42", align 8 - %8 = load i32, ptr addrspace(5) %"43", align 4 - %"54" = inttoptr i64 %7 to ptr - store i32 %8, ptr %"54", align 4 + %7 = call i32 @llvm.ctpop.i32(i32 %6) + store i32 %7, ptr addrspace(5) %"43", align 4 + %8 = load i64, ptr addrspace(5) %"42", align 8 + %9 = load i32, ptr addrspace(5) %"43", align 4 + %"54" = inttoptr i64 %8 to ptr + store i32 %9, ptr %"54", align 4 ret void } diff --git a/ptx/src/test/ll/popc_b64.ll b/ptx/src/test/ll/popc_b64.ll new file mode 100644 index 000000000..8d4b87465 --- /dev/null +++ b/ptx/src/test/ll/popc_b64.ll @@ -0,0 +1,35 @@ +define amdgpu_kernel void @popc_b64(ptr addrspace(4) byref(i64) %"40", ptr addrspace(4) byref(i64) %"41") #0 { + %"42" = alloca i64, align 8, addrspace(5) + %"43" = alloca i64, align 8, addrspace(5) + %"44" = alloca i32, align 4, addrspace(5) + %"45" = alloca i64, align 8, addrspace(5) + br label %1 + +1: ; preds = %0 + br label %"39" + +"39": ; preds = %1 + %2 = load i64, ptr addrspace(4) %"40", align 8 + store i64 %2, ptr addrspace(5) %"42", align 8 + %3 = load i64, ptr addrspace(4) %"41", align 8 + store i64 %3, ptr addrspace(5) %"43", align 8 + %4 = load i64, ptr addrspace(5) %"42", align 8 + %"54" = inttoptr i64 %4 to ptr + %5 = load i64, ptr %"54", align 8 + store i64 %5, ptr addrspace(5) %"45", align 8 + %6 = load i64, ptr addrspace(5) %"45", align 8 + %7 = call i64 @llvm.ctpop.i64(i64 %6) + %"55" = trunc i64 %7 to i32 + store i32 %"55", ptr addrspace(5) %"44", align 4 + %8 = load i64, ptr addrspace(5) %"43", align 8 + %9 = load i32, ptr addrspace(5) %"44", align 4 + %"56" = inttoptr i64 %8 to ptr + store i32 %9, ptr %"56", align 4 + ret void +} + +; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none) +declare i64 @llvm.ctpop.i64(i64) #1 + +attributes #0 = { "amdgpu-ieee"="false" "amdgpu-unsafe-fp-atomics"="true" "denormal-fp-math"="preserve-sign" "denormal-fp-math-f32"="preserve-sign" "no-trapping-math"="true" "target-features"="+wavefrontsize32,-wavefrontsize64,+cumode,+precise-memory" "uniform-work-group-size"="true" } +attributes #1 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) } diff --git a/ptx/src/test/spirv_run/match_sync.ptx b/ptx/src/test/spirv_run/match_sync.ptx new file mode 100644 index 000000000..618f4e854 --- /dev/null +++ b/ptx/src/test/spirv_run/match_sync.ptx @@ -0,0 +1,32 @@ +.version 7.0 +.target sm_70 +.address_size 64 + +.visible .entry match_sync( + .param .u64 output +) +{ + .reg .u64 out_addr; + .reg .u64 out_index; + .reg .u32 thread_id; + .reg .u32 source; + .reg .u32 result; + + ld.param.u64 out_addr, [output]; + mov.u32 thread_id, %tid.x; + + // source = thread_id & 1 (0 for even lanes, 1 for odd lanes) + and.b32 source, thread_id, 1; + + // result = bitmask of all lanes in the warp with the same source value + // even lanes: result = 0x55555555, odd lanes: result = 0xAAAAAAAA + match.any.sync.b32 result, source, 0xFFFFFFFF; + + // Store u32 result at output[thread_id * 4] + cvt.u64.u32 out_index, thread_id; + mul.lo.u64 out_index, out_index, 4; + add.u64 out_addr, out_addr, out_index; + st.u32 [out_addr], result; + + ret; +} diff --git a/ptx/src/test/spirv_run/mod.rs b/ptx/src/test/spirv_run/mod.rs index f71f47c1e..53722bfbf 100644 --- a/ptx/src/test/spirv_run/mod.rs +++ b/ptx/src/test/spirv_run/mod.rs @@ -327,6 +327,7 @@ test_ptx!(cvt_rn_f16x2_e5m2x2, [0x36EDu16], [0x3600ED00u32]); test_ptx!(cvt_rn_bf16x2_f32, [0.40625, 12.9f32], [0x3ED0414Eu32]); test_ptx!(clz, [0b00000101_00101101_00010011_10101011u32], [5u32]); test_ptx!(popc, [0b10111100_10010010_01001001_10001010u32], [14u32]); +test_ptx!(popc_b64, [0x99427D688BCB5258u64], [30u32]); test_ptx!( brev, [0b11000111_01011100_10101110_11111011u32], @@ -533,6 +534,75 @@ test_ptx!(trap); test_ptx!(noreturn); test_ptx!(createpolicy); +test_ptx_warp!( + match_sync, + [ + 0x55555555u32, + 0xAAAAAAAAu32, + 0x55555555u32, + 0xAAAAAAAAu32, + 0x55555555u32, + 0xAAAAAAAAu32, + 0x55555555u32, + 0xAAAAAAAAu32, + 0x55555555u32, + 0xAAAAAAAAu32, + 0x55555555u32, + 0xAAAAAAAAu32, + 0x55555555u32, + 0xAAAAAAAAu32, + 0x55555555u32, + 0xAAAAAAAAu32, + 0x55555555u32, + 0xAAAAAAAAu32, + 0x55555555u32, + 0xAAAAAAAAu32, + 0x55555555u32, + 0xAAAAAAAAu32, + 0x55555555u32, + 0xAAAAAAAAu32, + 0x55555555u32, + 0xAAAAAAAAu32, + 0x55555555u32, + 0xAAAAAAAAu32, + 0x55555555u32, + 0xAAAAAAAAu32, + 0x55555555u32, + 0xAAAAAAAAu32, + 0x55555555u32, + 0xAAAAAAAAu32, + 0x55555555u32, + 0xAAAAAAAAu32, + 0x55555555u32, + 0xAAAAAAAAu32, + 0x55555555u32, + 0xAAAAAAAAu32, + 0x55555555u32, + 0xAAAAAAAAu32, + 0x55555555u32, + 0xAAAAAAAAu32, + 0x55555555u32, + 0xAAAAAAAAu32, + 0x55555555u32, + 0xAAAAAAAAu32, + 0x55555555u32, + 0xAAAAAAAAu32, + 0x55555555u32, + 0xAAAAAAAAu32, + 0x55555555u32, + 0xAAAAAAAAu32, + 0x55555555u32, + 0xAAAAAAAAu32, + 0x55555555u32, + 0xAAAAAAAAu32, + 0x55555555u32, + 0xAAAAAAAAu32, + 0x55555555u32, + 0xAAAAAAAAu32, + 0x55555555u32, + 0xAAAAAAAAu32, + ] +); test_ptx_warp!( tid, [ @@ -1541,12 +1611,9 @@ fn run_zluda32 + Copy + Debug, Output: From + Copy + Debug + ) .unwrap(); let zluda32 = kernel_metadata::ModuleMetadata32Bit::read_object(&elf_module).unwrap(); - assert_eq!(zluda32.explicit_args_size_align.len(), 1); - assert_eq!( - zluda32.explicit_args_size_align[0].0, - name.to_str().unwrap() - ); - assert_eq!(zluda32.explicit_args_size_align[0].1.len(), 2); + assert_eq!(zluda32.explicit_arg_count.len(), 1); + assert_eq!(zluda32.explicit_arg_count[0].0, name.to_str().unwrap()); + assert_eq!(zluda32.explicit_arg_count[0].1, 2); let mut module = unsafe { mem::zeroed() }; unsafe { hipModuleLoadData(&mut module, elf_module.as_ptr() as _) }.unwrap(); let mut kernel = unsafe { mem::zeroed() }; diff --git a/ptx/src/test/spirv_run/popc_b64.ptx b/ptx/src/test/spirv_run/popc_b64.ptx new file mode 100644 index 000000000..8f4e9bd66 --- /dev/null +++ b/ptx/src/test/spirv_run/popc_b64.ptx @@ -0,0 +1,22 @@ +.version 6.5 +.target sm_30 +.address_size 64 + +.visible .entry popc_b64( + .param .u64 input, + .param .u64 output +) +{ + .reg .u64 in_addr; + .reg .u64 out_addr; + .reg .b32 temp32; + .reg .b64 temp64; + + ld.param.u64 in_addr, [input]; + ld.param.u64 out_addr, [output]; + + ld.b64 temp64, [in_addr]; + popc.b64 temp32, temp64; + st.b32 [out_addr], temp32; + ret; +} diff --git a/ptx_parser/src/ast.rs b/ptx_parser/src/ast.rs index 48714296c..726a682a4 100644 --- a/ptx_parser/src/ast.rs +++ b/ptx_parser/src/ast.rs @@ -664,6 +664,18 @@ ptx_parser_macros::generate_instruction_type!( src_membermask: T } }, + MatchSync { + data: ScalarType, + type: Type::Scalar(ScalarType::B32), + arguments: { + dst: T, + src: { + repr: T, + type: Type::Scalar(data.clone()) + }, + src_membermask: T + } + }, Shf { data: ShfDetails, type: Type::Scalar(ScalarType::B32), diff --git a/ptx_parser/src/lib.rs b/ptx_parser/src/lib.rs index 8bf86c43a..c134c48ca 100644 --- a/ptx_parser/src/lib.rs +++ b/ptx_parser/src/lib.rs @@ -9,7 +9,8 @@ use winnow::ascii::dec_uint; use winnow::combinator::*; use winnow::error::{ErrMode, ErrorKind}; use winnow::stream::Accumulate; -use winnow::token::{any, take_till}; +use winnow::token; +use winnow::token::take_till; use winnow::{ error::{ContextError, ParserError}, stream::{Offset, Stream, StreamIsPartial}, @@ -154,7 +155,7 @@ type PtxParser<'a, 'input> = fn ident<'a, 'input>(stream: &mut PtxParser<'a, 'input>) -> PResult<&'input str> { trace( "ident", - any.verify_map(|(t, _)| { + token::any.verify_map(|(t, _)| { if let Token::Ident(text) = t { if matches!( text, @@ -207,7 +208,7 @@ fn ident<'a, 'input>(stream: &mut PtxParser<'a, 'input>) -> PResult<&'input str> fn dot_ident<'a, 'input>(stream: &mut PtxParser<'a, 'input>) -> PResult<&'input str> { trace( "dot_ident", - any.verify_map(|(t, _)| { + token::any.verify_map(|(t, _)| { if let Token::DotIdent(text) = t { Some(text) } else { @@ -221,7 +222,7 @@ fn dot_ident<'a, 'input>(stream: &mut PtxParser<'a, 'input>) -> PResult<&'input fn num<'a, 'input>(stream: &mut PtxParser<'a, 'input>) -> PResult<(&'input str, u32, bool)> { trace( "num", - any.verify_map(|(t, _)| { + token::any.verify_map(|(t, _)| { Some(match t { Token::Hex(s) => { if s.ends_with('U') { @@ -287,7 +288,7 @@ fn int_immediate<'a, 'input>(input: &mut PtxParser<'a, 'input>) -> PResult(stream: &mut PtxParser<'a, 'input>) -> PResult { - take_error(any.verify_map(|(t, _)| match t { + take_error(token::any.verify_map(|(t, _)| match t { Token::F32Hex(f) => Some(match u32::from_str_radix(&f[2..], 16) { Ok(x) => Ok(f32::from_bits(x)), Err(err) => Err((0.0, PtxError::from(err))), @@ -298,7 +299,7 @@ fn f32<'a, 'input>(stream: &mut PtxParser<'a, 'input>) -> PResult { } fn f64<'a, 'input>(stream: &mut PtxParser<'a, 'input>) -> PResult { - take_error(any.verify_map(|(t, _)| match t { + take_error(token::any.verify_map(|(t, _)| match t { Token::F64Hex(f) => Some(match u64::from_str_radix(&f[2..], 16) { Ok(x) => Ok(f64::from_bits(x)), Err(err) => Err((0.0, PtxError::from(err))), @@ -351,14 +352,15 @@ fn u32<'a, 'input>(stream: &mut PtxParser<'a, 'input>) -> PResult { fn constant<'a, 'input>(stream: &mut PtxParser<'a, 'input>) -> PResult { // Currently the only built-in constant is WARP_SZ // If new ones are added, we can change this to use a Token::Constant(&str) instead - any.verify_map(|(t, _)| { - if t == Token::WarpSz { - Some(ast::ImmediateValue::U64(32)) - } else { - None - } - }) - .parse_next(stream) + token::any + .verify_map(|(t, _)| { + if t == Token::WarpSz { + Some(ast::ImmediateValue::U64(32)) + } else { + None + } + }) + .parse_next(stream) } fn immediate_value<'a, 'input>(stream: &mut PtxParser<'a, 'input>) -> PResult { @@ -552,7 +554,7 @@ fn shader_model<'a>(stream: &mut &str) -> PResult<(u32, Option)> { ( "sm_", dec_uint, - opt(any.verify(|c: &char| c.is_ascii_lowercase())), + opt(token::any.verify(|c: &char| c.is_ascii_lowercase())), eof, ) .map(|(_, digits, arch_variant, _)| (digits, arch_variant)) @@ -582,7 +584,7 @@ fn directive<'a, 'input>( .map(|((linking, var), _)| Some(ast::Directive::Variable(linking, var))), )), ( - any, + token::any, take_till(1.., |(token, _)| match token { // visibility Token::DotExtern | Token::DotVisible | Token::DotWeak @@ -716,7 +718,7 @@ fn linking_directives<'a, 'input>( "linking_directives", repeat( 0.., - dispatch! { any; + dispatch! { token::any; (Token::DotExtern, _) => empty.value(ast::LinkingDirective::EXTERN), (Token::DotVisible, _) => empty.value(ast::LinkingDirective::VISIBLE), (Token::DotWeak, _) => empty.value(ast::LinkingDirective::WEAK), @@ -731,7 +733,7 @@ fn linking_directives<'a, 'input>( fn tuning_directive<'a, 'input>( stream: &mut PtxParser<'a, 'input>, ) -> PResult { - dispatch! {any; + dispatch! {token::any; (Token::DotMaxnreg, _) => u32.map(ast::TuningDirective::MaxNReg), (Token::DotMaxntid, _) => tuple1to3_u32.map(|(nx, ny, nz)| ast::TuningDirective::MaxNtid(nx, ny, nz)), (Token::DotReqntid, _) => tuple1to3_u32.map(|(nx, ny, nz)| ast::TuningDirective::ReqNtid(nx, ny, nz)), @@ -745,7 +747,7 @@ fn tuning_directive<'a, 'input>( fn method_declaration<'a, 'input>( stream: &mut PtxParser<'a, 'input>, ) -> PResult> { - dispatch! {any; + dispatch! {token::any; (Token::DotEntry, _) => (ident, kernel_arguments).map(|(name, input_arguments)| ast::MethodDeclaration{ return_arguments: Vec::new(), name: ast::MethodName::Kernel(name), input_arguments, shared_mem: None }), @@ -788,7 +790,7 @@ fn kernel_input<'a, 'input>( } fn fn_input<'a, 'input>(stream: &mut PtxParser<'a, 'input>) -> PResult> { - dispatch! { any; + dispatch! { token::any; (Token::DotParam, _) => method_parameter(StateSpace::Param, false), (Token::DotReg, _) => method_parameter(StateSpace::Reg, false), _ => fail @@ -837,7 +839,7 @@ fn tuple1to3_u32<'a, 'input>(stream: &mut PtxParser<'a, 'input>) -> PResult<(u32 fn function_body<'a, 'input>( stream: &mut PtxParser<'a, 'input>, ) -> PResult>>>> { - trace("function_body", dispatch! {any; + trace("function_body", dispatch! {token::any; (Token::LBrace, _) => terminated(repeat_without_none(statement), Token::RBrace).map(Some), (Token::Semicolon, _) => empty.map(|_| None), _ => fail @@ -1323,34 +1325,35 @@ fn vector_prefix<'a, 'input>(stream: &mut PtxParser<'a, 'input>) -> PResult(stream: &mut PtxParser<'a, 'input>) -> PResult { - any.verify_map(|(t, _)| { - Some(match t { - Token::DotS8 => ScalarType::S8, - Token::DotS16 => ScalarType::S16, - Token::DotS16x2 => ScalarType::S16x2, - Token::DotS32 => ScalarType::S32, - Token::DotS64 => ScalarType::S64, - Token::DotU8 => ScalarType::U8, - Token::DotU16 => ScalarType::U16, - Token::DotU16x2 => ScalarType::U16x2, - Token::DotU32 => ScalarType::U32, - Token::DotU64 => ScalarType::U64, - Token::DotB8 => ScalarType::B8, - Token::DotB16 => ScalarType::B16, - Token::DotB32 => ScalarType::B32, - Token::DotB64 => ScalarType::B64, - Token::DotB128 => ScalarType::B128, - Token::DotPred => ScalarType::Pred, - Token::DotF16 => ScalarType::F16, - Token::DotF16x2 => ScalarType::F16x2, - Token::DotF32 => ScalarType::F32, - Token::DotF64 => ScalarType::F64, - Token::DotBF16 => ScalarType::BF16, - Token::DotBF16x2 => ScalarType::BF16x2, - _ => return None, + token::any + .verify_map(|(t, _)| { + Some(match t { + Token::DotS8 => ScalarType::S8, + Token::DotS16 => ScalarType::S16, + Token::DotS16x2 => ScalarType::S16x2, + Token::DotS32 => ScalarType::S32, + Token::DotS64 => ScalarType::S64, + Token::DotU8 => ScalarType::U8, + Token::DotU16 => ScalarType::U16, + Token::DotU16x2 => ScalarType::U16x2, + Token::DotU32 => ScalarType::U32, + Token::DotU64 => ScalarType::U64, + Token::DotB8 => ScalarType::B8, + Token::DotB16 => ScalarType::B16, + Token::DotB32 => ScalarType::B32, + Token::DotB64 => ScalarType::B64, + Token::DotB128 => ScalarType::B128, + Token::DotPred => ScalarType::Pred, + Token::DotF16 => ScalarType::F16, + Token::DotF16x2 => ScalarType::F16x2, + Token::DotF32 => ScalarType::F32, + Token::DotF64 => ScalarType::F64, + Token::DotBF16 => ScalarType::BF16, + Token::DotBF16x2 => ScalarType::BF16x2, + _ => return None, + }) }) - }) - .parse_next(stream) + .parse_next(stream) } fn predicated_instruction<'a, 'input>( @@ -1393,7 +1396,7 @@ fn debug_directive<'a, 'input>(stream: &mut PtxParser<'a, 'input>) -> PResult<() Token::Comma, ident_literal("function_name"), ident, - dispatch! { any; + dispatch! { token::any; (Token::Comma, _) => (ident_literal("inlined_at"), u32, u32, u32).void(), (Token::Plus, _) => (u32, Token::Comma, ident_literal("inlined_at"), u32, u32, u32).void(), _ => fail @@ -1458,7 +1461,8 @@ fn ident_literal< s: &'input str, ) -> impl Parser + 'input { move |stream: &mut I| { - any.verify(|(t, _)| matches!(t, Token::Ident(text) if *text == s)) + token::any + .verify(|(t, _)| matches!(t, Token::Ident(text) if *text == s)) .void() .parse_next(stream) } @@ -1672,7 +1676,7 @@ impl<'input, X, I: Stream + StreamIsPartial, E: ParserError for Token<'input> { fn parse_next(&mut self, input: &mut I) -> PResult<(Self, X), E> { - any.verify(|(t, _)| t == self).parse_next(input) + token::any.verify(|(t, _)| t == self).parse_next(input) } } @@ -1681,7 +1685,7 @@ fn bra<'a, 'input>( ) -> PResult>> { preceded( opt(Token::DotUni), - any.verify_map(|(t, _)| match t { + token::any.verify_map(|(t, _)| match t { Token::Ident(ident) => Some(ast::Instruction::Bra { arguments: BraArgs { src: ident }, }), @@ -4398,8 +4402,18 @@ derive_parser!( } } - .dtype: ScalarType = { .u32, .s32, .f32 }; + .dtype: ScalarType = { .s32, .f32 }; .ctype: ScalarType = { .s32, .f32 }; + + // https://docs.nvidia.com/cuda/parallel-thread-execution/ + match.any.sync.type d, a, membermask => { + Instruction::MatchSync { + data: type_, + arguments: MatchSyncArgs { dst: d, src: a, src_membermask: membermask } + } + } + + .type: ScalarType = { .b32, .b64 }; ); #[cfg(test)] diff --git a/ptx_parser_macros/src/lib.rs b/ptx_parser_macros/src/lib.rs index 9000b74c5..51ad91e51 100644 --- a/ptx_parser_macros/src/lib.rs +++ b/ptx_parser_macros/src/lib.rs @@ -1,7 +1,7 @@ use either::Either; use proc_macro2::{Span, TokenStream}; -use ptx_parser_macros_impl::parser; -use quote::{format_ident, quote, ToTokens}; +use ptx_parser_macros_impl::parser::{self, IdentLike}; +use quote::{quote, ToTokens}; use rustc_hash::{FxHashMap, FxHashSet}; use std::{collections::hash_map, hash::Hash, iter, rc::Rc}; use syn::{ @@ -33,7 +33,7 @@ struct OpcodeDefinitions { } impl OpcodeDefinitions { - fn new(opcode: &Ident, definitions: Vec) -> Self { + fn new(opcode: &IdentLike, definitions: Vec) -> Self { let mut selections = vec![None; definitions.len()]; let mut generation = 0usize; loop { @@ -231,8 +231,8 @@ impl SingleOpcodeDefinition { } fn extract_and_insert( - definitions: &mut FxHashMap>, - special_definitions: &mut FxHashMap, + definitions: &mut FxHashMap>, + special_definitions: &mut FxHashMap, parser::OpcodeDefinition(pattern_seq, rules): parser::OpcodeDefinition, ) { let (mut named_rules, mut unnamed_rules) = gather_rules(rules); @@ -471,9 +471,9 @@ fn emit_enum_types( fn emit_parse_function( type_name: &Ident, - defs: &FxHashMap, - special_defs: &FxHashMap, - all_opcode: Vec<&Ident>, + defs: &FxHashMap, + special_defs: &FxHashMap, + all_opcode: Vec<&IdentLike>, all_modifier: FxHashSet<&parser::DotModifier>, ) -> TokenStream { use std::fmt::Write; @@ -606,7 +606,7 @@ fn emit_parse_function( fn emit_definition_parser( token_type: &Ident, - (opcode, fn_idx): (&Ident, usize), + (opcode, fn_idx): (&IdentLike, usize), definition: &SingleOpcodeDefinition, ) -> TokenStream { let return_error_ref = quote! { @@ -630,11 +630,11 @@ fn emit_definition_parser( let variant = value.dot_capitalized(); if *optional { quote! { - #arg_name = opt(any.verify(|(t, _)| *t == #token_type :: #variant)).parse_next(&mut stream)?.is_some(); + #arg_name = opt(winnow::token::any.verify(|(t, _)| *t == #token_type :: #variant)).parse_next(&mut stream)?.is_some(); } } else { quote! { - any.verify(|(t, _)| *t == #token_type :: #variant).parse_next(&mut stream)?; + winnow::token::any.verify(|(t, _)| *t == #token_type :: #variant).parse_next(&mut stream)?; } } } @@ -643,7 +643,7 @@ fn emit_definition_parser( let variant = value.dot_capitalized(); let parsed_variant = value.variant_capitalized(); quote! { - any.verify(|(t, _)| *t == #token_type :: #variant).parse_next(&mut stream)?; + winnow::token::any.verify(|(t, _)| *t == #token_type :: #variant).parse_next(&mut stream)?; #variable = #type_ :: #parsed_variant; } } @@ -659,7 +659,7 @@ fn emit_definition_parser( }); if *optional { quote! { - #arg_name = opt(any.verify_map(|(tok, _)| { + #arg_name = opt(winnow::token::any.verify_map(|(tok, _)| { Some(match tok { #(#variants)* _ => return None @@ -668,7 +668,7 @@ fn emit_definition_parser( } } else { quote! { - #arg_name = any.verify_map(|(tok, _)| { + #arg_name = winnow::token::any.verify_map(|(tok, _)| { Some(match tok { #(#variants)* _ => return None @@ -797,12 +797,12 @@ fn emit_definition_parser( let comma = if idx == 0 || arg.pre_pipe { quote! { empty } } else { - quote! { any.verify(|(t, _)| *t == #token_type::Comma).void() } + quote! { winnow::token::any.verify(|(t, _)| *t == #token_type::Comma).void() } }; let pre_bracket = if arg.pre_bracket { quote! { - any.verify(|(t, _)| *t == #token_type::LBracket).void() + winnow::token::any.verify(|(t, _)| *t == #token_type::LBracket).void() } } else { quote! { @@ -811,7 +811,7 @@ fn emit_definition_parser( }; let pre_pipe = if arg.pre_pipe { quote! { - any.verify(|(t, _)| *t == #token_type::Pipe).void() + winnow::token::any.verify(|(t, _)| *t == #token_type::Pipe).void() } } else { quote! { @@ -820,7 +820,7 @@ fn emit_definition_parser( }; let can_be_negated = if arg.can_be_negated { quote! { - opt(any.verify(|(t, _)| *t == #token_type::Exclamation)).map(|o| o.is_some()) + opt(winnow::token::any.verify(|(t, _)| *t == #token_type::Exclamation)).map(|o| o.is_some()) } } else { quote! { @@ -834,7 +834,7 @@ fn emit_definition_parser( }; let post_bracket = if arg.post_bracket { quote! { - any.verify(|(t, _)| *t == #token_type::RBracket).void() + winnow::token::any.verify(|(t, _)| *t == #token_type::RBracket).void() } } else { quote! { @@ -843,7 +843,7 @@ fn emit_definition_parser( }; let unified = if arg.unified { quote! { - opt(any.verify(|(t, _)| *t == #token_type::DotUnified).void()).map(|u| u.is_some()) + opt(winnow::token::any.verify(|(t, _)| *t == #token_type::DotUnified).void()).map(|u| u.is_some()) } } else { quote! { @@ -886,7 +886,7 @@ fn emit_definition_parser( quote! { let #arguments_pattern = ( #arguments_parser ).parse_next(stream)?; }; let fn_args = definition.function_arguments(); - let fn_name = format_ident!("{}_{}", opcode, fn_idx); + let fn_name = Ident::new(&*format!("{}_{}", opcode, fn_idx), opcode.span()); let fn_call = quote! { #fn_name(&mut stream.state, #(#fn_args),* ) }; @@ -911,10 +911,10 @@ fn emit_definition_parser( } fn write_definitions_into_tokens<'a>( - defs: &'a FxHashMap, - special_definitions: impl Iterator, + defs: &'a FxHashMap, + special_definitions: impl Iterator, variants: &mut Punctuated, -) -> (Vec<&'a Ident>, FxHashSet<&'a parser::DotModifier>) { +) -> (Vec<&'a IdentLike>, FxHashSet<&'a parser::DotModifier>) { let mut all_opcodes = Vec::new(); let mut all_modifiers = FxHashSet::default(); for (opcode, definitions) in defs.iter() { diff --git a/ptx_parser_macros_impl/src/parser.rs b/ptx_parser_macros_impl/src/parser.rs index 71dc8b53b..c318c5380 100644 --- a/ptx_parser_macros_impl/src/parser.rs +++ b/ptx_parser_macros_impl/src/parser.rs @@ -32,7 +32,7 @@ impl Parse for ParseDefinitions { if lookahead.peek(Token![#]) { let enum_ = input.parse::()?; additional_enums.insert(enum_.ident.clone(), enum_); - } else if lookahead.peek(Ident) { + } else if lookahead.peek(Ident) || lookahead.peek(Token![match]) { definitions.push(input.parse::()?); } else { return Err(lookahead.error()); @@ -229,12 +229,12 @@ impl Parse for Rule { } pub struct Instruction { - pub name: Ident, + pub name: IdentLike, pub modifiers: Vec, } impl Instruction { fn peek(input: syn::parse::ParseStream) -> bool { - if !input.peek(Ident) { + if !input.peek(Ident) && !input.peek(Token![match]) { return false; } if input.peek2(Token![=]) && input.peek3(syn::token::Brace) { @@ -246,7 +246,7 @@ impl Instruction { impl Parse for Instruction { fn parse(input: syn::parse::ParseStream) -> syn::Result { - let instruction = input.parse::()?; + let instruction = input.parse::()?; let mut modifiers = Vec::new(); loop { if !MaybeDotModifier::peek(input) { @@ -333,7 +333,10 @@ impl DotModifier { write!(&mut result, "_{}", part2.0).unwrap(); } else { match self.part1 { - IdentLike::Type(_) | IdentLike::Const(_) | IdentLike::Async(_) => result.push('_'), + IdentLike::Match(_) + | IdentLike::Type(_) + | IdentLike::Const(_) + | IdentLike::Async(_) => result.push('_'), IdentLike::Ident(_) | IdentLike::Integer(_) => {} } } @@ -443,7 +446,8 @@ impl Parse for HyphenatedIdent { } #[derive(PartialEq, Eq, Hash, Clone)] -enum IdentLike { +pub enum IdentLike { + Match(Token![match]), Type(Token![type]), Const(Token![const]), Async(Token![async]), @@ -452,8 +456,9 @@ enum IdentLike { } impl IdentLike { - fn span(&self) -> Span { + pub fn span(&self) -> Span { match self { + IdentLike::Match(m) => m.span(), IdentLike::Type(c) => c.span(), IdentLike::Const(t) => t.span(), IdentLike::Async(a) => a.span(), @@ -466,6 +471,7 @@ impl IdentLike { impl std::fmt::Display for IdentLike { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { + IdentLike::Match(_) => f.write_str("match"), IdentLike::Type(_) => f.write_str("type"), IdentLike::Const(_) => f.write_str("const"), IdentLike::Async(_) => f.write_str("async"), @@ -478,6 +484,7 @@ impl std::fmt::Display for IdentLike { impl ToTokens for IdentLike { fn to_tokens(&self, tokens: &mut TokenStream) { match self { + IdentLike::Match(_) => quote! { match }.to_tokens(tokens), IdentLike::Type(_) => quote! { type }.to_tokens(tokens), IdentLike::Const(_) => quote! { const }.to_tokens(tokens), IdentLike::Async(_) => quote! { async }.to_tokens(tokens), @@ -496,6 +503,8 @@ impl Parse for IdentLike { IdentLike::Type(input.parse::()?) } else if lookahead.peek(Token![async]) { IdentLike::Async(input.parse::()?) + } else if lookahead.peek(Token![match]) { + IdentLike::Match(input.parse::()?) } else if lookahead.peek(Ident) { IdentLike::Ident(input.parse::()?) } else if lookahead.peek(LitInt) { diff --git a/xtask/src/main.rs b/xtask/src/main.rs index c362655d2..5e4763bdc 100644 --- a/xtask/src/main.rs +++ b/xtask/src/main.rs @@ -37,14 +37,11 @@ struct Cargo { release: Option, #[bpaf(long)] profile: Option, - #[bpaf(long)] - target: Option, #[bpaf(any("", Some), many)] _unused: Vec, } struct Project { - is_32bit: bool, #[cfg_attr(unix, allow(unused))] manifest_path: PathBuf, name: String, @@ -54,7 +51,7 @@ struct Project { } impl Project { - fn try_new(p: Package, is_32bit: bool) -> Option { + fn try_new(p: Package) -> Option { let name = p.name; let manifest_path = p.manifest_path.into(); serde_json::from_value::>(p.metadata) @@ -79,14 +76,13 @@ impl Project { target_name, target_kind, meta: m.zluda, - is_32bit, } }) } #[cfg(windows)] fn zip_compiler_output(&self) -> bool { - self.meta.windows_paths(self.is_32bit).is_empty() + self.meta.windows_paths.is_empty() } #[cfg(unix)] @@ -150,7 +146,7 @@ impl Project { target_dir, profile, libname, - self.meta.windows_paths(self.is_32bit).as_slice(), + self.meta.windows_paths.as_slice(), ) .map(move |(.., full_path, target)| { let copy_output = full_path.clone(); @@ -243,10 +239,6 @@ struct ZludaMetadata { linux_only: bool, #[serde(default)] windows_only: bool, - #[serde(default = "always_true", rename = "64bit")] - is_64bit: bool, - #[serde(default, rename = "32bit")] - is_32bit: bool, #[serde(default)] debug_only: bool, #[cfg_attr(not(unix), allow(unused))] @@ -257,26 +249,9 @@ struct ZludaMetadata { windows_paths: Vec, #[serde(default)] #[cfg_attr(unix, allow(unused))] - windows32_paths: Vec, - #[serde(default)] - #[cfg_attr(unix, allow(unused))] windows_extra_files: HashMap, } -impl ZludaMetadata { - fn windows_paths(&self, is_32bit: bool) -> &Vec { - if is_32bit && !self.windows32_paths.is_empty() { - &self.windows32_paths - } else { - &self.windows_paths - } - } -} - -fn always_true() -> bool { - true -} - fn main() { let options = match options().run_inner(Args::current_args()) { Ok(b) => b, @@ -297,33 +272,21 @@ fn main() { } fn compile(b: Build) -> (PathBuf, String, Vec) { - let cargo_flags = sniff_out_cargo_flags(&b.cargo_arguments); + let profile = sniff_out_profile_name(&b.cargo_arguments); let meta = MetadataCommand::new().no_deps().exec().unwrap(); - let mut target_directory = meta.target_directory.into_std_path_buf(); - if let Some(target) = &cargo_flags.target { - target_directory.push(target); - } + let target_directory = meta.target_directory.into_std_path_buf(); let projects = meta .packages .into_iter() - .filter_map(|pkg| Project::try_new(pkg, cargo_flags.is_32bit)) + .filter_map(Project::try_new) .filter(|project| { - if cargo_flags.is_32bit { - if !project.meta.is_32bit { - return false; - } - } else { - if !project.meta.is_64bit { - return false; - } - } if project.meta.linux_only && cfg!(windows) { return false; } if project.meta.windows_only && cfg!(not(windows)) { return false; } - if project.meta.debug_only && cargo_flags.profile != "debug" { + if project.meta.debug_only && profile != "debug" { return false; } true @@ -339,21 +302,13 @@ fn compile(b: Build) -> (PathBuf, String, Vec) { } command.args(b.cargo_arguments); assert!(command.status().unwrap().success()); - os::make_symlinks(&target_directory, &*projects, &*cargo_flags.profile); - (target_directory, cargo_flags.profile, projects) + os::make_symlinks(&target_directory, &*projects, &*profile); + (target_directory, profile, projects) } -fn sniff_out_cargo_flags(b: &[OsString]) -> CargoFlags { +fn sniff_out_profile_name(b: &[OsString]) -> String { let parsed_cargo_arguments = cargo().to_options().run_inner(b); - let (target, is_32bit) = match parsed_cargo_arguments.as_ref() { - Ok(Cargo { - target: Some(target), - .. - }) => (Some(target.clone()), target.starts_with("i686")), - Ok(Cargo { target: None, .. }) => (None, cfg!(target_pointer_width = "32")), - _ => (None, false), - }; - let profile = match parsed_cargo_arguments { + match parsed_cargo_arguments { Ok(Cargo { release: Some(true), .. @@ -363,20 +318,9 @@ fn sniff_out_cargo_flags(b: &[OsString]) -> CargoFlags { .. }) => profile, _ => "debug".to_string(), - }; - CargoFlags { - profile, - target, - is_32bit, } } -struct CargoFlags { - profile: String, - target: Option, - is_32bit: bool, -} - fn zip(zip: Build) { let (target_dir, profile, projects) = compile(zip); os::zip(target_dir, profile, projects) diff --git a/zluda/src/impl/driver.rs b/zluda/src/impl/driver.rs index 11e593c7e..1a8987cb5 100644 --- a/zluda/src/impl/driver.rs +++ b/zluda/src/impl/driver.rs @@ -1,6 +1,5 @@ use crate::r#impl::{self, context, device, function, module}; use cuda_types::cuda::*; -use dark_api::FunctionArgInfo; use hip_runtime_sys::*; use libloading::Library; use std::{ @@ -470,91 +469,6 @@ fn get_device_hash_info() -> Result, CUerror> { static EXPORT_TABLE: ::dark_api::cuda::CudaDarkApiGlobalTable = ::dark_api::cuda::CudaDarkApiGlobalTable::new::(); -struct Zluda32DarkApi {} - -impl ::dark_api::zluda32::CudaDarkApi for Zluda32DarkApi { - unsafe extern "system" fn get_module_globals( - names: *mut *mut u8, - initializers: *mut *const u8, - sizes: *mut u32, - alignments: *mut u32, - count: *mut u32, - module: cuda_types::cuda::CUmodule, - ) -> cuda_types::cuda::CUresult { - let module: &module::Module = FromCuda::<_, CUerror>::from_cuda(&module)?; - let zluda32 = module.bit32.as_ref().ok_or(CUerror::NOT_FOUND)?; - if let Some(c) = count.as_mut() { - *c = zluda32.globals.len() as u32; - } - let mut names = if names.is_null() { - None - } else { - Some(slice::from_raw_parts_mut(names, zluda32.globals.len())) - }; - let mut initializers = if initializers.is_null() { - None - } else { - Some(slice::from_raw_parts_mut( - initializers, - zluda32.globals.len(), - )) - }; - let mut sizes = if sizes.is_null() { - None - } else { - Some(slice::from_raw_parts_mut(sizes, zluda32.globals.len())) - }; - let mut alignments = if alignments.is_null() { - None - } else { - Some(slice::from_raw_parts_mut(alignments, zluda32.globals.len())) - }; - if names.is_some() || initializers.is_some() || sizes.is_some() || alignments.is_some() { - for (i, global) in zluda32.globals.iter().enumerate() { - if let Some(names) = &mut names { - names[i] = global.name.as_ptr() as *mut u8; - } - if let Some(initializers) = &mut initializers { - initializers[i] = global.initializer.as_ptr(); - } - if let Some(sizes) = &mut sizes { - sizes[i] = global.initializer.len() as u32; - } - if let Some(alignments) = &mut alignments { - alignments[i] = global.align as u32; - } - } - } - Ok(()) - } - - unsafe extern "system" fn get_function_info( - explicit_sizes_out: *mut FunctionArgInfo, - explicit_count_out: *mut u32, - func: cuda_types::cuda::CUfunction, - ) -> cuda_types::cuda::CUresult { - let func: &function::Function = FromCuda::<_, CUerror>::from_cuda(&func)?; - let explicit_args_size_align = match &func.explicit_args_size_align { - Some(sizes) => sizes, - None => return CUresult::ERROR_NOT_FOUND, - }; - if !explicit_sizes_out.is_null() { - std::ptr::copy_nonoverlapping( - explicit_args_size_align.as_ptr(), - explicit_sizes_out, - explicit_args_size_align.len(), - ); - } - if let Some(explicit_count_out) = explicit_count_out.as_mut() { - *explicit_count_out = explicit_args_size_align.len() as u32; - } - Ok(()) - } -} - -static ZLUDA32_EXPORT_TABLE: ::dark_api::zluda32::CudaDarkApiGlobalTable = - ::dark_api::zluda32::CudaDarkApiGlobalTable::new::(); - pub(crate) fn get_export_table( pp_export_table: &mut *const ::core::ffi::c_void, p_export_table_id: &CUuuid, @@ -562,9 +476,6 @@ pub(crate) fn get_export_table( if let Some(table) = EXPORT_TABLE.get(p_export_table_id) { *pp_export_table = table.start(); cuda_types::cuda::CUresult::SUCCESS - } else if let Some(table) = ZLUDA32_EXPORT_TABLE.get(p_export_table_id) { - *pp_export_table = table.start(); - cuda_types::cuda::CUresult::SUCCESS } else { cuda_types::cuda::CUresult::ERROR_INVALID_VALUE } diff --git a/zluda/src/impl/function.rs b/zluda/src/impl/function.rs index aea11d554..6dd6f3144 100644 --- a/zluda/src/impl/function.rs +++ b/zluda/src/impl/function.rs @@ -1,12 +1,10 @@ use cuda_types::cuda::{CUfunction, CUfunction_attribute, CUkernel}; -use dark_api::FunctionArgInfo; use hip_runtime_sys::*; use std::mem; pub(crate) struct Function { pub(crate) base: hipFunction_t, pub(crate) sm_version: u32, - pub(crate) explicit_args_size_align: Option>, } impl<'a, E: zluda_common::CudaErrorType> zluda_common::FromCuda<'a, CUfunction, E> diff --git a/zluda/src/impl/hipfix.rs b/zluda/src/impl/hipfix.rs index 3326da8cd..f8de70767 100644 --- a/zluda/src/impl/hipfix.rs +++ b/zluda/src/impl/hipfix.rs @@ -18,9 +18,6 @@ const HIP_TRSA_OVERRIDE_FORMAT: u32 = 1; pub(crate) unsafe fn refresh_texref(raw_texref: *mut textureReference) -> hipError_t { let texref = raw_texref.as_ref().ok_or(hipErrorCode_t::InvalidValue)?; let mut res_desc = std::mem::zeroed(); - if texref.textureObject.is_null() { - return Ok(()); - } hipTexObjectGetResourceDesc(&mut res_desc, texref.textureObject)?; match res_desc.resType { HIPresourcetype::HIP_RESOURCE_TYPE_ARRAY => hipTexRefSetArray( diff --git a/zluda/src/impl/library.rs b/zluda/src/impl/library.rs index 98be33e67..9869d8eca 100644 --- a/zluda/src/impl/library.rs +++ b/zluda/src/impl/library.rs @@ -21,8 +21,8 @@ impl Library { let module_lock = self.modules.get(device).ok_or(CUerror::INVALID_DEVICE)?; *module_lock.get_or_init(|| match self.data { LibraryData::Lazy(lib) => { - let (module, sm_version, meta32) = module::load_hip_module(lib)?; - Ok(Module::new(module, sm_version, meta32).wrap()) + let (module, sm_version) = module::load_hip_module(lib)?; + Ok(Module::new(module, sm_version).wrap()) } LibraryData::Eager(()) => Err(CUerror::NOT_SUPPORTED), }) diff --git a/zluda/src/impl/module.rs b/zluda/src/impl/module.rs index f49c72478..c49051ddd 100644 --- a/zluda/src/impl/module.rs +++ b/zluda/src/impl/module.rs @@ -2,7 +2,6 @@ use super::driver; use crate::r#impl::function; use crate::r#impl::{driver::GlobalState, function::Function}; use cuda_types::{cuda::*, dark_api::FatbinFileHeader}; -use dark_api::FunctionArgInfo; use hip_runtime_sys::*; use rustc_hash::FxHashMap; use std::collections::hash_map; @@ -18,7 +17,6 @@ use zluda_common::{CodeLibraryRef, CodeModuleRef, ZludaObject}; pub(crate) struct Module { pub(crate) base: hipModule_t, pub(crate) sm_version: u32, - pub(crate) bit32: Option, mutable: Mutex, } @@ -32,7 +30,6 @@ impl ModuleMutable { module: hipModule_t, sm_version: u32, name: CString, - explicit_args_size_align: Option>, ) -> Result<&Function, CUerror> { Ok(match self.functions.entry(name) { hash_map::Entry::Occupied(entry) => &*entry.into_mut(), @@ -42,7 +39,6 @@ impl ModuleMutable { let func = Box::new(Function { base: func_handle, sm_version, - explicit_args_size_align, }); &*entry.insert(func) } @@ -62,102 +58,21 @@ impl ZludaObject for Module { } } -pub(crate) struct Metadata32Bit { - pub globals: Vec, - pub explicit_args_size_align: FxHashMap>, -} - -impl Metadata32Bit { - fn new(meta: &kernel_metadata::ModuleMetadata32Bit) -> Self { - let globals = meta - .globals - .iter() - .map(|g| Global32Bit { - name: CString::new(&*g.name).unwrap(), - initializer: g.initializer.to_vec(), - align: g.align, - }) - .collect(); - let explicit_args_size_align = meta - .explicit_args_size_align - .iter() - .map(|(key, value)| { - let key = key.to_string(); - let value = value - .iter() - .map(|(size, align)| FunctionArgInfo { - size: *size, - align: *align, - }) - .collect(); - (key, value) - }) - .collect(); - Self { - globals, - explicit_args_size_align, - } - } - - fn from_archived(archived: &kernel_metadata::ArchivedModuleMetadata32Bit) -> Self { - let globals = archived - .globals - .iter() - .map(|g| Global32Bit { - name: CString::new(g.name.as_str()).unwrap(), - initializer: g.initializer.to_vec(), - align: g.align.to_native(), - }) - .collect(); - let explicit_args_size_align = archived - .explicit_args_size_align - .iter() - .map(|kv| { - ( - kv.0.to_string(), - kv.1.iter() - .map(|x| FunctionArgInfo { - size: x.0.to_native(), - align: x.1.to_native(), - }) - .collect(), - ) - }) - .collect(); - Self { - globals, - explicit_args_size_align, - } - } -} - -pub(crate) struct Global32Bit { - pub name: CString, - pub initializer: Vec, - pub align: u32, -} - impl Module { - pub(crate) fn new(base: hipModule_t, sm_version: u32, bit32: Option) -> Self { + pub(crate) fn new(base: hipModule_t, sm_version: u32) -> Self { Self { base, sm_version, mutable: Mutex::new(ModuleMutable { functions: FxHashMap::default(), }), - bit32, } } pub(crate) fn get_function<'a>(&'a self, name: &CStr) -> Result<&'static Function, CUerror> { let mut mutable = self.mutable.lock().map_err(|_| CUerror::UNKNOWN)?; - let explicit_args = self.bit32.as_ref().and_then(|meta| { - meta.explicit_args_size_align - .get(name.to_str().ok()?) - .map(Vec::clone) - }); mutable - .get_function(self.base, self.sm_version, name.to_owned(), explicit_args) + .get_function(self.base, self.sm_version, name.to_owned()) .map(|f| unsafe { (f as *const Function).as_ref().unwrap() }) } } @@ -165,7 +80,7 @@ impl Module { fn get_best_ptx_and_compile( global_state: &GlobalState, image: CodeLibraryRef<'_>, -) -> Result<(hipModule_t, u32, Option), CUerror> { +) -> Result<(hipModule_t, u32), CUerror> { let mut ptx_modules = Vec::new(); unsafe { CodeLibraryRef::iterate_modules(image, |_, module| match module { @@ -176,7 +91,7 @@ fn get_best_ptx_and_compile( if file.header.kind != FatbinFileHeader::HEADER_KIND_PTX { return; } - if let Ok(text) = file.get_or_decompress_content(true) { + if let Ok(text) = file.get_or_decompress_content() { if let Some(text) = cow_bytes_to_str(text) { ptx_modules.push(text); } @@ -253,12 +168,12 @@ fn get_best_ptx_and_compile( _ => None, }; let cached_binary = load_cached_binary(&mut cache_with_key); - let (elf_module, sm_version, zluda32) = cached_binary + let (elf_module, sm_version) = cached_binary .ok_or(CUerror::UNKNOWN) .or_else(|_| compile_and_cache(gcn_arch, attributes, module, &mut cache_with_key))?; let mut hip_module = unsafe { mem::zeroed() }; unsafe { hipModuleLoadData(&mut hip_module, elf_module.as_ptr().cast()) }?; - Ok((hip_module, sm_version, zluda32)) + Ok((hip_module, sm_version)) } fn cow_bytes_to_str<'a>(data: Cow<'a, [u8]>) -> Option> { @@ -268,9 +183,7 @@ fn cow_bytes_to_str<'a>(data: Cow<'a, [u8]>) -> Option> { } } -pub(crate) fn load_hip_module( - library: CodeLibraryRef, -) -> Result<(hipModule_t, u32, Option), CUerror> { +pub(crate) fn load_hip_module(library: CodeLibraryRef) -> Result<(hipModule_t, u32), CUerror> { let global_state = driver::global_state()?; get_best_ptx_and_compile(global_state, library) } @@ -316,16 +229,14 @@ fn get_cache_key<'a, 'b>( fn load_cached_binary( cache_with_key: &mut Option<(zluda_cache::ModuleCache, zluda_cache::ModuleKey)>, -) -> Option<(Vec, u32, Option)> { +) -> Option<(Vec, u32)> { let binary = cache_with_key .as_mut() .and_then(|(c, key)| c.get_module_binary(key))?; let sm_version = kernel_metadata::ModuleMetadataV1::read_object(&binary)? .sm_version .to_native(); - let zluda32 = kernel_metadata::ModuleMetadata32Bit::read_object(&binary) - .map(Metadata32Bit::from_archived); - Some((binary, sm_version, zluda32)) + Some((binary, sm_version)) } fn compile_and_cache( @@ -333,7 +244,7 @@ fn compile_and_cache( attributes: ExtraCacheAttributes, ast: ptx_parser::Module, cache_with_key: &mut Option<(zluda_cache::ModuleCache, zluda_cache::ModuleKey)>, -) -> Result<(Vec, u32, Option), CUerror> { +) -> Result<(Vec, u32), CUerror> { let llvm_module = ptx::to_llvm_module( ast, ptx::Attributes { @@ -344,7 +255,6 @@ fn compile_and_cache( .map_err(|_| CUerror::UNKNOWN)?; let ptx_impl = llvm_module.linked_bitcode(); let sm_version = llvm_module.metadata.sm_version; - let metadata32 = llvm_module.metadata32.as_ref().map(Metadata32Bit::new); let elf_module = llvm_zluda::compile( &llvm_module.context, gcn_arch, @@ -360,7 +270,7 @@ fn compile_and_cache( key.last_access = zluda_cache::ModuleCache::time_now(); cache.insert_module(key, &elf_module); } - Ok((elf_module, sm_version, metadata32)) + Ok((elf_module, sm_version)) } pub(crate) fn load(module: &mut CUmodule, fname: &CStr) -> CUresult { @@ -370,16 +280,16 @@ pub(crate) fn load(module: &mut CUmodule, fname: &CStr) -> CUresult { image.push(0); let library = unsafe { CodeLibraryRef::try_load(image.as_ptr() as *const std::ffi::c_void) } .map_err(|_| CUerror::NO_BINARY_FOR_GPU)?; - let (hip_module, sm_version, meta32) = load_hip_module(library)?; - *module = Module::new(hip_module, sm_version, meta32).wrap(); + let (hip_module, sm_version) = load_hip_module(library)?; + *module = Module::new(hip_module, sm_version).wrap(); Ok(()) } pub(crate) fn load_data(module: &mut CUmodule, image: &std::ffi::c_void) -> CUresult { let library = unsafe { CodeLibraryRef::try_load(image) }.map_err(|_| CUerror::NO_BINARY_FOR_GPU)?; - let (hip_module, sm_version, meta32) = load_hip_module(library)?; - *module = Module::new(hip_module, sm_version, meta32).wrap(); + let (hip_module, sm_version) = load_hip_module(library)?; + *module = Module::new(hip_module, sm_version).wrap(); Ok(()) } diff --git a/zluda/src/impl/tex.rs b/zluda/src/impl/tex.rs index 347469a65..225e10a2a 100644 --- a/zluda/src/impl/tex.rs +++ b/zluda/src/impl/tex.rs @@ -101,9 +101,6 @@ pub(crate) unsafe fn ref_set_address_v2( dev_ptr: hipDeviceptr_t, bytes: usize, ) -> hipError_t { - if dev_ptr.0.is_null() { - return hipUnbindTexture(texref); - } hipTexRefSetAddress(byte_offset, texref, dev_ptr, bytes) } diff --git a/zluda32/Cargo.toml b/zluda32/Cargo.toml deleted file mode 100644 index 6dec35bd4..000000000 --- a/zluda32/Cargo.toml +++ /dev/null @@ -1,44 +0,0 @@ -[package] -name = "zluda32" -version = "0.0.0" -authors = ["Andrzej Janik "] -edition = "2021" - -[lib] -name = "nvcuda" -crate-type = ["cdylib"] - -[dependencies] -cuda_types = { path = "../cuda_types" } -zluda_common = { path = "../zluda_common" } -cuda_macros = { path = "../cuda_macros" } -zluda_windows = { path = "../zluda_windows" } -zluda_server_common = { path = "../zluda_server_common" } -dark_api = { path = "../dark_api" } -paste = "1.0" -ipc-channel = "^0.21.0" -windows = { version = "0.62.2", features = [ - "Win32_Foundation", - "Win32_Storage_FileSystem", - "Win32_System_IO", - "Win32_System_Pipes", - "Win32_Security", -] } -# windows-sys = { version = "0.61.2", features = [ -# "Win32_Foundation", -# "Win32_System_Pipes", -# "Win32_Storage_FileSystem", -# ] } -rand = "0.10.1" -widestring = "1.2.1" -bitcode = "0.6.9" -postcard = "1.1.3" -bincode = "2.0.1" -rkyv = "0.8.15" -unwrap_or = "1.0.1" -rustc-hash = "2.0.0" - -[package.metadata.zluda] -windows_only = true -64bit = false -32bit = true diff --git a/zluda32/src/ipc.rs b/zluda32/src/ipc.rs deleted file mode 100644 index fc527aec6..000000000 --- a/zluda32/src/ipc.rs +++ /dev/null @@ -1,175 +0,0 @@ -use cuda_types::cuda::CUerror; -use rand::distr::{Alphanumeric, SampleString}; -use rkyv::api::high::HighSerializer; -use rkyv::de::Pool; -use rkyv::rancor::{Failure, Strategy}; -use rkyv::rend::u32_le; -use rkyv::ser::allocator::ArenaHandle; -use rkyv::util::AlignedVec; -use rkyv::{rancor, Archive, Deserialize, Portable, Serialize}; -use std::io::{Read, Write}; -use std::os::windows::io::{AsHandle, AsRawHandle, FromRawHandle}; -// use rkyv::util::AlignedVec; -use std::num::NonZeroU32; -use std::process::{Child, Command, Stdio}; -use std::sync::{Mutex, OnceLock}; -use std::{mem, ptr}; -use widestring::{u16str, U16CString}; -use windows::core::{Error, Owned, PCSTR}; -use windows::Win32::Foundation::*; -use windows::Win32::System::Pipes::*; -use zluda_server_common::Opcode; - -fn server_path() -> &'static str { - if cfg!(debug_assertions) { - r"C:\dev\ZLUDA\target\debug\zluda64_server.exe" - } else { - //"zluda64_server.exe" - r"C:\dev\ZLUDA\target\release\zluda64_server.exe" - } -} - -pub(crate) struct Server { - pipe: std::fs::File, - _child: Child, - buffer: AlignedVec, -} - -unsafe impl Sync for Server {} -unsafe impl Send for Server {} - -impl Server { - fn new(pipe: std::fs::File, child: Child) -> Self { - Self { - pipe, - _child: child, - buffer: AlignedVec::new(), - } - } - - pub unsafe fn start() -> Result { - let name = Alphanumeric.sample_string(&mut rand::rng(), 32); - let pipe_path = format!("\\\\.\\pipe\\zluda-{name}\0"); - let pipe = std::fs::File::from_raw_handle( - CreateNamedPipeA( - PCSTR(pipe_path.as_ptr()), - windows::Win32::Storage::FileSystem::PIPE_ACCESS_DUPLEX, - PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT | PIPE_REJECT_REMOTE_CLIENTS, - 1, - 4 * 1024, - 4 * 1024, - 0, - None, - )? - .0, - ); - let child = Command::new(server_path()) - .arg(&pipe_path[..pipe_path.len() - 1]) - .stdin(Stdio::null()) - .stdout(Stdio::null()) - .stderr(Stdio::null()) - .spawn()?; - zluda_windows::kill_child_on_process_exit(child.as_handle().as_raw_handle())?; - match ConnectNamedPipe(HANDLE(pipe.as_raw_handle()), None) { - Ok(_) => Ok(Server::new(pipe, child)), - Err(e) if e.code() == ERROR_PIPE_CONNECTED.into() => Ok(Server::new(pipe, child)), - Err(e) => Err(e), - } - } - - pub(crate) fn remote_call_zero_copy( - &mut self, - opcode: Opcode, - data: impl for<'a, 'b> Serialize< - HighSerializer<&'a mut AlignedVec, ArenaHandle<'b>, rkyv::rancor::Failure>, - >, - ) -> Result { - self.buffer.clear(); - self.pipe - .write_all(&(opcode as u32).to_le_bytes()[..]) - .map_err(|_| CUerror::UNKNOWN)?; - let slice = - rkyv::api::high::to_bytes_in::<_, rkyv::rancor::Failure>(&data, &mut self.buffer) - .map_err(|_| CUerror::UNKNOWN)?; - self.pipe.write_all(&slice).map_err(|_| CUerror::UNKNOWN)?; - read_return_code(self)?; - self.buffer.resize(mem::size_of::(), 0); - self.pipe - .read_exact(&mut self.buffer) - .map_err(|_| CUerror::UNKNOWN)?; - let output = unsafe { rkyv::access_unchecked::(&self.buffer) }; - Ok(output.clone()) - } - - pub(crate) fn remote_call_framed_in( - &mut self, - opcode: Opcode, - data: impl for<'a, 'b> Serialize< - HighSerializer<&'a mut AlignedVec, ArenaHandle<'b>, rkyv::rancor::Failure>, - >, - ) -> Result { - self.buffer.clear(); - self.pipe - .write_all(&(opcode as u32).to_le_bytes()[..]) - .map_err(|_| CUerror::UNKNOWN)?; - let slice = - rkyv::api::high::to_bytes_in::<_, rkyv::rancor::Failure>(&data, &mut self.buffer) - .map_err(|_| CUerror::UNKNOWN)?; - self.pipe - .write_all(&(slice.len() as u32).to_le_bytes()[..]) - .map_err(|_| CUerror::UNKNOWN)?; - self.pipe.write_all(&slice).map_err(|_| CUerror::UNKNOWN)?; - read_return_code(self)?; - self.buffer.resize(mem::size_of::(), 0); - self.pipe - .read_exact(&mut self.buffer) - .map_err(|_| CUerror::UNKNOWN)?; - let output = unsafe { rkyv::access_unchecked::(&self.buffer) }; - Ok(output.clone()) - } - - pub(crate) fn remote_call_framed_out( - &mut self, - opcode: Opcode, - data: impl for<'a, 'b> Serialize< - HighSerializer<&'a mut AlignedVec, ArenaHandle<'b>, rkyv::rancor::Failure>, - >, - ) -> Result - where - ::Archived: Deserialize>, - { - self.buffer.clear(); - self.pipe - .write_all(&(opcode as u32).to_le_bytes()[..]) - .map_err(|_| CUerror::UNKNOWN)?; - let slice = - rkyv::api::high::to_bytes_in::<_, rkyv::rancor::Failure>(&data, &mut self.buffer) - .map_err(|_| CUerror::UNKNOWN)?; - self.pipe.write_all(&slice).map_err(|_| CUerror::UNKNOWN)?; - read_return_code(self)?; - let out_size = read_u32(self)?; - self.buffer.resize(out_size as usize, 0); - self.pipe - .read_exact(&mut self.buffer) - .map_err(|_| CUerror::UNKNOWN)?; - unsafe { rkyv::from_bytes_unchecked::(&self.buffer) } - .map_err(|_| CUerror::UNKNOWN) - } -} - -fn read_return_code(this: &mut Server) -> Result<(), CUerror> { - let code = read_u32(this)?; - match NonZeroU32::new(code) { - None => Ok(()), - Some(code) => Err(CUerror(code)), - } -} - -fn read_u32(this: &mut Server) -> Result { - let mut code_buffer = [0u8; 4]; - this.pipe - .read_exact(&mut code_buffer) - .map_err(|_| CUerror::UNKNOWN)?; - let code = u32::from_le_bytes(code_buffer); - Ok(code) -} diff --git a/zluda32/src/lib.rs b/zluda32/src/lib.rs deleted file mode 100644 index 5b8c69739..000000000 --- a/zluda32/src/lib.rs +++ /dev/null @@ -1,1014 +0,0 @@ -use cuda_macros::cuda_function_declarations; -use cuda_types::cuda::*; -use dark_api::cuda::CudaDarkApi; -use dark_api::FunctionArgInfo; -use paste::paste; -use rkyv::api::high::HighSerializer; -use rkyv::de::Pool; -use rkyv::rancor::{Failure, Strategy}; -use rkyv::rend::u32_le; -use rkyv::ser::allocator::ArenaHandle; -use rkyv::util::AlignedVec; -use rkyv::{Archive, Deserialize, Portable, Serialize}; -use rustc_hash::FxHashMap; -use std::alloc::Layout; -use std::slice; -use std::sync::{Mutex, OnceLock}; -use std::{cell::RefCell, ffi::c_void, ptr}; -use zluda_common::{CodeLibraryRef, CodeModuleRef, CudaErrorType}; -use zluda_server_common::*; - -mod ipc; - -macro_rules! not_implemented { - ($($abi:literal fn $fn_name:ident( $($arg_id:ident : $arg_type:ty),* ) -> $ret_type:ty;)*) => { - $( - #[cfg_attr(not(test), no_mangle)] - #[allow(improper_ctypes)] - #[allow(improper_ctypes_definitions)] - #[allow(unused_variables)] - pub unsafe extern $abi fn $fn_name ( $( $arg_id : $arg_type),* ) -> $ret_type { - Err(cuda_types::cuda::CUerror::NOT_SUPPORTED) - } - )* - }; -} - -macro_rules! implemented { - ($($abi:literal fn $fn_name:ident( $($arg_id:ident : $arg_type:ty),* ) -> $ret_type:ty;)*) => { - $( - #[cfg_attr(not(test), no_mangle)] - #[allow(improper_ctypes)] - #[allow(improper_ctypes_definitions)] - pub unsafe extern $abi fn $fn_name ( $( $arg_id : $arg_type),* ) -> $ret_type { - paste!{ [< $fn_name:snake >] ( $( $arg_id ),* ) } - } - )* - - }; -} - -cuda_function_declarations! { - not_implemented, - implemented <= [ - cuCtxCreate_v2, - cuCtxDetach, - cuCtxGetApiVersion, - cuCtxGetCurrent, - cuCtxGetDevice, - cuCtxSynchronize, - cuDeviceComputeCapability, - cuDeviceGet, - cuDeviceGetAttribute, - cuDeviceGetCount, - cuDeviceGetName, - cuDeviceGetProperties, - cuDeviceTotalMem_v2, - cuDriverGetVersion, - cuEventCreate, - cuEventDestroy_v2, - cuGetExportTable, - cuInit, - cuLaunchKernel, - cuMemAlloc_v2, - cuMemcpyDtoDAsync_v2, - cuMemcpyDtoHAsync_v2, - cuMemcpyHtoDAsync_v2, - cuMemFree_v2, - cuMemFreeHost, - cuMemGetAddressRange_v2, - cuMemHostAlloc, - cuMemsetD8_v2, - cuModuleGetFunction, - cuModuleGetGlobal_v2, - cuModuleGetTexRef, - cuStreamCreate, - cuStreamDestroy_v2, - cuTexRefSetAddress_v2, - cuTexRefSetAddressMode, - cuTexRefSetFilterMode, - cuTexRefSetFlags, - cuTexRefSetFormat, - cuTexRefSetMaxAnisotropy, - cuTexRefSetMipmapFilterMode, - cuTexRefSetMipmapLevelBias, - cuTexRefSetMipmapLevelClamp, - ] -} - -thread_local! { - pub(crate) static CONTEXT_STACK: ContextStack = ContextStack::new(); -} - -struct ContextStack(RefCell>); - -impl ContextStack { - fn new() -> Self { - ContextStack(RefCell::new(Vec::new())) - } - - fn push(&self, ctx: CUcontext, dev: CUdevice) { - self.0.borrow_mut().push((ctx, dev)); - } - - fn unwrap(&self, ctx: CUcontext) -> Result { - if ctx.0.is_null() { - let stack = self.0.borrow(); - stack - .last() - .map(|(ctx, _)| *ctx) - .ok_or(CUerror::INVALID_VALUE) - } else { - Ok(ctx) - } - } - - fn current(&self) -> (CUcontext, CUdevice) { - self.0 - .borrow() - .last() - .copied() - .unwrap_or((CUcontext(ptr::null_mut()), 0)) - } -} - -struct GlobalState { - function_args: FxHashMap>, - server: ipc::Server, -} - -impl GlobalState { - fn get() -> Result<&'static Mutex, CUerror> { - static LOCK: OnceLock, windows::core::Error>> = OnceLock::new(); - LOCK.get_or_init(|| { - Ok(Mutex::new(GlobalState { - function_args: FxHashMap::default(), - server: unsafe { ipc::Server::start() }?, - })) - }) - .as_ref() - .map_err(|_| CUerror::UNKNOWN) - } - - pub(crate) fn remote_call_zero_copy( - opcode: Opcode, - data: impl for<'a, 'b> Serialize< - HighSerializer<&'a mut AlignedVec, ArenaHandle<'b>, rkyv::rancor::Failure>, - >, - ) -> Result { - Self::get()? - .lock() - .map_err(|_| CUerror::UNKNOWN)? - .server - .remote_call_zero_copy(opcode, data) - } - - pub(crate) fn remote_call_framed_in( - opcode: Opcode, - data: impl for<'a, 'b> Serialize< - HighSerializer<&'a mut AlignedVec, ArenaHandle<'b>, rkyv::rancor::Failure>, - >, - ) -> Result { - Self::get()? - .lock() - .map_err(|_| CUerror::UNKNOWN)? - .server - .remote_call_framed_in(opcode, data) - } - - pub(crate) fn remote_call_framed_out( - opcode: Opcode, - data: impl for<'a, 'b> Serialize< - HighSerializer<&'a mut AlignedVec, ArenaHandle<'b>, rkyv::rancor::Failure>, - >, - ) -> Result - where - ::Archived: Deserialize>, - { - Self::get()? - .lock() - .map_err(|_| CUerror::UNKNOWN)? - .server - .remote_call_framed_out(opcode, data) - } -} - -pub(crate) fn cu_init(flags: u32) -> Result<(), CUerror> { - GlobalState::remote_call_zero_copy::(Opcode::cuInit, cuInitIn { Flags: flags })?; - Ok(()) -} - -pub(crate) fn cu_ctx_create_v2( - pctx: *mut CUcontext, - flags: ::core::ffi::c_uint, - dev: CUdevice, -) -> Result<(), CUerror> { - let ctx_ref = unsafe { pctx.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - let cu_ctx = CudaEncode::decode( - GlobalState::remote_call_zero_copy::( - Opcode::cuCtxCreate_v2, - cuCtxCreate_v2In { flags, dev }, - )? - .pctx, - ); - CONTEXT_STACK.with(|stack| { - stack.push(cu_ctx, dev); - }); - *ctx_ref = cu_ctx; - Ok(()) -} - -pub(crate) fn cu_ctx_detach(ctx: CUcontext) -> Result<(), CUerror> { - unimplemented!() -} - -pub(crate) fn cu_ctx_get_api_version( - ctx: CUcontext, - version: *mut ::core::ffi::c_uint, -) -> Result<(), CUerror> { - let version = unsafe { version.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - let ctx = CONTEXT_STACK.with(|s| s.unwrap(ctx))?; - *version = CudaEncode::decode( - GlobalState::remote_call_zero_copy::( - Opcode::cuCtxGetApiVersion, - cuCtxGetApiVersionIn { - ctx: CudaEncode::encode(ctx), - }, - )? - .version, - ); - Ok(()) -} - -pub(crate) fn cu_ctx_get_current(pctx: *mut CUcontext) -> Result<(), CUerror> { - let pctx = unsafe { pctx.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - *pctx = CONTEXT_STACK.with(|s| s.current()).0; - Ok(()) -} - -pub(crate) fn cu_ctx_get_device(device: *mut CUdevice) -> Result<(), CUerror> { - let device = unsafe { device.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - let (_, dev) = CONTEXT_STACK.with(|s| s.current()); - *device = dev; - Ok(()) -} - -pub(crate) fn cu_ctx_synchronize() -> Result<(), CUerror> { - GlobalState::remote_call_zero_copy::( - Opcode::cuCtxSynchronize, - cuCtxSynchronizeIn {}, - )?; - Ok(()) -} - -pub(crate) fn cu_device_compute_capability( - major: *mut ::core::ffi::c_int, - minor: *mut ::core::ffi::c_int, - dev: CUdevice, -) -> Result<(), CUerror> { - unimplemented!() -} - -pub(crate) fn cu_device_get( - device: *mut CUdevice, - ordinal: ::core::ffi::c_int, -) -> Result<(), CUerror> { - let device = unsafe { device.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - *device = GlobalState::remote_call_zero_copy::( - Opcode::cuDeviceGet, - cuDeviceGetIn { ordinal }, - )? - .device; - Ok(()) -} - -pub(crate) fn cu_device_get_attribute( - pi: *mut ::core::ffi::c_int, - attrib: CUdevice_attribute, - dev: CUdevice, -) -> Result<(), CUerror> { - let pi = unsafe { pi.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - *pi = GlobalState::remote_call_zero_copy::( - Opcode::cuDeviceGetAttribute, - cuDeviceGetAttributeIn { - attrib: CudaEncode::encode(attrib), - dev, - }, - )? - .pi; - Ok(()) -} - -pub(crate) fn cu_device_get_count(count: *mut ::core::ffi::c_int) -> Result<(), CUerror> { - let count = unsafe { count.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - *count = GlobalState::remote_call_zero_copy::( - Opcode::cuDeviceGetCount, - cuDeviceGetCountIn {}, - )? - .count; - Ok(()) -} - -pub(crate) fn cu_device_get_name( - name: *mut ::core::ffi::c_char, - len: ::core::ffi::c_int, - dev: CUdevice, -) -> Result<(), CUerror> { - if name.is_null() { - return Err(CUerror::INVALID_VALUE); - } - let name_out = GlobalState::remote_call_framed_out::( - Opcode::cuDeviceGetName, - cuDeviceGetNameIn { len, dev }, - )?; - unsafe { - std::ptr::copy_nonoverlapping( - name_out.name.as_ptr() as *const i8, - name, - (len as usize).min(name_out.name.len()), - ) - }; - Ok(()) -} - -pub(crate) fn cu_device_get_properties(prop: *mut CUdevprop, dev: CUdevice) -> Result<(), CUerror> { - unimplemented!() -} - -pub(crate) fn cu_device_total_mem_v2(bytes: *mut usize, dev: CUdevice) -> Result<(), CUerror> { - let bytes = unsafe { bytes.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - *bytes = GlobalState::remote_call_zero_copy::( - Opcode::cuDeviceTotalMem_v2, - cuDeviceTotalMem_v2In { dev }, - )? - .bytes - .to_native() - .min(u32::MAX as u64) as usize; - Ok(()) -} - -pub(crate) fn cu_driver_get_version( - driver_version: *mut ::core::ffi::c_int, -) -> Result<(), CUerror> { - let driver_version = unsafe { driver_version.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - *driver_version = GlobalState::remote_call_zero_copy::( - Opcode::cuDriverGetVersion, - cuDriverGetVersionIn {}, - )? - .driverVersion; - Ok(()) -} - -pub(crate) fn cu_event_create( - phEvent: *mut CUevent, - Flags: ::core::ffi::c_uint, -) -> Result<(), CUerror> { - unimplemented!() -} - -pub(crate) fn cu_event_destroy_v2(hEvent: CUevent) -> Result<(), CUerror> { - unimplemented!() -} - -static EXPORT_TABLE: ::dark_api::cuda::CudaDarkApiGlobalTable = - ::dark_api::cuda::CudaDarkApiGlobalTable::new::(); - -pub(crate) fn cu_get_export_table( - pp_export_table: *mut *const ::core::ffi::c_void, - p_export_table_id: *const CUuuid, -) -> Result<(), CUerror> { - if let (Some(result), Some(guid)) = - unsafe { (pp_export_table.as_mut(), p_export_table_id.as_ref()) } - { - if let Some(table) = EXPORT_TABLE.get(guid) { - *result = table.start(); - cuda_types::cuda::CUresult::SUCCESS - } else { - cuda_types::cuda::CUresult::ERROR_NOT_SUPPORTED - } - } else { - cuda_types::cuda::CUresult::ERROR_INVALID_VALUE - } -} - -pub(crate) fn cu_launch_kernel( - f: CUfunction, - grid_dim_x: ::core::ffi::c_uint, - grid_dim_y: ::core::ffi::c_uint, - grid_dim_z: ::core::ffi::c_uint, - block_dim_x: ::core::ffi::c_uint, - block_dim_y: ::core::ffi::c_uint, - block_dim_z: ::core::ffi::c_uint, - shared_mem_bytes: ::core::ffi::c_uint, - stream: CUstream, - kernel_params: *mut *mut ::core::ffi::c_void, - extra: *mut *mut ::core::ffi::c_void, -) -> Result<(), CUerror> { - if !kernel_params.is_null() || extra.is_null() { - return Err(CUerror::NOT_SUPPORTED); - } - let mut state = GlobalState::get()?.lock().map_err(|_| CUerror::UNKNOWN)?; - let args = state.function_args.get(&f).ok_or(CUerror::INVALID_VALUE)?; - let extra_slice = unsafe { std::slice::from_raw_parts(extra, 5) }; - if extra_slice[0] != CU_LAUNCH_PARAM_BUFFER_POINTER_AS_INT as _ { - return Err(CUerror::INVALID_VALUE); - } - if extra_slice[2] != CU_LAUNCH_PARAM_BUFFER_SIZE_AS_INT as _ { - return Err(CUerror::INVALID_VALUE); - } - if extra_slice[4] != CU_LAUNCH_PARAM_END_AS_INT as _ { - return Err(CUerror::INVALID_VALUE); - } - let arg_ptr = extra_slice[1]; - let arg_size = unsafe { *extra_slice[3].cast::() }; - let mut total_size = 0; - let kernel_params = args - .iter() - .scan( - unsafe { Layout::from_size_align_unchecked(0, 1) }, - |layout, arg_info| { - let (new_layout, offset) = layout.extend(arg_info.to_layout().unwrap()).unwrap(); - total_size = offset + arg_info.size as usize; - *layout = new_layout; - let start = arg_ptr.wrapping_byte_add(offset as usize).cast::(); - Some(Ok(unsafe { - std::slice::from_raw_parts(start, arg_info.size as usize) - } - .to_vec())) - }, - ) - .collect::, CUerror>>()?; - if total_size as usize != arg_size { - return Err(CUerror::INVALID_VALUE); - } - state.server.remote_call_framed_in::( - Opcode::cuLaunchKernel, - cuLaunchKernelIn { - f: CudaEncode::encode(f), - grid_dim_x: u32_le::from_native(grid_dim_x), - grid_dim_y: u32_le::from_native(grid_dim_y), - grid_dim_z: u32_le::from_native(grid_dim_z), - block_dim_x: u32_le::from_native(block_dim_x), - block_dim_y: u32_le::from_native(block_dim_y), - block_dim_z: u32_le::from_native(block_dim_z), - shared_mem_bytes: u32_le::from_native(shared_mem_bytes), - stream: CudaEncode::encode(stream), - kernel_params, - }, - )?; - Ok(()) -} - -pub(crate) fn cu_mem_alloc_v2(dptr: *mut CUdeviceptr, bytesize: usize) -> Result<(), CUerror> { - let dptr = unsafe { dptr.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - *dptr = CudaEncode::decode( - GlobalState::remote_call_zero_copy::( - Opcode::cuMemAlloc_v2, - cuMemAlloc_v2In { - bytesize: u32_le::from_native(bytesize as u32), - }, - )? - .dptr, - ); - Ok(()) -} - -pub(crate) fn cu_mem_free_host(p: *mut ::core::ffi::c_void) -> Result<(), CUerror> { - unimplemented!() -} - -pub(crate) fn cu_mem_free_v2(dptr: CUdeviceptr) -> Result<(), CUerror> { - unimplemented!() -} - -pub(crate) fn cu_mem_get_address_range_v2( - pbase: *mut CUdeviceptr, - psize: *mut usize, - dptr: CUdeviceptr, -) -> Result<(), CUerror> { - let pbase = unsafe { pbase.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - let psize = unsafe { psize.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - let result = GlobalState::remote_call_zero_copy::( - Opcode::cuMemGetAddressRange_v2, - cuMemGetAddressRange_v2In { - dptr: CudaEncode::encode(dptr), - }, - )?; - *pbase = CudaEncode::decode(result.pbase); - *psize = result.psize.to_native() as usize; - Ok(()) -} - -pub(crate) fn cu_mem_host_alloc( - pp: *mut *mut ::core::ffi::c_void, - bytesize: usize, - _flags: ::core::ffi::c_uint, -) -> Result<(), CUerror> { - let pp = unsafe { pp.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - *pp = unsafe { - std::alloc::alloc_zeroed(std::alloc::Layout::from_size_align(bytesize, 32).unwrap()) - } - .cast(); - Ok(()) -} - -pub(crate) fn cu_memcpy_dto_d_async_v2( - dstDevice: CUdeviceptr, - srcDevice: CUdeviceptr, - ByteCount: usize, - hStream: CUstream, -) -> Result<(), CUerror> { - unimplemented!() -} - -pub(crate) fn cu_memcpy_dto_h_async_v2( - dst_host: *mut ::core::ffi::c_void, - src_device: CUdeviceptr, - byte_count: usize, - stream: CUstream, -) -> Result<(), CUerror> { - if dst_host.is_null() || src_device.0.is_null() { - return Err(CUerror::INVALID_VALUE); - } - let dst_slice = unsafe { std::slice::from_raw_parts_mut(dst_host.cast::(), byte_count) }; - let result = GlobalState::remote_call_framed_out::( - Opcode::cuMemcpyDtoHAsync_v2, - cuMemcpyDtoHAsync_v2In { - src_device: CudaEncode::encode(src_device), - stream: CudaEncode::encode(stream), - byte_count: u32_le::from_native(byte_count as u32), - }, - )?; - dst_slice.copy_from_slice(&result.dst_host); - Ok(()) -} - -pub(crate) fn cu_memcpy_hto_d_async_v2( - dst_device: CUdeviceptr, - src_host: *const ::core::ffi::c_void, - byte_count: usize, - h_stream: CUstream, -) -> Result<(), CUerror> { - if src_host.is_null() || dst_device.0.is_null() { - return Err(CUerror::INVALID_VALUE); - } - let slice = unsafe { std::slice::from_raw_parts(src_host.cast::(), byte_count) }; - GlobalState::remote_call_framed_in::( - Opcode::cuMemcpyHtoDAsync_v2, - cuMemcpyHtoDAsync_v2In { - dst_device: CudaEncode::encode(dst_device), - src_host: slice.to_vec(), - stream: CudaEncode::encode(h_stream), - }, - )?; - Ok(()) -} - -pub(crate) fn cu_memset_d8_v2( - dstDevice: CUdeviceptr, - uc: ::core::ffi::c_uchar, - N: usize, -) -> Result<(), CUerror> { - unimplemented!() -} - -pub(crate) fn cu_module_get_function( - hfunc: *mut CUfunction, - hmod: CUmodule, - name: *const ::core::ffi::c_char, -) -> Result<(), CUerror> { - let hfunc = unsafe { hfunc.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - let mut state = GlobalState::get()?.lock().map_err(|_| CUerror::UNKNOWN)?; - *hfunc = CUfunction( - state - .server - .remote_call_framed_in::( - Opcode::cuModuleGetFunction, - cuModuleGetFunctionIn { - hmod: CudaEncode::encode(hmod), - name: unsafe { std::ffi::CStr::from_ptr(name) } - .to_bytes_with_nul() - .to_vec(), - }, - )? - .hfunc - .to_native() as _, - ); - let arg_sizes_out = state - .server - .remote_call_framed_out::( - Opcode::zludaGetFunctionArgs, - zludaGetFunctionArgsIn { - f: CudaEncode::encode(*hfunc), - }, - )?; - state.function_args.insert(*hfunc, arg_sizes_out.args); - Ok(()) -} - -pub(crate) fn cu_module_get_global_v2( - dptr: *mut CUdeviceptr, - bytes: *mut usize, - hmod: CUmodule, - name: *const ::core::ffi::c_char, -) -> Result<(), CUerror> { - let mut bytes_fallback = 0usize; - let dptr = unsafe { dptr.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - let bytes = unsafe { bytes.as_mut() }.unwrap_or(&mut bytes_fallback); - let result = GlobalState::remote_call_framed_in::( - Opcode::cuModuleGetGlobal_v2, - cuModuleGetGlobal_v2In { - hmod: CudaEncode::encode(hmod), - name: unsafe { std::ffi::CStr::from_ptr(name) } - .to_bytes() - .to_vec(), - }, - )?; - *dptr = CudaEncode::decode(result.dptr); - *bytes = result.bytes.to_native() as usize; - Ok(()) -} - -pub(crate) fn cu_module_get_tex_ref( - texref: *mut CUtexref, - hmod: CUmodule, - name: *const ::core::ffi::c_char, -) -> Result<(), CUerror> { - let texref = unsafe { texref.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - let result = GlobalState::remote_call_framed_in::( - Opcode::cuModuleGetTexRef, - cuModuleGetTexRefIn { - hmod: CudaEncode::encode(hmod), - name: unsafe { std::ffi::CStr::from_ptr(name) } - .to_bytes_with_nul() - .to_vec(), - }, - )?; - *texref = CudaEncode::decode(result.texref); - Ok(()) -} - -pub(crate) fn cu_stream_create( - phStream: *mut CUstream, - Flags: ::core::ffi::c_uint, -) -> Result<(), CUerror> { - unimplemented!() -} - -pub(crate) fn cu_stream_destroy_v2(hStream: CUstream) -> Result<(), CUerror> { - unimplemented!() -} - -pub(crate) fn cu_tex_ref_set_address_mode( - _tex_ref: CUtexref, - _dim: ::core::ffi::c_int, - _am: CUaddress_mode, -) -> Result<(), CUerror> { - // TODO - Ok(()) -} - -pub(crate) fn cu_tex_ref_set_address_v2( - byte_offset: *mut usize, - tex_ref: CUtexref, - dptr: CUdeviceptr, - bytes: usize, -) -> Result<(), CUerror> { - let mut bytes_fallback = 0usize; - let byte_offset = unsafe { byte_offset.as_mut() }.unwrap_or(&mut bytes_fallback); - let result = GlobalState::remote_call_zero_copy::( - Opcode::cuTexRefSetAddress_v2, - cuTexRefSetAddress_v2In { - hTexRef: CudaEncode::encode(tex_ref), - dptr: CudaEncode::encode(dptr), - bytes: u32_le::from_native(bytes as u32), - }, - )?; - *byte_offset = CudaEncode::decode(result.ByteOffset); - Ok(()) -} - -pub(crate) fn cu_tex_ref_set_filter_mode( - _tex_ref: CUtexref, - _fm: CUfilter_mode, -) -> Result<(), CUerror> { - // TODO - Ok(()) -} - -pub(crate) fn cu_tex_ref_set_flags( - tex_ref: CUtexref, - flags: ::core::ffi::c_uint, -) -> Result<(), CUerror> { - GlobalState::remote_call_zero_copy::( - Opcode::cuTexRefSetFlags, - cuTexRefSetFlagsIn { - hTexRef: CudaEncode::encode(tex_ref), - Flags: flags, - }, - )?; - Ok(()) -} - -pub(crate) fn cu_tex_ref_set_format( - tex_ref: CUtexref, - fmt: CUarray_format, - num_packed_components: ::core::ffi::c_int, -) -> Result<(), CUerror> { - GlobalState::remote_call_zero_copy::( - Opcode::cuTexRefSetFormat, - cuTexRefSetFormatIn { - hTexRef: CudaEncode::encode(tex_ref), - fmt: fmt.0.into(), - NumPackedComponents: num_packed_components, - }, - )?; - Ok(()) -} - -pub(crate) fn cu_tex_ref_set_max_anisotropy( - _tex_ref: CUtexref, - _max_aniso: ::core::ffi::c_uint, -) -> Result<(), CUerror> { - // TODO - Ok(()) -} - -pub(crate) fn cu_tex_ref_set_mipmap_filter_mode( - _tex_ref: CUtexref, - _fm: CUfilter_mode, -) -> Result<(), CUerror> { - // TODO - Ok(()) -} - -pub(crate) fn cu_tex_ref_set_mipmap_level_bias( - _tex_ref: CUtexref, - _bias: f32, -) -> Result<(), CUerror> { - // TODO - Ok(()) -} - -pub(crate) fn cu_tex_ref_set_mipmap_level_clamp( - _tex_ref: CUtexref, - _min_mipmap_level_clamp: f32, - _max_mipmap_level_clamp: f32, -) -> Result<(), CUerror> { - // TODO - Ok(()) -} - -struct UnknownBuffer { - buffer: std::cell::UnsafeCell<[u32; S]>, -} - -impl UnknownBuffer { - const fn new() -> Self { - UnknownBuffer { - buffer: std::cell::UnsafeCell::new([0; S]), - } - } - const fn len(&self) -> usize { - S - } -} - -unsafe impl Sync for UnknownBuffer {} - -static UNKNOWN_BUFFER1: UnknownBuffer<1024> = UnknownBuffer::new(); -static UNKNOWN_BUFFER2: UnknownBuffer<14> = UnknownBuffer::new(); - -struct DarkApi32; - -#[repr(C)] -struct AllocRecord { - x: usize, - y: usize, -} - -impl CudaDarkApi for DarkApi32 { - unsafe extern "system" fn get_module_from_cubin( - result: *mut cuda_types::cuda::CUmodule, - fatbinc_wrapper: *const cuda_types::dark_api::FatbincWrapper, - ) -> cuda_types::cuda::CUresult { - let result = match result.as_mut() { - Some(p) => p, - None => return CUresult::ERROR_INVALID_VALUE, - }; - let code_lib = CodeLibraryRef::try_load(fatbinc_wrapper.cast()) - .map_err(|_| CUerror::NO_BINARY_FOR_GPU)?; - let mut modules = Vec::with_capacity(1); - code_lib.iterate_modules(|_, module| match module { - Ok(CodeModuleRef::Text(ptx)) => { - modules.push(std::borrow::Cow::Borrowed(ptx.as_bytes())); - } - Ok(CodeModuleRef::File(file)) => { - if file.kind() == "ptx" { - if let Ok(text) = file.get_or_decompress_content(false) { - modules.push(text); - } - } - } - _ => {} - }); - let mut last_module = - unwrap_or::unwrap_some_or!(modules.pop(), return Err(CUerror::NO_BINARY_FOR_GPU)); - if last_module.last() != Some(&0) { - last_module.to_mut().push(0); - } - *result = CUmodule( - GlobalState::remote_call_framed_in::( - Opcode::cuModuleLoadData, - cuModuleLoadDataIn { - image: last_module.into_owned(), - }, - )? - .module - .to_native() as _, - ); - Ok(()) - } - - unsafe extern "system" fn cudart_interface_fn2( - pctx: *mut cuda_types::cuda::CUcontext, - _dev: cuda_types::cuda::CUdevice, - ) -> cuda_types::cuda::CUresult { - let ctx = unsafe { pctx.as_mut() }.ok_or(cuda_types::cuda::CUerror::INVALID_VALUE)?; - *ctx = CUcontext(0xDEADBEEFu32 as _); - cuda_types::cuda::CUresult::SUCCESS - } - - unsafe extern "system" fn get_module_from_cubin_ext1( - result: *mut cuda_types::cuda::CUmodule, - fatbinc_wrapper: *const cuda_types::dark_api::FatbincWrapper, - arg3: *mut std::ffi::c_void, - arg4: *mut std::ffi::c_void, - arg5: u32, - ) -> cuda_types::cuda::CUresult { - unimplemented!() - } - - unsafe extern "system" fn cudart_interface_fn7(arg1: usize) -> () { - unimplemented!() - } - - unsafe extern "system" fn get_module_from_cubin_ext2( - fatbin_header: *const cuda_types::dark_api::FatbinHeader, - result: *mut cuda_types::cuda::CUmodule, - arg3: *mut std::ffi::c_void, - arg4: *mut std::ffi::c_void, - arg5: u32, - ) -> cuda_types::cuda::CUresult { - unimplemented!() - } - - unsafe extern "system" fn load_compilers() -> cuda_types::cuda::CUresult { - unimplemented!() - } - - unsafe extern "system" fn get_unknown_buffer1( - ptr: *mut *mut std::ffi::c_void, - size: *mut usize, - ) -> () { - *ptr = UNKNOWN_BUFFER1.buffer.get() as *mut std::ffi::c_void; - *size = UNKNOWN_BUFFER1.len(); - } - - unsafe extern "system" fn get_unknown_buffer2( - ptr: *mut *mut std::ffi::c_void, - size: *mut usize, - ) -> () { - *ptr = UNKNOWN_BUFFER2.buffer.get() as *mut std::ffi::c_void; - *size = UNKNOWN_BUFFER2.len(); - } - - unsafe extern "system" fn context_local_storage_put( - cu_ctx: cuda_types::cuda::CUcontext, - key: *mut std::ffi::c_void, - value: *mut std::ffi::c_void, - _dtor_cb: Option< - extern "system" fn( - cuda_types::cuda::CUcontext, - *mut std::ffi::c_void, - *mut std::ffi::c_void, - ), - >, - ) -> cuda_types::cuda::CUresult { - let cu_ctx = CONTEXT_STACK.with(|s| s.unwrap(cu_ctx))?; - GlobalState::remote_call_zero_copy::( - Opcode::ContextLocalStoragePut, - ContextLocalStoragePutIn { - cu_ctx: cu_ctx.encode().into(), - key: (key as u32).into(), - value: (value as u32).into(), - }, - )?; - Ok(()) - } - - unsafe extern "system" fn context_local_storage_delete( - context: cuda_types::cuda::CUcontext, - key: *mut std::ffi::c_void, - ) -> cuda_types::cuda::CUresult { - unimplemented!() - } - - unsafe extern "system" fn context_local_storage_get( - value: *mut *mut std::ffi::c_void, - cu_ctx: cuda_types::cuda::CUcontext, - key: *mut std::ffi::c_void, - ) -> cuda_types::cuda::CUresult { - let value = unsafe { value.as_mut() }.ok_or(cuda_types::cuda::CUerror::INVALID_VALUE)?; - let cu_ctx = CONTEXT_STACK.with(|s| s.unwrap(cu_ctx))?; - *value = GlobalState::remote_call_zero_copy::( - Opcode::ContextLocalStorageGet, - ContextLocalStorageGetIn { - cu_ctx: cu_ctx.encode().into(), - key: (key as u32).into(), - }, - )? - .value - .to_native() as _; - Ok(()) - } - - unsafe extern "system" fn ctx_create_v2_bypass( - pctx: *mut cuda_types::cuda::CUcontext, - flags: ::std::os::raw::c_uint, - dev: cuda_types::cuda::CUdevice, - ) -> cuda_types::cuda::CUresult { - cu_ctx_create_v2(pctx, flags, dev) - } - - unsafe extern "system" fn heap_alloc( - heap_alloc_record_ptr: *mut *const std::ffi::c_void, - arg2: usize, - arg3: usize, - ) -> cuda_types::cuda::CUresult { - let heap_alloc_record_ptr = heap_alloc_record_ptr as *mut *mut AllocRecord; - let alloc_record = Box::into_raw(Box::new(AllocRecord { x: arg2, y: arg3 })); - *heap_alloc_record_ptr = alloc_record; - Ok(()) - } - - unsafe extern "system" fn heap_free( - heap_alloc_record_ptr: *const std::ffi::c_void, - arg2: *mut usize, - ) -> cuda_types::cuda::CUresult { - let heap_alloc_record_ptr = heap_alloc_record_ptr as *mut AllocRecord; - let record = Box::from_raw(heap_alloc_record_ptr); - if !arg2.is_null() { - *arg2 = record.y; - } - Ok(()) - } - - unsafe extern "system" fn device_get_attribute_ext( - dev: cuda_types::cuda::CUdevice, - attribute: std::ffi::c_uint, - unknown: std::ffi::c_int, - result: *mut [usize; 2], - ) -> cuda_types::cuda::CUresult { - unimplemented!() - } - - unsafe extern "system" fn device_get_something( - result: *mut std::ffi::c_uchar, - dev: cuda_types::cuda::CUdevice, - ) -> cuda_types::cuda::CUresult { - unimplemented!() - } - - unsafe extern "system" fn integrity_check( - version: u32, - unix_seconds: u64, - result: *mut [u64; 2], - ) -> cuda_types::cuda::CUresult { - unimplemented!() - } - - unsafe extern "system" fn context_check( - ctx_in: cuda_types::cuda::CUcontext, - result1: *mut u32, - result2: *mut *const std::ffi::c_void, - ) -> cuda_types::cuda::CUresult { - unimplemented!() - } - - unsafe extern "system" fn check_fn3() -> u32 { - unimplemented!() - } - - unsafe extern "system" fn hybrid_runtime_load_get_proc_address( - name: *const std::ffi::c_char, - fn_ptr: *mut *const std::ffi::c_void, - token: *mut usize, - ) -> cuda_types::cuda::CUresult { - unimplemented!() - } - - unsafe extern "system" fn hybrid_runtime_free(token: usize) -> cuda_types::cuda::CUresult { - unimplemented!() - } -} diff --git a/zluda64_server/Cargo.toml b/zluda64_server/Cargo.toml deleted file mode 100644 index 69be4b5e9..000000000 --- a/zluda64_server/Cargo.toml +++ /dev/null @@ -1,26 +0,0 @@ -[package] -name = "zluda64_server" -version = "0.0.0" -authors = ["Andrzej Janik "] -edition = "2021" - -[[bin]] -name = "zluda64_server" -path = "src/main.rs" - -[dependencies] -cuda_types = { path = "../cuda_types" } -cuda_macros = { path = "../cuda_macros" } -zluda_server_common = { path = "../zluda_server_common" } -dark_api = { path = "../dark_api" } -windows-sys = { version = "0.61.2", features = ["Win32_Foundation"] } -compio = { version = "0.18.0", features = ["macros", "fs"] } -slab = "0.4.12" -bincode = "2.0.1" -rkyv = "0.8.15" -orderly-allocator = "0.2.2" -range-alloc = "0.1.5" -rustc-hash = "2.0.0" - -[package.metadata.zluda] -windows_only = true diff --git a/zluda64_server/src/main.rs b/zluda64_server/src/main.rs deleted file mode 100644 index 10cfd24d5..000000000 --- a/zluda64_server/src/main.rs +++ /dev/null @@ -1,1151 +0,0 @@ -// Prevent the console window from appearing when running the server on Windows -#![windows_subsystem = "windows"] - -use compio::{ - buf::{buf_try, IoBuf, IoBufMut, ReserveError, ReserveExactError, SetLen}, - fs::named_pipe::{ClientOptions, NamedPipeClient}, - io::{AsyncRead, AsyncReadExt, AsyncReadManaged, AsyncWrite, AsyncWriteExt}, - BufResult, -}; -use cuda_macros::cuda_function_declarations; -use cuda_types::cuda::*; -use dark_api::FunctionArgInfo; -use rkyv::{ - api::high::HighSerializer, - rend::{u32_le, u64_le}, - ser::allocator::ArenaHandle, - util::AlignedVec, - Archive, Portable, Serialize, -}; -use rustc_hash::FxHashMap; -use slab::Slab; -use std::{ - collections::BTreeMap, - ffi::{c_void, CStr, CString}, - io::{self, Write}, - mem, - ops::Range, - ptr::{self, NonNull}, - rc::Rc, -}; -use zluda_server_common::*; - -struct State { - handles: HandlePool, - dark_api: dark_api::cuda::ContextLocalStorageInterfaceV0301, - devmemory: Vec, - modules: ModuleLaunchData, -} - -struct HandlePool { - handles: Slab, -} - -impl HandlePool { - fn new() -> Self { - Self { - handles: Slab::new(), - } - } - - fn insert(&mut self, handle: *mut T) -> u32 { - (self.handles.insert(handle as usize) as u32) + 1 - } - - fn get(&self, id: u32) -> Result<*mut T, CUerror> { - if id == 0 { - return Err(CUerror::INVALID_VALUE); - } - self.handles - .get((id - 1) as usize) - .map(|&handle| handle as *mut T) - .ok_or(CUerror::INVALID_VALUE) - } -} - -struct ModuleLaunchData { - dark_api: dark_api::zluda32::Zluda32Internal, - modules: FxHashMap, - functions: FxHashMap, -} - -impl ModuleLaunchData { - fn new() -> Result { - let mut zluda32_ptr = unsafe { mem::zeroed() }; - unsafe { cuGetExportTable(&mut zluda32_ptr, &dark_api::zluda32::Zluda32Internal::GUID) }?; - let zluda32 = unsafe { dark_api::zluda32::Zluda32Internal::new(zluda32_ptr) }; - Ok(Self { - dark_api: zluda32, - modules: FxHashMap::default(), - functions: FxHashMap::default(), - }) - } - - unsafe fn new_module( - &mut self, - devmemory: &mut Vec, - module: CUmodule, - ) -> Result<(), CUerror> { - let mut count = 0; - self.dark_api.get_module_globals( - ptr::null_mut(), - ptr::null_mut(), - ptr::null_mut(), - ptr::null_mut(), - &mut count, - module, - )?; - let mut names = vec![mem::zeroed(); count as usize]; - let mut initializers = vec![mem::zeroed(); count as usize]; - let mut sizes = vec![mem::zeroed(); count as usize]; - let mut alignments = vec![mem::zeroed(); count as usize]; - self.dark_api.get_module_globals( - names.as_mut_ptr(), - initializers.as_mut_ptr(), - sizes.as_mut_ptr(), - alignments.as_mut_ptr(), - &mut count, - module, - )?; - let mut device = 0; - unsafe { cuCtxGetDevice(&mut device) }?; - let globals = (0..count as usize) - .map(|i| { - if alignments[i] > Allocator::ALLOCATION_UNIT { - return Err(CUerror::OUT_OF_MEMORY); - } - let initializer = std::slice::from_raw_parts(initializers[i], sizes[i] as usize); - let allocation = devmemory[device as usize].alloc_range(sizes[i])?; - let devptr = devmemory[device as usize].translate_range(allocation.clone())?; - unsafe { - cuMemcpyHtoD_v2( - CUdeviceptr_v2(devptr), - initializer.as_ptr().cast(), - initializer.len(), - ) - }?; - Ok::<_, CUerror>(Global { - name: unsafe { CStr::from_ptr(names[i].cast()) } - .to_string_lossy() - .into_owned(), - allocation, - size: sizes[i], - }) - }) - .collect::, _>>()?; - let module_data = Module { - globals: Rc::new(globals), - texrefs: FxHashMap::default(), - }; - self.modules.insert(module, module_data); - Ok(()) - } -} - -struct Module { - globals: Rc>, - texrefs: FxHashMap, u32>, -} - -struct Global { - name: String, - allocation: Range, - size: u32, -} - -impl Global { - fn address(&self) -> u32 { - self.allocation.start * Allocator::ALLOCATION_UNIT - } -} - -struct Function { - globals: Rc>, -} - -struct Allocator { - start: Option<*mut c_void>, - allocator: range_alloc::RangeAllocator, - allocation_ends: BTreeMap, -} - -impl Allocator { - const ALLOCATION_UNIT: u32 = 128; - const ALLOCATOR_SIZE: u32 = 512 * 1024 * 1024; // 512 MiB - - fn new() -> Self { - Self { - start: None, - allocator: range_alloc::RangeAllocator::new( - // starting from 1 to avoid handing out null pointers - 1..Self::ALLOCATOR_SIZE / Self::ALLOCATION_UNIT, - ), - allocation_ends: BTreeMap::new(), - } - } - - fn get_or_allocate_device_ptr(&mut self) -> Result<*mut c_void, CUerror> { - match self.start { - Some(ptr) => Ok(ptr), - None => { - let mut dev_ptr = CUdeviceptr_v2(ptr::null_mut()); - unsafe { cuMemAlloc_v2(&mut dev_ptr, Self::ALLOCATOR_SIZE as usize) }?; - self.start = Some(dev_ptr.0); - Ok(dev_ptr.0) - } - } - } - - fn get_device_ptr(&self) -> Result<*mut c_void, CUerror> { - self.start.ok_or(CUerror::INVALID_VALUE) - } - - fn alloc_range(&mut self, size: u32) -> Result, CUerror> { - self.get_or_allocate_device_ptr()?; - let units = size.next_multiple_of(Self::ALLOCATION_UNIT) / Self::ALLOCATION_UNIT; - self.allocator - .allocate_range(units) - .map_err(|_| CUerror::OUT_OF_MEMORY) - } - - fn alloc(&mut self, size: u32) -> Result { - let offset = self.alloc_range(size)?; - self.allocation_ends.insert(offset.start, offset.end); - Ok(offset.start * Self::ALLOCATION_UNIT) - } - - fn free(&mut self, start: u32) -> Result<(), CUerror> { - let end = self - .allocation_ends - .remove(&start) - .ok_or(CUerror::INVALID_VALUE)?; - self.allocator.free_range(start..end); - Ok(()) - } - - fn translate(&self, offset: u32) -> Result<*mut c_void, CUerror> { - let base_ptr = self.get_device_ptr()?; - Ok(base_ptr.wrapping_byte_add(offset as usize)) - } - - fn translate_range(&self, range: Range) -> Result<*mut c_void, CUerror> { - let base_ptr = self.get_device_ptr()?; - Ok(base_ptr.wrapping_byte_add(range.start as usize * Self::ALLOCATION_UNIT as usize)) - } - - fn get_range(&self, mut offset: u32) -> Option> { - offset /= Self::ALLOCATION_UNIT; - // Find last pair where `start <= ptr` - let (start, alloc) = self.allocation_ends.range(..=offset).rev().next()?; - let range = *start..*alloc; - // Check if allocation contains the pointer - if range.contains(&offset) { - Some(range) - } else { - None - } - } -} - -impl State { - fn new() -> Result { - unsafe { cuInit(0) }?; - let mut table_ptr = std::ptr::null(); - unsafe { - cuGetExportTable( - &mut table_ptr, - &dark_api::cuda::ContextLocalStorageInterfaceV0301::GUID, - ) - }?; - let dark_api = unsafe { dark_api::cuda::ContextLocalStorageInterfaceV0301::new(table_ptr) }; - let mut devices = 0; - unsafe { cuDeviceGetCount(&mut devices) }?; - Ok(Self { - handles: HandlePool::new(), - dark_api, - devmemory: (0..devices).map(|_| Allocator::new()).collect(), - modules: ModuleLaunchData::new()?, - }) - } -} - -#[compio::main] -async fn main() -> std::io::Result<()> { - let pipe_name = std::env::args_os().nth(1).ok_or(std::io::Error::new( - std::io::ErrorKind::InvalidInput, - "Pipe name not provided", - ))?; - let mut client = ClientOptions::new() - .pipe_mode(compio::fs::named_pipe::PipeMode::Byte) - .read(true) - .write(true) - .open(pipe_name) - .await?; - let mut buffer = AlignedVecBuffer(AlignedVec::new()); - let mut state = State::new().map_err(|_| { - std::io::Error::new( - std::io::ErrorKind::Other, - "Failed to initialize CUDA context", - ) - })?; - loop { - let opcode = client.read_u32_le().await?; // Read the length prefix - buffer.clear(); - match Opcode::from_repr(opcode) { - Some(Opcode::cuInit) => { - buffer = handle_cuda_function::(&mut client, buffer, cu_init) - .await?; - } - Some(Opcode::cuDeviceGetCount) => { - buffer = handle_cuda_function::( - &mut client, - buffer, - cu_device_get_count, - ) - .await?; - } - Some(Opcode::cuDeviceGetAttribute) => { - buffer = handle_cuda_function::( - &mut client, - buffer, - cu_device_get_attribute, - ) - .await?; - } - Some(Opcode::cuDeviceGet) => { - buffer = handle_cuda_function::( - &mut client, - buffer, - cu_device_get, - ) - .await?; - } - Some(Opcode::cuCtxCreate_v2) => { - buffer = handle_cuda_function::( - &mut client, - buffer, - |input| cu_ctx_create_v2(input, &mut state), - ) - .await?; - } - Some(Opcode::cuDriverGetVersion) => { - buffer = handle_cuda_function::( - &mut client, - buffer, - cu_driver_get_version, - ) - .await?; - } - Some(Opcode::cuDeviceGetName) => { - buffer = handle_cuda_function_framed_out::( - &mut client, - buffer, - cu_device_get_name, - ) - .await?; - } - Some(Opcode::cuDeviceTotalMem_v2) => { - buffer = handle_cuda_function::( - &mut client, - buffer, - cu_device_total_mem_v2, - ) - .await?; - } - Some(Opcode::ContextLocalStoragePut) => { - buffer = - handle_cuda_function::( - &mut client, - buffer, - |input| context_local_storage_put(&mut state, input), - ) - .await?; - } - Some(Opcode::ContextLocalStorageGet) => { - buffer = - handle_cuda_function::( - &mut client, - buffer, - |input| context_local_storage_get(&mut state, input), - ) - .await?; - } - Some(Opcode::cuCtxGetApiVersion) => { - buffer = handle_cuda_function::( - &mut client, - buffer, - |input| cu_ctx_get_api_version(&mut state, input), - ) - .await?; - } - Some(Opcode::cuModuleLoadData) => { - buffer = handle_cuda_function_framed_in::( - &mut client, - buffer, - |input| cu_module_load_data(&mut state, input), - ) - .await?; - } - Some(Opcode::cuModuleGetFunction) => { - buffer = handle_cuda_function_framed_in::< - cuModuleGetFunctionIn, - cuModuleGetFunctionOut, - >(&mut client, buffer, |input| { - cu_module_get_function(&mut state, input) - }) - .await?; - } - Some(Opcode::cuModuleGetGlobal_v2) => { - buffer = handle_cuda_function_framed_in::< - cuModuleGetGlobal_v2In, - cuModuleGetGlobal_v2Out, - >(&mut client, buffer, |input| { - cu_module_get_global_v2(&mut state, input) - }) - .await?; - } - Some(Opcode::cuMemAlloc_v2) => { - buffer = handle_cuda_function::( - &mut client, - buffer, - |input| cu_mem_alloc_v2(&mut state, input), - ) - .await?; - } - Some(Opcode::cuMemcpyHtoDAsync_v2) => { - buffer = handle_cuda_function_framed_in::< - cuMemcpyHtoDAsync_v2In, - cuMemcpyHtoDAsync_v2Out, - >(&mut client, buffer, |input| { - cu_memcpy_hto_d_async_v2(&mut state, input) - }) - .await?; - } - Some(Opcode::cuModuleGetTexRef) => { - buffer = - handle_cuda_function_framed_in::( - &mut client, - buffer, - |input| cu_module_get_tex_ref(&mut state, input), - ) - .await?; - } - Some(Opcode::zludaGetFunctionArgs) => { - buffer = handle_cuda_function_framed_out::< - zludaGetFunctionArgsIn, - zludaGetFunctionArgsOut, - >(&mut client, buffer, |input| { - zluda_get_function_args(&mut state, input) - }) - .await?; - } - Some(Opcode::cuLaunchKernel) => { - buffer = handle_cuda_function_framed_in::( - &mut client, - buffer, - |input| cu_launch_kernel(&mut state, input), - ) - .await?; - } - Some(Opcode::cuCtxSynchronize) => { - buffer = handle_cuda_function::( - &mut client, - buffer, - cu_ctx_synchronize, - ) - .await?; - } - Some(Opcode::cuMemcpyDtoHAsync_v2) => { - buffer = handle_cuda_function_framed_out::< - cuMemcpyDtoHAsync_v2In, - cuMemcpyDtoHAsync_v2Out, - >(&mut client, buffer, |input| { - cu_memcpy_dtoh_async_v2(&mut state, input) - }) - .await?; - } - Some(Opcode::cuMemGetAddressRange_v2) => { - buffer = handle_cuda_function::< - cuMemGetAddressRange_v2In, - cuMemGetAddressRange_v2Out, - >(&mut client, buffer, |input| { - cu_mem_get_address_range_v2(&mut state, input) - }) - .await?; - } - Some(Opcode::cuTexRefSetAddress_v2) => { - buffer = handle_cuda_function::( - &mut client, - buffer, - |input| cu_tex_ref_set_address_v2(&mut state, input), - ) - .await?; - } - Some(Opcode::cuTexRefSetFlags) => { - buffer = handle_cuda_function::( - &mut client, - buffer, - |input| cu_tex_ref_set_flags(&mut state, input), - ) - .await?; - } - Some(Opcode::cuTexRefSetFormat) => { - buffer = handle_cuda_function::( - &mut client, - buffer, - |input| cu_tex_ref_set_format(&mut state, input), - ) - .await?; - } - _ => { - client.write_u32_le(CUerror::NOT_SUPPORTED.0.get()).await?; - return Err(std::io::Error::new( - std::io::ErrorKind::Other, - "Unsupported operation", - )); - } - } - } -} - -fn cu_tex_ref_set_format( - state: &mut State, - input: &ArchivedcuTexRefSetFormatIn, -) -> Result { - let tex_ref = state.handles.get(input.hTexRef.to_native())?; - unsafe { - cuTexRefSetFormat( - tex_ref, - CUarray_format(input.fmt.to_native()), - input.NumPackedComponents.to_native(), - ) - }?; - Ok(cuTexRefSetFormatOut {}) -} - -fn cu_tex_ref_set_flags( - state: &mut State, - input: &ArchivedcuTexRefSetFlagsIn, -) -> Result { - let tex_ref = state.handles.get(input.hTexRef.to_native())?; - unsafe { cuTexRefSetFlags(tex_ref, input.Flags.to_native()) }?; - Ok(cuTexRefSetFlagsOut {}) -} - -fn cu_tex_ref_set_address_v2( - state: &mut State, - input: &ArchivedcuTexRefSetAddress_v2In, -) -> Result { - let mut device = 0; - unsafe { cuCtxGetDevice(&mut device) }?; - let mut byte_offset = 0; - let dptr = input.dptr.to_native(); - let dptr = if dptr != 0 { - CUdeviceptr_v2(state.devmemory[device as usize].translate(dptr)?) - } else { - CUdeviceptr_v2(ptr::null_mut()) - }; - unsafe { - cuTexRefSetAddress_v2( - &mut byte_offset, - state.handles.get(input.hTexRef.to_native())?, - dptr, - input.bytes.to_native() as usize, - ) - }?; - Ok(cuTexRefSetAddress_v2Out { - ByteOffset: (byte_offset as u32).into(), - }) -} - -fn cu_mem_get_address_range_v2( - state: &mut State, - input: &ArchivedcuMemGetAddressRange_v2In, -) -> Result { - let mut device = 0; - unsafe { cuCtxGetDevice(&mut device) }?; - let allocator = &state.devmemory[device as usize]; - let range = allocator - .get_range(input.dptr.to_native()) - .ok_or(CUerror::INVALID_VALUE)?; - Ok(cuMemGetAddressRange_v2Out { - pbase: (range.start * Allocator::ALLOCATION_UNIT).into(), - psize: ((range.end - range.start) * Allocator::ALLOCATION_UNIT).into(), - }) -} - -fn cu_memcpy_dtoh_async_v2( - state: &mut State, - input: &ArchivedcuMemcpyDtoHAsync_v2In, -) -> Result { - let mut device = 0; - unsafe { cuCtxGetDevice(&mut device) }?; - let devptr = state.devmemory[device as usize].translate(input.src_device.to_native())?; - let stream = input.stream.to_native(); - let stream = if stream == 0 { - CUstream(ptr::null_mut()) - } else { - CUstream(state.handles.get(stream)?) - }; - let mut dst_host = vec![0u8; input.byte_count.to_native() as usize]; - unsafe { - cuMemcpyDtoHAsync_v2( - dst_host.as_mut_ptr().cast(), - CUdeviceptr_v2(devptr), - input.byte_count.to_native() as usize, - stream, - ) - }?; - unsafe { cuStreamSynchronize(stream) }?; - Ok(cuMemcpyDtoHAsync_v2Out { dst_host }) -} - -fn cu_ctx_synchronize(input: &ArchivedcuCtxSynchronizeIn) -> Result { - unsafe { cuCtxSynchronize() }?; - Ok(cuCtxSynchronizeOut {}) -} - -fn cu_launch_kernel( - state: &mut State, - input: &ArchivedcuLaunchKernelIn, -) -> Result { - let mut device = 0; - unsafe { cuCtxGetDevice(&mut device) }?; - let mut params = input - .kernel_params - .iter() - .map(|p| p.as_ptr().cast_mut().cast::()) - .collect::>(); - let mut base64_ptr = state.devmemory[device as usize].get_device_ptr()?; - params.push(ptr::from_mut(&mut base64_ptr).cast()); - let function = CUfunction(state.handles.get(input.f.to_native())?); - let function_info = state - .modules - .functions - .get(&function) - .ok_or(CUerror::INVALID_VALUE)?; - let globals = function_info - .globals - .iter() - .map(|global| global.allocation.start * Allocator::ALLOCATION_UNIT) - .collect::>(); - for g in globals.iter() { - params.push(ptr::from_ref(g).cast_mut().cast()); - } - unsafe { - cuLaunchKernel( - function, - input.grid_dim_x.to_native(), - input.grid_dim_y.to_native(), - input.grid_dim_z.to_native(), - input.block_dim_x.to_native(), - input.block_dim_y.to_native(), - input.block_dim_z.to_native(), - input.shared_mem_bytes.to_native(), - if input.stream == 0 { - CUstream(ptr::null_mut()) - } else { - CUstream(state.handles.get(input.stream.to_native())?) - }, - params.as_mut_ptr(), - std::ptr::null_mut(), - ) - }?; - Ok(cuLaunchKernelOut {}) -} - -fn zluda_get_function_args( - state: &mut State, - input: &ArchivedzludaGetFunctionArgsIn, -) -> Result { - let hfunc = state.handles.get(input.f.to_native())?; - let mut count = 0; - unsafe { - state.modules.dark_api.get_function_info( - std::ptr::null_mut(), - &mut count, - CUfunction(hfunc), - ) - }?; - let mut arg_sizes = vec![FunctionArgInfo { size: 0, align: 0 }; count as usize]; - unsafe { - state.modules.dark_api.get_function_info( - arg_sizes.as_mut_ptr(), - &mut count, - CUfunction(hfunc), - ) - }?; - Ok(zludaGetFunctionArgsOut { args: arg_sizes }) -} - -fn cu_module_get_tex_ref( - state: &mut State, - input: &ArchivedcuModuleGetTexRefIn, -) -> Result { - let hmod = state.handles.get::(input.hmod.to_native())?; - let module = state - .modules - .modules - .get_mut(&CUmodule(hmod)) - .ok_or(CUerror::INVALID_VALUE)?; - let texref = match module.texrefs.entry(input.name.to_vec()) { - std::collections::hash_map::Entry::Occupied(entry) => *entry.get(), - std::collections::hash_map::Entry::Vacant(entry) => { - let mut texref = unsafe { mem::zeroed() }; - unsafe { cuModuleGetTexRef(&mut texref, CUmodule(hmod), input.name.as_ptr().cast()) }?; - let handle = state.handles.insert(texref); - *entry.insert(handle) - } - }; - Ok(cuModuleGetTexRefOut { - texref: u32_le::from_native(texref), - }) -} - -fn cu_memcpy_hto_d_async_v2( - state: &mut State, - input: &ArchivedcuMemcpyHtoDAsync_v2In, -) -> Result { - let mut device = 0; - unsafe { cuCtxGetDevice(&mut device) }?; - let devptr = state.devmemory[device as usize].translate(input.dst_device.to_native())?; - let stream = input.stream.to_native(); - let stream = if stream == 0 { - CUstream(ptr::null_mut()) - } else { - CUstream(state.handles.get(stream)?) - }; - unsafe { - cuMemcpyHtoDAsync_v2( - CUdeviceptr_v2(devptr), - input.src_host.as_ptr().cast(), - input.src_host.len(), - stream, - ) - }?; - Ok(cuMemcpyHtoDAsync_v2Out {}) -} - -fn cu_mem_alloc_v2( - state: &mut State, - input: &ArchivedcuMemAlloc_v2In, -) -> Result { - let mut device = 0; - unsafe { cuCtxGetDevice(&mut device) }?; - let fake_ptr = state.devmemory[device as usize].alloc(input.bytesize.to_native())?; - Ok(cuMemAlloc_v2Out { - dptr: u32_le::from_native(fake_ptr), - }) -} - -fn cu_module_get_global_v2( - state: &mut State, - input: &ArchivedcuModuleGetGlobal_v2In, -) -> Result { - let hmod = state.handles.get::(input.hmod.to_native())?; - let module = state - .modules - .modules - .get(&CUmodule(hmod)) - .ok_or(CUerror::INVALID_VALUE)?; - let global = module - .globals - .iter() - .find(|global| global.name.as_bytes() == input.name.as_slice()) - .ok_or(CUerror::NOT_FOUND)?; - Ok(cuModuleGetGlobal_v2Out { - dptr: u32_le::from_native(global.address()), - bytes: u64_le::from_native(global.size as u64), - }) -} - -fn cu_module_get_function( - state: &mut State, - input: &ArchivedcuModuleGetFunctionIn, -) -> Result { - let mut hfunc = unsafe { mem::zeroed() }; - let hmod = state.handles.get(input.hmod.to_native())?; - unsafe { cuModuleGetFunction(&mut hfunc, CUmodule(hmod), input.name.as_ptr().cast()) }?; - state - .modules - .functions - .entry(hfunc) - .or_insert_with(|| Function { - globals: Rc::clone(&state.modules.modules[&CUmodule(hmod)].globals), - }); - Ok(cuModuleGetFunctionOut { - hfunc: u32_le::from_native(state.handles.insert(hfunc.0)), - }) -} - -fn cu_module_load_data( - state: &mut State, - input: &ArchivedcuModuleLoadDataIn, -) -> Result { - let mut module = unsafe { mem::zeroed() }; - unsafe { cuModuleLoadData(&mut module, input.image.as_ptr().cast()) }?; - unsafe { state.modules.new_module(&mut state.devmemory, module) }?; - Ok(cuModuleLoadDataOut { - module: u32_le::from_native(state.handles.insert(module.0)), - }) -} - -fn cu_init(input: &ArchivedcuInitIn) -> Result { - unsafe { cuInit(input.Flags.to_native()) }?; - Ok(cuInitOut {}) -} - -fn cu_device_get_count( - _input: &ArchivedcuDeviceGetCountIn, -) -> Result { - let mut count = 0; - unsafe { cuDeviceGetCount(&mut count) }?; - Ok(cuDeviceGetCountOut { count }) -} - -fn cu_device_get_attribute( - input: &ArchivedcuDeviceGetAttributeIn, -) -> Result { - let mut pi = 0; - unsafe { - cuDeviceGetAttribute( - &mut pi, - CUdevice_attribute_enum(input.attrib.to_native()), - input.dev.to_native(), - ) - }?; - Ok(cuDeviceGetAttributeOut { pi }) -} - -fn cu_device_get(input: &ArchivedcuDeviceGetIn) -> Result { - let mut device = 0; - unsafe { cuDeviceGet(&mut device, input.ordinal.to_native()) }?; - Ok(cuDeviceGetOut { device }) -} - -fn cu_device_get_name(input: &ArchivedcuDeviceGetNameIn) -> Result { - let mut name = vec![0u8; input.len.to_native() as usize]; - unsafe { - cuDeviceGetName( - name.as_mut_ptr().cast(), - input.len.to_native(), - input.dev.to_native(), - ) - }?; - if let Some(pos) = name.iter().copied().position(|c| c == 0) { - name.truncate(pos); - } - Ok(cuDeviceGetNameOut { name }) -} - -fn cu_ctx_create_v2( - input: &ArchivedcuCtxCreate_v2In, - state: &mut State, -) -> Result { - let mut pctx = unsafe { mem::zeroed() }; - unsafe { cuCtxCreate_v2(&mut pctx, input.flags.to_native(), input.dev.to_native()) }?; - let pctx = state.handles.insert(pctx.0); - Ok(cuCtxCreate_v2Out { - pctx: u32_le::from_native(pctx), - }) -} - -fn cu_device_total_mem_v2( - input: &ArchivedcuDeviceTotalMem_v2In, -) -> Result { - let mut bytes = 0usize; - unsafe { cuDeviceTotalMem_v2(&mut bytes, input.dev.to_native()) }?; - Ok(cuDeviceTotalMem_v2Out { - bytes: u64_le::from_native(bytes as u64), - }) -} - -fn cu_driver_get_version( - _input: &ArchivedcuDriverGetVersionIn, -) -> Result { - let mut driver_version = 0; - unsafe { cuDriverGetVersion(&mut driver_version) }?; - Ok(cuDriverGetVersionOut { - driverVersion: driver_version, - }) -} - -fn cu_ctx_get_api_version( - state: &mut State, - input: &ArchivedcuCtxGetApiVersionIn, -) -> Result { - let ctx = CUcontext(state.handles.get(input.ctx.to_native())?); - let mut version = 0; - unsafe { cuCtxGetApiVersion(ctx, &mut version) }?; - Ok(cuCtxGetApiVersionOut { version }) -} - -fn context_local_storage_put( - state: &mut State, - input: &ArchivedContextLocalStoragePutIn, -) -> Result { - unsafe { - state.dark_api.context_local_storage_put( - CUcontext(state.handles.get(input.cu_ctx.to_native())?), - input.key.to_native() as _, - input.value.to_native() as _, - None, - ) - }?; - Ok(ContextLocalStoragePutOut {}) -} - -fn context_local_storage_get( - state: &mut State, - input: &ArchivedContextLocalStorageGetIn, -) -> Result { - let mut value = ptr::null_mut(); - unsafe { - state.dark_api.context_local_storage_get( - &mut value, - CUcontext(state.handles.get(input.cu_ctx.to_native())?), - input.key.to_native() as _, - ) - }?; - Ok(ContextLocalStorageGetOut { - value: u32_le::from_native(value as u32), - }) -} - -async fn handle_cuda_function( - client: &mut NamedPipeClient, - mut buffer: AlignedVecBuffer, - handler: impl FnOnce(&In::Archived) -> Result, -) -> std::io::Result -where - Out: for<'a, 'b> Serialize< - HighSerializer<&'a mut AlignedVec, ArenaHandle<'b>, rkyv::rancor::Failure>, - >, -{ - buffer = read_all::(buffer, client).await?; - let input = unsafe { rkyv::access_unchecked::(buffer.as_init()) }; - match handler(input) { - Ok(output) => { - buffer.clear(); - client.write_u32_le(0).await?; - rkyv::api::high::to_bytes_in::<_, rkyv::rancor::Failure>(&output, &mut buffer.0) - .map_err(|_| { - std::io::Error::new(std::io::ErrorKind::Other, "Failed to serialize response") - })?; - let ((), new_buffer) = buf_try!(@try client.write_all(buffer).await); - Ok(new_buffer) - } - Err(e) => { - client.write_u32_le(e.0.get()).await?; - Ok(buffer) - } - } -} - -async fn handle_cuda_function_framed_in( - client: &mut NamedPipeClient, - mut buffer: AlignedVecBuffer, - handler: impl FnOnce(&In::Archived) -> Result, -) -> std::io::Result -where - Out: for<'a, 'b> Serialize< - HighSerializer<&'a mut AlignedVec, ArenaHandle<'b>, rkyv::rancor::Failure>, - >, -{ - let length_prefix = client.read_u32_le().await? as usize; - buffer = read_sized(buffer, client, length_prefix).await?; - let input = unsafe { rkyv::access_unchecked::(buffer.as_init()) }; - match handler(input) { - Ok(output) => { - buffer.clear(); - client.write_u32_le(0).await?; - rkyv::api::high::to_bytes_in::<_, rkyv::rancor::Failure>(&output, &mut buffer.0) - .map_err(|_| { - std::io::Error::new(std::io::ErrorKind::Other, "Failed to serialize response") - })?; - let ((), new_buffer) = buf_try!(@try client.write_all(buffer).await); - Ok(new_buffer) - } - Err(e) => { - client.write_u32_le(e.0.get()).await?; - Ok(buffer) - } - } -} - -async fn handle_cuda_function_framed_out( - client: &mut NamedPipeClient, - mut buffer: AlignedVecBuffer, - handler: impl FnOnce(&In::Archived) -> Result, -) -> std::io::Result -where - Out: for<'a, 'b> Serialize< - HighSerializer<&'a mut AlignedVec, ArenaHandle<'b>, rkyv::rancor::Failure>, - >, -{ - buffer = read_all::(buffer, client).await?; - let input = unsafe { rkyv::access_unchecked::(buffer.as_init()) }; - match handler(input) { - Ok(output) => { - buffer.clear(); - rkyv::api::high::to_bytes_in::<_, rkyv::rancor::Failure>(&output, &mut buffer.0) - .map_err(|_| { - std::io::Error::new(std::io::ErrorKind::Other, "Failed to serialize response") - })?; - let code_and_len = unsafe { - std::mem::transmute::<(u32, u32), [u8; 8]>((0u32, buffer.0.len() as u32)) - }; - client.write_all(code_and_len).await.0?; - let ((), new_buffer) = buf_try!(@try client.write_all(buffer).await); - Ok(new_buffer) - } - Err(e) => { - client.write_u32_le(e.0.get()).await?; - Ok(buffer) - } - } -} - -async fn read_all( - buffer: AlignedVecBuffer, - client: &mut NamedPipeClient, -) -> std::io::Result { - read_sized(buffer, client, mem::size_of::()).await -} - -async fn read_sized( - mut buffer: AlignedVecBuffer, - client: &mut NamedPipeClient, - mut remaining_read: usize, -) -> std::io::Result { - buffer.clear(); - buffer.reserve(remaining_read)?; - while remaining_read > 0 { - let BufResult(read_result, new_buffer) = client.append(buffer).await; - let n = read_result?; - remaining_read = remaining_read.checked_sub(n).ok_or_else(|| { - std::io::Error::new( - std::io::ErrorKind::InvalidData, - "Read more bytes than expected", - ) - })?; - buffer = new_buffer; - } - Ok(buffer) -} - -struct AlignedVecBuffer(AlignedVec); - -impl AlignedVecBuffer { - fn clear(&mut self) { - self.0.clear(); - } -} - -impl IoBuf for AlignedVecBuffer { - fn as_init(&self) -> &[u8] { - self.0.as_slice() - } -} - -impl SetLen for AlignedVecBuffer { - unsafe fn set_len(&mut self, len: usize) { - unsafe { self.0.set_len(len) } - } -} - -impl IoBufMut for AlignedVecBuffer { - fn as_uninit(&mut self) -> &mut [std::mem::MaybeUninit] { - let ptr = self.0.as_mut_ptr() as *mut std::mem::MaybeUninit; - let cap = self.0.capacity(); - unsafe { std::slice::from_raw_parts_mut(ptr, cap) } - } - - fn reserve(&mut self, len: usize) -> Result<(), ReserveError> { - self.0.reserve(len); - Ok(()) - } - - fn reserve_exact(&mut self, len: usize) -> Result<(), ReserveExactError> { - if self.0.capacity() - self.0.len() >= len { - return Ok(()); - } - - self.0.reserve_exact(len); - - if self.0.capacity() - self.0.len() != len { - return Err(ReserveExactError::ExactSizeMismatch { - reserved: self.0.capacity() - self.0.len(), - expected: len, - }); - } - Ok(()) - } -} - -macro_rules! nop { - ($($abi:literal fn $fn_name:ident( $($arg_id:ident : $arg_type:ty),* ) -> $ret_type:ty;)*) => {}; -} - -macro_rules! implemented { - ($($abi:literal fn $fn_name:ident( $($arg_id:ident : $arg_type:ty),* ) -> $ret_type:ty;)*) => { - $( - #[link(name = "nvcuda", kind = "raw-dylib")] - unsafe extern $abi { - fn $fn_name ( $( $arg_id : $arg_type),* ) -> $ret_type; - } - )* - - }; -} - -cuda_function_declarations! { - nop, - implemented <= [ - cuCtxCreate_v2, - // cuCtxDetach, - cuCtxGetApiVersion, - // cuCtxGetCurrent, - cuCtxGetDevice, - cuCtxSynchronize, - // cuDeviceComputeCapability, - cuDeviceGet, - cuDeviceGetAttribute, - cuDeviceGetCount, - cuDeviceGetName, - // cuDeviceGetProperties, - cuDeviceTotalMem_v2, - cuDriverGetVersion, - // cuEventCreate, - // cuEventDestroy_v2, - cuGetExportTable, - cuInit, - cuLaunchKernel, - cuMemAlloc_v2, - // cuMemFreeHost, - // cuMemFree_v2, - // cuMemGetAddressRange_v2, - // cuMemHostAlloc, - // cuMemcpyDtoDAsync_v2, - cuMemcpyDtoHAsync_v2, - cuMemcpyHtoD_v2, - cuMemcpyHtoDAsync_v2, - // cuMemsetD8_v2, - cuModuleGetFunction, - cuModuleGetGlobal_v2, - cuModuleGetTexRef, - cuModuleLoadData, - // cuStreamCreate, - // cuStreamDestroy_v2, - // cuTexRefSetAddressMode, - cuTexRefSetAddress_v2, - // cuTexRefSetFilterMode, - cuTexRefSetFlags, - cuTexRefSetFormat, - // cuTexRefSetMaxAnisotropy, - // cuTexRefSetMipmapFilterMode, - // cuTexRefSetMipmapLevelBias, - // cuTexRefSetMipmapLevelClamp, - cuStreamSynchronize, - ] -} diff --git a/zluda_common/src/constants.rs b/zluda_common/src/constants.rs index fb468e9bf..8d316211b 100644 --- a/zluda_common/src/constants.rs +++ b/zluda_common/src/constants.rs @@ -2,7 +2,6 @@ pub const PROJECT_SUFFIX: &[u8] = b" [ZLUDA]\0"; const COMPUTE_CAPABILITY_MAJOR: i32 = 8; const COMPUTE_CAPABILITY_MINOR: i32 = 8; -#[cfg(target_pointer_width = "64")] pub const BLAS_HANDLE_COOKIE: usize = 0x57c3fdb0fd72b08e; pub fn compute_capability() -> (i32, i32) { diff --git a/zluda_common/src/lib.rs b/zluda_common/src/lib.rs index 02fa9817a..8b2c19b5a 100644 --- a/zluda_common/src/lib.rs +++ b/zluda_common/src/lib.rs @@ -135,7 +135,6 @@ macro_rules! from_cuda_nop { macro_rules! from_cuda_transmute { ($($from:ty => $to:ty),*) => { $( - #[cfg(target_pointer_width = "64")] impl<'a, E: CudaErrorType> FromCuda<'a, $from, E> for $to { fn from_cuda(x: &'a $from) -> Result { Ok(unsafe { std::mem::transmute(*x) }) diff --git a/zluda_inject/Cargo.toml b/zluda_inject/Cargo.toml index a8bd44775..a334ded57 100644 --- a/zluda_inject/Cargo.toml +++ b/zluda_inject/Cargo.toml @@ -13,6 +13,7 @@ windows = { version = "0.62.2", features = [ "Win32_Foundation", "Win32_System_Threading", "Win32_Security", + "Win32_System_JobObjects", "Win32_System_Diagnostics_Debug", "Win32_System_LibraryLoader", ] } @@ -33,4 +34,3 @@ zluda_ml = { path = "../zluda_ml" } [package.metadata.zluda] windows_only = true -32bit = true diff --git a/zluda_inject/src/bin.rs b/zluda_inject/src/bin.rs index dd571fbe1..a75ee40f6 100644 --- a/zluda_inject/src/bin.rs +++ b/zluda_inject/src/bin.rs @@ -7,6 +7,10 @@ use std::ffi::{CString, OsStr}; use std::path::PathBuf; use std::{env, mem, process, ptr}; use windows::Win32::Foundation::{HANDLE, WAIT_FAILED}; +use windows::Win32::System::JobObjects::{ + AssignProcessToJobObject, JobObjectExtendedLimitInformation, SetInformationJobObject, + JOBOBJECT_EXTENDED_LIMIT_INFORMATION, JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE, +}; use windows::Win32::System::Threading::{ self, GetExitCodeProcess, ResumeThread, WaitForSingleObject, CREATE_SUSPENDED, CREATE_UNICODE_ENVIRONMENT, @@ -65,7 +69,7 @@ pub fn main_impl() -> Result<(), Box> { Option::None ) }; - zluda_windows::kill_child_on_process_exit(proc_info.hProcess)?; + kill_child_on_process_exit(proc_info.hProcess)?; injection_env.copy_payloads_to_process(proc_info.hProcess)?; os_call! { ResumeThread(HANDLE(proc_info.hThread)), |x| x == -1i32 as u32 }; os_call! { WaitForSingleObject(HANDLE(proc_info.hProcess), Threading::INFINITE), |x| x == WAIT_FAILED }; @@ -334,3 +338,19 @@ impl InjectionConfig { Ok(result.into_vec()) } } + +fn kill_child_on_process_exit(child: detours_sys::HANDLE) -> Result<(), Box> { + let job_handle = unsafe { windows::Win32::System::JobObjects::CreateJobObjectA(None, None) }?; + let mut info = JOBOBJECT_EXTENDED_LIMIT_INFORMATION::default(); + info.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE; + unsafe { + SetInformationJobObject( + job_handle, + JobObjectExtendedLimitInformation, + &mut info as *mut _ as *mut _, + size_of_val(&info) as u32, + ) + }?; + unsafe { AssignProcessToJobObject(job_handle, HANDLE(child)) }?; + Ok(()) +} diff --git a/zluda_redirect/Cargo.toml b/zluda_redirect/Cargo.toml index 9133e6567..e216fd7b2 100644 --- a/zluda_redirect/Cargo.toml +++ b/zluda_redirect/Cargo.toml @@ -36,4 +36,3 @@ rustc-hash = "2.0.0" [package.metadata.zluda] windows_only = true -32bit = true diff --git a/zluda_server_common/Cargo.toml b/zluda_server_common/Cargo.toml deleted file mode 100644 index c1b9de263..000000000 --- a/zluda_server_common/Cargo.toml +++ /dev/null @@ -1,17 +0,0 @@ -[package] -name = "zluda_server_common" -version = "0.0.0" -authors = ["Andrzej Janik "] -edition = "2021" - -[dependencies] -dark_api = { path = "../dark_api" } -cuda_types = { path = "../cuda_types" } -cuda_macros = { path = "../cuda_macros" } -bitcode = "0.6.9" -paste = "1" -postcard = "1.1.3" -bincode = "2.0.1" -rkyv = "0.8.15" -strum = "0.28" -strum_macros = "0.28" diff --git a/zluda_server_common/src/lib.rs b/zluda_server_common/src/lib.rs deleted file mode 100644 index cf1e28a06..000000000 --- a/zluda_server_common/src/lib.rs +++ /dev/null @@ -1,356 +0,0 @@ -use bincode::{Decode, Encode}; -use cuda_macros::{cuda_function_declarations, generate_input_struct, generate_output_struct}; -use cuda_types::cuda::*; -use paste::paste; -use rkyv::rend::{u32_le, u64_le}; -use rkyv::{rend, Archive, Deserialize, Portable, Serialize}; -use std::ffi::CString; -use std::num::NonZeroU32; -use std::{ffi::CStr, num::NonZero}; -use strum_macros::FromRepr; - -macro_rules! noop { - ($($abi:literal fn $fn_name:ident( $($arg_id:ident : $arg_type:ty),* ) -> $ret_type:ty;)*) => {}; -} - -macro_rules! generate_messages_inout { - ($($abi:literal fn $fn_name:ident( $($arg_id:ident : $arg_type:ty),* ) -> $ret_type:ty;)*) => { - $( - generate_input_struct!($fn_name, $($arg_id : $arg_type),*); - generate_output_struct!($fn_name, $($arg_id : $arg_type),*); - )* - - #[repr(u32)] - #[derive(FromRepr)] - pub enum Opcode { - System = 0, - $( - $fn_name, - )* - cuDeviceGetName, - cuDeviceTotalMem_v2, - cuModuleLoadData, - ContextLocalStoragePut, - ContextLocalStorageGet, - cuModuleGetFunction, - cuModuleGetGlobal_v2, - cuMemAlloc_v2, - cuMemcpyHtoDAsync_v2, - cuModuleGetTexRef, - cuLaunchKernel, - zludaGetFunctionArgs, - cuMemcpyDtoHAsync_v2 - } - }; -} - -macro_rules! generate_messages_in { - ($($abi:literal fn $fn_name:ident( $($arg_id:ident : $arg_type:ty),* ) -> $ret_type:ty;)*) => { - $( - generate_input_struct!($fn_name, $($arg_id : $arg_type),*); - )* - }; -} - -cuda_function_declarations! { - noop, - generate_messages_inout <= [ - cuCtxCreate_v2, - cuCtxDetach, - cuCtxGetApiVersion, - cuCtxGetCurrent, - cuCtxGetDevice, - cuCtxSynchronize, - cuDeviceComputeCapability, - cuDeviceGet, - cuDeviceGetAttribute, - cuDeviceGetCount, - cuDeviceGetProperties, - cuDriverGetVersion, - cuEventCreate, - cuEventDestroy_v2, - //cuGetExportTable, - cuInit, - // cuLaunchKernel, - //cuMemAlloc_v2, - //cuMemFreeHost, - //cuMemFree_v2, - cuMemGetAddressRange_v2, - //cuMemHostAlloc, - //cuMemcpyDtoDAsync_v2, - //cuMemcpyDtoHAsync_v2, - //cuMemcpyHtoDAsync_v2, - // cuMemsetD8_v2, - // cuModuleGetFunction, - // cuModuleGetGlobal_v2, - // cuModuleGetTexRef, - cuStreamCreate, - cuStreamDestroy_v2, - cuTexRefSetAddressMode, - cuTexRefSetAddress_v2, - cuTexRefSetFilterMode, - cuTexRefSetFlags, - cuTexRefSetFormat, - cuTexRefSetMaxAnisotropy, - cuTexRefSetMipmapFilterMode, - cuTexRefSetMipmapLevelBias, - cuTexRefSetMipmapLevelClamp, - ], - generate_messages_in <= [ - cuDeviceGetName, - cuDeviceTotalMem_v2 - ] -} - -pub trait CudaEncode: Copy { - type WireObject; - fn encode(self) -> Self::WireObject; - fn decode(o: Self::WireObject) -> Self; -} - -macro_rules! encode_as_self { - ($type_:ty) => { - impl CudaEncode for $type_ { - type WireObject = Self; - fn encode(self) -> Self { - self - } - fn decode(o: Self::WireObject) -> Self { - o - } - } - }; -} - -macro_rules! encode_as_proxy { - ($type_:ty, $proxy_type:ty) => { - impl CudaEncode for $type_ { - type WireObject = $proxy_type; - fn encode(self) -> $proxy_type { - unsafe { std::mem::transmute::(self) } - } - fn decode(o: Self::WireObject) -> Self { - unsafe { std::mem::transmute::<$proxy_type, Self>(o) } - } - } - }; -} - -macro_rules! encode_as_u32 { - ($type_:ty) => { - impl CudaEncode for $type_ { - type WireObject = u32_le; - fn encode(self) -> u32_le { - unsafe { std::mem::transmute_copy::(&self) } - } - fn decode(o: Self::WireObject) -> Self { - unsafe { std::mem::transmute_copy::(&o) } - } - } - }; -} - -encode_as_self!(u8); -encode_as_self!(i8); -encode_as_self!(u32); -encode_as_self!(i32); -encode_as_self!(f32); - -encode_as_proxy!(CUdevprop_v1, CUdevprop_v1_Wire); -encode_as_proxy!(CUdevice_attribute, u32_le); -encode_as_proxy!(CUfilter_mode, u32_le); -encode_as_proxy!(CUaddress_mode, u32_le); -encode_as_proxy!(CUarray_format, u32_le); - -encode_as_u32!(CUcontext); -encode_as_u32!(CUdeviceptr_v2); -encode_as_u32!(CUevent); -encode_as_u32!(CUfunction); -encode_as_u32!(CUmodule); -encode_as_u32!(CUstream); -encode_as_u32!(CUtexref); - -impl CudaEncode for usize { - type WireObject = u32_le; - fn encode(self) -> u32_le { - (self as u32).into() - } - fn decode(o: Self::WireObject) -> Self { - o.to_native() as usize - } -} - -#[repr(C)] -#[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] -pub struct CUdevprop_v1_Wire { - pub maxThreadsPerBlock: ::core::ffi::c_int, - pub maxThreadsDim: [::core::ffi::c_int; 3usize], - pub maxGridSize: [::core::ffi::c_int; 3usize], - pub sharedMemPerBlock: ::core::ffi::c_int, - pub totalConstantMemory: ::core::ffi::c_int, - pub SIMDWidth: ::core::ffi::c_int, - pub memPitch: ::core::ffi::c_int, - pub regsPerBlock: ::core::ffi::c_int, - pub clockRate: ::core::ffi::c_int, - pub textureAlign: ::core::ffi::c_int, -} - -unsafe impl Portable for CUdevprop_v1_Wire {} - -#[repr(C)] -#[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] -pub struct cuDeviceGetNameOut { - pub name: Vec, -} - -#[repr(C)] -#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] -pub struct cuDeviceTotalMem_v2Out { - pub bytes: u64_le, -} - -#[repr(C)] -#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] -pub struct ContextLocalStoragePutIn { - pub cu_ctx: u32_le, - pub key: u32_le, - pub value: u32_le, -} - -#[repr(C)] -#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] -pub struct ContextLocalStoragePutOut {} - -#[repr(C)] -#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] -pub struct ContextLocalStorageGetIn { - pub cu_ctx: u32_le, - pub key: u32_le, -} - -#[repr(C)] -#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] -pub struct ContextLocalStorageGetOut { - pub value: u32_le, -} - -#[repr(C)] -#[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] -pub struct cuModuleLoadDataIn { - pub image: Vec, -} - -#[repr(C)] -#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] -pub struct cuModuleLoadDataOut { - pub module: ::WireObject, -} - -#[repr(C)] -#[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] -pub struct cuModuleGetFunctionIn { - pub hmod: ::WireObject, - pub name: Vec, -} - -#[repr(C)] -#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] -pub struct cuModuleGetFunctionOut { - pub hfunc: ::WireObject, -} - -#[repr(C)] -#[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] -pub struct cuModuleGetGlobal_v2In { - pub hmod: ::WireObject, - pub name: Vec, -} - -#[repr(C)] -#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] -pub struct cuModuleGetGlobal_v2Out { - pub dptr: ::WireObject, - pub bytes: u64_le, -} - -#[repr(C)] -#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] -pub struct cuMemAlloc_v2In { - pub bytesize: u32_le, -} - -#[repr(C)] -#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] -pub struct cuMemAlloc_v2Out { - pub dptr: ::WireObject, -} - -#[repr(C)] -#[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] -pub struct cuMemcpyHtoDAsync_v2In { - pub dst_device: ::WireObject, - pub src_host: Vec, - pub stream: ::WireObject, -} - -#[repr(C)] -#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] -pub struct cuMemcpyHtoDAsync_v2Out {} - -#[repr(C)] -#[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] -pub struct cuModuleGetTexRefIn { - pub hmod: ::WireObject, - pub name: Vec, -} - -#[repr(C)] -#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] -pub struct cuModuleGetTexRefOut { - pub texref: ::WireObject, -} - -#[repr(C)] -#[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] -pub struct cuLaunchKernelIn { - pub f: ::WireObject, - pub grid_dim_x: u32_le, - pub grid_dim_y: u32_le, - pub grid_dim_z: u32_le, - pub block_dim_x: u32_le, - pub block_dim_y: u32_le, - pub block_dim_z: u32_le, - pub shared_mem_bytes: u32_le, - pub stream: ::WireObject, - pub kernel_params: Vec>, -} - -#[repr(C)] -#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] -pub struct cuLaunchKernelOut {} - -#[repr(C)] -#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] -pub struct zludaGetFunctionArgsIn { - pub f: ::WireObject, -} - -#[repr(C)] -#[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] -pub struct zludaGetFunctionArgsOut { - pub args: Vec, -} - -#[repr(C)] -#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] -pub struct cuMemcpyDtoHAsync_v2In { - pub src_device: ::WireObject, - pub stream: ::WireObject, - pub byte_count: u32_le, -} - -#[repr(C)] -#[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] -pub struct cuMemcpyDtoHAsync_v2Out { - pub dst_host: Vec, -} diff --git a/zluda_trace/Cargo.toml b/zluda_trace/Cargo.toml index decfa48f7..d36cb1cb1 100644 --- a/zluda_trace/Cargo.toml +++ b/zluda_trace/Cargo.toml @@ -9,14 +9,15 @@ name = "zluda_trace" crate-type = ["cdylib"] [dependencies] +ptx = { path = "../ptx" } ptx_parser = { path = "../ptx_parser" } zluda_trace_common = { path = "../zluda_trace_common" } zluda_common = { path = "../zluda_common" } format = { path = "../format" } dark_api = { path = "../dark_api" } regex = "1.4" -dynasm = "5.0" -dynasmrt = "5.0" +dynasm = "1.2" +dynasmrt = "1.2" # we don't need elf32, but goblin has a bug where elf64 does not build without elf32 goblin = { version = "0.9", default-features = false, features = [ "elf64", @@ -51,4 +52,3 @@ linux_symlinks = [ "trace_nvidia/libcuda.so.1", ] windows_paths = ["trace/nvcuda.dll"] -32bit = true diff --git a/zluda_trace/src/lib.rs b/zluda_trace/src/lib.rs index 967387497..b813f631e 100644 --- a/zluda_trace/src/lib.rs +++ b/zluda_trace/src/lib.rs @@ -147,19 +147,13 @@ struct InternalTableImpl; impl ::dark_api::zluda_trace::CudaDarkApi for InternalTableImpl { unsafe extern "system" fn logged_call( fn_name: cglue::slice::CSliceRef<'static, u8>, - nvapi_interface: u32, args: ::dark_api::FnFfiRef<::dark_api::ByteVecFfi>, fn_: ::dark_api::FnFfiRef, internal_error: usize, format_status: extern "C" fn(usize) -> ::dark_api::ByteVecFfi, ) -> usize { - let fn_name = if nvapi_interface == 0 { - CudaFunctionName::Normal(unsafe { fn_name.into_str() }) - } else { - CudaFunctionName::Nvapi(nvapi_interface) - }; GlobalState2::under_lock( - fn_name, + CudaFunctionName::Normal(unsafe { fn_name.into_str() }), Some(|| args.call().to_vec()), internal_error, |status| format_status(status).to_vec(), diff --git a/zluda_trace/src/log.rs b/zluda_trace/src/log.rs index 023d7979d..5915f1938 100644 --- a/zluda_trace/src/log.rs +++ b/zluda_trace/src/log.rs @@ -236,7 +236,6 @@ impl Write for WriteBuffer { pub(crate) enum CudaFunctionName { Normal(&'static str), Dark { guid: CUuuid, index: usize }, - Nvapi(u32) } impl Display for CudaFunctionName { @@ -258,9 +257,6 @@ impl Display for CudaFunctionName { } } } - CudaFunctionName::Nvapi(interface) => { - write!(f, "{{nvapi:{:#010x}}}", interface) - } } } } diff --git a/zluda_trace/src/trace.rs b/zluda_trace/src/trace.rs index 1db1c62c1..fa3315076 100644 --- a/zluda_trace/src/trace.rs +++ b/zluda_trace/src/trace.rs @@ -102,10 +102,9 @@ impl StateTracker { }) } Ok(zluda_common::CodeModuleRef::File(file)) => { - if let Some(buffer) = fn_logger.try_(|_| { - file.get_or_decompress_content(true) - .map_err(ErrorEntry::from) - }) { + if let Some(buffer) = fn_logger + .try_(|_| file.get_or_decompress_content().map_err(ErrorEntry::from)) + { self.record_new_submodule(index, &*buffer, fn_logger, file.kind()); } } diff --git a/zluda_trace_blas/src/lib.rs b/zluda_trace_blas/src/lib.rs index 0ef7600eb..b1bc28fdc 100644 --- a/zluda_trace_blas/src/lib.rs +++ b/zluda_trace_blas/src/lib.rs @@ -35,7 +35,6 @@ macro_rules! unimplemented { }); ReprUsize::from_usize(export_table.logged_call( cglue::slice::CSliceRef::from_str(stringify!($fn_name)), - 0, cglue::trait_obj!(&format_args as dark_api::FnFfi), cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), internal_error_untyped, diff --git a/zluda_trace_blaslt/src/lib.rs b/zluda_trace_blaslt/src/lib.rs index e1c4b1f1a..5202a79dc 100644 --- a/zluda_trace_blaslt/src/lib.rs +++ b/zluda_trace_blaslt/src/lib.rs @@ -35,7 +35,6 @@ macro_rules! unimplemented { }); ReprUsize::from_usize(export_table.logged_call( cglue::slice::CSliceRef::from_str(stringify!($fn_name)), - 0, cglue::trait_obj!(&format_args as dark_api::FnFfi), cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), internal_error_untyped, diff --git a/zluda_trace_dnn8/src/lib.rs b/zluda_trace_dnn8/src/lib.rs index f0ebd0402..6e98a384b 100644 --- a/zluda_trace_dnn8/src/lib.rs +++ b/zluda_trace_dnn8/src/lib.rs @@ -35,7 +35,6 @@ macro_rules! unimplemented { }); ReprUsize::from_usize(export_table.logged_call( cglue::slice::CSliceRef::from_str(stringify!($fn_name)), - 0, cglue::trait_obj!(&format_args as dark_api::FnFfi), cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), internal_error_untyped, diff --git a/zluda_trace_dnn9/src/lib.rs b/zluda_trace_dnn9/src/lib.rs index 96e1a7536..5989ccb3a 100644 --- a/zluda_trace_dnn9/src/lib.rs +++ b/zluda_trace_dnn9/src/lib.rs @@ -35,7 +35,6 @@ macro_rules! unimplemented { }); ReprUsize::from_usize(export_table.logged_call( cglue::slice::CSliceRef::from_str(stringify!($fn_name)), - 0, cglue::trait_obj!(&format_args as dark_api::FnFfi), cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), internal_error_untyped, diff --git a/zluda_trace_fft/src/lib.rs b/zluda_trace_fft/src/lib.rs index ca1f83881..dbedc29fd 100644 --- a/zluda_trace_fft/src/lib.rs +++ b/zluda_trace_fft/src/lib.rs @@ -35,7 +35,6 @@ macro_rules! unimplemented { }); ReprUsize::from_usize(export_table.logged_call( cglue::slice::CSliceRef::from_str(stringify!($fn_name)), - 0, cglue::trait_obj!(&format_args as dark_api::FnFfi), cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), internal_error_untyped, diff --git a/zluda_trace_nvml/src/lib.rs b/zluda_trace_nvml/src/lib.rs index 8fe8b5b51..4eed6940f 100644 --- a/zluda_trace_nvml/src/lib.rs +++ b/zluda_trace_nvml/src/lib.rs @@ -35,7 +35,6 @@ macro_rules! unimplemented { }); ReprUsize::from_usize(export_table.logged_call( cglue::slice::CSliceRef::from_str(stringify!($fn_name)), - 0, cglue::trait_obj!(&format_args as dark_api::FnFfi), cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), internal_error_untyped, diff --git a/zluda_trace_sparse/src/lib.rs b/zluda_trace_sparse/src/lib.rs index 2e2d7683a..44a286d0c 100644 --- a/zluda_trace_sparse/src/lib.rs +++ b/zluda_trace_sparse/src/lib.rs @@ -35,7 +35,6 @@ macro_rules! unimplemented { }); ReprUsize::from_usize(export_table.logged_call( cglue::slice::CSliceRef::from_str(stringify!($fn_name)), - 0, cglue::trait_obj!(&format_args as dark_api::FnFfi), cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), internal_error_untyped, diff --git a/zluda_windows/src/lib.rs b/zluda_windows/src/lib.rs index 26ba82846..c9d482e70 100644 --- a/zluda_windows/src/lib.rs +++ b/zluda_windows/src/lib.rs @@ -13,19 +13,11 @@ use widestring::{u16str, U16Str, U16String}; use windows::{ core::{w, HRESULT, PCWSTR}, Win32::{ - Foundation::{HANDLE, HINSTANCE, HMODULE, HWND, LPARAM, S_OK, WPARAM}, - System::{ - JobObjects::{ - AssignProcessToJobObject, JobObjectExtendedLimitInformation, - SetInformationJobObject, JOBOBJECT_EXTENDED_LIMIT_INFORMATION, - JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE, - }, - LibraryLoader::{ - GetModuleFileNameA, GetModuleFileNameW, GetModuleHandleExW, LoadLibraryExW, - GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, - GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, LOAD_LIBRARY_SEARCH_DEFAULT_DIRS, - LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR, - }, + Foundation::{HINSTANCE, HMODULE, HWND, LPARAM, S_OK, WPARAM}, + System::LibraryLoader::{ + GetModuleFileNameA, GetModuleFileNameW, GetModuleHandleExW, LoadLibraryExW, + GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, + LOAD_LIBRARY_SEARCH_DEFAULT_DIRS, LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR, }, UI::{ Controls::{ @@ -38,13 +30,9 @@ use windows::{ }, }; -#[cfg(target_pointer_width = "32")] -pub static LIBRARIES: [LibraryInfo; 2] = [NVCUDA, NVAPI]; - -#[cfg(target_pointer_width = "64")] -pub static LIBRARIES: [LibraryInfo; 17] = [ +pub static LIBRARIES: [LibraryInfo; 16] = [ NVCUDA, NVML, DNN8, DNN9, BLAS13, BLAS12, BLAS11, BLAS_LT13, BLAS_LT12, BLAS_LT11, SPARSE12, - SPARSE11, SPARSE10, FFT12, FFT11, FFT10, NVAPI, + SPARSE11, SPARSE10, FFT12, FFT11, FFT10, ]; pub const NVCUDA: LibraryInfo = LibraryInfo { @@ -207,22 +195,6 @@ pub const FFT10: LibraryInfo = LibraryInfo { in_system32: false, }; -pub const NVAPI: LibraryInfo = LibraryInfo { - short_name: "nvapi", - is_alias: false, - #[cfg(target_pointer_width = "32")] - ascii_name: "nvapi.dll", - #[cfg(target_pointer_width = "64")] - ascii_name: "nvapi64.dll", - #[cfg(target_pointer_width = "32")] - utf16_name: u16str!("nvapi.dll"), - #[cfg(target_pointer_width = "64")] - utf16_name: u16str!("nvapi64.dll"), - guid: uuid!("f7449ed6-d01c-4376-9fc4-446eb2e4cf70"), - trace_env_var: "ZLUDA_NVAPI_LIB", - in_system32: true, -}; - #[derive(Debug)] pub struct LibraryInfo { pub short_name: &'static str, @@ -611,22 +583,6 @@ pub fn get_module_path_utf16(hm: HMODULE) -> OsString { OsString::from_wide(&buffer) } -pub fn kill_child_on_process_exit(child: *mut c_void) -> windows::core::Result<()> { - let job_handle = unsafe { windows::Win32::System::JobObjects::CreateJobObjectA(None, None) }?; - let mut info = JOBOBJECT_EXTENDED_LIMIT_INFORMATION::default(); - info.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE; - unsafe { - SetInformationJobObject( - job_handle, - JobObjectExtendedLimitInformation, - &mut info as *mut _ as *mut _, - size_of_val(&info) as u32, - ) - }?; - unsafe { AssignProcessToJobObject(job_handle, HANDLE(child)) }?; - Ok(()) -} - #[cfg(test)] mod tests { use super::*; From 0d25248005245bbfac028d509bcb2b65bfbab8d0 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Wed, 27 May 2026 21:10:28 -0700 Subject: [PATCH 57/85] Fix clz.b64 and add bfind.shiftamt (#644) --- ptx/src/pass/insert_post_saturation.rs | 1 + .../instruction_mode_to_global_mode/mod.rs | 1 + ptx/src/pass/llvm/emit.rs | 55 ++++++++++++--- ptx/src/test/ll/bfind_shiftamt.ll | 67 +++++++++++++++++++ ptx/src/test/ll/clz.ll | 12 ++-- ptx/src/test/spirv_run/bfind_shiftamt.ptx | 27 ++++++++ ptx/src/test/spirv_run/mod.rs | 5 ++ ptx_parser/src/ast.rs | 16 +++++ ptx_parser/src/lib.rs | 8 +++ 9 files changed, 178 insertions(+), 14 deletions(-) create mode 100644 ptx/src/test/ll/bfind_shiftamt.ll create mode 100644 ptx/src/test/spirv_run/bfind_shiftamt.ptx diff --git a/ptx/src/pass/insert_post_saturation.rs b/ptx/src/pass/insert_post_saturation.rs index 32c3bb60c..3269dbe86 100644 --- a/ptx/src/pass/insert_post_saturation.rs +++ b/ptx/src/pass/insert_post_saturation.rs @@ -87,6 +87,7 @@ fn run_instruction<'input>( | ast::Instruction::Brev { .. } | ast::Instruction::Call { .. } | ast::Instruction::Clz { .. } + | ast::Instruction::Bfind { .. } | ast::Instruction::Cos { .. } | ast::Instruction::Copysign { .. } | ast::Instruction::CpAsync { .. } diff --git a/ptx/src/pass/instruction_mode_to_global_mode/mod.rs b/ptx/src/pass/instruction_mode_to_global_mode/mod.rs index 005c42ce7..a3e7735c6 100644 --- a/ptx/src/pass/instruction_mode_to_global_mode/mod.rs +++ b/ptx/src/pass/instruction_mode_to_global_mode/mod.rs @@ -2133,6 +2133,7 @@ fn get_modes(inst: &ast::Instruction) -> InstructionModes { | ast::Instruction::And { .. } | ast::Instruction::Bra { .. } | ast::Instruction::Clz { .. } + | ast::Instruction::Bfind { .. } | ast::Instruction::Brev { .. } | ast::Instruction::Dp4a { .. } | ast::Instruction::Popc { .. } diff --git a/ptx/src/pass/llvm/emit.rs b/ptx/src/pass/llvm/emit.rs index 2250b01de..c4c7adedb 100644 --- a/ptx/src/pass/llvm/emit.rs +++ b/ptx/src/pass/llvm/emit.rs @@ -633,6 +633,7 @@ impl<'a> MethodEmitContext<'a> { ast::Instruction::Lg2 { data, arguments } => self.emit_lg2(data, arguments), ast::Instruction::Ex2 { data, arguments } => self.emit_ex2(data, arguments), ast::Instruction::Clz { data, arguments } => self.emit_clz(data, arguments), + ast::Instruction::Bfind { data, arguments } => self.emit_bfind(data, arguments), ast::Instruction::Brev { data, arguments } => self.emit_brev(data, arguments), ast::Instruction::Popc { data, arguments } => self.emit_popc(data, arguments), ast::Instruction::Xor { data, arguments } => self.emit_xor(data, arguments), @@ -1394,22 +1395,35 @@ impl<'a> MethodEmitContext<'a> { data: ptx_parser::ScalarType, arguments: ptx_parser::ClzArgs, ) -> Result<(), TranslateError> { - let llvm_fn = match data.size_of() { + let clz_result = self.emit_clz_impl(data, arguments.src)?; + self.resolver.register(arguments.dst, clz_result); + Ok(()) + } + + fn emit_clz_impl( + &mut self, + type_: ptx_parser::ScalarType, + src: SpirvWord, + ) -> Result { + let llvm_fn = match type_.size_of() { 4 => c"llvm.ctlz.i32", 8 => c"llvm.ctlz.i64", _ => return Err(error_unreachable()), }; - let type_ = get_scalar_type(self.context, data.into()); + let llvm_type = get_scalar_type(self.context, type_); let pred = get_scalar_type(self.context, ast::ScalarType::Pred); - let src = self.resolver.value(arguments.src)?; + let src = self.resolver.value(src)?; let false_ = unsafe { LLVMConstInt(pred, 0, 0) }; - self.emit_intrinsic( + let result = self.emit_intrinsic( llvm_fn, - Some(arguments.dst), - vec![&data.into()], - vec![(src, type_), (false_, pred)], + None, + vec![&type_.into()], + vec![(src, llvm_type), (false_, pred)], )?; - Ok(()) + let i32_llvm = get_scalar_type(self.context, ast::ScalarType::B32); + Ok(unsafe { + LLVMBuildTruncOrBitCast(self.builder, result, i32_llvm, LLVM_UNNAMED.as_ptr()) + }) } fn emit_mul( @@ -3530,6 +3544,31 @@ impl<'a> MethodEmitContext<'a> { Ok(()) } + fn emit_bfind( + &mut self, + _data: (), + arguments: ast::BfindArgs, + ) -> Result<(), TranslateError> { + let src = self.resolver.value(arguments.src)?; + let llvm_i32 = get_scalar_type(self.context, ast::ScalarType::B32); + let const_0 = unsafe { LLVMConstInt(llvm_i32, 0, 0) }; + let const_max = unsafe { LLVMConstInt(llvm_i32, u64::MAX, 0) }; + let src_is_zero = unsafe { + LLVMBuildICmp( + self.builder, + LLVMIntPredicate::LLVMIntEQ, + src, + const_0, + LLVM_UNNAMED.as_ptr(), + ) + }; + let clz_result = self.emit_clz_impl(ast::ScalarType::B32, arguments.src)?; + self.resolver.with_result(arguments.dst, |dst_name| unsafe { + LLVMBuildSelect(self.builder, src_is_zero, const_max, clz_result, dst_name) + }); + Ok(()) + } + /* // Currently unused, LLVM 18 (ROCm 6.2) does not support `llvm.set.rounding` // Should be available in LLVM 19 diff --git a/ptx/src/test/ll/bfind_shiftamt.ll b/ptx/src/test/ll/bfind_shiftamt.ll new file mode 100644 index 000000000..cdc2632af --- /dev/null +++ b/ptx/src/test/ll/bfind_shiftamt.ll @@ -0,0 +1,67 @@ +define amdgpu_kernel void @bfind_shiftamt(ptr addrspace(4) byref(i64) %"49", ptr addrspace(4) byref(i64) %"50") #0 { + %"51" = alloca i64, align 8, addrspace(5) + %"52" = alloca i64, align 8, addrspace(5) + %"53" = alloca i32, align 4, addrspace(5) + %"54" = alloca i32, align 4, addrspace(5) + %"55" = alloca i32, align 4, addrspace(5) + br label %1 + +1: ; preds = %0 + br label %"48" + +"48": ; preds = %1 + %2 = load i64, ptr addrspace(4) %"49", align 8 + store i64 %2, ptr addrspace(5) %"51", align 8 + %3 = load i64, ptr addrspace(4) %"50", align 8 + store i64 %3, ptr addrspace(5) %"52", align 8 + %4 = load i64, ptr addrspace(5) %"51", align 8 + %"76" = inttoptr i64 %4 to ptr + %5 = load i32, ptr %"76", align 4 + store i32 %5, ptr addrspace(5) %"53", align 4 + %6 = load i64, ptr addrspace(5) %"51", align 8 + %"77" = inttoptr i64 %6 to ptr + %"41" = getelementptr inbounds i8, ptr %"77", i64 4 + %7 = load i32, ptr %"41", align 4 + store i32 %7, ptr addrspace(5) %"54", align 4 + %8 = load i64, ptr addrspace(5) %"51", align 8 + %"78" = inttoptr i64 %8 to ptr + %"43" = getelementptr inbounds i8, ptr %"78", i64 8 + %9 = load i32, ptr %"43", align 4 + store i32 %9, ptr addrspace(5) %"55", align 4 + %10 = load i32, ptr addrspace(5) %"53", align 4 + %11 = icmp eq i32 %10, 0 + %12 = call i32 @llvm.ctlz.i32(i32 %10, i1 false) + %"79" = select i1 %11, i32 -1, i32 %12 + store i32 %"79", ptr addrspace(5) %"53", align 4 + %13 = load i32, ptr addrspace(5) %"54", align 4 + %14 = icmp eq i32 %13, 0 + %15 = call i32 @llvm.ctlz.i32(i32 %13, i1 false) + %"81" = select i1 %14, i32 -1, i32 %15 + store i32 %"81", ptr addrspace(5) %"54", align 4 + %16 = load i32, ptr addrspace(5) %"55", align 4 + %17 = icmp eq i32 %16, 0 + %18 = call i32 @llvm.ctlz.i32(i32 %16, i1 false) + %"83" = select i1 %17, i32 -1, i32 %18 + store i32 %"83", ptr addrspace(5) %"55", align 4 + %19 = load i64, ptr addrspace(5) %"52", align 8 + %20 = load i32, ptr addrspace(5) %"53", align 4 + %"85" = inttoptr i64 %19 to ptr + store i32 %20, ptr %"85", align 4 + %21 = load i64, ptr addrspace(5) %"52", align 8 + %"86" = inttoptr i64 %21 to ptr + %"45" = getelementptr inbounds i8, ptr %"86", i64 4 + %22 = load i32, ptr addrspace(5) %"54", align 4 + store i32 %22, ptr %"45", align 4 + %23 = load i64, ptr addrspace(5) %"52", align 8 + %"87" = inttoptr i64 %23 to ptr + %"47" = getelementptr inbounds i8, ptr %"87", i64 8 + %24 = load i32, ptr addrspace(5) %"55", align 4 + store i32 %24, ptr %"47", align 4 + ret void +} + +; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none) +declare i32 @llvm.ctlz.i32(i32, i1 immarg) #1 + +attributes #0 = { "amdgpu-ieee"="false" "amdgpu-unsafe-fp-atomics"="true" "denormal-fp-math"="preserve-sign" "denormal-fp-math-f32"="preserve-sign" "no-trapping-math"="true" "target-features"="+wavefrontsize32,-wavefrontsize64,+cumode,+precise-memory" "uniform-work-group-size"="true" } +attributes #1 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) } diff --git a/ptx/src/test/ll/clz.ll b/ptx/src/test/ll/clz.ll index 49e5b8d45..3abbb73b0 100644 --- a/ptx/src/test/ll/clz.ll +++ b/ptx/src/test/ll/clz.ll @@ -17,12 +17,12 @@ define amdgpu_kernel void @clz(ptr addrspace(4) byref(i64) %"39", ptr addrspace( %5 = load i32, ptr %"52", align 4 store i32 %5, ptr addrspace(5) %"43", align 4 %6 = load i32, ptr addrspace(5) %"43", align 4 - %"53" = call i32 @llvm.ctlz.i32(i32 %6, i1 false) - store i32 %"53", ptr addrspace(5) %"43", align 4 - %7 = load i64, ptr addrspace(5) %"42", align 8 - %8 = load i32, ptr addrspace(5) %"43", align 4 - %"54" = inttoptr i64 %7 to ptr - store i32 %8, ptr %"54", align 4 + %7 = call i32 @llvm.ctlz.i32(i32 %6, i1 false) + store i32 %7, ptr addrspace(5) %"43", align 4 + %8 = load i64, ptr addrspace(5) %"42", align 8 + %9 = load i32, ptr addrspace(5) %"43", align 4 + %"54" = inttoptr i64 %8 to ptr + store i32 %9, ptr %"54", align 4 ret void } diff --git a/ptx/src/test/spirv_run/bfind_shiftamt.ptx b/ptx/src/test/spirv_run/bfind_shiftamt.ptx new file mode 100644 index 000000000..8c6ed5413 --- /dev/null +++ b/ptx/src/test/spirv_run/bfind_shiftamt.ptx @@ -0,0 +1,27 @@ +.version 6.5 +.target sm_30 +.address_size 64 + +.visible .entry bfind_shiftamt( + .param .u64 input, + .param .u64 output +) +{ + .reg .u64 in_addr; + .reg .u64 out_addr; + .reg .b32 temp<3>; + + ld.param.u64 in_addr, [input]; + ld.param.u64 out_addr, [output]; + + ld.b32 temp0, [in_addr]; + ld.b32 temp1, [in_addr+4]; + ld.b32 temp2, [in_addr+8]; + bfind.shiftamt.u32 temp0, temp0; + bfind.shiftamt.u32 temp1, temp1; + bfind.shiftamt.u32 temp2, temp2; + st.b32 [out_addr], temp0; + st.b32 [out_addr+4], temp1; + st.b32 [out_addr+8], temp2; + ret; +} diff --git a/ptx/src/test/spirv_run/mod.rs b/ptx/src/test/spirv_run/mod.rs index 53722bfbf..0161b13c2 100644 --- a/ptx/src/test/spirv_run/mod.rs +++ b/ptx/src/test/spirv_run/mod.rs @@ -326,6 +326,11 @@ test_ptx!(cvt_rn_f16x2_e4m3x2, [0x2D55u16], [0x36804a80u32]); test_ptx!(cvt_rn_f16x2_e5m2x2, [0x36EDu16], [0x3600ED00u32]); test_ptx!(cvt_rn_bf16x2_f32, [0.40625, 12.9f32], [0x3ED0414Eu32]); test_ptx!(clz, [0b00000101_00101101_00010011_10101011u32], [5u32]); +test_ptx!( + bfind_shiftamt, + [0u32, u32::MAX, 0x2cd1a4c1u32], + [4294967295u32, 0, 2] +); test_ptx!(popc, [0b10111100_10010010_01001001_10001010u32], [14u32]); test_ptx!(popc_b64, [0x99427D688BCB5258u64], [30u32]); test_ptx!( diff --git a/ptx_parser/src/ast.rs b/ptx_parser/src/ast.rs index 726a682a4..57825194d 100644 --- a/ptx_parser/src/ast.rs +++ b/ptx_parser/src/ast.rs @@ -944,6 +944,22 @@ ptx_parser_macros::generate_instruction_type!( }, } }, + Bfind { + type: !, + data: (), + arguments: { + dst: { + repr: T, + type: { Type::Scalar(ScalarType::U32) } + + }, + src: { + repr: T, + type: { Type::Scalar(ScalarType::U32) } + + } + } + }, } ); diff --git a/ptx_parser/src/lib.rs b/ptx_parser/src/lib.rs index c134c48ca..a73251241 100644 --- a/ptx_parser/src/lib.rs +++ b/ptx_parser/src/lib.rs @@ -4414,6 +4414,14 @@ derive_parser!( } .type: ScalarType = { .b32, .b64 }; + + // https://docs.nvidia.com/cuda/parallel-thread-execution/ + bfind.shiftamt.u32 d, a => { + Instruction::Bfind { + data: (), + arguments: BfindArgs { dst: d, src: a } + } + } ); #[cfg(test)] From 3e3952bf38108263162f01821a287249b7f6354f Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Sun, 31 May 2026 14:20:10 -0700 Subject: [PATCH 58/85] Add cuDeviceGetPCIBusId (#645) --- zluda/src/impl/device.rs | 8 ++++++++ zluda/src/lib.rs | 1 + 2 files changed, 9 insertions(+) diff --git a/zluda/src/impl/device.rs b/zluda/src/impl/device.rs index 45191a713..03ad3643d 100644 --- a/zluda/src/impl/device.rs +++ b/zluda/src/impl/device.rs @@ -553,6 +553,14 @@ pub(crate) unsafe fn can_access_peer( hipDeviceCanAccessPeer(can_access_peer, dev1, dev2) } +pub(crate) unsafe fn get_p_c_i_bus_id( + pci_bus_id: *mut ::core::ffi::c_char, + len: ::core::ffi::c_int, + dev: hipDevice_t, +) -> hipError_t { + hipDeviceGetPCIBusId(pci_bus_id, len, dev) +} + #[cfg(test)] mod tests { use crate::tests::CudaApi; diff --git a/zluda/src/lib.rs b/zluda/src/lib.rs index 5fe1a5c62..46fbebfd0 100644 --- a/zluda/src/lib.rs +++ b/zluda/src/lib.rs @@ -95,6 +95,7 @@ cuda_macros::cuda_function_declarations!( cuDeviceGetCount, cuDeviceGetLuid, cuDeviceGetName, + cuDeviceGetPCIBusId, cuDeviceGetProperties, cuDeviceGetUuid_v2, cuDeviceGetUuid, From 64dceafdbe6961672a7cdf43115cca5388e6f6b7 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Mon, 8 Jun 2026 10:13:49 -0700 Subject: [PATCH 59/85] Minor improvements for PyTorch (#643) Add cuCtxCreate_v4 and exit and a broken printf implementation --- ptx/lib/zluda_ptx_impl.bc | 4 +-- ptx/lib/zluda_ptx_impl.cpp | 7 +++-- ptx/src/pass/insert_post_saturation.rs | 1 + .../instruction_mode_to_global_mode/mod.rs | 1 + ptx/src/pass/llvm/emit.rs | 23 +++++++++++--- ptx/src/pass/normalize_basic_blocks.rs | 1 + ptx/src/test/ll/exit.ll | 30 +++++++++++++++++++ ptx/src/test/spirv_run/exit.ptx | 22 ++++++++++++++ ptx/src/test/spirv_run/mod.rs | 1 + ptx_parser/src/ast.rs | 1 + ptx_parser/src/lib.rs | 6 ++++ zluda/src/impl/context.rs | 9 ++++++ zluda/src/lib.rs | 1 + zluda_common/src/lib.rs | 3 +- zluda_ld/src/lib.rs | 6 +++- 15 files changed, 105 insertions(+), 11 deletions(-) create mode 100644 ptx/src/test/ll/exit.ll create mode 100644 ptx/src/test/spirv_run/exit.ptx diff --git a/ptx/lib/zluda_ptx_impl.bc b/ptx/lib/zluda_ptx_impl.bc index f6e7ca246..7c41edf75 100644 --- a/ptx/lib/zluda_ptx_impl.bc +++ b/ptx/lib/zluda_ptx_impl.bc @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:04a280e445b8566fcddc9257efd426d7fd37d12a80be53b4be5116ab7fecb7cf -size 45728 +oid sha256:38b37e9a427c3354e4c878f14c535606242cbee8e4049895f64490d820d4aa2f +size 46280 diff --git a/ptx/lib/zluda_ptx_impl.cpp b/ptx/lib/zluda_ptx_impl.cpp index 2b293f91f..39baf2ba4 100644 --- a/ptx/lib/zluda_ptx_impl.cpp +++ b/ptx/lib/zluda_ptx_impl.cpp @@ -340,7 +340,7 @@ extern "C" uint64_t char_size) { (void)char_size; - __assert_fail((const char *)message, (const char *)file, line, (const char *)function); + [[clang::noinline]] __assert_fail((const char *)message, (const char *)file, line, (const char *)function); } // * Smallest denormal is 1.4 × 10^-45 @@ -786,12 +786,13 @@ extern "C" return output.u32; } - int FUNC(vprintf)(const char *format __attribute__((unused)), void *vlist __attribute__((unused))) + [[clang::noinline]] + int FUNC(vprintf)(const char *format , void *vlist __attribute__((unused))) { // TODO: replace calls to vprintf with a raising pass to printf when we have a mechanism // to write SSA passes // Use https://github.com/ROCm/llvm-project/blob/99a81d16b9d811cadd420190bed16981a0a57bc6/llvm/lib/Transforms/Utils/AMDGPUEmitPrintf.cpp#L426 - return -1; + return printf("%s", format); } } diff --git a/ptx/src/pass/insert_post_saturation.rs b/ptx/src/pass/insert_post_saturation.rs index 3269dbe86..d18ddc151 100644 --- a/ptx/src/pass/insert_post_saturation.rs +++ b/ptx/src/pass/insert_post_saturation.rs @@ -202,6 +202,7 @@ fn run_instruction<'input>( } | ast::Instruction::Tanh { .. } | ast::Instruction::Trap {} + | ast::Instruction::Exit {} | ast::Instruction::Xor { .. } | ast::Instruction::Vote { .. } | ast::Instruction::ReduxSync { .. } diff --git a/ptx/src/pass/instruction_mode_to_global_mode/mod.rs b/ptx/src/pass/instruction_mode_to_global_mode/mod.rs index a3e7735c6..e0d5aa5bc 100644 --- a/ptx/src/pass/instruction_mode_to_global_mode/mod.rs +++ b/ptx/src/pass/instruction_mode_to_global_mode/mod.rs @@ -2128,6 +2128,7 @@ fn get_modes(inst: &ast::Instruction) -> InstructionModes { | ast::Instruction::Activemask { .. } | ast::Instruction::Membar { .. } | ast::Instruction::Trap {} + | ast::Instruction::Exit {} | ast::Instruction::Not { .. } | ast::Instruction::Or { .. } | ast::Instruction::And { .. } diff --git a/ptx/src/pass/llvm/emit.rs b/ptx/src/pass/llvm/emit.rs index c4c7adedb..44d18d828 100644 --- a/ptx/src/pass/llvm/emit.rs +++ b/ptx/src/pass/llvm/emit.rs @@ -182,12 +182,13 @@ impl<'a, 'input> ModuleEmitContext<'a, 'input> { unsafe { LLVMAddAttributeAtIndex(fn_, i as u32 + 1, attr) }; } } - if !method.is_kernel() { + let is_kernel = method.is_kernel(); + if !is_kernel { unsafe { LLVMSetVisibility(fn_, llvm_zluda::LLVMVisibility::LLVMHiddenVisibility); } } - let call_conv = if method.is_kernel() { + let call_conv = if is_kernel { Self::kernel_call_convention() } else { Self::func_call_convention() @@ -213,7 +214,7 @@ impl<'a, 'input> ModuleEmitContext<'a, 'input> { unsafe { LLVMPositionBuilderAtEnd(self.builder.get(), real_bb) }; let base_32bit_memory = method.kernel_meta32.as_ref().map(|m| m.implicit_memory_ptr); let mut method_emitter = - MethodEmitContext::new(self, fn_, variables_builder, base_32bit_memory); + MethodEmitContext::new(self, fn_, variables_builder, base_32bit_memory, is_kernel); for var in method.return_arguments { method_emitter.emit_variable(var)?; } @@ -466,6 +467,7 @@ struct MethodEmitContext<'a> { resolver: &'a mut ResolveIdent, carry_flag: Option, base_32bit_memory: Option, + is_kernel: bool, } impl<'a> MethodEmitContext<'a> { @@ -474,6 +476,7 @@ impl<'a> MethodEmitContext<'a> { method: LLVMValueRef, variables_builder: Builder, base_32bit_memory: Option, + is_kernel: bool, ) -> MethodEmitContext<'a> { MethodEmitContext { context: parent.context, @@ -483,7 +486,8 @@ impl<'a> MethodEmitContext<'a> { resolver: &mut parent.resolver, method, carry_flag: None, - base_32bit_memory: base_32bit_memory, + base_32bit_memory, + is_kernel, } } @@ -613,6 +617,7 @@ impl<'a> MethodEmitContext<'a> { ast::Instruction::Shr { data, arguments } => self.emit_shr(data, arguments), ast::Instruction::Shl { data, arguments } => self.emit_shl(data, arguments), ast::Instruction::Ret { data } => Ok(self.emit_ret(data)), + ast::Instruction::Exit {} => self.emit_exit(), ast::Instruction::Cvta { data, arguments } => self.emit_cvta(data, arguments), ast::Instruction::Abs { data, arguments } => self.emit_abs(data, arguments), ast::Instruction::Mad { data, arguments } => self.emit_mad(data, arguments), @@ -3569,6 +3574,16 @@ impl<'a> MethodEmitContext<'a> { Ok(()) } + fn emit_exit(&mut self) -> Result<(), TranslateError> { + if !self.is_kernel { + return Err(error_todo()); + } + unsafe { + LLVMBuildRetVoid(self.builder); + } + Ok(()) + } + /* // Currently unused, LLVM 18 (ROCm 6.2) does not support `llvm.set.rounding` // Should be available in LLVM 19 diff --git a/ptx/src/pass/normalize_basic_blocks.rs b/ptx/src/pass/normalize_basic_blocks.rs index 3c392c0c3..cc470a5ac 100644 --- a/ptx/src/pass/normalize_basic_blocks.rs +++ b/ptx/src/pass/normalize_basic_blocks.rs @@ -129,6 +129,7 @@ fn is_block_terminator( match statement { Statement::Conditional(..) | Statement::Instruction(ast::Instruction::Trap { .. }) + | Statement::Instruction(ast::Instruction::Exit { .. }) | Statement::Instruction(ast::Instruction::Bra { .. }) // Normally call is not a terminator, but we treat it as such because it // makes the "instruction modes to global modes" pass possible diff --git a/ptx/src/test/ll/exit.ll b/ptx/src/test/ll/exit.ll new file mode 100644 index 000000000..bea6269d2 --- /dev/null +++ b/ptx/src/test/ll/exit.ll @@ -0,0 +1,30 @@ +define amdgpu_kernel void @exit(ptr addrspace(4) byref(i64) %"41", ptr addrspace(4) byref(i64) %"42") #0 { + %"43" = alloca i64, align 8, addrspace(5) + %"44" = alloca i64, align 8, addrspace(5) + %"45" = alloca i64, align 8, addrspace(5) + %"46" = alloca i64, align 8, addrspace(5) + br label %1 + +1: ; preds = %0 + br label %"40" + +"40": ; preds = %1 + %2 = load i64, ptr addrspace(4) %"41", align 8 + store i64 %2, ptr addrspace(5) %"43", align 8 + %3 = load i64, ptr addrspace(4) %"42", align 8 + store i64 %3, ptr addrspace(5) %"44", align 8 + %4 = load i64, ptr addrspace(5) %"43", align 8 + %"55" = inttoptr i64 %4 to ptr + %5 = load i64, ptr %"55", align 8 + store i64 %5, ptr addrspace(5) %"45", align 8 + %6 = load i64, ptr addrspace(5) %"45", align 8 + %"51" = add i64 %6, 1 + store i64 %"51", ptr addrspace(5) %"46", align 8 + %7 = load i64, ptr addrspace(5) %"44", align 8 + %8 = load i64, ptr addrspace(5) %"46", align 8 + %"56" = inttoptr i64 %7 to ptr + store i64 %8, ptr %"56", align 8 + ret void +} + +attributes #0 = { "amdgpu-ieee"="false" "amdgpu-unsafe-fp-atomics"="true" "denormal-fp-math"="preserve-sign" "denormal-fp-math-f32"="preserve-sign" "no-trapping-math"="true" "target-features"="+wavefrontsize32,-wavefrontsize64,+cumode,+precise-memory" "uniform-work-group-size"="true" } \ No newline at end of file diff --git a/ptx/src/test/spirv_run/exit.ptx b/ptx/src/test/spirv_run/exit.ptx new file mode 100644 index 000000000..6c29c7cce --- /dev/null +++ b/ptx/src/test/spirv_run/exit.ptx @@ -0,0 +1,22 @@ +.version 6.5 +.target sm_30 +.address_size 64 + +.visible .entry exit( + .param .u64 input, + .param .u64 output +) +{ + .reg .u64 in_addr; + .reg .u64 out_addr; + .reg .u64 temp; + .reg .u64 temp2; + + ld.param.u64 in_addr, [input]; + ld.param.u64 out_addr, [output]; + + ld.u64 temp, [in_addr]; + add.u64 temp2, temp, 1; + st.u64 [out_addr], temp2; + exit; +} diff --git a/ptx/src/test/spirv_run/mod.rs b/ptx/src/test/spirv_run/mod.rs index 0161b13c2..fbe6a5c37 100644 --- a/ptx/src/test/spirv_run/mod.rs +++ b/ptx/src/test/spirv_run/mod.rs @@ -132,6 +132,7 @@ test_ptx!(mov, [1u64], [1u64]); test_ptx!(mul_lo, [1u64], [2u64]); test_ptx!(mul_hi, [u64::max_value()], [1u64]); test_ptx_with_32!(add, [1u64], [2u64]); +test_ptx!(exit, [1u64], [2u64]); test_ptx!( add_extended, [ diff --git a/ptx_parser/src/ast.rs b/ptx_parser/src/ast.rs index 57825194d..76eb7993c 100644 --- a/ptx_parser/src/ast.rs +++ b/ptx_parser/src/ast.rs @@ -760,6 +760,7 @@ ptx_parser_macros::generate_instruction_type!( } }, Trap { }, + Exit { }, Xor { type: Type::Scalar(data.clone()), data: ScalarType, diff --git a/ptx_parser/src/lib.rs b/ptx_parser/src/lib.rs index a73251241..6d6a11e0a 100644 --- a/ptx_parser/src/lib.rs +++ b/ptx_parser/src/lib.rs @@ -4067,6 +4067,12 @@ derive_parser!( Instruction::Trap {} } + // https://docs.nvidia.com/cuda/parallel-thread-execution/#control-flow-instructions-exit + + exit => { + Instruction::Exit {} + } + // https://docs.nvidia.com/cuda/parallel-thread-execution/#integer-arithmetic-instructions-dp4a dp4a.atype.btype d, a, b, c => { diff --git a/zluda/src/impl/context.rs b/zluda/src/impl/context.rs index 571d69840..e521a1bf3 100644 --- a/zluda/src/impl/context.rs +++ b/zluda/src/impl/context.rs @@ -280,6 +280,15 @@ pub(crate) unsafe fn create_v2( Ok(()) } +pub(crate) unsafe fn create_v4( + ctx: &mut CUcontext, + _ctx_create_params: Option<&mut cuda_types::cuda::CUctxCreateParams>, + flags: ::core::ffi::c_uint, + dev: cuda_types::cuda::CUdevice, +) -> CUresult { + create_v2(ctx, flags, dev) +} + pub(crate) unsafe fn destroy_v2(ctx: CUcontext) -> CUresult { zluda_common::drop_checked::(ctx) } diff --git a/zluda/src/lib.rs b/zluda/src/lib.rs index 46fbebfd0..54e1598c5 100644 --- a/zluda/src/lib.rs +++ b/zluda/src/lib.rs @@ -72,6 +72,7 @@ cuda_macros::cuda_function_declarations!( cuArrayCreate_v2, cuArrayDestroy, cuCtxCreate_v2, + cuCtxCreate_v4, cuCtxDestroy_v2, cuCtxGetApiVersion, cuCtxGetCurrent, diff --git a/zluda_common/src/lib.rs b/zluda_common/src/lib.rs index 8b2c19b5a..4568f2ac2 100644 --- a/zluda_common/src/lib.rs +++ b/zluda_common/src/lib.rs @@ -255,7 +255,8 @@ from_cuda_nop!( cudnn9::cudnnConvolutionBwdDataAlgoPerf_t, cudnn9::cudnnConvolutionBwdFilterAlgoPerf_t, cublasLtMatmulPreferenceAttributes_t, - CUfunc_cache + CUfunc_cache, + CUctxCreateParams ); from_cuda_transmute!( CUuuid => hipUUID, diff --git a/zluda_ld/src/lib.rs b/zluda_ld/src/lib.rs index c4d954120..a62e189b6 100644 --- a/zluda_ld/src/lib.rs +++ b/zluda_ld/src/lib.rs @@ -19,12 +19,14 @@ struct DlPhdrInfo { dlpi_phnum: u16, } -static FILES_FOR_REDIRECT: [&'static str; 19] = [ +static FILES_FOR_REDIRECT: [&'static str; 23] = [ "libcublas.so.13", "libcublas.so.12", + "libcublas.so.11", "libcublas.so", "libcublasLt.so.13", "libcublasLt.so.12", + "libcublasLt.so.11", "libcublasLt.so", "libcuda.so.1", "libcuda.so", @@ -33,9 +35,11 @@ static FILES_FOR_REDIRECT: [&'static str; 19] = [ "libcudnn.so", "libcufft.so.12", "libcufft.so.11", + "libcufft.so.10", "libcufft.so", "libcusparse.so.13", "libcusparse.so.12", + "libcusparse.so.11", "libcusparse.so", "libnvidia-ml.so.1", "libnvidia-ml.so", From 4425da7fa7ce53f3574b9549f8bebdd733a5f14c Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Sun, 21 Jun 2026 19:16:45 -0700 Subject: [PATCH 60/85] Update compiler and make some minor compiler fixes --- Cargo.lock | 4 +-- ext/llvm-project | 2 +- llvm_zluda/Cargo.toml | 2 +- llvm_zluda/src/device-libs/ockl.bc | 4 +-- llvm_zluda/src/device-libs/ocml.bc | 4 +-- ptx/lib/zluda_ptx_impl.bc | 4 +-- ptx/lib/zluda_ptx_impl.cpp | 47 +++++++++++++++--------------- ptx/src/test/spirv_run/mod.rs | 5 ++++ ptx_parser/src/lib.rs | 10 ++++++- 9 files changed, 48 insertions(+), 34 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index eb27ec012..a83ce01f1 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2515,9 +2515,9 @@ checksum = "241eaef5fd12c88705a01fc1066c48c4b36e0dd4377dcdc7ec3942cea7a69956" [[package]] name = "llvm-sys" -version = "191.0.0" +version = "211.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "893cddf1adf0354b93411e413553dd4daf5c43195d73f1acfa1e394bdd371456" +checksum = "44007a7a44b73bdd877fa9c9ccef256036511220e90f65b4d50e7a15773c0ee3" dependencies = [ "anyhow", "cc", diff --git a/ext/llvm-project b/ext/llvm-project index fd25b11ef..63e7c64bd 160000 --- a/ext/llvm-project +++ b/ext/llvm-project @@ -1 +1 @@ -Subproject commit fd25b11efa05c5f3491b2f15de4d2b48dd63e50d +Subproject commit 63e7c64bd6d6560ecb9eb2e0e23aaf61b80e07e3 diff --git a/llvm_zluda/Cargo.toml b/llvm_zluda/Cargo.toml index d26ea1168..bcb6e6a53 100644 --- a/llvm_zluda/Cargo.toml +++ b/llvm_zluda/Cargo.toml @@ -12,7 +12,7 @@ kernel_metadata = { path = "../kernel_metadata" } tempfile = "3" [dependencies.llvm-sys] -version = "191" +version = "211" features = ["disable-alltargets-init", "no-llvm-linking"] [build-dependencies] diff --git a/llvm_zluda/src/device-libs/ockl.bc b/llvm_zluda/src/device-libs/ockl.bc index 491b7c5c4..475319f0c 100644 --- a/llvm_zluda/src/device-libs/ockl.bc +++ b/llvm_zluda/src/device-libs/ockl.bc @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:e7b2f66c694f3f6771b9f2800502ed3fb62c9c769a6ab455330c6e2f5e36b6de -size 244908 +oid sha256:cf32a60cb9369f4869f822db0a4307a9a9f54315f5a7b8e74235760867d1e52a +size 266372 diff --git a/llvm_zluda/src/device-libs/ocml.bc b/llvm_zluda/src/device-libs/ocml.bc index e6917a962..43519d55c 100644 --- a/llvm_zluda/src/device-libs/ocml.bc +++ b/llvm_zluda/src/device-libs/ocml.bc @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:0be4e146cb9b602e9517be481d5a2f0461b0e84e8ee50712be4eeee1d34dbf1c -size 204612 +oid sha256:cfe97fe9ee29379f522e5f20ae55aae1cdb96eb41d6aa250ea11c4941c54e019 +size 206684 diff --git a/ptx/lib/zluda_ptx_impl.bc b/ptx/lib/zluda_ptx_impl.bc index 7c41edf75..2e671fa0e 100644 --- a/ptx/lib/zluda_ptx_impl.bc +++ b/ptx/lib/zluda_ptx_impl.bc @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:38b37e9a427c3354e4c878f14c535606242cbee8e4049895f64490d820d4aa2f -size 46280 +oid sha256:9cd5a56df98c6c96ef86efa251781b4bb1e7ad6c341cad122d28f962f88eb5c0 +size 50820 diff --git a/ptx/lib/zluda_ptx_impl.cpp b/ptx/lib/zluda_ptx_impl.cpp index 39baf2ba4..65d5545bd 100644 --- a/ptx/lib/zluda_ptx_impl.cpp +++ b/ptx/lib/zluda_ptx_impl.cpp @@ -52,6 +52,7 @@ then cd to the directory with this file and run this simple command: #include #include +#define GLOBAL_SPACE __attribute__((address_space(1))) #define SHARED_SPACE __attribute__((address_space(3))) #define CONSTANT_SPACE __attribute__((address_space(4))) @@ -81,12 +82,12 @@ typedef char s8x4 __attribute__((ext_vector_type(4))); #define FUNC_CALL(NAME) __zluda_ptx_impl_##NAME #define ATTR(NAME) __ZLUDA_PTX_IMPL_ATTRIBUTE_##NAME #define DECLARE_ATTR(TYPE, NAME) \ - extern "C" __attribute__((constant)) CONSTANT_SPACE TYPE ATTR(NAME) \ + extern "C" __attribute__((constant)) TYPE ATTR(NAME) \ __device__ extern "C" { - extern "C" __attribute__((constant)) CONSTANT_SPACE uint32_t __oclc_ISA_version __device__; + extern "C" __attribute__((constant)) uint32_t __oclc_ISA_version __device__; uint32_t FUNC(activemask)() { @@ -884,7 +885,7 @@ __device__ static void mma_load_col(T upper_row[16], T lower_row[16], T left_col } template -__device__ HIP_vector_base fallback_mma_sync_aligned(uint4::Native_vec_ a_reg, uint2::Native_vec_ b_reg, HIP_vector_base c_reg) +__device__ HIP_vector_base::Native_vec_ fallback_mma_sync_aligned(uint4::Native_vec_ a_reg, uint2::Native_vec_ b_reg, HIP_vector_base c_reg) { uint8_t laneid = uint8_t(FUNC_CALL(sreg_laneid)()); uint8_t quad_index = laneid % 4; @@ -946,7 +947,7 @@ extern "C" { float4::Native_vec_ FUNC(mma_sync_aligned_m16n8k16_row_col_f32_f16_f16_f32)(uint4::Native_vec_ a_reg, uint2::Native_vec_ b_reg, float4::Native_vec_ c_reg) { - return fallback_mma_sync_aligned(a_reg, b_reg, HIP_vector_base(c_reg.x, c_reg.y, c_reg.z, c_reg.w)).data; + return fallback_mma_sync_aligned(a_reg, b_reg, HIP_vector_base(c_reg.x, c_reg.y, c_reg.z, c_reg.w)); } // We wrap the intrinsic in an optnone function to prevent ZLUDA-specific @@ -965,7 +966,7 @@ extern "C" } else { - return fallback_mma_sync_aligned(a_reg, b_reg, HIP_vector_base(c_reg.x, c_reg.y, c_reg.z, c_reg.w)).data; + return fallback_mma_sync_aligned(a_reg, b_reg, HIP_vector_base(c_reg.x, c_reg.y, c_reg.z, c_reg.w)); } } @@ -1047,25 +1048,25 @@ extern "C" c; } - static std::pair get_image_and_sampler(uint64_t texobj) __device__ + static std::pair get_image_and_sampler(uint64_t texobj) __device__ { - unsigned int CONSTANT_SPACE *image = (unsigned int CONSTANT_SPACE *)texobj; - unsigned int ADDRESS_SPACE_CONSTANT *sampler = image + HIP_SAMPLER_OBJECT_OFFSET_DWORD; + unsigned int GLOBAL_SPACE *image = (unsigned int GLOBAL_SPACE *)texobj; + unsigned int GLOBAL_SPACE *sampler = image + HIP_SAMPLER_OBJECT_OFFSET_DWORD; return {image, sampler}; } - static v4f32 sample_1D(CONSTANT_SPACE void *image, CONSTANT_SPACE void *sampler, float coord) __device__ + static v4f32 sample_1D(GLOBAL_SPACE void *image, GLOBAL_SPACE void *sampler, float coord) __device__ { __device__ v4f32 __llvm_amdgcn_image_sample_lz_1d_v4f32_f32(uint32_t, float, v8s32, v4s32, bool, int, int) __asm("llvm.amdgcn.image.sample.lz.1d.v4f32.f32"); - CONSTANT_SPACE v8s32 *image_typed = (CONSTANT_SPACE v8s32 *)image; - CONSTANT_SPACE v4s32 *sampler_typed = (CONSTANT_SPACE v4s32 *)sampler; + GLOBAL_SPACE v8s32 *image_typed = (GLOBAL_SPACE v8s32 *)image; + GLOBAL_SPACE v4s32 *sampler_typed = (GLOBAL_SPACE v4s32 *)sampler; return __llvm_amdgcn_image_sample_lz_1d_v4f32_f32(0xf, coord, *image_typed, *sampler_typed, false, 0, 0); } - static v4f32 sample_1Db(CONSTANT_SPACE void *image, s32 coord) __device__ + static v4f32 sample_1Db(GLOBAL_SPACE void *image, s32 coord) __device__ { __device__ v4f32 __llvm_amdgcn_struct_buffer_load_format_v4f32(v4s32, int, int, int, int) __asm("llvm.amdgcn.struct.buffer.load.format.v4f32"); - CONSTANT_SPACE v4s32 *image_typed = (CONSTANT_SPACE v4s32 *)image; + GLOBAL_SPACE v4s32 *image_typed = (GLOBAL_SPACE v4s32 *)image; return __llvm_amdgcn_struct_buffer_load_format_v4f32(*image_typed, coord, 0, 0, 0); } #define tex_1d(RETURN_TYPE) \ @@ -1075,7 +1076,7 @@ extern "C" auto result = sample_1D(i, s, coord.x); \ return v4##RETURN_TYPE{std::bit_cast(result.x), std::bit_cast(result.y), std::bit_cast(result.z), std::bit_cast(result.w)}; \ } \ - v4##RETURN_TYPE FUNC(texref_1d_v4_##RETURN_TYPE##_f32)(struct textureReference CONSTANT_SPACE * texref, v1f32 coord) \ + v4##RETURN_TYPE FUNC(texref_1d_v4_##RETURN_TYPE##_f32)(struct textureReference GLOBAL_SPACE * texref, v1f32 coord) \ { \ return FUNC_CALL(texobj_1d_v4_##RETURN_TYPE##_f32)(uint64_t(texref->textureObject), coord); \ } @@ -1086,7 +1087,7 @@ extern "C" auto result = sample_1Db(i, coord.x); \ return v4##RETURN_TYPE{std::bit_cast(result.x), std::bit_cast(result.y), std::bit_cast(result.z), std::bit_cast(result.w)}; \ } \ - v4##RETURN_TYPE FUNC(texref_1d_v4_##RETURN_TYPE##_s32)(struct textureReference CONSTANT_SPACE * texref, v1s32 coord) \ + v4##RETURN_TYPE FUNC(texref_1d_v4_##RETURN_TYPE##_s32)(struct textureReference GLOBAL_SPACE * texref, v1s32 coord) \ { \ return FUNC_CALL(texobj_1d_v4_##RETURN_TYPE##_s32)(uint64_t(texref->textureObject), coord); \ } @@ -1096,11 +1097,11 @@ extern "C" tex_1db(s32); tex_1db(f32); - static v4f32 sample_2D(CONSTANT_SPACE void *image, CONSTANT_SPACE void *sampler, v2f32 coord) __device__ + static v4f32 sample_2D(GLOBAL_SPACE void *image, GLOBAL_SPACE void *sampler, v2f32 coord) __device__ { __device__ v4f32 __llvm_amdgcn_image_sample_lz_2d_v4f32_f32(uint32_t, float, float, v8s32, v4s32, bool, int, int) __asm("llvm.amdgcn.image.sample.lz.2d.v4f32.f32"); - CONSTANT_SPACE v8s32 *image_typed = (CONSTANT_SPACE v8s32 *)image; - CONSTANT_SPACE v4s32 *sampler_typed = (CONSTANT_SPACE v4s32 *)sampler; + GLOBAL_SPACE v8s32 *image_typed = (GLOBAL_SPACE v8s32 *)image; + GLOBAL_SPACE v4s32 *sampler_typed = (GLOBAL_SPACE v4s32 *)sampler; return __llvm_amdgcn_image_sample_lz_2d_v4f32_f32(0xf, coord.x, coord.y, *image_typed, *sampler_typed, false, 0, 0); } #define tex_2d(RETURN_TYPE, COORD_TYPE) \ @@ -1110,7 +1111,7 @@ extern "C" auto result = sample_2D(i, s, v2f32{float(coord.x), float(coord.y)}); \ return v4##RETURN_TYPE{std::bit_cast(result.x), std::bit_cast(result.y), std::bit_cast(result.z), std::bit_cast(result.w)}; \ } \ - v4##RETURN_TYPE FUNC(texref_2d_v4_##RETURN_TYPE##_##COORD_TYPE)(struct textureReference CONSTANT_SPACE * texref, v2##COORD_TYPE coord) \ + v4##RETURN_TYPE FUNC(texref_2d_v4_##RETURN_TYPE##_##COORD_TYPE)(struct textureReference GLOBAL_SPACE * texref, v2##COORD_TYPE coord) \ { \ return FUNC_CALL(texobj_2d_v4_##RETURN_TYPE##_##COORD_TYPE)(uint64_t(texref->textureObject), coord); \ } @@ -1120,11 +1121,11 @@ extern "C" tex_2d(f32, s32); tex_2d(s32, f32); - static v4f32 sample_3D(CONSTANT_SPACE void *image, CONSTANT_SPACE void *sampler, v4f32 coord) __device__ + static v4f32 sample_3D(GLOBAL_SPACE void *image, GLOBAL_SPACE void *sampler, v4f32 coord) __device__ { __device__ v4f32 __llvm_amdgcn_image_sample_lz_3d_v4f32_f32(uint32_t, float, float, float, v8s32, v4s32, bool, int, int) __asm("llvm.amdgcn.image.sample.lz.3d.v4f32.f32"); - CONSTANT_SPACE v8s32 *image_typed = (CONSTANT_SPACE v8s32 *)image; - CONSTANT_SPACE v4s32 *sampler_typed = (CONSTANT_SPACE v4s32 *)sampler; + GLOBAL_SPACE v8s32 *image_typed = (GLOBAL_SPACE v8s32 *)image; + GLOBAL_SPACE v4s32 *sampler_typed = (GLOBAL_SPACE v4s32 *)sampler; return __llvm_amdgcn_image_sample_lz_3d_v4f32_f32(0xf, coord.x, coord.y, coord.z, *image_typed, *sampler_typed, false, 0, 0); } #define tex_3d(RETURN_TYPE, COORD_TYPE) \ @@ -1134,7 +1135,7 @@ extern "C" auto result = sample_3D(i, s, v4f32{float(coord.x), float(coord.y), float(coord.z), float(coord.w)}); \ return v4##RETURN_TYPE{std::bit_cast(result.x), std::bit_cast(result.y), std::bit_cast(result.z), std::bit_cast(result.w)}; \ } \ - v4##RETURN_TYPE FUNC(texref_3d_v4_##RETURN_TYPE##_##COORD_TYPE)(struct textureReference CONSTANT_SPACE * texref, v4##COORD_TYPE coord) \ + v4##RETURN_TYPE FUNC(texref_3d_v4_##RETURN_TYPE##_##COORD_TYPE)(struct textureReference GLOBAL_SPACE * texref, v4##COORD_TYPE coord) \ { \ return FUNC_CALL(texobj_3d_v4_##RETURN_TYPE##_##COORD_TYPE)(uint64_t(texref->textureObject), coord); \ } diff --git a/ptx/src/test/spirv_run/mod.rs b/ptx/src/test/spirv_run/mod.rs index fbe6a5c37..36f3da393 100644 --- a/ptx/src/test/spirv_run/mod.rs +++ b/ptx/src/test/spirv_run/mod.rs @@ -1773,7 +1773,12 @@ pub fn verify_symbols(test_name: &str, ctx: &llvm_zluda::utils::Context, elf_mod let expected = [ "_DYNAMIC".to_string(), test_name.to_string(), + format!("{}.has_dyn_sized_stack", test_name), + format!("{}.has_recursion", test_name), format!("{}.kd", test_name), + format!("{}.num_agpr", test_name), + format!("{}.num_vgpr", test_name), + format!("{}.private_seg_size", test_name), ]; if symbols != expected { panic!( diff --git a/ptx_parser/src/lib.rs b/ptx_parser/src/lib.rs index 6d6a11e0a..f2a0c5d26 100644 --- a/ptx_parser/src/lib.rs +++ b/ptx_parser/src/lib.rs @@ -547,7 +547,15 @@ fn version<'a, 'input>(stream: &mut PtxParser<'a, 'input>) -> PResult<(u8, u8)> } fn target<'a, 'input>(stream: &mut PtxParser<'a, 'input>) -> PResult<(u32, Option)> { - preceded(Token::DotTarget, ident.and_then(shader_model)).parse_next(stream) + preceded( + Token::DotTarget, + ( + ident.and_then(shader_model), + opt((Token::Comma, ident_literal("debug"))), + ), + ) + .map(|((target, arch_variant), _debug)| (target, arch_variant)) + .parse_next(stream) } fn shader_model<'a>(stream: &mut &str) -> PResult<(u32, Option)> { From 3651150f13bc2e8d8628347169f9550782cc552a Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Sun, 21 Jun 2026 19:41:39 -0700 Subject: [PATCH 61/85] Use different file name for kernel cache --- zluda_cache/src/lib.rs | 463 +++++++++++++++++++++-------------------- 1 file changed, 232 insertions(+), 231 deletions(-) diff --git a/zluda_cache/src/lib.rs b/zluda_cache/src/lib.rs index ed30ccab4..6dacb3363 100644 --- a/zluda_cache/src/lib.rs +++ b/zluda_cache/src/lib.rs @@ -1,231 +1,232 @@ -use crate::schema::modules; -use arrayvec::ArrayString; -use diesel::{connection::SimpleConnection, prelude::*}; -use diesel_migrations::{embed_migrations, EmbeddedMigrations, MigrationHarness}; -use std::time::Duration; - -pub(crate) mod models; -pub(crate) mod schema; - -pub const MIGRATIONS: EmbeddedMigrations = embed_migrations!("./migrations"); - -pub struct ModuleKey<'a> { - pub hash: ArrayString<64>, - pub compiler_version: &'static str, - pub zluda_version: &'static str, - pub device: &'a str, - pub backend_key: String, - pub last_access: i64, -} - -pub struct ModuleCache(SqliteConnection); - -impl ModuleCache { - pub fn create_cache_dir_and_get_path() -> Option { - let mut cache_dir = dirs::cache_dir()?; - cache_dir.extend(["zluda", "ComputeCache"]); - // We ensure that the cache directory exists - std::fs::create_dir_all(&cache_dir).ok()?; - // No need to create the file, it will be created by SQLite on first access - cache_dir.push("zluda.db"); - Some(cache_dir.to_string_lossy().into()) - } - - pub fn open(file_path: &str) -> Option { - let mut conn = SqliteConnection::establish(file_path).ok()?; - conn.batch_execute("PRAGMA journal_mode = WAL; PRAGMA synchronous = NORMAL;") - .ok()?; - conn.run_pending_migrations(MIGRATIONS).ok()?; - Some(Self(conn)) - } - - pub fn get_module_binary(&mut self, key: &ModuleKey) -> Option> { - diesel::update(modules::dsl::modules) - .set(modules::last_access.eq(key.last_access)) - .filter(modules::hash.eq(key.hash.as_str())) - .filter(modules::compiler_version.eq(&key.compiler_version)) - .filter(modules::zluda_version.eq(key.zluda_version)) - .filter(modules::device.eq(key.device)) - .filter(modules::backend_key.eq(&key.backend_key)) - .returning(modules::binary) - .get_result(&mut self.0) - .ok() - } - - pub fn insert_module(&mut self, key: &ModuleKey, binary: &[u8]) { - diesel::insert_into(modules::dsl::modules) - .values(models::AddModule { - hash: key.hash.as_str(), - compiler_version: &key.compiler_version, - zluda_version: key.zluda_version, - device: key.device, - backend_key: &key.backend_key, - last_access: key.last_access, - binary, - }) - .execute(&mut self.0) - .ok(); - } - - pub fn time_now() -> i64 { - use std::time::{SystemTime, UNIX_EPOCH}; - SystemTime::now() - .duration_since(UNIX_EPOCH) - .unwrap_or(Duration::ZERO) - .as_millis() as i64 - } -} - -#[cfg(test)] -mod tests { - use crate::{ - schema::{globals::dsl::*, modules::dsl::*}, - ModuleCache, - }; - use arrayvec::ArrayString; - use diesel::prelude::*; - - #[derive(Queryable, Selectable)] - #[diesel(table_name = crate::schema::modules)] - #[diesel(check_for_backend(diesel::sqlite::Sqlite))] - pub struct Module { - pub id: i64, - pub hash: String, - pub binary: Vec, - pub last_access: i64, - } - - #[derive(Queryable, Selectable)] - #[diesel(table_name = crate::schema::globals)] - #[diesel(check_for_backend(diesel::sqlite::Sqlite))] - pub struct Global { - pub key: String, - pub value: i64, - } - - #[test] - fn empty_db_returns_no_module() { - let mut db = ModuleCache::open(":memory:").unwrap(); - let module_binary = db.get_module_binary(&super::ModuleKey { - hash: ArrayString::from("test_hash").unwrap(), - compiler_version: "1.0.0", - zluda_version: "1.0.0", - device: "test_device", - backend_key: "{}".to_string(), - last_access: 123, - }); - assert!(module_binary.is_none()); - let all_modules = modules.select(Module::as_select()).load(&mut db.0).unwrap(); - assert_eq!(all_modules.len(), 0); - let all_globals: Vec = globals.select(Global::as_select()).load(&mut db.0).unwrap(); - assert_eq!(all_globals[0].key, "total_size"); - assert_eq!(all_globals[0].value, 0); - } - - #[test] - fn newly_inserted_module_increments_total_size() { - let mut db = ModuleCache::open(":memory:").unwrap(); - db.insert_module( - &super::ModuleKey { - hash: ArrayString::from("test_hash1").unwrap(), - compiler_version: "1.0.0", - zluda_version: "1.0.0", - device: "test_device", - backend_key: "{}".to_string(), - last_access: 123, - }, - &[1, 2, 3, 4, 5], - ); - db.insert_module( - &super::ModuleKey { - hash: ArrayString::from("test_hash2").unwrap(), - compiler_version: "1.0.0", - zluda_version: "1.0.0", - device: "test_device", - backend_key: "{}".to_string(), - last_access: 124, - }, - &[1, 2, 3], - ); - let mut all_modules = modules.select(Module::as_select()).load(&mut db.0).unwrap(); - all_modules.sort_by_key(|m: &Module| m.id); - assert_eq!(all_modules.len(), 2); - assert_eq!(all_modules[0].hash, "test_hash1"); - assert_eq!(all_modules[0].last_access, 123); - assert_eq!(all_modules[0].binary, &[1, 2, 3, 4, 5]); - assert_eq!(all_modules[1].hash, "test_hash2"); - assert_eq!(all_modules[1].last_access, 124); - assert_eq!(all_modules[1].binary, &[1, 2, 3]); - let all_globals = globals.select(Global::as_select()).load(&mut db.0).unwrap(); - assert_eq!(all_globals[0].key, "total_size"); - assert_eq!(all_globals[0].value, 8); - } - - #[test] - fn get_bumps_last_access() { - let mut db = ModuleCache::open(":memory:").unwrap(); - db.insert_module( - &super::ModuleKey { - hash: ArrayString::from("test_hash").unwrap(), - compiler_version: "1.0.0", - zluda_version: "1.0.0", - device: "test_device", - backend_key: "{}".to_string(), - last_access: 123, - }, - &[1, 2, 3, 4, 5], - ); - let module_binary = db - .get_module_binary(&super::ModuleKey { - hash: ArrayString::from("test_hash").unwrap(), - compiler_version: "1.0.0", - zluda_version: "1.0.0", - device: "test_device", - backend_key: "{}".to_string(), - last_access: 124, - }) - .unwrap(); - let all_modules = modules.select(Module::as_select()).load(&mut db.0).unwrap(); - assert_eq!(all_modules.len(), 1); - assert_eq!(all_modules[0].last_access, 124); - assert_eq!(module_binary, &[1, 2, 3, 4, 5]); - assert_eq!(all_modules[0].binary, &[1, 2, 3, 4, 5]); - let all_globals = globals.select(Global::as_select()).load(&mut db.0).unwrap(); - assert_eq!(all_globals[0].key, "total_size"); - assert_eq!(all_globals[0].value, 5); - } - - #[test] - fn double_insert_does_not_override() { - let mut db = ModuleCache::open(":memory:").unwrap(); - db.insert_module( - &super::ModuleKey { - hash: ArrayString::from("test_hash").unwrap(), - compiler_version: "1.0.0", - zluda_version: "1.0.0", - device: "test_device", - backend_key: "{}".to_string(), - last_access: 123, - }, - &[1, 2, 3, 4, 5], - ); - db.insert_module( - &super::ModuleKey { - hash: ArrayString::from("test_hash").unwrap(), - compiler_version: "1.0.0", - zluda_version: "1.0.0", - device: "test_device", - backend_key: "{}".to_string(), - last_access: 124, - }, - &[5, 4, 3, 2, 1], - ); - let all_modules = modules.select(Module::as_select()).load(&mut db.0).unwrap(); - assert_eq!(all_modules.len(), 1); - assert_eq!(all_modules[0].last_access, 123); - assert_eq!(all_modules[0].binary, &[1, 2, 3, 4, 5]); - let all_globals = globals.select(Global::as_select()).load(&mut db.0).unwrap(); - assert_eq!(all_globals[0].key, "total_size"); - assert_eq!(all_globals[0].value, 5); - } -} +use crate::schema::modules; +use arrayvec::ArrayString; +use diesel::{connection::SimpleConnection, prelude::*}; +use diesel_migrations::{embed_migrations, EmbeddedMigrations, MigrationHarness}; +use std::time::Duration; + +pub(crate) mod models; +pub(crate) mod schema; + +pub const MIGRATIONS: EmbeddedMigrations = embed_migrations!("./migrations"); + +pub struct ModuleKey<'a> { + pub hash: ArrayString<64>, + pub compiler_version: &'static str, + pub zluda_version: &'static str, + pub device: &'a str, + pub backend_key: String, + pub last_access: i64, +} + +pub struct ModuleCache(SqliteConnection); + +impl ModuleCache { + pub fn create_cache_dir_and_get_path() -> Option { + let mut cache_dir = dirs::cache_dir()?; + cache_dir.extend(["zluda", "ComputeCache"]); + // We ensure that the cache directory exists + std::fs::create_dir_all(&cache_dir).ok()?; + // No need to create the file, it will be created by SQLite on first access + // zluda.db might be in use by older versions of ZLUDA + cache_dir.push("zluda2.db"); + Some(cache_dir.to_string_lossy().into()) + } + + pub fn open(file_path: &str) -> Option { + let mut conn = SqliteConnection::establish(file_path).ok()?; + conn.batch_execute("PRAGMA journal_mode = WAL; PRAGMA synchronous = NORMAL;") + .ok()?; + conn.run_pending_migrations(MIGRATIONS).ok()?; + Some(Self(conn)) + } + + pub fn get_module_binary(&mut self, key: &ModuleKey) -> Option> { + diesel::update(modules::dsl::modules) + .set(modules::last_access.eq(key.last_access)) + .filter(modules::hash.eq(key.hash.as_str())) + .filter(modules::compiler_version.eq(&key.compiler_version)) + .filter(modules::zluda_version.eq(key.zluda_version)) + .filter(modules::device.eq(key.device)) + .filter(modules::backend_key.eq(&key.backend_key)) + .returning(modules::binary) + .get_result(&mut self.0) + .ok() + } + + pub fn insert_module(&mut self, key: &ModuleKey, binary: &[u8]) { + diesel::insert_into(modules::dsl::modules) + .values(models::AddModule { + hash: key.hash.as_str(), + compiler_version: &key.compiler_version, + zluda_version: key.zluda_version, + device: key.device, + backend_key: &key.backend_key, + last_access: key.last_access, + binary, + }) + .execute(&mut self.0) + .ok(); + } + + pub fn time_now() -> i64 { + use std::time::{SystemTime, UNIX_EPOCH}; + SystemTime::now() + .duration_since(UNIX_EPOCH) + .unwrap_or(Duration::ZERO) + .as_millis() as i64 + } +} + +#[cfg(test)] +mod tests { + use crate::{ + schema::{globals::dsl::*, modules::dsl::*}, + ModuleCache, + }; + use arrayvec::ArrayString; + use diesel::prelude::*; + + #[derive(Queryable, Selectable)] + #[diesel(table_name = crate::schema::modules)] + #[diesel(check_for_backend(diesel::sqlite::Sqlite))] + pub struct Module { + pub id: i64, + pub hash: String, + pub binary: Vec, + pub last_access: i64, + } + + #[derive(Queryable, Selectable)] + #[diesel(table_name = crate::schema::globals)] + #[diesel(check_for_backend(diesel::sqlite::Sqlite))] + pub struct Global { + pub key: String, + pub value: i64, + } + + #[test] + fn empty_db_returns_no_module() { + let mut db = ModuleCache::open(":memory:").unwrap(); + let module_binary = db.get_module_binary(&super::ModuleKey { + hash: ArrayString::from("test_hash").unwrap(), + compiler_version: "1.0.0", + zluda_version: "1.0.0", + device: "test_device", + backend_key: "{}".to_string(), + last_access: 123, + }); + assert!(module_binary.is_none()); + let all_modules = modules.select(Module::as_select()).load(&mut db.0).unwrap(); + assert_eq!(all_modules.len(), 0); + let all_globals: Vec = globals.select(Global::as_select()).load(&mut db.0).unwrap(); + assert_eq!(all_globals[0].key, "total_size"); + assert_eq!(all_globals[0].value, 0); + } + + #[test] + fn newly_inserted_module_increments_total_size() { + let mut db = ModuleCache::open(":memory:").unwrap(); + db.insert_module( + &super::ModuleKey { + hash: ArrayString::from("test_hash1").unwrap(), + compiler_version: "1.0.0", + zluda_version: "1.0.0", + device: "test_device", + backend_key: "{}".to_string(), + last_access: 123, + }, + &[1, 2, 3, 4, 5], + ); + db.insert_module( + &super::ModuleKey { + hash: ArrayString::from("test_hash2").unwrap(), + compiler_version: "1.0.0", + zluda_version: "1.0.0", + device: "test_device", + backend_key: "{}".to_string(), + last_access: 124, + }, + &[1, 2, 3], + ); + let mut all_modules = modules.select(Module::as_select()).load(&mut db.0).unwrap(); + all_modules.sort_by_key(|m: &Module| m.id); + assert_eq!(all_modules.len(), 2); + assert_eq!(all_modules[0].hash, "test_hash1"); + assert_eq!(all_modules[0].last_access, 123); + assert_eq!(all_modules[0].binary, &[1, 2, 3, 4, 5]); + assert_eq!(all_modules[1].hash, "test_hash2"); + assert_eq!(all_modules[1].last_access, 124); + assert_eq!(all_modules[1].binary, &[1, 2, 3]); + let all_globals = globals.select(Global::as_select()).load(&mut db.0).unwrap(); + assert_eq!(all_globals[0].key, "total_size"); + assert_eq!(all_globals[0].value, 8); + } + + #[test] + fn get_bumps_last_access() { + let mut db = ModuleCache::open(":memory:").unwrap(); + db.insert_module( + &super::ModuleKey { + hash: ArrayString::from("test_hash").unwrap(), + compiler_version: "1.0.0", + zluda_version: "1.0.0", + device: "test_device", + backend_key: "{}".to_string(), + last_access: 123, + }, + &[1, 2, 3, 4, 5], + ); + let module_binary = db + .get_module_binary(&super::ModuleKey { + hash: ArrayString::from("test_hash").unwrap(), + compiler_version: "1.0.0", + zluda_version: "1.0.0", + device: "test_device", + backend_key: "{}".to_string(), + last_access: 124, + }) + .unwrap(); + let all_modules = modules.select(Module::as_select()).load(&mut db.0).unwrap(); + assert_eq!(all_modules.len(), 1); + assert_eq!(all_modules[0].last_access, 124); + assert_eq!(module_binary, &[1, 2, 3, 4, 5]); + assert_eq!(all_modules[0].binary, &[1, 2, 3, 4, 5]); + let all_globals = globals.select(Global::as_select()).load(&mut db.0).unwrap(); + assert_eq!(all_globals[0].key, "total_size"); + assert_eq!(all_globals[0].value, 5); + } + + #[test] + fn double_insert_does_not_override() { + let mut db = ModuleCache::open(":memory:").unwrap(); + db.insert_module( + &super::ModuleKey { + hash: ArrayString::from("test_hash").unwrap(), + compiler_version: "1.0.0", + zluda_version: "1.0.0", + device: "test_device", + backend_key: "{}".to_string(), + last_access: 123, + }, + &[1, 2, 3, 4, 5], + ); + db.insert_module( + &super::ModuleKey { + hash: ArrayString::from("test_hash").unwrap(), + compiler_version: "1.0.0", + zluda_version: "1.0.0", + device: "test_device", + backend_key: "{}".to_string(), + last_access: 124, + }, + &[5, 4, 3, 2, 1], + ); + let all_modules = modules.select(Module::as_select()).load(&mut db.0).unwrap(); + assert_eq!(all_modules.len(), 1); + assert_eq!(all_modules[0].last_access, 123); + assert_eq!(all_modules[0].binary, &[1, 2, 3, 4, 5]); + let all_globals = globals.select(Global::as_select()).load(&mut db.0).unwrap(); + assert_eq!(all_globals[0].key, "total_size"); + assert_eq!(all_globals[0].value, 5); + } +} From c30d3c10055a7192dbbbc33510cf350c73787350 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Sun, 21 Jun 2026 19:43:02 -0700 Subject: [PATCH 62/85] Formatting --- zluda_cache/src/lib.rs | 464 ++++++++++++++++++++--------------------- 1 file changed, 232 insertions(+), 232 deletions(-) diff --git a/zluda_cache/src/lib.rs b/zluda_cache/src/lib.rs index 6dacb3363..acd262e05 100644 --- a/zluda_cache/src/lib.rs +++ b/zluda_cache/src/lib.rs @@ -1,232 +1,232 @@ -use crate::schema::modules; -use arrayvec::ArrayString; -use diesel::{connection::SimpleConnection, prelude::*}; -use diesel_migrations::{embed_migrations, EmbeddedMigrations, MigrationHarness}; -use std::time::Duration; - -pub(crate) mod models; -pub(crate) mod schema; - -pub const MIGRATIONS: EmbeddedMigrations = embed_migrations!("./migrations"); - -pub struct ModuleKey<'a> { - pub hash: ArrayString<64>, - pub compiler_version: &'static str, - pub zluda_version: &'static str, - pub device: &'a str, - pub backend_key: String, - pub last_access: i64, -} - -pub struct ModuleCache(SqliteConnection); - -impl ModuleCache { - pub fn create_cache_dir_and_get_path() -> Option { - let mut cache_dir = dirs::cache_dir()?; - cache_dir.extend(["zluda", "ComputeCache"]); - // We ensure that the cache directory exists - std::fs::create_dir_all(&cache_dir).ok()?; - // No need to create the file, it will be created by SQLite on first access - // zluda.db might be in use by older versions of ZLUDA - cache_dir.push("zluda2.db"); - Some(cache_dir.to_string_lossy().into()) - } - - pub fn open(file_path: &str) -> Option { - let mut conn = SqliteConnection::establish(file_path).ok()?; - conn.batch_execute("PRAGMA journal_mode = WAL; PRAGMA synchronous = NORMAL;") - .ok()?; - conn.run_pending_migrations(MIGRATIONS).ok()?; - Some(Self(conn)) - } - - pub fn get_module_binary(&mut self, key: &ModuleKey) -> Option> { - diesel::update(modules::dsl::modules) - .set(modules::last_access.eq(key.last_access)) - .filter(modules::hash.eq(key.hash.as_str())) - .filter(modules::compiler_version.eq(&key.compiler_version)) - .filter(modules::zluda_version.eq(key.zluda_version)) - .filter(modules::device.eq(key.device)) - .filter(modules::backend_key.eq(&key.backend_key)) - .returning(modules::binary) - .get_result(&mut self.0) - .ok() - } - - pub fn insert_module(&mut self, key: &ModuleKey, binary: &[u8]) { - diesel::insert_into(modules::dsl::modules) - .values(models::AddModule { - hash: key.hash.as_str(), - compiler_version: &key.compiler_version, - zluda_version: key.zluda_version, - device: key.device, - backend_key: &key.backend_key, - last_access: key.last_access, - binary, - }) - .execute(&mut self.0) - .ok(); - } - - pub fn time_now() -> i64 { - use std::time::{SystemTime, UNIX_EPOCH}; - SystemTime::now() - .duration_since(UNIX_EPOCH) - .unwrap_or(Duration::ZERO) - .as_millis() as i64 - } -} - -#[cfg(test)] -mod tests { - use crate::{ - schema::{globals::dsl::*, modules::dsl::*}, - ModuleCache, - }; - use arrayvec::ArrayString; - use diesel::prelude::*; - - #[derive(Queryable, Selectable)] - #[diesel(table_name = crate::schema::modules)] - #[diesel(check_for_backend(diesel::sqlite::Sqlite))] - pub struct Module { - pub id: i64, - pub hash: String, - pub binary: Vec, - pub last_access: i64, - } - - #[derive(Queryable, Selectable)] - #[diesel(table_name = crate::schema::globals)] - #[diesel(check_for_backend(diesel::sqlite::Sqlite))] - pub struct Global { - pub key: String, - pub value: i64, - } - - #[test] - fn empty_db_returns_no_module() { - let mut db = ModuleCache::open(":memory:").unwrap(); - let module_binary = db.get_module_binary(&super::ModuleKey { - hash: ArrayString::from("test_hash").unwrap(), - compiler_version: "1.0.0", - zluda_version: "1.0.0", - device: "test_device", - backend_key: "{}".to_string(), - last_access: 123, - }); - assert!(module_binary.is_none()); - let all_modules = modules.select(Module::as_select()).load(&mut db.0).unwrap(); - assert_eq!(all_modules.len(), 0); - let all_globals: Vec = globals.select(Global::as_select()).load(&mut db.0).unwrap(); - assert_eq!(all_globals[0].key, "total_size"); - assert_eq!(all_globals[0].value, 0); - } - - #[test] - fn newly_inserted_module_increments_total_size() { - let mut db = ModuleCache::open(":memory:").unwrap(); - db.insert_module( - &super::ModuleKey { - hash: ArrayString::from("test_hash1").unwrap(), - compiler_version: "1.0.0", - zluda_version: "1.0.0", - device: "test_device", - backend_key: "{}".to_string(), - last_access: 123, - }, - &[1, 2, 3, 4, 5], - ); - db.insert_module( - &super::ModuleKey { - hash: ArrayString::from("test_hash2").unwrap(), - compiler_version: "1.0.0", - zluda_version: "1.0.0", - device: "test_device", - backend_key: "{}".to_string(), - last_access: 124, - }, - &[1, 2, 3], - ); - let mut all_modules = modules.select(Module::as_select()).load(&mut db.0).unwrap(); - all_modules.sort_by_key(|m: &Module| m.id); - assert_eq!(all_modules.len(), 2); - assert_eq!(all_modules[0].hash, "test_hash1"); - assert_eq!(all_modules[0].last_access, 123); - assert_eq!(all_modules[0].binary, &[1, 2, 3, 4, 5]); - assert_eq!(all_modules[1].hash, "test_hash2"); - assert_eq!(all_modules[1].last_access, 124); - assert_eq!(all_modules[1].binary, &[1, 2, 3]); - let all_globals = globals.select(Global::as_select()).load(&mut db.0).unwrap(); - assert_eq!(all_globals[0].key, "total_size"); - assert_eq!(all_globals[0].value, 8); - } - - #[test] - fn get_bumps_last_access() { - let mut db = ModuleCache::open(":memory:").unwrap(); - db.insert_module( - &super::ModuleKey { - hash: ArrayString::from("test_hash").unwrap(), - compiler_version: "1.0.0", - zluda_version: "1.0.0", - device: "test_device", - backend_key: "{}".to_string(), - last_access: 123, - }, - &[1, 2, 3, 4, 5], - ); - let module_binary = db - .get_module_binary(&super::ModuleKey { - hash: ArrayString::from("test_hash").unwrap(), - compiler_version: "1.0.0", - zluda_version: "1.0.0", - device: "test_device", - backend_key: "{}".to_string(), - last_access: 124, - }) - .unwrap(); - let all_modules = modules.select(Module::as_select()).load(&mut db.0).unwrap(); - assert_eq!(all_modules.len(), 1); - assert_eq!(all_modules[0].last_access, 124); - assert_eq!(module_binary, &[1, 2, 3, 4, 5]); - assert_eq!(all_modules[0].binary, &[1, 2, 3, 4, 5]); - let all_globals = globals.select(Global::as_select()).load(&mut db.0).unwrap(); - assert_eq!(all_globals[0].key, "total_size"); - assert_eq!(all_globals[0].value, 5); - } - - #[test] - fn double_insert_does_not_override() { - let mut db = ModuleCache::open(":memory:").unwrap(); - db.insert_module( - &super::ModuleKey { - hash: ArrayString::from("test_hash").unwrap(), - compiler_version: "1.0.0", - zluda_version: "1.0.0", - device: "test_device", - backend_key: "{}".to_string(), - last_access: 123, - }, - &[1, 2, 3, 4, 5], - ); - db.insert_module( - &super::ModuleKey { - hash: ArrayString::from("test_hash").unwrap(), - compiler_version: "1.0.0", - zluda_version: "1.0.0", - device: "test_device", - backend_key: "{}".to_string(), - last_access: 124, - }, - &[5, 4, 3, 2, 1], - ); - let all_modules = modules.select(Module::as_select()).load(&mut db.0).unwrap(); - assert_eq!(all_modules.len(), 1); - assert_eq!(all_modules[0].last_access, 123); - assert_eq!(all_modules[0].binary, &[1, 2, 3, 4, 5]); - let all_globals = globals.select(Global::as_select()).load(&mut db.0).unwrap(); - assert_eq!(all_globals[0].key, "total_size"); - assert_eq!(all_globals[0].value, 5); - } -} +use crate::schema::modules; +use arrayvec::ArrayString; +use diesel::{connection::SimpleConnection, prelude::*}; +use diesel_migrations::{embed_migrations, EmbeddedMigrations, MigrationHarness}; +use std::time::Duration; + +pub(crate) mod models; +pub(crate) mod schema; + +pub const MIGRATIONS: EmbeddedMigrations = embed_migrations!("./migrations"); + +pub struct ModuleKey<'a> { + pub hash: ArrayString<64>, + pub compiler_version: &'static str, + pub zluda_version: &'static str, + pub device: &'a str, + pub backend_key: String, + pub last_access: i64, +} + +pub struct ModuleCache(SqliteConnection); + +impl ModuleCache { + pub fn create_cache_dir_and_get_path() -> Option { + let mut cache_dir = dirs::cache_dir()?; + cache_dir.extend(["zluda", "ComputeCache"]); + // We ensure that the cache directory exists + std::fs::create_dir_all(&cache_dir).ok()?; + // No need to create the file, it will be created by SQLite on first access + // zluda.db might be in use by older versions of ZLUDA + cache_dir.push("zluda2.db"); + Some(cache_dir.to_string_lossy().into()) + } + + pub fn open(file_path: &str) -> Option { + let mut conn = SqliteConnection::establish(file_path).ok()?; + conn.batch_execute("PRAGMA journal_mode = WAL; PRAGMA synchronous = NORMAL;") + .ok()?; + conn.run_pending_migrations(MIGRATIONS).ok()?; + Some(Self(conn)) + } + + pub fn get_module_binary(&mut self, key: &ModuleKey) -> Option> { + diesel::update(modules::dsl::modules) + .set(modules::last_access.eq(key.last_access)) + .filter(modules::hash.eq(key.hash.as_str())) + .filter(modules::compiler_version.eq(&key.compiler_version)) + .filter(modules::zluda_version.eq(key.zluda_version)) + .filter(modules::device.eq(key.device)) + .filter(modules::backend_key.eq(&key.backend_key)) + .returning(modules::binary) + .get_result(&mut self.0) + .ok() + } + + pub fn insert_module(&mut self, key: &ModuleKey, binary: &[u8]) { + diesel::insert_into(modules::dsl::modules) + .values(models::AddModule { + hash: key.hash.as_str(), + compiler_version: &key.compiler_version, + zluda_version: key.zluda_version, + device: key.device, + backend_key: &key.backend_key, + last_access: key.last_access, + binary, + }) + .execute(&mut self.0) + .ok(); + } + + pub fn time_now() -> i64 { + use std::time::{SystemTime, UNIX_EPOCH}; + SystemTime::now() + .duration_since(UNIX_EPOCH) + .unwrap_or(Duration::ZERO) + .as_millis() as i64 + } +} + +#[cfg(test)] +mod tests { + use crate::{ + schema::{globals::dsl::*, modules::dsl::*}, + ModuleCache, + }; + use arrayvec::ArrayString; + use diesel::prelude::*; + + #[derive(Queryable, Selectable)] + #[diesel(table_name = crate::schema::modules)] + #[diesel(check_for_backend(diesel::sqlite::Sqlite))] + pub struct Module { + pub id: i64, + pub hash: String, + pub binary: Vec, + pub last_access: i64, + } + + #[derive(Queryable, Selectable)] + #[diesel(table_name = crate::schema::globals)] + #[diesel(check_for_backend(diesel::sqlite::Sqlite))] + pub struct Global { + pub key: String, + pub value: i64, + } + + #[test] + fn empty_db_returns_no_module() { + let mut db = ModuleCache::open(":memory:").unwrap(); + let module_binary = db.get_module_binary(&super::ModuleKey { + hash: ArrayString::from("test_hash").unwrap(), + compiler_version: "1.0.0", + zluda_version: "1.0.0", + device: "test_device", + backend_key: "{}".to_string(), + last_access: 123, + }); + assert!(module_binary.is_none()); + let all_modules = modules.select(Module::as_select()).load(&mut db.0).unwrap(); + assert_eq!(all_modules.len(), 0); + let all_globals: Vec = globals.select(Global::as_select()).load(&mut db.0).unwrap(); + assert_eq!(all_globals[0].key, "total_size"); + assert_eq!(all_globals[0].value, 0); + } + + #[test] + fn newly_inserted_module_increments_total_size() { + let mut db = ModuleCache::open(":memory:").unwrap(); + db.insert_module( + &super::ModuleKey { + hash: ArrayString::from("test_hash1").unwrap(), + compiler_version: "1.0.0", + zluda_version: "1.0.0", + device: "test_device", + backend_key: "{}".to_string(), + last_access: 123, + }, + &[1, 2, 3, 4, 5], + ); + db.insert_module( + &super::ModuleKey { + hash: ArrayString::from("test_hash2").unwrap(), + compiler_version: "1.0.0", + zluda_version: "1.0.0", + device: "test_device", + backend_key: "{}".to_string(), + last_access: 124, + }, + &[1, 2, 3], + ); + let mut all_modules = modules.select(Module::as_select()).load(&mut db.0).unwrap(); + all_modules.sort_by_key(|m: &Module| m.id); + assert_eq!(all_modules.len(), 2); + assert_eq!(all_modules[0].hash, "test_hash1"); + assert_eq!(all_modules[0].last_access, 123); + assert_eq!(all_modules[0].binary, &[1, 2, 3, 4, 5]); + assert_eq!(all_modules[1].hash, "test_hash2"); + assert_eq!(all_modules[1].last_access, 124); + assert_eq!(all_modules[1].binary, &[1, 2, 3]); + let all_globals = globals.select(Global::as_select()).load(&mut db.0).unwrap(); + assert_eq!(all_globals[0].key, "total_size"); + assert_eq!(all_globals[0].value, 8); + } + + #[test] + fn get_bumps_last_access() { + let mut db = ModuleCache::open(":memory:").unwrap(); + db.insert_module( + &super::ModuleKey { + hash: ArrayString::from("test_hash").unwrap(), + compiler_version: "1.0.0", + zluda_version: "1.0.0", + device: "test_device", + backend_key: "{}".to_string(), + last_access: 123, + }, + &[1, 2, 3, 4, 5], + ); + let module_binary = db + .get_module_binary(&super::ModuleKey { + hash: ArrayString::from("test_hash").unwrap(), + compiler_version: "1.0.0", + zluda_version: "1.0.0", + device: "test_device", + backend_key: "{}".to_string(), + last_access: 124, + }) + .unwrap(); + let all_modules = modules.select(Module::as_select()).load(&mut db.0).unwrap(); + assert_eq!(all_modules.len(), 1); + assert_eq!(all_modules[0].last_access, 124); + assert_eq!(module_binary, &[1, 2, 3, 4, 5]); + assert_eq!(all_modules[0].binary, &[1, 2, 3, 4, 5]); + let all_globals = globals.select(Global::as_select()).load(&mut db.0).unwrap(); + assert_eq!(all_globals[0].key, "total_size"); + assert_eq!(all_globals[0].value, 5); + } + + #[test] + fn double_insert_does_not_override() { + let mut db = ModuleCache::open(":memory:").unwrap(); + db.insert_module( + &super::ModuleKey { + hash: ArrayString::from("test_hash").unwrap(), + compiler_version: "1.0.0", + zluda_version: "1.0.0", + device: "test_device", + backend_key: "{}".to_string(), + last_access: 123, + }, + &[1, 2, 3, 4, 5], + ); + db.insert_module( + &super::ModuleKey { + hash: ArrayString::from("test_hash").unwrap(), + compiler_version: "1.0.0", + zluda_version: "1.0.0", + device: "test_device", + backend_key: "{}".to_string(), + last_access: 124, + }, + &[5, 4, 3, 2, 1], + ); + let all_modules = modules.select(Module::as_select()).load(&mut db.0).unwrap(); + assert_eq!(all_modules.len(), 1); + assert_eq!(all_modules[0].last_access, 123); + assert_eq!(all_modules[0].binary, &[1, 2, 3, 4, 5]); + let all_globals = globals.select(Global::as_select()).load(&mut db.0).unwrap(); + assert_eq!(all_globals[0].key, "total_size"); + assert_eq!(all_globals[0].value, 5); + } +} From 8150c1a3dfd3ce45f717f7b250ff197df82ad754 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Sun, 21 Jun 2026 22:40:03 -0700 Subject: [PATCH 63/85] More minor fixes --- llvm_zluda/src/utils.rs | 6 +++++- ptx/src/pass/llvm/emit.rs | 13 ++++++++++++- 2 files changed, 17 insertions(+), 2 deletions(-) diff --git a/llvm_zluda/src/utils.rs b/llvm_zluda/src/utils.rs index f407bbb0e..b0a2e267b 100644 --- a/llvm_zluda/src/utils.rs +++ b/llvm_zluda/src/utils.rs @@ -23,7 +23,11 @@ pub struct Context(LLVMContextRef); impl Context { pub fn new() -> Self { - Self(unsafe { LLVMContextCreate() }) + let ctx = unsafe { LLVMContextCreate() }; + if !cfg!(debug_assertions) { + unsafe { LLVMContextSetDiscardValueNames(ctx, 1) }; + } + Self(ctx) } pub fn get(&self) -> LLVMContextRef { diff --git a/ptx/src/pass/llvm/emit.rs b/ptx/src/pass/llvm/emit.rs index 44d18d828..f8e2f5bb9 100644 --- a/ptx/src/pass/llvm/emit.rs +++ b/ptx/src/pass/llvm/emit.rs @@ -769,6 +769,13 @@ impl<'a> MethodEmitContext<'a> { Ok(()) } ConversionKind::PtrToPtr => { + if conversion.from_space == conversion.to_space { + // With opaque pointers it's meaningless + return self.emit_mov(ast::MovArgs { + dst: conversion.dst, + src: conversion.src, + }); + } let src = self.resolver.value(conversion.src)?; let dst_type = get_pointer_type(self.context, conversion.to_space)?; self.resolver.with_result(conversion.dst, |dst| unsafe { @@ -1714,8 +1721,12 @@ impl<'a> MethodEmitContext<'a> { let src = self.resolver.value(arguments.src)?; let temp_ptr = unsafe { LLVMBuildIntToPtr(self.builder, src, from_type, LLVM_UNNAMED.as_ptr()) }; + let temp_converted = unsafe { + LLVMBuildAddrSpaceCast(self.builder, temp_ptr, dest_type, LLVM_UNNAMED.as_ptr()) + }; + let scalar_type = unsafe { LLVMIntTypeInContext(self.context, arguments.size) }; self.resolver.with_result(arguments.dst, |dst| unsafe { - LLVMBuildAddrSpaceCast(self.builder, temp_ptr, dest_type, dst) + LLVMBuildPtrToInt(self.builder, temp_converted, scalar_type, dst) }); Ok(()) } From d10645627632c5ee7609478dca305ac2c9c46236 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Sun, 21 Jun 2026 23:11:57 -0700 Subject: [PATCH 64/85] Update tests --- ptx/src/pass/llvm/emit.rs | 2 +- ptx/src/test/ll/cvta.ll | 30 ++++++------ ptx/src/test/ll/ldmatrix.ll | 41 +++++++++-------- ptx/src/test/ll/param_is_addressable.ll | 27 +++++------ ptx/src/test/ll/stateful_ld_st_ntid.ll | 48 ++++++++++---------- ptx/src/test/ll/stateful_ld_st_ntid_chain.ll | 48 ++++++++++---------- ptx/src/test/ll/stateful_ld_st_ntid_sub.ll | 48 ++++++++++---------- ptx/src/test/ll/stateful_ld_st_simple.ll | 30 ++++++------ ptx/src/test/ll/stateful_neg_offset.ll | 40 ++++++++-------- 9 files changed, 164 insertions(+), 150 deletions(-) diff --git a/ptx/src/pass/llvm/emit.rs b/ptx/src/pass/llvm/emit.rs index f8e2f5bb9..9bfbcd92e 100644 --- a/ptx/src/pass/llvm/emit.rs +++ b/ptx/src/pass/llvm/emit.rs @@ -1724,7 +1724,7 @@ impl<'a> MethodEmitContext<'a> { let temp_converted = unsafe { LLVMBuildAddrSpaceCast(self.builder, temp_ptr, dest_type, LLVM_UNNAMED.as_ptr()) }; - let scalar_type = unsafe { LLVMIntTypeInContext(self.context, arguments.size) }; + let scalar_type = unsafe { LLVMIntTypeInContext(self.context, data.size as u32) }; self.resolver.with_result(arguments.dst, |dst| unsafe { LLVMBuildPtrToInt(self.builder, temp_converted, scalar_type, dst) }); diff --git a/ptx/src/test/ll/cvta.ll b/ptx/src/test/ll/cvta.ll index 22970d3d2..3ef128ae3 100644 --- a/ptx/src/test/ll/cvta.ll +++ b/ptx/src/test/ll/cvta.ll @@ -14,20 +14,22 @@ define amdgpu_kernel void @cvta(ptr addrspace(4) byref(i64) %"39", ptr addrspace store i64 %3, ptr addrspace(5) %"42", align 8 %4 = load i64, ptr addrspace(5) %"41", align 8 %5 = inttoptr i64 %4 to ptr - %"54" = addrspacecast ptr %5 to ptr addrspace(1) - store ptr addrspace(1) %"54", ptr addrspace(5) %"41", align 8 - %6 = load i64, ptr addrspace(5) %"42", align 8 - %7 = inttoptr i64 %6 to ptr - %"56" = addrspacecast ptr %7 to ptr addrspace(1) - store ptr addrspace(1) %"56", ptr addrspace(5) %"42", align 8 - %8 = load i64, ptr addrspace(5) %"41", align 8 - %"58" = inttoptr i64 %8 to ptr addrspace(1) - %9 = load float, ptr addrspace(1) %"58", align 4 - store float %9, ptr addrspace(5) %"43", align 4 - %10 = load i64, ptr addrspace(5) %"42", align 8 - %11 = load float, ptr addrspace(5) %"43", align 4 - %"59" = inttoptr i64 %10 to ptr addrspace(1) - store float %11, ptr addrspace(1) %"59", align 4 + %6 = addrspacecast ptr %5 to ptr addrspace(1) + %"54" = ptrtoint ptr addrspace(1) %6 to i64 + store i64 %"54", ptr addrspace(5) %"41", align 8 + %7 = load i64, ptr addrspace(5) %"42", align 8 + %8 = inttoptr i64 %7 to ptr + %9 = addrspacecast ptr %8 to ptr addrspace(1) + %"56" = ptrtoint ptr addrspace(1) %9 to i64 + store i64 %"56", ptr addrspace(5) %"42", align 8 + %10 = load i64, ptr addrspace(5) %"41", align 8 + %"58" = inttoptr i64 %10 to ptr addrspace(1) + %11 = load float, ptr addrspace(1) %"58", align 4 + store float %11, ptr addrspace(5) %"43", align 4 + %12 = load i64, ptr addrspace(5) %"42", align 8 + %13 = load float, ptr addrspace(5) %"43", align 4 + %"59" = inttoptr i64 %12 to ptr addrspace(1) + store float %13, ptr addrspace(1) %"59", align 4 ret void } diff --git a/ptx/src/test/ll/ldmatrix.ll b/ptx/src/test/ll/ldmatrix.ll index 310157c05..a6a0733a1 100644 --- a/ptx/src/test/ll/ldmatrix.ll +++ b/ptx/src/test/ll/ldmatrix.ll @@ -61,34 +61,35 @@ define amdgpu_kernel void @ldmatrix(ptr addrspace(4) byref(i64) %"60") #1 { store i64 ptrtoint (ptr addrspace(3) @values_s to i64), ptr addrspace(5) %"66", align 8 %19 = load i64, ptr addrspace(5) %"66", align 8 %20 = inttoptr i64 %19 to ptr addrspace(3) - %"91" = addrspacecast ptr addrspace(3) %20 to ptr - store ptr %"91", ptr addrspace(5) %"66", align 8 - %21 = load i64, ptr addrspace(5) %"63", align 8 - %22 = load i64, ptr addrspace(5) %"66", align 8 - %23 = mul i64 %21, 16 - %"122" = add i64 %23, %22 + %21 = addrspacecast ptr addrspace(3) %20 to ptr + %"91" = ptrtoint ptr %21 to i64 + store i64 %"91", ptr addrspace(5) %"66", align 8 + %22 = load i64, ptr addrspace(5) %"63", align 8 + %23 = load i64, ptr addrspace(5) %"66", align 8 + %24 = mul i64 %22, 16 + %"122" = add i64 %24, %23 store i64 %"122", ptr addrspace(5) %"66", align 8 - %24 = load i64, ptr addrspace(5) %"66", align 8 - %"124" = inttoptr i64 %24 to ptr addrspace(3) + %25 = load i64, ptr addrspace(5) %"66", align 8 + %"124" = inttoptr i64 %25 to ptr addrspace(3) %"54" = call <2 x i32> @__zluda_ptx_impl_ldmatrix_m8n8_x2_b16(ptr addrspace(3) %"124") %"125" = extractelement <2 x i32> %"54", i8 0 %"126" = extractelement <2 x i32> %"54", i8 1 store i32 %"125", ptr addrspace(5) %"68", align 4 store i32 %"126", ptr addrspace(5) %"69", align 4 - %25 = load i64, ptr addrspace(5) %"63", align 8 - %26 = load i64, ptr addrspace(5) %"61", align 8 - %27 = mul i64 %25, 8 - %"99" = add i64 %27, %26 + %26 = load i64, ptr addrspace(5) %"63", align 8 + %27 = load i64, ptr addrspace(5) %"61", align 8 + %28 = mul i64 %26, 8 + %"99" = add i64 %28, %27 store i64 %"99", ptr addrspace(5) %"61", align 8 - %28 = load i64, ptr addrspace(5) %"61", align 8 - %29 = load i32, ptr addrspace(5) %"68", align 4 - %"127" = inttoptr i64 %28 to ptr - store i32 %29, ptr %"127", align 4 - %30 = load i64, ptr addrspace(5) %"61", align 8 - %"128" = inttoptr i64 %30 to ptr + %29 = load i64, ptr addrspace(5) %"61", align 8 + %30 = load i32, ptr addrspace(5) %"68", align 4 + %"127" = inttoptr i64 %29 to ptr + store i32 %30, ptr %"127", align 4 + %31 = load i64, ptr addrspace(5) %"61", align 8 + %"128" = inttoptr i64 %31 to ptr %"57" = getelementptr inbounds i8, ptr %"128", i64 4 - %31 = load i32, ptr addrspace(5) %"69", align 4 - store i32 %31, ptr %"57", align 4 + %32 = load i32, ptr addrspace(5) %"69", align 4 + store i32 %32, ptr %"57", align 4 ret void } diff --git a/ptx/src/test/ll/param_is_addressable.ll b/ptx/src/test/ll/param_is_addressable.ll index ce1ab9ad5..e01c0c411 100644 --- a/ptx/src/test/ll/param_is_addressable.ll +++ b/ptx/src/test/ll/param_is_addressable.ll @@ -14,20 +14,21 @@ define amdgpu_kernel void @param_is_addressable(ptr addrspace(4) byref(i64) %"39 store i64 %3, ptr addrspace(5) %"42", align 8 %"55" = ptrtoint ptr addrspace(4) %"39" to i64 %4 = inttoptr i64 %"55" to ptr addrspace(4) - %"46" = addrspacecast ptr addrspace(4) %4 to ptr - store ptr %"46", ptr addrspace(5) %"43", align 8 - %5 = load i64, ptr addrspace(5) %"43", align 8 - %"56" = inttoptr i64 %5 to ptr - %6 = load i64, ptr %"56", align 8 - store i64 %6, ptr addrspace(5) %"43", align 8 - %7 = load i64, ptr addrspace(5) %"43", align 8 - %8 = load i64, ptr addrspace(5) %"41", align 8 - %"57" = sub i64 %7, %8 + %5 = addrspacecast ptr addrspace(4) %4 to ptr + %"46" = ptrtoint ptr %5 to i64 + store i64 %"46", ptr addrspace(5) %"43", align 8 + %6 = load i64, ptr addrspace(5) %"43", align 8 + %"56" = inttoptr i64 %6 to ptr + %7 = load i64, ptr %"56", align 8 + store i64 %7, ptr addrspace(5) %"43", align 8 + %8 = load i64, ptr addrspace(5) %"43", align 8 + %9 = load i64, ptr addrspace(5) %"41", align 8 + %"57" = sub i64 %8, %9 store i64 %"57", ptr addrspace(5) %"43", align 8 - %9 = load i64, ptr addrspace(5) %"42", align 8 - %10 = load i64, ptr addrspace(5) %"43", align 8 - %"59" = inttoptr i64 %9 to ptr - store i64 %10, ptr %"59", align 8 + %10 = load i64, ptr addrspace(5) %"42", align 8 + %11 = load i64, ptr addrspace(5) %"43", align 8 + %"59" = inttoptr i64 %10 to ptr + store i64 %11, ptr %"59", align 8 ret void } diff --git a/ptx/src/test/ll/stateful_ld_st_ntid.ll b/ptx/src/test/ll/stateful_ld_st_ntid.ll index eb2817445..c34a29858 100644 --- a/ptx/src/test/ll/stateful_ld_st_ntid.ll +++ b/ptx/src/test/ll/stateful_ld_st_ntid.ll @@ -18,33 +18,35 @@ define amdgpu_kernel void @stateful_ld_st_ntid(ptr addrspace(4) byref(i64) %"44" store i64 %3, ptr addrspace(5) %"47", align 8 %4 = load i64, ptr addrspace(5) %"46", align 8 %5 = inttoptr i64 %4 to ptr - %"53" = addrspacecast ptr %5 to ptr addrspace(1) - store ptr addrspace(1) %"53", ptr addrspace(5) %"46", align 8 - %6 = load i64, ptr addrspace(5) %"47", align 8 - %7 = inttoptr i64 %6 to ptr - %"55" = addrspacecast ptr %7 to ptr addrspace(1) - store ptr addrspace(1) %"55", ptr addrspace(5) %"47", align 8 + %6 = addrspacecast ptr %5 to ptr addrspace(1) + %"53" = ptrtoint ptr addrspace(1) %6 to i64 + store i64 %"53", ptr addrspace(5) %"46", align 8 + %7 = load i64, ptr addrspace(5) %"47", align 8 + %8 = inttoptr i64 %7 to ptr + %9 = addrspacecast ptr %8 to ptr addrspace(1) + %"55" = ptrtoint ptr addrspace(1) %9 to i64 + store i64 %"55", ptr addrspace(5) %"47", align 8 %"41" = call i32 @__zluda_ptx_impl_sreg_tid(i8 0) store i32 %"41", ptr addrspace(5) %"48", align 4 - %8 = load i32, ptr addrspace(5) %"48", align 4 - %9 = zext i32 %8 to i64 - store i64 %9, ptr addrspace(5) %"49", align 8 - %10 = load i64, ptr addrspace(5) %"46", align 8 - %11 = load i64, ptr addrspace(5) %"49", align 8 - %"72" = add i64 %10, %11 - store i64 %"72", ptr addrspace(5) %"46", align 8 - %12 = load i64, ptr addrspace(5) %"47", align 8 + %10 = load i32, ptr addrspace(5) %"48", align 4 + %11 = zext i32 %10 to i64 + store i64 %11, ptr addrspace(5) %"49", align 8 + %12 = load i64, ptr addrspace(5) %"46", align 8 %13 = load i64, ptr addrspace(5) %"49", align 8 - %"74" = add i64 %12, %13 + %"72" = add i64 %12, %13 + store i64 %"72", ptr addrspace(5) %"46", align 8 + %14 = load i64, ptr addrspace(5) %"47", align 8 + %15 = load i64, ptr addrspace(5) %"49", align 8 + %"74" = add i64 %14, %15 store i64 %"74", ptr addrspace(5) %"47", align 8 - %14 = load i64, ptr addrspace(5) %"46", align 8 - %"76" = inttoptr i64 %14 to ptr addrspace(1) - %15 = load i64, ptr addrspace(1) %"76", align 8 - store i64 %15, ptr addrspace(5) %"50", align 8 - %16 = load i64, ptr addrspace(5) %"47", align 8 - %17 = load i64, ptr addrspace(5) %"50", align 8 - %"77" = inttoptr i64 %16 to ptr addrspace(1) - store i64 %17, ptr addrspace(1) %"77", align 8 + %16 = load i64, ptr addrspace(5) %"46", align 8 + %"76" = inttoptr i64 %16 to ptr addrspace(1) + %17 = load i64, ptr addrspace(1) %"76", align 8 + store i64 %17, ptr addrspace(5) %"50", align 8 + %18 = load i64, ptr addrspace(5) %"47", align 8 + %19 = load i64, ptr addrspace(5) %"50", align 8 + %"77" = inttoptr i64 %18 to ptr addrspace(1) + store i64 %19, ptr addrspace(1) %"77", align 8 ret void } diff --git a/ptx/src/test/ll/stateful_ld_st_ntid_chain.ll b/ptx/src/test/ll/stateful_ld_st_ntid_chain.ll index 6ec2d1f5b..d488f840d 100644 --- a/ptx/src/test/ll/stateful_ld_st_ntid_chain.ll +++ b/ptx/src/test/ll/stateful_ld_st_ntid_chain.ll @@ -22,33 +22,35 @@ define amdgpu_kernel void @stateful_ld_st_ntid_chain(ptr addrspace(4) byref(i64) store i64 %3, ptr addrspace(5) %"53", align 8 %4 = load i64, ptr addrspace(5) %"50", align 8 %5 = inttoptr i64 %4 to ptr - %"61" = addrspacecast ptr %5 to ptr addrspace(1) - store ptr addrspace(1) %"61", ptr addrspace(5) %"51", align 8 - %6 = load i64, ptr addrspace(5) %"53", align 8 - %7 = inttoptr i64 %6 to ptr - %"63" = addrspacecast ptr %7 to ptr addrspace(1) - store ptr addrspace(1) %"63", ptr addrspace(5) %"54", align 8 + %6 = addrspacecast ptr %5 to ptr addrspace(1) + %"61" = ptrtoint ptr addrspace(1) %6 to i64 + store i64 %"61", ptr addrspace(5) %"51", align 8 + %7 = load i64, ptr addrspace(5) %"53", align 8 + %8 = inttoptr i64 %7 to ptr + %9 = addrspacecast ptr %8 to ptr addrspace(1) + %"63" = ptrtoint ptr addrspace(1) %9 to i64 + store i64 %"63", ptr addrspace(5) %"54", align 8 %"45" = call i32 @__zluda_ptx_impl_sreg_tid(i8 0) store i32 %"45", ptr addrspace(5) %"56", align 4 - %8 = load i32, ptr addrspace(5) %"56", align 4 - %9 = zext i32 %8 to i64 - store i64 %9, ptr addrspace(5) %"57", align 8 - %10 = load i64, ptr addrspace(5) %"51", align 8 - %11 = load i64, ptr addrspace(5) %"57", align 8 - %"80" = add i64 %10, %11 - store i64 %"80", ptr addrspace(5) %"52", align 8 - %12 = load i64, ptr addrspace(5) %"54", align 8 + %10 = load i32, ptr addrspace(5) %"56", align 4 + %11 = zext i32 %10 to i64 + store i64 %11, ptr addrspace(5) %"57", align 8 + %12 = load i64, ptr addrspace(5) %"51", align 8 %13 = load i64, ptr addrspace(5) %"57", align 8 - %"82" = add i64 %12, %13 + %"80" = add i64 %12, %13 + store i64 %"80", ptr addrspace(5) %"52", align 8 + %14 = load i64, ptr addrspace(5) %"54", align 8 + %15 = load i64, ptr addrspace(5) %"57", align 8 + %"82" = add i64 %14, %15 store i64 %"82", ptr addrspace(5) %"55", align 8 - %14 = load i64, ptr addrspace(5) %"52", align 8 - %"84" = inttoptr i64 %14 to ptr addrspace(1) - %15 = load i64, ptr addrspace(1) %"84", align 8 - store i64 %15, ptr addrspace(5) %"58", align 8 - %16 = load i64, ptr addrspace(5) %"55", align 8 - %17 = load i64, ptr addrspace(5) %"58", align 8 - %"85" = inttoptr i64 %16 to ptr addrspace(1) - store i64 %17, ptr addrspace(1) %"85", align 8 + %16 = load i64, ptr addrspace(5) %"52", align 8 + %"84" = inttoptr i64 %16 to ptr addrspace(1) + %17 = load i64, ptr addrspace(1) %"84", align 8 + store i64 %17, ptr addrspace(5) %"58", align 8 + %18 = load i64, ptr addrspace(5) %"55", align 8 + %19 = load i64, ptr addrspace(5) %"58", align 8 + %"85" = inttoptr i64 %18 to ptr addrspace(1) + store i64 %19, ptr addrspace(1) %"85", align 8 ret void } diff --git a/ptx/src/test/ll/stateful_ld_st_ntid_sub.ll b/ptx/src/test/ll/stateful_ld_st_ntid_sub.ll index 161149c54..67a9827e8 100644 --- a/ptx/src/test/ll/stateful_ld_st_ntid_sub.ll +++ b/ptx/src/test/ll/stateful_ld_st_ntid_sub.ll @@ -22,35 +22,37 @@ define amdgpu_kernel void @stateful_ld_st_ntid_sub(ptr addrspace(4) byref(i64) % store i64 %3, ptr addrspace(5) %"57", align 8 %4 = load i64, ptr addrspace(5) %"54", align 8 %5 = inttoptr i64 %4 to ptr - %"65" = addrspacecast ptr %5 to ptr addrspace(1) - store ptr addrspace(1) %"65", ptr addrspace(5) %"55", align 8 - %6 = load i64, ptr addrspace(5) %"57", align 8 - %7 = inttoptr i64 %6 to ptr - %"67" = addrspacecast ptr %7 to ptr addrspace(1) - store ptr addrspace(1) %"67", ptr addrspace(5) %"58", align 8 + %6 = addrspacecast ptr %5 to ptr addrspace(1) + %"65" = ptrtoint ptr addrspace(1) %6 to i64 + store i64 %"65", ptr addrspace(5) %"55", align 8 + %7 = load i64, ptr addrspace(5) %"57", align 8 + %8 = inttoptr i64 %7 to ptr + %9 = addrspacecast ptr %8 to ptr addrspace(1) + %"67" = ptrtoint ptr addrspace(1) %9 to i64 + store i64 %"67", ptr addrspace(5) %"58", align 8 %"45" = call i32 @__zluda_ptx_impl_sreg_tid(i8 0) store i32 %"45", ptr addrspace(5) %"60", align 4 - %8 = load i32, ptr addrspace(5) %"60", align 4 - %9 = zext i32 %8 to i64 - store i64 %9, ptr addrspace(5) %"61", align 8 - %10 = load i64, ptr addrspace(5) %"55", align 8 - %11 = load i64, ptr addrspace(5) %"61", align 8 - %"84" = sub i64 %10, %11 - store i64 %"84", ptr addrspace(5) %"56", align 8 - %12 = load i64, ptr addrspace(5) %"58", align 8 + %10 = load i32, ptr addrspace(5) %"60", align 4 + %11 = zext i32 %10 to i64 + store i64 %11, ptr addrspace(5) %"61", align 8 + %12 = load i64, ptr addrspace(5) %"55", align 8 %13 = load i64, ptr addrspace(5) %"61", align 8 - %"87" = sub i64 %12, %13 + %"84" = sub i64 %12, %13 + store i64 %"84", ptr addrspace(5) %"56", align 8 + %14 = load i64, ptr addrspace(5) %"58", align 8 + %15 = load i64, ptr addrspace(5) %"61", align 8 + %"87" = sub i64 %14, %15 store i64 %"87", ptr addrspace(5) %"59", align 8 - %14 = load i64, ptr addrspace(5) %"56", align 8 - %"90" = inttoptr i64 %14 to ptr addrspace(1) + %16 = load i64, ptr addrspace(5) %"56", align 8 + %"90" = inttoptr i64 %16 to ptr addrspace(1) %"47" = getelementptr inbounds i8, ptr addrspace(1) %"90", i64 0 - %15 = load i64, ptr addrspace(1) %"47", align 8 - store i64 %15, ptr addrspace(5) %"62", align 8 - %16 = load i64, ptr addrspace(5) %"59", align 8 - %"91" = inttoptr i64 %16 to ptr addrspace(1) + %17 = load i64, ptr addrspace(1) %"47", align 8 + store i64 %17, ptr addrspace(5) %"62", align 8 + %18 = load i64, ptr addrspace(5) %"59", align 8 + %"91" = inttoptr i64 %18 to ptr addrspace(1) %"49" = getelementptr inbounds i8, ptr addrspace(1) %"91", i64 0 - %17 = load i64, ptr addrspace(5) %"62", align 8 - store i64 %17, ptr addrspace(1) %"49", align 8 + %19 = load i64, ptr addrspace(5) %"62", align 8 + store i64 %19, ptr addrspace(1) %"49", align 8 ret void } diff --git a/ptx/src/test/ll/stateful_ld_st_simple.ll b/ptx/src/test/ll/stateful_ld_st_simple.ll index 1ffc2ad25..7d4893306 100644 --- a/ptx/src/test/ll/stateful_ld_st_simple.ll +++ b/ptx/src/test/ll/stateful_ld_st_simple.ll @@ -16,20 +16,22 @@ define amdgpu_kernel void @stateful_ld_st_simple(ptr addrspace(4) byref(i64) %"4 store i64 %3, ptr addrspace(5) %"44", align 8 %4 = load i64, ptr addrspace(5) %"43", align 8 %5 = inttoptr i64 %4 to ptr - %"58" = addrspacecast ptr %5 to ptr addrspace(1) - store ptr addrspace(1) %"58", ptr addrspace(5) %"45", align 8 - %6 = load i64, ptr addrspace(5) %"44", align 8 - %7 = inttoptr i64 %6 to ptr - %"60" = addrspacecast ptr %7 to ptr addrspace(1) - store ptr addrspace(1) %"60", ptr addrspace(5) %"46", align 8 - %8 = load i64, ptr addrspace(5) %"45", align 8 - %"62" = inttoptr i64 %8 to ptr addrspace(1) - %9 = load i64, ptr addrspace(1) %"62", align 8 - store i64 %9, ptr addrspace(5) %"47", align 8 - %10 = load i64, ptr addrspace(5) %"46", align 8 - %11 = load i64, ptr addrspace(5) %"47", align 8 - %"63" = inttoptr i64 %10 to ptr addrspace(1) - store i64 %11, ptr addrspace(1) %"63", align 8 + %6 = addrspacecast ptr %5 to ptr addrspace(1) + %"58" = ptrtoint ptr addrspace(1) %6 to i64 + store i64 %"58", ptr addrspace(5) %"45", align 8 + %7 = load i64, ptr addrspace(5) %"44", align 8 + %8 = inttoptr i64 %7 to ptr + %9 = addrspacecast ptr %8 to ptr addrspace(1) + %"60" = ptrtoint ptr addrspace(1) %9 to i64 + store i64 %"60", ptr addrspace(5) %"46", align 8 + %10 = load i64, ptr addrspace(5) %"45", align 8 + %"62" = inttoptr i64 %10 to ptr addrspace(1) + %11 = load i64, ptr addrspace(1) %"62", align 8 + store i64 %11, ptr addrspace(5) %"47", align 8 + %12 = load i64, ptr addrspace(5) %"46", align 8 + %13 = load i64, ptr addrspace(5) %"47", align 8 + %"63" = inttoptr i64 %12 to ptr addrspace(1) + store i64 %13, ptr addrspace(1) %"63", align 8 ret void } diff --git a/ptx/src/test/ll/stateful_neg_offset.ll b/ptx/src/test/ll/stateful_neg_offset.ll index 732da5314..ba17a9730 100644 --- a/ptx/src/test/ll/stateful_neg_offset.ll +++ b/ptx/src/test/ll/stateful_neg_offset.ll @@ -17,28 +17,30 @@ define amdgpu_kernel void @stateful_neg_offset(ptr addrspace(4) byref(i64) %"42" store i64 %3, ptr addrspace(5) %"45", align 8 %4 = load i64, ptr addrspace(5) %"44", align 8 %5 = inttoptr i64 %4 to ptr - %"66" = addrspacecast ptr %5 to ptr addrspace(1) - store ptr addrspace(1) %"66", ptr addrspace(5) %"46", align 8 - %6 = load i64, ptr addrspace(5) %"45", align 8 - %7 = inttoptr i64 %6 to ptr - %"68" = addrspacecast ptr %7 to ptr addrspace(1) - store ptr addrspace(1) %"68", ptr addrspace(5) %"47", align 8 - %8 = load i64, ptr addrspace(5) %"46", align 8 - %9 = load i64, ptr addrspace(5) %"47", align 8 - %"56" = add i64 %8, %9 - store i64 %"56", ptr addrspace(5) %"48", align 8 + %6 = addrspacecast ptr %5 to ptr addrspace(1) + %"66" = ptrtoint ptr addrspace(1) %6 to i64 + store i64 %"66", ptr addrspace(5) %"46", align 8 + %7 = load i64, ptr addrspace(5) %"45", align 8 + %8 = inttoptr i64 %7 to ptr + %9 = addrspacecast ptr %8 to ptr addrspace(1) + %"68" = ptrtoint ptr addrspace(1) %9 to i64 + store i64 %"68", ptr addrspace(5) %"47", align 8 %10 = load i64, ptr addrspace(5) %"46", align 8 %11 = load i64, ptr addrspace(5) %"47", align 8 - %"59" = sub i64 %10, %11 - store i64 %"59", ptr addrspace(5) %"48", align 8 + %"56" = add i64 %10, %11 + store i64 %"56", ptr addrspace(5) %"48", align 8 %12 = load i64, ptr addrspace(5) %"46", align 8 - %"70" = inttoptr i64 %12 to ptr addrspace(1) - %13 = load i64, ptr addrspace(1) %"70", align 8 - store i64 %13, ptr addrspace(5) %"49", align 8 - %14 = load i64, ptr addrspace(5) %"47", align 8 - %15 = load i64, ptr addrspace(5) %"49", align 8 - %"71" = inttoptr i64 %14 to ptr addrspace(1) - store i64 %15, ptr addrspace(1) %"71", align 8 + %13 = load i64, ptr addrspace(5) %"47", align 8 + %"59" = sub i64 %12, %13 + store i64 %"59", ptr addrspace(5) %"48", align 8 + %14 = load i64, ptr addrspace(5) %"46", align 8 + %"70" = inttoptr i64 %14 to ptr addrspace(1) + %15 = load i64, ptr addrspace(1) %"70", align 8 + store i64 %15, ptr addrspace(5) %"49", align 8 + %16 = load i64, ptr addrspace(5) %"47", align 8 + %17 = load i64, ptr addrspace(5) %"49", align 8 + %"71" = inttoptr i64 %16 to ptr addrspace(1) + store i64 %17, ptr addrspace(1) %"71", align 8 ret void } From 32c329938135d1ae2ef53d9695b367e9235bb8fb Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Mon, 22 Jun 2026 01:18:50 -0700 Subject: [PATCH 65/85] Add functions form the closing sequence --- Cargo.lock | 1354 +- Cargo.toml | 5 + cuda_check/Cargo.toml | 2 +- cuda_macros/src/lib.rs | 92 +- cuda_types/src/dark_api.rs | 2 + dark_api/Cargo.toml | 29 +- dark_api/src/fatbin.rs | 8 +- dark_api/src/lib.rs | 54 +- kernel_metadata/src/lib.rs | 2 +- nvapi/Cargo.toml | 26 + nvapi/src/lib.rs | 726 + nvapi/src/nvapi.rs | 19879 ++++++++++++++++ nvapi_trace/Cargo.toml | 29 + nvapi_trace/src/lib.rs | 704 + ptx/lib/zluda_ptx_impl.cpp | 2 +- ptx/src/pass/convert_32bit_to_64bit.rs | 30 +- ptx/src/pass/llvm/attributes.rs | 2 +- ptx/src/pass/llvm/emit.rs | 500 +- ptx/src/pass/llvm/mod.rs | 11 +- ptx/src/pass/mod.rs | 2 +- .../replace_instructions_with_functions.rs | 5 + ptx/src/test/spirv_run/mod.rs | 9 +- ptx_parser/src/lib.rs | 2 +- xtask/src/main.rs | 78 +- zluda/src/impl/driver.rs | 89 + zluda/src/impl/function.rs | 2 + zluda/src/impl/hipfix.rs | 3 + zluda/src/impl/library.rs | 4 +- zluda/src/impl/module.rs | 120 +- zluda/src/impl/tex.rs | 3 + zluda32/Cargo.toml | 45 + zluda32/src/ipc.rs | 175 + zluda32/src/lib.rs | 1064 + zluda64_server/Cargo.toml | 26 + zluda64_server/src/main.rs | 1192 + zluda_common/src/constants.rs | 1 + zluda_common/src/lib.rs | 1 + zluda_inject/Cargo.toml | 2 +- zluda_inject/src/bin.rs | 22 +- zluda_redirect/Cargo.toml | 1 + zluda_server_common/Cargo.toml | 17 + zluda_server_common/src/lib.rs | 368 + zluda_trace/Cargo.toml | 6 +- zluda_trace/src/lib.rs | 26 +- zluda_trace/src/log.rs | 4 + zluda_trace/src/trace.rs | 7 +- zluda_trace_blas/src/lib.rs | 1 + zluda_trace_blaslt/src/lib.rs | 1 + zluda_trace_dnn8/src/lib.rs | 1 + zluda_trace_dnn9/src/lib.rs | 1 + zluda_trace_fft/src/lib.rs | 1 + zluda_trace_nvml/src/lib.rs | 1 + zluda_trace_sparse/src/lib.rs | 1 + zluda_windows/src/lib.rs | 58 +- 54 files changed, 26295 insertions(+), 501 deletions(-) create mode 100644 nvapi/Cargo.toml create mode 100644 nvapi/src/lib.rs create mode 100644 nvapi/src/nvapi.rs create mode 100644 nvapi_trace/Cargo.toml create mode 100644 nvapi_trace/src/lib.rs create mode 100644 zluda32/Cargo.toml create mode 100644 zluda32/src/ipc.rs create mode 100644 zluda32/src/lib.rs create mode 100644 zluda64_server/Cargo.toml create mode 100644 zluda64_server/src/main.rs create mode 100644 zluda_server_common/Cargo.toml create mode 100644 zluda_server_common/src/lib.rs diff --git a/Cargo.lock b/Cargo.lock index a83ce01f1..72b33bb96 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -84,7 +84,7 @@ dependencies = [ "argh_shared", "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -108,6 +108,21 @@ version = "0.7.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50" +[[package]] +name = "async-task" +version = "4.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de" + +[[package]] +name = "atomic-polyfill" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8cf2bce30dfe09ef0bfaef228b9d414faaf7e563035494d7fe092dba54b300f4" +dependencies = [ + "critical-section", +] + [[package]] name = "autocfg" version = "1.4.0" @@ -120,13 +135,33 @@ version = "0.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3a8241f3ebb85c056b509d4327ad0358fbbba6ffb340bf388f26350aeda225b1" +[[package]] +name = "bincode" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "36eaf5d7b090263e8150820482d5d93cd964a81e4019913c972f4edcc6edb740" +dependencies = [ + "bincode_derive", + "serde", + "unty", +] + +[[package]] +name = "bincode_derive" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bf95709a440f45e986983918d0e8a1f30a9b1df04918fc828670606804ac3c09" +dependencies = [ + "virtue", +] + [[package]] name = "bindgen" version = "0.70.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f49d8fed880d473ea71efb9bf597651e77201bdd4893efe54c9e5d65ae04ce6f" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", "cexpr", "clang-sys", "itertools 0.13.0", @@ -137,7 +172,7 @@ dependencies = [ "regex", "rustc-hash 1.1.0", "shlex", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -146,7 +181,7 @@ version = "0.71.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5f58bf3d7db68cfbac37cfc485a8d711e87e064c3d0fe0435b92f7a407f9d6b3" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", "cexpr", "clang-sys", "itertools 0.13.0", @@ -155,9 +190,9 @@ dependencies = [ "proc-macro2", "quote", "regex", - "rustc-hash 2.1.1", + "rustc-hash 2.1.2", "shlex", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -166,6 +201,30 @@ version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7" +[[package]] +name = "bitcode" +version = "0.6.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0a6ed1b54d8dc333e7be604d00fa9262f4635485ffea923647b6521a5fff045d" +dependencies = [ + "arrayvec", + "bitcode_derive", + "bytemuck", + "glam", + "serde", +] + +[[package]] +name = "bitcode_derive" +version = "0.6.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "238b90427dfad9da4a9abd60f3ec1cdee6b80454bde49ed37f1781dd8e9dc7f9" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.117", +] + [[package]] name = "bitflags" version = "1.3.2" @@ -174,9 +233,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" [[package]] name = "bitflags" -version = "2.9.1" +version = "2.11.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1b8e56985ec62d17e9c1001dc89c88ecd7dc08e47eba5ec7c29c7b5eeecde967" +checksum = "c4512299f36f043ab09a583e57bceb5a5aab7a73db1805848e8fef3c9e8c78b3" [[package]] name = "blake3" @@ -219,7 +278,7 @@ checksum = "fefb4feeec9a091705938922f26081aad77c64cd2e76cd1c4a9ece8e42e1618a" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -259,7 +318,7 @@ checksum = "89385e82b5d1821d2219e0b095efa2cc1f246cbf99080f3be46a1a85c0d392d9" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -279,7 +338,7 @@ checksum = "f9abbd1bc6865053c427f7198e6af43bfdedc55ab791faed4fbd361d789575ff" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -314,10 +373,10 @@ dependencies = [ "gemm", "half", "libm", - "memmap2 0.9.7", + "memmap2", "num-traits", "num_cpus", - "rand", + "rand 0.9.2", "rand_distr", "rayon", "safetensors", @@ -376,6 +435,12 @@ version = "1.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" +[[package]] +name = "cfg_aliases" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724" + [[package]] name = "cglue" version = "0.3.5" @@ -414,6 +479,17 @@ dependencies = [ "syn 1.0.109", ] +[[package]] +name = "chacha20" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6f8d983286843e49675a4b7a2d174efe136dc93a18d69130dd18198a6c167601" +dependencies = [ + "cfg-if", + "cpufeatures 0.3.0", + "rand_core 0.10.0", +] + [[package]] name = "clang-sys" version = "1.8.1" @@ -440,6 +516,15 @@ dependencies = [ "cc", ] +[[package]] +name = "cobs" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fa961b519f0b462e3a3b4a34b64d119eeaca1d59af726fe450bbba07a9fc0a1" +dependencies = [ + "thiserror 2.0.12", +] + [[package]] name = "compiler" version = "0.0.0" @@ -453,6 +538,143 @@ dependencies = [ "thiserror 2.0.12", ] +[[package]] +name = "compio" +version = "0.18.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b84ee96a86948d04388f3a0b8c36b9f0a6b40b3528ac0d65737e53632fb37fe" +dependencies = [ + "compio-buf", + "compio-driver", + "compio-fs", + "compio-io", + "compio-log", + "compio-macros", + "compio-runtime", +] + +[[package]] +name = "compio-buf" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a00d719dbd8c602ab0d25d219cbc6b517008858de7a8d6c51b4dc95aefff4dce" +dependencies = [ + "arrayvec", + "bytes", + "libc", +] + +[[package]] +name = "compio-driver" +version = "0.11.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "74d42d98dc890ee4db00c1e68a723391711aab6d67085880d716b72830f7c715" +dependencies = [ + "cfg-if", + "cfg_aliases", + "compio-buf", + "compio-log", + "crossbeam-queue", + "flume", + "futures-util", + "io-uring", + "io_uring_buf_ring", + "libc", + "once_cell", + "paste", + "pin-project-lite", + "polling", + "slab", + "smallvec", + "socket2", + "synchrony", + "thin-cell", + "windows-sys 0.61.2", +] + +[[package]] +name = "compio-fs" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "65ee36e1acf2cec4835efe9a986c012b2462c5ef53580e4ee84ae6d5a3d8e3b3" +dependencies = [ + "cfg-if", + "cfg_aliases", + "compio-buf", + "compio-driver", + "compio-io", + "compio-runtime", + "libc", + "os_pipe", + "pin-project-lite", + "widestring", + "windows-sys 0.61.2", +] + +[[package]] +name = "compio-io" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "637522f28a64fd5f7dcceaa4ddef13fa8d8020025e8c993f7a069e237835580e" +dependencies = [ + "compio-buf", + "futures-util", + "paste", + "synchrony", +] + +[[package]] +name = "compio-log" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc4e560213c1996b618da369b7c9109564b41af9033802ae534465c4ee4e132f" +dependencies = [ + "tracing", +] + +[[package]] +name = "compio-macros" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f05ed201484967dc70de77a8f7a02b29aaa8e6c81cbea2e75492ee0c8d97766b" +dependencies = [ + "proc-macro-crate 3.3.0", + "proc-macro2", + "quote", + "syn 2.0.117", +] + +[[package]] +name = "compio-runtime" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6c1c71f011bdd9c8f30e97d877b606505ee6d241c7782cfaed172f66acbd9cd" +dependencies = [ + "async-task", + "compio-buf", + "compio-driver", + "compio-log", + "core_affinity", + "crossbeam-queue", + "futures-util", + "libc", + "once_cell", + "pin-project-lite", + "scoped-tls", + "slab", + "socket2", + "windows-sys 0.61.2", +] + +[[package]] +name = "concurrent-queue" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4ca0197aee26d1ae37445ee532fefce43251d24cc7c166799f4d46817f1d3973" +dependencies = [ + "crossbeam-utils", +] + [[package]] name = "console" version = "0.16.1" @@ -481,6 +703,17 @@ dependencies = [ "unicode-segmentation", ] +[[package]] +name = "core_affinity" +version = "0.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a034b3a7b624016c6e13f5df875747cc25f884156aad2abd12b6c46797971342" +dependencies = [ + "libc", + "num_cpus", + "winapi", +] + [[package]] name = "cpufeatures" version = "0.2.17" @@ -490,6 +723,15 @@ dependencies = [ "libc", ] +[[package]] +name = "cpufeatures" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b2a41393f66f16b0823bb79094d54ac5fbd34ab292ddafb9a0456ac9f87d201" +dependencies = [ + "libc", +] + [[package]] name = "crc32fast" version = "1.5.0" @@ -499,6 +741,21 @@ dependencies = [ "cfg-if", ] +[[package]] +name = "critical-section" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "790eea4361631c5e7d22598ecd5723ff611904e3344ce8720784c93e3d83d40b" + +[[package]] +name = "crossbeam-channel" +version = "0.5.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2" +dependencies = [ + "crossbeam-utils", +] + [[package]] name = "crossbeam-deque" version = "0.8.6" @@ -518,6 +775,15 @@ dependencies = [ "crossbeam-utils", ] +[[package]] +name = "crossbeam-queue" +version = "0.3.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0f58bbc28f91df819d0aa2a2c00cd19754769c2fad90579b3592b1c9ba7a3115" +dependencies = [ + "crossbeam-utils", +] + [[package]] name = "crossbeam-utils" version = "0.8.21" @@ -548,8 +814,8 @@ dependencies = [ "cuda_types", "libloading", "owo-colors", - "rand", - "windows", + "rand 0.10.1", + "windows 0.62.2", "zluda_windows", ] @@ -559,15 +825,15 @@ version = "0.0.0" dependencies = [ "proc-macro2", "quote", - "rustc-hash 2.1.1", - "syn 2.0.89", + "rustc-hash 2.1.2", + "syn 2.0.117", ] [[package]] name = "cuda_types" version = "0.0.0" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", "cuda_macros", "hip_runtime-sys", "hipblaslt-sys", @@ -587,6 +853,7 @@ dependencies = [ "format", "lz4-sys", "paste", + "rkyv", "uuid", "zstd-safe", ] @@ -612,7 +879,7 @@ dependencies = [ "proc-macro2", "quote", "strsim", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -623,7 +890,7 @@ checksum = "fc34b93ccb385b40dc71c6fceac4b2ad23662c7eeb248cf10d529b7e055b6ead" dependencies = [ "darling_core", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -668,7 +935,7 @@ checksum = "30542c1ad912e0e3d22a1935c290e12e8a29d704a420177a31faad4a601a0800" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -689,7 +956,7 @@ dependencies = [ "darling", "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -699,7 +966,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ab63b0e2bf4d5928aff72e83a7dace85d7bba5fe12dcc3c5a572d78caffd3f3c" dependencies = [ "derive_builder_core", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -719,7 +986,7 @@ checksum = "cb7330aeadfbe296029522e6c40f315320aba36fc43a5b3632f3795348f3bd22" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", "unicode-xid", ] @@ -752,7 +1019,7 @@ dependencies = [ "dsl_auto_type", "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -772,7 +1039,7 @@ version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "209c735641a413bc68c4923a9d6ad4bcb3ca306b794edaa7eb0b3228a99ffb25" dependencies = [ - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -820,7 +1087,7 @@ checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -834,7 +1101,7 @@ dependencies = [ "heck", "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -876,28 +1143,29 @@ checksum = "e1d926b4d407d372f141f93bb444696142c29d32962ccbd3531117cf3aa0bfa9" [[package]] name = "dynasm" -version = "1.2.3" +version = "5.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "add9a102807b524ec050363f09e06f1504214b0e1c7797f64261c891022dce8b" +checksum = "df4bf11ba8aecc00489b7ec4e8963cd3860651c3ea2a114394f8ba7e92a0e94a" dependencies = [ - "bitflags 1.3.2", + "bitflags 2.11.1", "byteorder", "lazy_static", - "proc-macro-error", + "proc-macro-error2", "proc-macro2", "quote", - "syn 1.0.109", + "syn 2.0.117", ] [[package]] name = "dynasmrt" -version = "1.2.3" +version = "5.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "64fba5a42bd76a17cad4bfa00de168ee1cbfa06a5e8ce992ae880218c05641a9" +checksum = "b38e5331d851567729d892ed28d898d22f49a96940b29e23b5c3e681bd30ffb3" dependencies = [ "byteorder", "dynasm", - "memmap2 0.5.10", + "fnv", + "memmap2", ] [[package]] @@ -920,6 +1188,18 @@ dependencies = [ "winreg", ] +[[package]] +name = "embedded-io" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ef1a6892d9eef45c8fa6b9e0086428a2cca8491aca8f787c534a3d6d0bcb3ced" + +[[package]] +name = "embedded-io" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "edd0f118536f44f5ccd48bcb8b111bdc3de888b58c74639dfb034a357d0f206d" + [[package]] name = "encode_unicode" version = "1.0.0" @@ -944,7 +1224,7 @@ dependencies = [ "heck", "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -978,7 +1258,7 @@ version = "0.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7223ae2d2f179b803433d9c830478527e92b8117eab39460edae7f1614d9fb73" dependencies = [ - "heapless", + "heapless 0.8.0", "serde", ] @@ -1031,10 +1311,19 @@ checksum = "719a903cc23e4a89e87962c2a80fdb45cdaad0983a89bd150bb57b4c8571a7d5" dependencies = [ "half", "num-traits", - "rand", + "rand 0.9.2", "rand_distr", ] +[[package]] +name = "flume" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5e139bc46ca777eb5efaf62df0ab8cc5fd400866427e56c68b22e414e53bd3be" +dependencies = [ + "spin", +] + [[package]] name = "fnv" version = "1.0.7" @@ -1070,6 +1359,49 @@ dependencies = [ "uuid", ] +[[package]] +name = "futures-core" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d" + +[[package]] +name = "futures-macro" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e835b70203e41293343137df5c0664546da5745f82ec9b84d40be8336958447b" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.117", +] + +[[package]] +name = "futures-sink" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c39754e157331b013978ec91992bde1ac089843443c49cbc7f46150b0fad0893" + +[[package]] +name = "futures-task" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393" + +[[package]] +name = "futures-util" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6" +dependencies = [ + "futures-core", + "futures-macro", + "futures-sink", + "futures-task", + "pin-project-lite", + "slab", +] + [[package]] name = "gemm" version = "0.19.0" @@ -1189,6 +1521,21 @@ dependencies = [ "seq-macro", ] +[[package]] +name = "generator" +version = "0.8.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52f04ae4152da20c76fe800fa48659201d5cf627c5149ca0b707b69d7eef6cf9" +dependencies = [ + "cc", + "cfg-if", + "libc", + "log", + "rustversion", + "windows-link 0.2.1", + "windows-result 0.4.1", +] + [[package]] name = "generic-array" version = "0.14.7" @@ -1218,10 +1565,24 @@ checksum = "26145e563e54f2cadc477553f1ec5ee650b00862f0a58bcd12cbdc5f0ea2d2f4" dependencies = [ "cfg-if", "libc", - "r-efi", + "r-efi 5.3.0", "wasi 0.14.2+wasi-0.2.4", ] +[[package]] +name = "getrandom" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0de51e6874e94e7bf76d726fc5d13ba782deca734ff60d5bb2fb2607c7406555" +dependencies = [ + "cfg-if", + "libc", + "r-efi 6.0.0", + "rand_core 0.10.0", + "wasip2", + "wasip3", +] + [[package]] name = "gix" version = "0.71.0" @@ -1345,7 +1706,7 @@ dependencies = [ "bstr", "gix-chunk", "gix-hash 0.17.0", - "memmap2 0.9.7", + "memmap2", "thiserror 2.0.12", ] @@ -1376,7 +1737,7 @@ version = "0.14.12" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8dc2c844c4cf141884678cabef736fd91dd73068b9146e6f004ba1a0457944b6" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", "bstr", "gix-path", "libc", @@ -1540,7 +1901,7 @@ version = "0.19.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "20972499c03473e773a2099e5fd0c695b9b72465837797a51a43391a1635a030" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", "bstr", "gix-features 0.41.1", "gix-path", @@ -1600,7 +1961,7 @@ version = "0.39.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "855bece2d4153453aa5d0a80d51deea1ce8cd6a3b4cf213da85ac344ccb908a7" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", "bstr", "filetime", "fnv", @@ -1616,7 +1977,7 @@ dependencies = [ "hashbrown 0.14.5", "itoa", "libc", - "memmap2 0.9.7", + "memmap2", "rustix 0.38.37", "smallvec", "thiserror 2.0.12", @@ -1688,7 +2049,7 @@ dependencies = [ "gix-hashtable", "gix-object", "gix-path", - "memmap2 0.9.7", + "memmap2", "smallvec", "thiserror 2.0.12", ] @@ -1737,7 +2098,7 @@ version = "0.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "fef8422c3c9066d649074b24025125963f85232bfad32d6d16aea9453b82ec14" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", "bstr", "gix-attributes", "gix-config-value", @@ -1792,7 +2153,7 @@ dependencies = [ "gix-tempfile", "gix-utils 0.2.0", "gix-validate 0.9.4", - "memmap2 0.9.7", + "memmap2", "thiserror 2.0.12", "winnow 0.7.10", ] @@ -1817,7 +2178,7 @@ version = "0.33.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "342caa4e158df3020cadf62f656307c3948fe4eacfdf67171d7212811860c3e9" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", "bstr", "gix-commitgraph", "gix-date", @@ -1850,7 +2211,7 @@ version = "0.10.12" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "47aeb0f13de9ef2f3033f5ff218de30f44db827ac9f1286f9ef050aacddd5888" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", "gix-path", "libc", "windows-sys 0.52.0", @@ -1950,7 +2311,7 @@ version = "0.45.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "36c0b049f8bdb61b20016694102f7b507f2e1727e83e9c5e6dad4f7d84ff7384" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", "gix-commitgraph", "gix-date", "gix-hash 0.17.0", @@ -2035,6 +2396,12 @@ dependencies = [ "gix-validate 0.9.4", ] +[[package]] +name = "glam" +version = "0.32.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f70749695b063ecbf6b62949ccccde2e733ec3ecbbd71d467dca4e5c6c97cca0" + [[package]] name = "glob" version = "0.3.1" @@ -2062,11 +2429,20 @@ dependencies = [ "cfg-if", "crunchy", "num-traits", - "rand", + "rand 0.9.2", "rand_distr", "zerocopy", ] +[[package]] +name = "hash32" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b0c35f58762feb77d74ebe43bdbc3210f09be9fe6742234d573bacc26ed92b67" +dependencies = [ + "byteorder", +] + [[package]] name = "hash32" version = "0.3.1" @@ -2108,13 +2484,27 @@ dependencies = [ "serde_core", ] +[[package]] +name = "heapless" +version = "0.7.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cdc6457c0eb62c71aac4bc17216026d8410337c4126773b9c5daba343f17964f" +dependencies = [ + "atomic-polyfill", + "hash32 0.2.1", + "rustc_version", + "serde", + "spin", + "stable_deref_trait", +] + [[package]] name = "heapless" version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0bfb9eb618601c89945a70e254898da93b13be0388091d42117462b265bb3fad" dependencies = [ - "hash32", + "hash32 0.3.1", "stable_deref_trait", ] @@ -2255,6 +2645,12 @@ dependencies = [ "zerovec", ] +[[package]] +name = "id-arena" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954" + [[package]] name = "ident_case" version = "1.0.1" @@ -2299,6 +2695,7 @@ checksum = "8c9c992b02b5b4c94ea26e32fe5bccb7aa7d9f390ab5c1221ff895bc7ea8b652" dependencies = [ "equivalent", "hashbrown 0.15.2", + "serde", ] [[package]] @@ -2323,23 +2720,64 @@ dependencies = [ "proc-macro2", "proc-macro2-diagnostics", "quote", - "syn 2.0.89", + "syn 2.0.117", "version_check", ] [[package]] -name = "is-terminal" -version = "0.4.17" +name = "io-uring" +version = "0.7.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3640c1c38b8e4e43584d8df18be5fc6b0aa314ce6ebf51b53313d4306cca8e46" +checksum = "fdd7bddefd0a8833b88a4b68f90dae22c7450d11b354198baee3874fd811b344" dependencies = [ - "hermit-abi", + "bitflags 2.11.1", + "cfg-if", "libc", - "windows-sys 0.61.2", ] [[package]] -name = "is_ci" +name = "io_uring_buf_ring" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1838759bb8c2f24cf05a35429d83145c4aa6af43f8ad38477295e12a7320a80e" +dependencies = [ + "bytes", + "io-uring", + "rustix 1.1.4", +] + +[[package]] +name = "ipc-channel" +version = "0.21.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a441490012d80e9aea75fb27503df8e87e9557dcfc6fe4244dde86bfc12e94e3" +dependencies = [ + "crossbeam-channel", + "libc", + "mio", + "postcard", + "rand 0.9.2", + "rustc-hash 2.1.2", + "serde_core", + "tempfile", + "thiserror 2.0.12", + "uuid", + "windows 0.61.3", +] + +[[package]] +name = "is-terminal" +version = "0.4.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3640c1c38b8e4e43584d8df18be5fc6b0aa314ce6ebf51b53313d4306cca8e46" +dependencies = [ + "hermit-abi", + "libc", + "windows-sys 0.61.2", +] + +[[package]] +name = "is_ci" version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7655c9839580ee829dfacba1d1278c2b7883e50a277ff7541299489d6bdfdc45" @@ -2442,11 +2880,17 @@ version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe" +[[package]] +name = "leb128fmt" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2" + [[package]] name = "libc" -version = "0.2.174" +version = "0.2.184" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1171693293099992e19cddea4e8b849964e9846f4acee11b3948bcc337be8776" +checksum = "48f5d2a454e16a5ea0f4ced81bd44e4cfc7bd3a507b61887c99fd3538b28e4af" [[package]] name = "libloading" @@ -2470,7 +2914,7 @@ version = "0.1.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", "libc", "redox_syscall", ] @@ -2503,9 +2947,9 @@ checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89" [[package]] name = "linux-raw-sys" -version = "0.9.3" +version = "0.12.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fe7db12097d22ec582439daf8618b8fdd1a7bef6270e9af3b1ebcd30893cf413" +checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53" [[package]] name = "litemap" @@ -2581,7 +3025,7 @@ dependencies = [ "proc-macro2", "quote", "regex-syntax", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -2593,6 +3037,20 @@ dependencies = [ "logos-codegen", ] +[[package]] +name = "loom" +version = "0.7.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "419e0dc8046cb947daa77eb95ae174acfbddb7673b4151f56d1eed8e93fbfaca" +dependencies = [ + "cfg-if", + "generator", + "pin-utils", + "scoped-tls", + "tracing", + "tracing-subscriber", +] + [[package]] name = "lz4-sys" version = "1.11.1+lz4-1.10.0" @@ -2603,6 +3061,15 @@ dependencies = [ "libc", ] +[[package]] +name = "matchers" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d1525a2a28c7f4fa0fc98bb91ae755d1e2d1505079e05539e35bc876b5d65ae9" +dependencies = [ + "regex-automata", +] + [[package]] name = "maybe-async" version = "0.2.10" @@ -2611,7 +3078,7 @@ checksum = "5cf92c10c7e361d6b99666ec1c6f9805b0bea2c3bd8c78dc6fe98ac5bd78db11" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -2622,18 +3089,9 @@ checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3" [[package]] name = "memmap2" -version = "0.5.10" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "83faa42c0a078c393f6b29d5db232d8be22776a891f8f56e5284faee4a20b327" -dependencies = [ - "libc", -] - -[[package]] -name = "memmap2" -version = "0.9.7" +version = "0.9.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "483758ad303d734cec05e5c12b41d7e93e6a6390c5e9dae6bdeb7c1259012d28" +checksum = "714098028fe011992e1c3962653c96b2d578c4b4bce9036e15ff220319b1e0e3" dependencies = [ "libc", "stable_deref_trait", @@ -2675,6 +3133,17 @@ dependencies = [ "adler2", ] +[[package]] +name = "mio" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50b7e5b27aa02a74bac8c3f23f448f8d87ff11f92d3aac1a6ed369ee08cc56c1" +dependencies = [ + "libc", + "wasi 0.11.1+wasi-snapshot-preview1", + "windows-sys 0.61.2", +] + [[package]] name = "miopen-sys" version = "0.0.0" @@ -2699,7 +3168,7 @@ checksum = "4568f25ccbd45ab5d5603dc34318c1ec56b117531781260002151b8530a9f931" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -2718,6 +3187,15 @@ dependencies = [ "minimal-lexical", ] +[[package]] +name = "nu-ansi-term" +version = "0.50.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5" +dependencies = [ + "windows-sys 0.61.2", +] + [[package]] name = "num" version = "0.4.3" @@ -2828,6 +3306,40 @@ dependencies = [ "libc", ] +[[package]] +name = "nvapi" +version = "0.0.0" +dependencies = [ + "cglue", + "cuda_macros", + "cuda_types", + "dark_api", + "format", + "libloading", + "paste", + "rustc-hash 2.1.2", + "unwrap_or", + "zluda_trace_common", +] + +[[package]] +name = "nvapi_trace" +version = "0.0.0" +dependencies = [ + "cglue", + "cuda_macros", + "cuda_types", + "dark_api", + "dynasm", + "dynasmrt", + "format", + "libloading", + "paste", + "rustc-hash 2.1.2", + "unwrap_or", + "zluda_trace_common", +] + [[package]] name = "object" version = "0.38.1" @@ -2854,6 +3366,22 @@ version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d" +[[package]] +name = "orderly-allocator" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "801f8900aedd8c4060d155f0c8e0269e011ddd0e061bf56a87e5d9ddba3ce995" + +[[package]] +name = "os_pipe" +version = "1.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d8fae84b431384b68627d0f9b3b1245fcf9f46f6c0e3dc902e9dce64edd1967" +dependencies = [ + "libc", + "windows-sys 0.61.2", +] + [[package]] name = "owo-colors" version = "4.2.3" @@ -2915,6 +3443,18 @@ dependencies = [ "indexmap", ] +[[package]] +name = "pin-project-lite" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd" + +[[package]] +name = "pin-utils" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" + [[package]] name = "pkg-config" version = "0.3.32" @@ -2927,6 +3467,20 @@ version = "0.2.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6" +[[package]] +name = "polling" +version = "3.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d0e4f59085d47d8241c88ead0f274e8a0cb551f3625263c05eb8dd897c34218" +dependencies = [ + "cfg-if", + "concurrent-queue", + "hermit-abi", + "pin-project-lite", + "rustix 1.1.4", + "windows-sys 0.61.2", +] + [[package]] name = "portable-atomic" version = "1.11.1" @@ -2942,6 +3496,19 @@ dependencies = [ "portable-atomic", ] +[[package]] +name = "postcard" +version = "1.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6764c3b5dd454e283a30e6dfe78e9b31096d9e32036b5d1eaac7a6119ccb9a24" +dependencies = [ + "cobs", + "embedded-io 0.4.0", + "embedded-io 0.6.1", + "heapless 0.7.17", + "serde", +] + [[package]] name = "potential_utf" version = "0.1.2" @@ -2983,7 +3550,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "64d1ec885c64d0457d564db4ec299b2dae3f9c02808b8ad9c3a089c591b18033" dependencies = [ "proc-macro2", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -3005,34 +3572,32 @@ dependencies = [ ] [[package]] -name = "proc-macro-error" -version = "1.0.4" +name = "proc-macro-error-attr2" +version = "2.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c" +checksum = "96de42df36bb9bba5542fe9f1a054b8cc87e172759a1868aa05c1f3acc89dfc5" dependencies = [ - "proc-macro-error-attr", "proc-macro2", "quote", - "syn 1.0.109", - "version_check", ] [[package]] -name = "proc-macro-error-attr" -version = "1.0.4" +name = "proc-macro-error2" +version = "2.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869" +checksum = "11ec05c52be0a07b08061f7dd003e7d7092e0472bc731b4af7bb1ef876109802" dependencies = [ + "proc-macro-error-attr2", "proc-macro2", "quote", - "version_check", + "syn 2.0.117", ] [[package]] name = "proc-macro2" -version = "1.0.92" +version = "1.0.106" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "37d3544b3f2748c54e147655edb5025752e2303145b5aefb3c3ea2c78b973bb0" +checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934" dependencies = [ "unicode-ident", ] @@ -3045,7 +3610,7 @@ checksum = "af066a9c399a26e020ada66a034357a868728e72cd426f3adcd35f80d88d88c8" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", "version_check", "yansi", ] @@ -3077,7 +3642,7 @@ checksum = "7347867d0a7e1208d93b46767be83e2b8f978c3dad35f775ac8d8847551d6fe1" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -3101,7 +3666,7 @@ dependencies = [ "pretty_assertions", "ptx_parser", "quick-error", - "rustc-hash 2.1.1", + "rustc-hash 2.1.2", "smallvec", "strum 0.28.0", "strum_macros 0.28.0", @@ -3118,7 +3683,7 @@ dependencies = [ "derive_more", "logos", "ptx_parser_macros", - "rustc-hash 2.1.1", + "rustc-hash 2.1.2", "strum 0.27.1", "thiserror 1.0.64", "winnow 0.6.20", @@ -3133,8 +3698,8 @@ dependencies = [ "proc-macro2", "ptx_parser_macros_impl", "quote", - "rustc-hash 2.1.1", - "syn 2.0.89", + "rustc-hash 2.1.2", + "syn 2.0.117", ] [[package]] @@ -3143,8 +3708,8 @@ version = "0.0.0" dependencies = [ "proc-macro2", "quote", - "rustc-hash 2.1.1", - "syn 2.0.89", + "rustc-hash 2.1.2", + "syn 2.0.117", ] [[package]] @@ -3188,9 +3753,9 @@ checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0" [[package]] name = "quote" -version = "1.0.37" +version = "1.0.45" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af" +checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924" dependencies = [ "proc-macro2", ] @@ -3201,6 +3766,12 @@ version = "5.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f" +[[package]] +name = "r-efi" +version = "6.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf" + [[package]] name = "rancor" version = "0.1.1" @@ -3217,7 +3788,18 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1" dependencies = [ "rand_chacha", - "rand_core", + "rand_core 0.9.5", +] + +[[package]] +name = "rand" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d2e8e8bcc7961af1fdac401278c6a831614941f6164ee3bf4ce61b7edb162207" +dependencies = [ + "chacha20", + "getrandom 0.4.2", + "rand_core 0.10.0", ] [[package]] @@ -3227,7 +3809,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb" dependencies = [ "ppv-lite86", - "rand_core", + "rand_core 0.9.5", ] [[package]] @@ -3239,6 +3821,12 @@ dependencies = [ "getrandom 0.3.3", ] +[[package]] +name = "rand_core" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c8d0fd677905edcbeedbf2edb6494d676f0e98d54d5cf9bda0b061cb8fb8aba" + [[package]] name = "rand_distr" version = "0.5.1" @@ -3246,16 +3834,22 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6a8615d50dcf34fa31f7ab52692afec947c4dd0ab803cc87cb3b0b4570ff7463" dependencies = [ "num-traits", - "rand", + "rand 0.9.2", ] +[[package]] +name = "range-alloc" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ca45419789ae5a7899559e9512e58ca889e41f04f1f2445e9f4b290ceccd1d08" + [[package]] name = "raw-cpuid" version = "11.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "498cd0dc59d73224351ee52a95fee0f1a617a2eae0e7d9d720cc622c73a54186" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", ] [[package]] @@ -3290,7 +3884,7 @@ version = "0.5.11" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d2f103c6d277498fbceb16e84d317e2a400f160f46904d5f5410848c829511a3" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", ] [[package]] @@ -3375,7 +3969,7 @@ checksum = "8100bb34c0a1d0f907143db3149e6b4eea3c33b9ee8b189720168e818303986f" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -3404,9 +3998,9 @@ checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2" [[package]] name = "rustc-hash" -version = "2.1.1" +version = "2.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d" +checksum = "94300abf3f1ae2e2b8ffb7b58043de3d399c73fa6f4b73826402a5c457614dbe" [[package]] name = "rustc_version" @@ -3423,7 +4017,7 @@ version = "0.38.37" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8acb788b847c24f28525660c4d7758620a7210875711f79e7f663cc152726811" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", "errno", "libc", "linux-raw-sys 0.4.14", @@ -3432,15 +4026,15 @@ dependencies = [ [[package]] name = "rustix" -version = "1.0.5" +version = "1.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d97817398dd4bb2e6da002002db259209759911da105da92bec29ccb12cf58bf" +checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", "errno", "libc", - "linux-raw-sys 0.9.3", - "windows-sys 0.59.0", + "linux-raw-sys 0.12.1", + "windows-sys 0.61.2", ] [[package]] @@ -3484,6 +4078,12 @@ dependencies = [ "winapi-util", ] +[[package]] +name = "scoped-tls" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294" + [[package]] name = "scopeguard" version = "1.2.0" @@ -3507,7 +4107,7 @@ checksum = "1783eabc414609e28a5ba76aee5ddd52199f7107a0b24c2e9746a1ecc34a683d" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -3552,7 +4152,7 @@ checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -3583,7 +4183,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba" dependencies = [ "cfg-if", - "cpufeatures", + "cpufeatures 0.2.17", "digest", ] @@ -3597,6 +4197,15 @@ dependencies = [ "sha1", ] +[[package]] +name = "sharded-slab" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6" +dependencies = [ + "lazy_static", +] + [[package]] name = "shell-words" version = "1.1.0" @@ -3640,12 +4249,37 @@ version = "0.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e" +[[package]] +name = "slab" +version = "0.4.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5" + [[package]] name = "smallvec" version = "1.15.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03" +[[package]] +name = "socket2" +version = "0.6.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3a766e1110788c36f4fa1c2b71b387a7815aa65f88ce0229841826633d93723e" +dependencies = [ + "libc", + "windows-sys 0.61.2", +] + +[[package]] +name = "spin" +version = "0.9.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67" +dependencies = [ + "lock_api", +] + [[package]] name = "stable_deref_trait" version = "1.2.0" @@ -3689,7 +4323,7 @@ dependencies = [ "proc-macro2", "quote", "rustversion", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -3701,7 +4335,7 @@ dependencies = [ "heck", "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -3736,15 +4370,25 @@ dependencies = [ [[package]] name = "syn" -version = "2.0.89" +version = "2.0.117" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "44d46482f1c1c87acd84dea20c1bf5ebff4c757009ed6bf19cfd36fb10e92c4e" +checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99" dependencies = [ "proc-macro2", "quote", "unicode-ident", ] +[[package]] +name = "synchrony" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c174d82fd56da8214ec095cfe4568e59e5ccb49d060e70c2f98e3ba352b23e45" +dependencies = [ + "futures-util", + "loom", +] + [[package]] name = "synstructure" version = "0.13.2" @@ -3753,7 +4397,7 @@ checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -3762,7 +4406,7 @@ version = "0.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "01198a2debb237c62b6826ec7081082d951f46dbb64b0e8c7649a452230d1dfc" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", "byteorder", "enum-as-inner", "libc", @@ -3796,10 +4440,16 @@ dependencies = [ "fastrand", "getrandom 0.3.3", "once_cell", - "rustix 1.0.5", + "rustix 1.1.4", "windows-sys 0.59.0", ] +[[package]] +name = "thin-cell" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4164c6c316ba9733b0ab021e7f9852c788a4b991b49c25820f1be48e1d41345b" + [[package]] name = "thiserror" version = "1.0.64" @@ -3826,7 +4476,7 @@ checksum = "08904e7672f5eb876eaaf87e0ce17857500934f4981c4a0ab2b4aa98baac7fc3" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -3837,7 +4487,16 @@ checksum = "7f7cf42b4507d8ea322120659672cf1b9dbb93f8f2d4ecfd6e51350ff5b17a1d" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", +] + +[[package]] +name = "thread_local" +version = "1.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f60246a4944f24f6e018aa17cdeffb7818b76356965d03b07d6a9886e8962185" +dependencies = [ + "cfg-if", ] [[package]] @@ -3963,6 +4622,55 @@ version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "fcc842091f2def52017664b53082ecbbeb5c7731092bad69d2c63050401dfd64" +[[package]] +name = "tracing" +version = "0.1.44" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100" +dependencies = [ + "pin-project-lite", + "tracing-core", +] + +[[package]] +name = "tracing-core" +version = "0.1.36" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a" +dependencies = [ + "once_cell", + "valuable", +] + +[[package]] +name = "tracing-log" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3" +dependencies = [ + "log", + "once_cell", + "tracing-core", +] + +[[package]] +name = "tracing-subscriber" +version = "0.3.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cb7f578e5945fb242538965c2d0b04418d38ec25c79d160cd279bf0731c8d319" +dependencies = [ + "matchers", + "nu-ansi-term", + "once_cell", + "regex-automata", + "sharded-slab", + "smallvec", + "thread_local", + "tracing", + "tracing-core", + "tracing-log", +] + [[package]] name = "trie-hard" version = "0.1.0" @@ -4032,6 +4740,12 @@ version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "323402cff2dd658f39ca17c789b502021b3f18707c91cdf22e3838e1b4023817" +[[package]] +name = "unty" +version = "0.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6d49784317cd0d1ee7ec5c716dd598ec5b4483ea832a2dced265471cc0f690ae" + [[package]] name = "unwrap_or" version = "1.0.1" @@ -4061,10 +4775,17 @@ version = "1.18.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2f87b8aa10b915a06587d0dec516c282ff295b475d94abf425d62b57710070a2" dependencies = [ + "getrandom 0.3.3", "js-sys", "wasm-bindgen", ] +[[package]] +name = "valuable" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65" + [[package]] name = "vcpkg" version = "0.2.15" @@ -4115,6 +4836,12 @@ version = "0.9.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" +[[package]] +name = "virtue" +version = "0.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "051eb1abcf10076295e815102942cc58f9d5e3b4560e46e53c21e8ff6f3af7b1" + [[package]] name = "vswhom" version = "0.1.0" @@ -4160,6 +4887,24 @@ dependencies = [ "wit-bindgen-rt", ] +[[package]] +name = "wasip2" +version = "1.0.2+wasi-0.2.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9517f9239f02c069db75e65f174b3da828fe5f5b945c4dd26bd25d89c03ebcf5" +dependencies = [ + "wit-bindgen", +] + +[[package]] +name = "wasip3" +version = "0.4.0+wasi-0.3.0-rc-2026-01-06" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5" +dependencies = [ + "wit-bindgen", +] + [[package]] name = "wasm-bindgen" version = "0.2.104" @@ -4183,7 +4928,7 @@ dependencies = [ "log", "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", "wasm-bindgen-shared", ] @@ -4205,7 +4950,7 @@ checksum = "9f07d2f20d4da7b26400c9f4a0511e6e0345b040694e8a75bd41d578fa4421d7" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", "wasm-bindgen-backend", "wasm-bindgen-shared", ] @@ -4219,6 +4964,40 @@ dependencies = [ "unicode-ident", ] +[[package]] +name = "wasm-encoder" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319" +dependencies = [ + "leb128fmt", + "wasmparser", +] + +[[package]] +name = "wasm-metadata" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909" +dependencies = [ + "anyhow", + "indexmap", + "wasm-encoder", + "wasmparser", +] + +[[package]] +name = "wasmparser" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe" +dependencies = [ + "bitflags 2.11.1", + "hashbrown 0.15.2", + "indexmap", + "semver", +] + [[package]] name = "web-time" version = "1.1.0" @@ -4266,16 +5045,38 @@ version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" +[[package]] +name = "windows" +version = "0.61.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9babd3a767a4c1aef6900409f85f5d53ce2544ccdfaa86dad48c91782c6d6893" +dependencies = [ + "windows-collections 0.2.0", + "windows-core 0.61.2", + "windows-future 0.2.1", + "windows-link 0.1.3", + "windows-numerics 0.2.0", +] + [[package]] name = "windows" version = "0.62.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "527fadee13e0c05939a6a05d5bd6eec6cd2e3dbd648b9f8e447c6518133d8580" dependencies = [ - "windows-collections", - "windows-core", - "windows-future", - "windows-numerics", + "windows-collections 0.3.2", + "windows-core 0.62.2", + "windows-future 0.3.2", + "windows-numerics 0.3.1", +] + +[[package]] +name = "windows-collections" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3beeceb5e5cfd9eb1d76b381630e82c4241ccd0d27f1a39ed41b2760b255c5e8" +dependencies = [ + "windows-core 0.61.2", ] [[package]] @@ -4284,7 +5085,20 @@ version = "0.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "23b2d95af1a8a14a3c7367e1ed4fc9c20e0a26e79551b1454d72583c97cc6610" dependencies = [ - "windows-core", + "windows-core 0.62.2", +] + +[[package]] +name = "windows-core" +version = "0.61.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3" +dependencies = [ + "windows-implement", + "windows-interface", + "windows-link 0.1.3", + "windows-result 0.3.4", + "windows-strings 0.4.2", ] [[package]] @@ -4295,9 +5109,20 @@ checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb" dependencies = [ "windows-implement", "windows-interface", - "windows-link", - "windows-result", - "windows-strings", + "windows-link 0.2.1", + "windows-result 0.4.1", + "windows-strings 0.5.1", +] + +[[package]] +name = "windows-future" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc6a41e98427b19fe4b73c550f060b59fa592d7d686537eebf9385621bfbad8e" +dependencies = [ + "windows-core 0.61.2", + "windows-link 0.1.3", + "windows-threading 0.1.0", ] [[package]] @@ -4306,9 +5131,9 @@ version = "0.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e1d6f90251fe18a279739e78025bd6ddc52a7e22f921070ccdc67dde84c605cb" dependencies = [ - "windows-core", - "windows-link", - "windows-threading", + "windows-core 0.62.2", + "windows-link 0.2.1", + "windows-threading 0.2.1", ] [[package]] @@ -4319,7 +5144,7 @@ checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -4330,23 +5155,48 @@ checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] +[[package]] +name = "windows-link" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a" + [[package]] name = "windows-link" version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" +[[package]] +name = "windows-numerics" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9150af68066c4c5c07ddc0ce30421554771e528bde427614c61038bc2c92c2b1" +dependencies = [ + "windows-core 0.61.2", + "windows-link 0.1.3", +] + [[package]] name = "windows-numerics" version = "0.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6e2e40844ac143cdb44aead537bbf727de9b044e107a0f1220392177d15b0f26" dependencies = [ - "windows-core", - "windows-link", + "windows-core 0.62.2", + "windows-link 0.2.1", +] + +[[package]] +name = "windows-result" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6" +dependencies = [ + "windows-link 0.1.3", ] [[package]] @@ -4355,7 +5205,16 @@ version = "0.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5" dependencies = [ - "windows-link", + "windows-link 0.2.1", +] + +[[package]] +name = "windows-strings" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57" +dependencies = [ + "windows-link 0.1.3", ] [[package]] @@ -4364,7 +5223,7 @@ version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091" dependencies = [ - "windows-link", + "windows-link 0.2.1", ] [[package]] @@ -4391,7 +5250,7 @@ version = "0.61.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" dependencies = [ - "windows-link", + "windows-link 0.2.1", ] [[package]] @@ -4410,13 +5269,22 @@ dependencies = [ "windows_x86_64_msvc", ] +[[package]] +name = "windows-threading" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b66463ad2e0ea3bbf808b7f1d371311c80e115c0b71d60efc142cafbcfb057a6" +dependencies = [ + "windows-link 0.1.3", +] + [[package]] name = "windows-threading" version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3949bd5b99cafdf1c7ca86b43ca564028dfe27d66958f2470940f73d86d75b37" dependencies = [ - "windows-link", + "windows-link 0.2.1", ] [[package]] @@ -4495,13 +5363,101 @@ dependencies = [ "windows-sys 0.59.0", ] +[[package]] +name = "wit-bindgen" +version = "0.51.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5" +dependencies = [ + "wit-bindgen-rust-macro", +] + +[[package]] +name = "wit-bindgen-core" +version = "0.51.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc" +dependencies = [ + "anyhow", + "heck", + "wit-parser", +] + [[package]] name = "wit-bindgen-rt" version = "0.39.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6f42320e61fe2cfd34354ecb597f86f413484a798ba44a8ca1165c58d42da6c1" dependencies = [ - "bitflags 2.9.1", + "bitflags 2.11.1", +] + +[[package]] +name = "wit-bindgen-rust" +version = "0.51.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21" +dependencies = [ + "anyhow", + "heck", + "indexmap", + "prettyplease", + "syn 2.0.117", + "wasm-metadata", + "wit-bindgen-core", + "wit-component", +] + +[[package]] +name = "wit-bindgen-rust-macro" +version = "0.51.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c0f9bfd77e6a48eccf51359e3ae77140a7f50b1e2ebfe62422d8afdaffab17a" +dependencies = [ + "anyhow", + "prettyplease", + "proc-macro2", + "quote", + "syn 2.0.117", + "wit-bindgen-core", + "wit-bindgen-rust", +] + +[[package]] +name = "wit-component" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2" +dependencies = [ + "anyhow", + "bitflags 2.11.1", + "indexmap", + "log", + "serde", + "serde_derive", + "serde_json", + "wasm-encoder", + "wasm-metadata", + "wasmparser", + "wit-parser", +] + +[[package]] +name = "wit-parser" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736" +dependencies = [ + "anyhow", + "id-arena", + "indexmap", + "log", + "semver", + "serde", + "serde_derive", + "serde_json", + "unicode-xid", + "wasmparser", ] [[package]] @@ -4517,7 +5473,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0d65cbf2f12c15564212d48f4e3dfb87923d25d611f2aed18f4cb23f0413d89e" dependencies = [ "libc", - "rustix 1.0.5", + "rustix 1.1.4", ] [[package]] @@ -4560,7 +5516,7 @@ checksum = "38da3c9736e16c5d3c8c597a9aaa5d1fa565d0532ae05e27c24aa62fb32c0ab6" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", "synstructure", ] @@ -4581,7 +5537,7 @@ checksum = "9ecf5b4cc5364572d7f4c329661bcc82724222973f2cab6f050a4e5c22f75181" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -4601,7 +5557,7 @@ checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", "synstructure", ] @@ -4635,7 +5591,7 @@ checksum = "5b96237efa0c878c64bd89c436f661be4e46b2f3eff1ebb976f7ef2321d2f58f" dependencies = [ "proc-macro2", "quote", - "syn 2.0.89", + "syn 2.0.117", ] [[package]] @@ -4692,17 +5648,58 @@ dependencies = [ "paste", "ptx", "ptx_parser", - "rustc-hash 2.1.1", + "rustc-hash 2.1.2", "serde", "serde_json", "tempfile", "vergen-gix", - "windows", + "windows 0.62.2", "zluda_cache", "zluda_common", "zluda_windows", ] +[[package]] +name = "zluda32" +version = "0.0.0" +dependencies = [ + "bincode", + "bitcode", + "cuda_macros", + "cuda_types", + "dark_api", + "ipc-channel", + "paste", + "postcard", + "rand 0.10.1", + "rkyv", + "rustc-hash 2.1.2", + "unwrap_or", + "widestring", + "windows 0.62.2", + "zluda_common", + "zluda_server_common", + "zluda_windows", +] + +[[package]] +name = "zluda64_server" +version = "0.0.0" +dependencies = [ + "bincode", + "compio", + "cuda_macros", + "cuda_types", + "dark_api", + "orderly-allocator", + "range-alloc", + "rkyv", + "rustc-hash 2.1.2", + "slab", + "windows-sys 0.61.2", + "zluda_server_common", +] + [[package]] name = "zluda_bindgen" version = "0.1.0" @@ -4713,8 +5710,8 @@ dependencies = [ "prettyplease", "proc-macro2", "quote", - "rustc-hash 2.1.1", - "syn 2.0.89", + "rustc-hash 2.1.2", + "syn 2.0.117", ] [[package]] @@ -4783,7 +5780,7 @@ dependencies = [ "hip_runtime-sys", "libloading", "miopen-sys", - "rustc-hash 2.1.1", + "rustc-hash 2.1.2", "static_assertions", "zluda_common", "zluda_windows", @@ -4811,9 +5808,9 @@ dependencies = [ "half", "libloading", "paste", - "rand", + "rand 0.9.2", "rand_chacha", - "windows", + "windows 0.62.2", "zluda_common", "zluda_dnn", "zluda_windows", @@ -4834,11 +5831,11 @@ dependencies = [ "argh", "bpaf", "detours-sys", - "rustc-hash 2.1.1", + "rustc-hash 2.1.2", "tempfile", "widestring", - "windows", - "windows-core", + "windows 0.62.2", + "windows-core 0.62.2", "zluda_ml", "zluda_redirect", "zluda_trace", @@ -4879,15 +5876,31 @@ name = "zluda_redirect" version = "0.0.0" dependencies = [ "detours-sys", - "rustc-hash 2.1.1", + "rustc-hash 2.1.2", "unwrap_or", "widestring", - "windows", + "windows 0.62.2", "windows-sys 0.61.2", "winnow 0.6.20", "zluda_windows", ] +[[package]] +name = "zluda_server_common" +version = "0.0.0" +dependencies = [ + "bincode", + "bitcode", + "cuda_macros", + "cuda_types", + "dark_api", + "paste", + "postcard", + "rkyv", + "strum 0.28.0", + "strum_macros 0.28.0", +] + [[package]] name = "zluda_sparse" version = "0.0.0" @@ -4919,12 +5932,11 @@ dependencies = [ "libloading", "parking_lot", "paste", - "ptx", "ptx_parser", "regex", - "rustc-hash 2.1.1", + "rustc-hash 2.1.2", "unwrap_or", - "windows", + "windows 0.62.2", "zluda_common", "zluda_trace_common", "zstd-safe", @@ -5055,7 +6067,7 @@ dependencies = [ "trie-hard", "uuid", "widestring", - "windows", + "windows 0.62.2", ] [[package]] diff --git a/Cargo.toml b/Cargo.toml index d199126eb..066ca9602 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -16,6 +16,8 @@ members = [ "ext/rocblas-sys", "format", "kernel_metadata", + "nvapi", + "nvapi_trace", "ptx_parser_macros_impl", "ptx_parser_macros", "ptx_parser", @@ -36,6 +38,7 @@ members = [ "zluda_ml", "zluda_precompile", "zluda_redirect", + "zluda_server_common", "zluda_sparse", "zluda_trace_blas", "zluda_trace_blaslt", @@ -47,6 +50,8 @@ members = [ "zluda_trace_sparse", "zluda_trace", "zluda", + "zluda32", + "zluda64_server", ] default-members = ["zluda", "zluda_ml", "zluda_inject", "zluda_redirect", "compiler"] diff --git a/cuda_check/Cargo.toml b/cuda_check/Cargo.toml index c0b9c3d4d..baefa150c 100644 --- a/cuda_check/Cargo.toml +++ b/cuda_check/Cargo.toml @@ -13,7 +13,7 @@ cuda_types = { path = "../cuda_types" } zluda_windows = { path = "../zluda_windows" } bpaf = { version = "0.9.19", features = ["derive", "bright-color"] } owo-colors = { version = "4", features = ["supports-colors"] } -rand = "0.9.2" +rand = "0.10.1" libloading = "0.8" [target.'cfg(windows)'.dependencies] diff --git a/cuda_macros/src/lib.rs b/cuda_macros/src/lib.rs index 769a672b9..1267860b9 100644 --- a/cuda_macros/src/lib.rs +++ b/cuda_macros/src/lib.rs @@ -9,8 +9,7 @@ use syn::parse::{Parse, ParseStream}; use syn::punctuated::Punctuated; use syn::visit_mut::VisitMut; use syn::{ - bracketed, parse_macro_input, File, ForeignItem, ForeignItemFn, Ident, Item, Path, Signature, - Token + File, ForeignItem, ForeignItemFn, Ident, Item, PatType, Path, Signature, Token, TypeGroup, bracketed, parse_macro_input }; const CUDA_RS: &'static str = include_str! {"cuda.rs"}; @@ -301,6 +300,95 @@ pub fn nvml_normalize_fn(tokens: TokenStream) -> TokenStream { normalize_fn_impl("nvml", None, tokens) } +#[proc_macro] +pub fn generate_input_struct(tokens: TokenStream) -> TokenStream { + let input = parse_macro_input!(tokens as FnWithFields); + let struct_name = format_ident!("{}In", input.fn_name); + let fields = input.fields.iter().filter(|pat| is_input_field(&pat.ty)).map(use_wire_object); + quote! { + #[derive(Archive, Deserialize, Serialize, Debug, PartialEq)] + #[repr(C)] + pub struct #struct_name { + #(#fields),* + } + unsafe impl Portable for #struct_name {} + }.into() +} + +#[proc_macro] +pub fn generate_output_struct(tokens: TokenStream) -> TokenStream { + let input = parse_macro_input!(tokens as FnWithFields); + let struct_name = format_ident!("{}Out", input.fn_name); + let fields = input.fields.iter().filter(|pat| !is_input_field(&pat.ty)).map(strip_mut_ptr); + quote! { + #[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] + #[repr(C)] + pub struct #struct_name { + #(#fields),* + } + unsafe impl Portable for #struct_name {} + }.into() +} + +fn is_input_field(ty: &syn::Type) -> bool { + match ty { + syn::Type::Ptr(token) if token.mutability.is_some() => false, + syn::Type::Group(TypeGroup {elem, ..}) => is_input_field(&*elem), + _ => true + } +} + +fn use_wire_object(ty: &syn::PatType) -> proc_macro2::TokenStream { + let pat = &ty.pat; + let type_ = &ty.ty; + quote! { pub #pat : <#type_ as crate::CudaEncode>::WireObject } +} + +fn strip_mut_ptr(ty: &syn::PatType) -> proc_macro2::TokenStream { + fn strip_mut_ptr_from_type(ty: &syn::Type) -> proc_macro2::TokenStream { + match ty { + syn::Type::Ptr(token) => { + let elem = &token.elem; + quote! { #elem } + }, + _ => unreachable!() + } + } + let pat = &ty.pat; + match &*ty.ty { + syn::Type::Ptr(token) => { + let type_ = strip_mut_ptr_from_type(&*token.elem); + quote! { pub #pat : <#type_ as crate::CudaEncode>::WireObject } + }, + syn::Type::Group(TypeGroup {elem, ..}) => { + let type_ = strip_mut_ptr_from_type(&*elem); + quote! { pub #pat : <#type_ as crate::CudaEncode>::WireObject } + }, + _ => unreachable!() + } +} + +struct FnWithFields { + fn_name: Ident, + fields: Punctuated, +} + +impl Parse for FnWithFields { + fn parse(input: ParseStream) -> syn::Result { + let fn_name = input.parse::()?; + let fields = if input.is_empty() { + Punctuated::new() + } else { + input.parse::()?; + input.parse_terminated(PatType::parse, Token![,])? + }; + Ok(Self { + fn_name, + fields, + }) + } +} + fn split(fn_: &str) -> Vec { let mut result = Vec::new(); let mut chars: iter::Peekable<_> = fn_.chars().peekable(); diff --git a/cuda_types/src/dark_api.rs b/cuda_types/src/dark_api.rs index bb7b2cfbf..c73863efc 100644 --- a/cuda_types/src/dark_api.rs +++ b/cuda_types/src/dark_api.rs @@ -68,6 +68,8 @@ bitflags! { pub struct FatbinFileHeaderFlags: u64 { const Is64Bit = 0x0000000000000001; const Debug = 0x0000000000000002; + const CUDA = 0x0000000000000004; + const OpenCL = 0x0000000000000008; const Linux = 0x0000000000000010; const Mac = 0x0000000000000020; const Windows = 0x0000000000000040; diff --git a/dark_api/Cargo.toml b/dark_api/Cargo.toml index f65e53827..c5c65bb82 100644 --- a/dark_api/Cargo.toml +++ b/dark_api/Cargo.toml @@ -1,14 +1,15 @@ -[package] -name = "dark_api" -version = "0.0.0" -edition = "2021" - -[dependencies] -cuda_types = { path = "../cuda_types" } -format = { path = "../format" } -uuid = "1.16" -paste = "1.0" -bit-vec = "0.8.0" -cglue = "0.3.5" -lz4-sys = "1.9" -zstd-safe = { version = "7.2.4", features = ["std"] } +[package] +name = "dark_api" +version = "0.0.0" +edition = "2021" + +[dependencies] +cuda_types = { path = "../cuda_types" } +format = { path = "../format" } +uuid = "1.16" +paste = "1.0" +bit-vec = "0.8.0" +cglue = "0.3.5" +lz4-sys = "1.9" +zstd-safe = { version = "7.2.4", features = ["std"] } +rkyv = "0.8.15" diff --git a/dark_api/src/fatbin.rs b/dark_api/src/fatbin.rs index 9488499a2..06a64d86f 100644 --- a/dark_api/src/fatbin.rs +++ b/dark_api/src/fatbin.rs @@ -196,7 +196,10 @@ impl<'a> FatbinFile<'a> { std::slice::from_raw_parts(start, self.header.compressed_size as usize) } - pub unsafe fn get_or_decompress_content(self) -> Result, FatbinError> { + pub unsafe fn get_or_decompress_content( + self, + strip_trailing_zero: bool, + ) -> Result, FatbinError> { let mut payload = if self .header .flags @@ -212,9 +215,8 @@ impl<'a> FatbinFile<'a> { } else { Cow::Borrowed(unsafe { self.get_non_compressed_payload() }) }; - // Remove trailing zeros - if self.header.kind == FatbinFileHeader::HEADER_KIND_PTX { + if strip_trailing_zero && self.header.kind == FatbinFileHeader::HEADER_KIND_PTX { match payload { Cow::Borrowed(ref mut slice) => { while slice.last() == Some(&0) { diff --git a/dark_api/src/lib.rs b/dark_api/src/lib.rs index cfd8c928e..e3eac45fb 100644 --- a/dark_api/src/lib.rs +++ b/dark_api/src/lib.rs @@ -1,6 +1,7 @@ -use std::ffi::c_void; - use cuda_types::cuda::CUuuid; +use format::CudaDisplay; +use rkyv::traits::{Archive, Deserialize, Serialize}; +use std::ffi::c_void; pub mod fatbin; @@ -354,6 +355,7 @@ dark_api! { #[noformat] [0] = logged_call( fn_name: cglue::slice::CSliceRef<'static, u8>, + nvapi_interface: u32, args: crate::FnFfiRef, fn_: crate::FnFfiRef, internal_error: usize, @@ -362,6 +364,54 @@ dark_api! { } } +#[repr(C)] +#[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone, Copy)] +pub struct FunctionArgInfo { + pub size: u32, + pub align: u32, +} + +impl FunctionArgInfo { + pub fn to_layout(self) -> Option { + std::alloc::Layout::from_size_align(self.size as usize, self.align as usize).ok() + } +} + +impl CudaDisplay for FunctionArgInfo { + fn write( + &self, + _fn_name: &'static str, + _index: usize, + writer: &mut (impl std::io::Write + ?Sized), + ) -> std::io::Result<()> { + writer.write_all(b"{ size: ")?; + CudaDisplay::write(&self.size, "", 0, writer)?; + writer.write_all(b", align: ")?; + CudaDisplay::write(&self.align, "", 0, writer)?; + writer.write_all(b" }") + } +} + +// Purely for internal use by ZLUDA32 +dark_api! { + zluda32; + "{EE376A1B-B858-42EB-A52D-9A106D50D914}" => ZLUDA32_INTERNAL[2] { + [0] = get_module_globals( + names: *mut *mut u8, + initializers: *mut *const u8, + sizes: *mut u32, + alignments: *mut u32, + count: *mut u32, + module: cuda_types::cuda::CUmodule + ) -> cuda_types::cuda::CUresult, + [1] = get_function_info( + explicit_arguments: *mut crate::FunctionArgInfo, + explicit_argument_count: *mut u32, + func: cuda_types::cuda::CUfunction + ) -> cuda_types::cuda::CUresult + } +} + #[repr(C)] pub struct ByteVecFfi { ptr: *mut u8, diff --git a/kernel_metadata/src/lib.rs b/kernel_metadata/src/lib.rs index d4db9baf3..40b817141 100644 --- a/kernel_metadata/src/lib.rs +++ b/kernel_metadata/src/lib.rs @@ -43,7 +43,7 @@ pub struct Global32Bit { #[derive(Archive, Serialize, Deserialize, Debug)] pub struct ModuleMetadata32Bit { pub globals: Vec, - pub explicit_arg_count: Vec<(String, u32)>, + pub explicit_args_size_align: Vec<(String, Vec<(u32, u32)>)>, } // If the alignment is larger than u64, then we need different padding diff --git a/nvapi/Cargo.toml b/nvapi/Cargo.toml new file mode 100644 index 000000000..a3699b162 --- /dev/null +++ b/nvapi/Cargo.toml @@ -0,0 +1,26 @@ +[package] +name = "nvapi" +version = "0.0.0" +authors = ["Andrzej Janik "] +edition = "2021" + +[lib] +name = "nvapi64" +crate-type = ["cdylib"] + +[dependencies] +format = { path = "../format" } +dark_api = { path = "../dark_api" } +cuda_macros = { path = "../cuda_macros" } +cuda_types = { path = "../cuda_types" } +zluda_trace_common = { path = "../zluda_trace_common" } +libloading = "0.8" +paste = "1.0" +unwrap_or = "1.0.1" +cglue = "0.3.5" +rustc-hash = "2.0.0" + +[package.metadata.zluda] +windows_only = true +windows32_paths = ["nvapi.dll"] +32bit = true diff --git a/nvapi/src/lib.rs b/nvapi/src/lib.rs new file mode 100644 index 000000000..a44cd3582 --- /dev/null +++ b/nvapi/src/lib.rs @@ -0,0 +1,726 @@ +use crate::nvapi::*; +use libloading::Library; +use rustc_hash::FxHashMap; +use std::{ + collections::hash_map, + ffi::c_void, + mem, ptr, + sync::{LazyLock, Mutex}, +}; + +#[allow(warnings)] +mod nvapi; + +macro_rules! interface_to_name { + ($({ $name:ident, $id:literal }),* $(,)?) => { + fn interface_to_fn(interface: u32) -> Option<*mut c_void> { + match interface { + $( + $id => Some($name as *mut c_void), + )* + _ => None, + } + } + }; +} + +interface_to_name!( + { NvAPI_Initialize, 0x0150e828 }, + { NvAPI_Unload, 0xd22bdd7e }, + // { NvAPI_GetErrorMessage, 0x6c2d048c }, + // { NvAPI_GetInterfaceVersionString, 0x01053fa5 }, + // { NvAPI_GPU_GetEDID, 0x37d32e69 }, + // { NvAPI_SetView, 0x0957d7b6 }, + // { NvAPI_SetViewEx, 0x06b89e68 }, + { NvAPI_GetDisplayDriverVersion, 0xf951a4d1 }, + { NvAPI_SYS_GetDriverAndBranchVersion, 0x2926aaad }, + // { NvAPI_GPU_GetMemoryInfo, 0x07f9b368 }, + // { NvAPI_GPU_GetMemoryInfoEx, 0xc0599498 }, + // { NvAPI_OGL_ExpertModeSet, 0x3805ef7a }, + // { NvAPI_OGL_ExpertModeGet, 0x22ed9516 }, + // { NvAPI_OGL_ExpertModeDefaultsSet, 0xb47a657e }, + // { NvAPI_OGL_ExpertModeDefaultsGet, 0xae921f12 }, + // { NvAPI_EnumPhysicalGPUs, 0xe5ac921f }, + // { NvAPI_EnumTCCPhysicalGPUs, 0xd9930b07 }, + // { NvAPI_EnumLogicalGPUs, 0x48b3ea59 }, + // { NvAPI_GetPhysicalGPUsFromDisplay, 0x34ef9506 }, + // { NvAPI_GetPhysicalGPUFromUnAttachedDisplay, 0x5018ed61 }, + // { NvAPI_GetLogicalGPUFromDisplay, 0xee1370cf }, + // { NvAPI_GetLogicalGPUFromPhysicalGPU, 0xadd604d1 }, + // { NvAPI_GetPhysicalGPUsFromLogicalGPU, 0xaea3fa32 }, + { NvAPI_GetPhysicalGPUFromGPUID, 0x5380ad1a }, + { NvAPI_GetGPUIDfromPhysicalGPU, 0x6533ea3e }, + // { NvAPI_GPU_GetShaderSubPipeCount, 0x0be17923 }, + // { NvAPI_GPU_GetGpuCoreCount, 0xc7026a87 }, + // { NvAPI_GPU_GetAllOutputs, 0x7d554f8e }, + // { NvAPI_GPU_GetConnectedOutputs, 0x1730bfc9 }, + // { NvAPI_GPU_GetConnectedSLIOutputs, 0x0680de09 }, + // { NvAPI_GPU_GetConnectedDisplayIds, 0x0078dba2 }, + // { NvAPI_GPU_GetAllDisplayIds, 0x785210a2 }, + // { NvAPI_GPU_GetConnectedOutputsWithLidState, 0xcf8caf39 }, + // { NvAPI_GPU_GetConnectedSLIOutputsWithLidState, 0x96043cc7 }, + // { NvAPI_GPU_GetSystemType, 0xbaaabfcc }, + // { NvAPI_GPU_GetActiveOutputs, 0xe3e89b6f }, + // { NvAPI_GPU_SetEDID, 0xe83d6456 }, + // { NvAPI_GPU_GetOutputType, 0x40a505e4 }, + // { NvAPI_GPU_ValidateOutputCombination, 0x34c9c2d4 }, + // { NvAPI_GPU_GetFullName, 0xceee8e9f }, + // { NvAPI_GPU_GetPCIIdentifiers, 0x2ddfb66e }, + // { NvAPI_GPU_GetGPUType, 0xc33baeb1 }, + // { NvAPI_GPU_GetBusType, 0x1bb18724 }, + // { NvAPI_GPU_GetBusId, 0x1be0b8e5 }, + // { NvAPI_GPU_GetBusSlotId, 0x2a0a350f }, + // { NvAPI_GPU_GetIRQ, 0xe4715417 }, + // { NvAPI_GPU_GetVbiosRevision, 0xacc3da0a }, + // { NvAPI_GPU_GetVbiosOEMRevision, 0x2d43fb31 }, + // { NvAPI_GPU_GetVbiosVersionString, 0xa561fd7d }, + // { NvAPI_GPU_GetAGPAperture, 0x6e042794 }, + // { NvAPI_GPU_GetCurrentAGPRate, 0xc74925a0 }, + // { NvAPI_GPU_GetCurrentPCIEDownstreamWidth, 0xd048c3b1 }, + // { NvAPI_GPU_GetPhysicalFrameBufferSize, 0x46fbeb03 }, + // { NvAPI_GPU_GetVirtualFrameBufferSize, 0x5a04b644 }, + // { NvAPI_GPU_GetQuadroStatus, 0xe332fa47 }, + // { NvAPI_GPU_GetBoardInfo, 0x22d54523 }, + // { NvAPI_GPU_GetRamBusWidth, 0x7975c581 }, + // { NvAPI_GPU_GetArchInfo, 0xd8265d24 }, + // { NvAPI_I2CRead, 0x2fde12c5 }, + // { NvAPI_I2CWrite, 0xe812eb07 }, + // { NvAPI_GPU_WorkstationFeatureSetup, 0x6c1f3fe4 }, + // { NvAPI_GPU_WorkstationFeatureQuery, 0x004537df }, + // { NvAPI_GPU_GetHDCPSupportStatus, 0xf089eef5 }, + { NvAPI_GPU_CudaEnumComputeCapableGpus, 0x5786cc6e }, + // { NvAPI_GPU_GetTachReading, 0x5f608315 }, + // { NvAPI_GPU_GetECCStatusInfo, 0xca1ddaf3 }, + // { NvAPI_GPU_GetECCErrorInfo, 0xc71f85a6 }, + // { NvAPI_GPU_ResetECCErrorInfo, 0xc02eec20 }, + // { NvAPI_GPU_GetECCConfigurationInfo, 0x77a796f3 }, + // { NvAPI_GPU_SetECCConfiguration, 0x1cf639d9 }, + // { NvAPI_GPU_QueryWorkstationFeatureSupport, 0x80b1abb9 }, + // { NvAPI_GPU_SetScanoutIntensity, 0xa57457a4 }, + // { NvAPI_GPU_GetScanoutIntensityState, 0xe81ce836 }, + // { NvAPI_GPU_SetScanoutWarping, 0xb34bab4f }, + // { NvAPI_GPU_GetScanoutWarpingState, 0x6f5435af }, + // { NvAPI_GPU_SetScanoutCompositionParameter, 0xf898247d }, + // { NvAPI_GPU_GetScanoutCompositionParameter, 0x58fe51e6 }, + // { NvAPI_GPU_GetScanoutConfiguration, 0x6a9f5b63 }, + // { NvAPI_GPU_GetScanoutConfigurationEx, 0xe2e1e6f0 }, + // { NvAPI_GPU_GetAdapterIdFromPhysicalGpu, 0x0ff07fde }, + // { NvAPI_GPU_GetVirtualizationInfo, 0x44e022a9 }, + // { NvAPI_GPU_GetLogicalGpuInfo, 0x842b066e }, + // { NvAPI_GPU_GetLicensableFeatures, 0x3fc596aa }, + // { NvAPI_GPU_GetEncoderStatistics, 0xf0a9aeeb }, + // { NvAPI_GPU_GetEncoderSessionsInfo, 0xd8a72ce5 }, + // { NvAPI_GPU_GetGPUInfo, 0xafd1b02c }, + // { NvAPI_GPU_GetVRReadyData, 0x81d629c5 }, + // { NvAPI_GPU_GetGspFeatures, 0x581c4391 }, + // { NvAPI_GPU_GetUUID, 0xdc95673d }, + // { NvAPI_GPU_NVLINK_GetCaps, 0xbef1119d }, + // { NvAPI_GPU_NVLINK_GetStatus, 0xc72a38e3 }, + // { NvAPI_GPU_GetPerfDecreaseInfo, 0x7f7f4600 }, + // { NvAPI_GPU_GetPstatesInfoEx, 0x843c0256 }, + // { NvAPI_GPU_GetPstates20, 0x6ff81213 }, + // { NvAPI_GPU_GetCurrentPstate, 0x927da4f6 }, + // { NvAPI_GPU_GetDynamicPstatesInfoEx, 0x60ded2ed }, + // { NvAPI_GPU_GetThermalSettings, 0xe3640a56 }, + // { NvAPI_GPU_GetAllClockFrequencies, 0xdcb616c3 }, + // { NvAPI_GPU_QueryIlluminationSupport, 0xa629da31 }, + // { NvAPI_GPU_GetIllumination, 0x9a1b9365 }, + // { NvAPI_GPU_SetIllumination, 0x0254a187 }, + // { NvAPI_GPU_ClientIllumDevicesGetInfo, 0xd4100e58 }, + // { NvAPI_GPU_ClientIllumDevicesGetControl, 0x73c01d58 }, + // { NvAPI_GPU_ClientIllumDevicesSetControl, 0x57024c62 }, + // { NvAPI_GPU_ClientIllumZonesGetInfo, 0x4b81241b }, + // { NvAPI_GPU_ClientIllumZonesGetControl, 0x3dbf5764 }, + // { NvAPI_GPU_ClientIllumZonesSetControl, 0x197d065e }, + // { NvAPI_Event_RegisterCallback, 0xe6dbea69 }, + // { NvAPI_Event_UnregisterCallback, 0xde1f9b45 }, + // { NvAPI_EnumNvidiaDisplayHandle, 0x9abdd40d }, + // { NvAPI_EnumNvidiaUnAttachedDisplayHandle, 0x20de9260 }, + // { NvAPI_CreateDisplayFromUnAttachedDisplay, 0x63f9799e }, + // { NvAPI_GetAssociatedNvidiaDisplayHandle, 0x35c29134 }, + // { NvAPI_DISP_GetAssociatedUnAttachedNvidiaDisplayHandle, 0xa70503b2 }, + // { NvAPI_GetAssociatedNvidiaDisplayName, 0x22a78b05 }, + // { NvAPI_GetUnAttachedAssociatedDisplayName, 0x4888d790 }, + // { NvAPI_EnableHWCursor, 0x2863148d }, + // { NvAPI_DisableHWCursor, 0xab163097 }, + // { NvAPI_GetVBlankCounter, 0x67b5db55 }, + // { NvAPI_SetRefreshRateOverride, 0x3092ac32 }, + // { NvAPI_GetAssociatedDisplayOutputId, 0xd995937e }, + // { NvAPI_GetDisplayPortInfo, 0xc64ff367 }, + // { NvAPI_SetDisplayPort, 0xfa13e65a }, + // { NvAPI_GetHDMISupportInfo, 0x6ae16ec3 }, + // { NvAPI_Disp_InfoFrameControl, 0x6067af3f }, + // { NvAPI_Disp_ColorControl, 0x92f9d80d }, + // { NvAPI_Disp_GetHdrCapabilities, 0x84f2a8df }, + // { NvAPI_Disp_HdrColorControl, 0x351da224 }, + // { NvAPI_Disp_SetSourceColorSpace, 0x473b6caf }, + // { NvAPI_Disp_GetSourceColorSpace, 0xceedc85b }, + // { NvAPI_Disp_SetSourceHdrMetadata, 0x905eb63b }, + // { NvAPI_Disp_GetSourceHdrMetadata, 0x0d3f52da }, + // { NvAPI_Disp_SetOutputMode, 0x98e7661a }, + // { NvAPI_Disp_GetOutputMode, 0x81fed88d }, + // { NvAPI_Disp_SetHdrToneMapping, 0xdd6da362 }, + // { NvAPI_Disp_GetHdrToneMapping, 0xfbd36e71 }, + // { NvAPI_Disp_GetColorimetry, 0x00b421ad }, + // { NvAPI_DISP_GetTiming, 0x175167e9 }, + // { NvAPI_DISP_GetMonitorCapabilities, 0x3b05c7e1 }, + // { NvAPI_DISP_GetMonitorColorCapabilities, 0x6ae4cfb5 }, + // { NvAPI_DISP_EnumCustomDisplay, 0xa2072d59 }, + // { NvAPI_DISP_TryCustomDisplay, 0x1f7db630 }, + // { NvAPI_DISP_DeleteCustomDisplay, 0x552e5b9b }, + // { NvAPI_DISP_SaveCustomDisplay, 0x49882876 }, + // { NvAPI_DISP_RevertCustomDisplayTrial, 0xcbbd40f0 }, + // { NvAPI_GetView, 0xd6b99d89 }, + // { NvAPI_GetViewEx, 0xdbbc0af4 }, + // { NvAPI_GetSupportedViews, 0x66fb7fc0 }, + // { NvAPI_DISP_GetDisplayIdByDisplayName, 0xae457190 }, + // { NvAPI_DISP_GetGDIPrimaryDisplayId, 0x1e9d8a31 }, + // { NvAPI_DISP_GetDisplayConfig, 0x11abccf8 }, + // { NvAPI_DISP_SetDisplayConfig, 0x5d8cf8de }, + // { NvAPI_DISP_GetEdidData, 0x436ced76 }, + // { NvAPI_DISP_GetAdaptiveSyncData, 0xb73d1ee9 }, + // { NvAPI_DISP_SetAdaptiveSyncData, 0x3eebba1d }, + // { NvAPI_DISP_GetVirtualRefreshRateData, 0x8c00429a }, + // { NvAPI_DISP_SetVirtualRefreshRateData, 0x5abbe6a3 }, + // { NvAPI_DISP_SetPreferredStereoDisplay, 0xc9d0e25f }, + // { NvAPI_DISP_GetPreferredStereoDisplay, 0x1f6b4666 }, + // { NvAPI_DISP_GetNvManagedDedicatedDisplays, 0xdbdf0cb2 }, + // { NvAPI_DISP_AcquireDedicatedDisplay, 0x47c917ba }, + // { NvAPI_DISP_ReleaseDedicatedDisplay, 0x1247825f }, + // { NvAPI_DISP_GetNvManagedDedicatedDisplayMetadata, 0xd645d80c }, + // { NvAPI_DISP_SetNvManagedDedicatedDisplayMetadata, 0x3d8b129a }, + // { NvAPI_Disp_GetDisplayIdInfo, 0xbae8aa5e }, + // { NvAPI_Disp_GetDisplayIdsFromTarget, 0xe7e5f89e }, + // { NvAPI_Disp_GetVRRInfo, 0xdf8fda57 }, + // { NvAPI_Mosaic_GetSupportedTopoInfo, 0xfdb63c81 }, + // { NvAPI_Mosaic_GetTopoGroup, 0xcb89381d }, + // { NvAPI_Mosaic_GetOverlapLimits, 0x989685f0 }, + // { NvAPI_Mosaic_SetCurrentTopo, 0x9b542831 }, + // { NvAPI_Mosaic_GetCurrentTopo, 0xec32944e }, + // { NvAPI_Mosaic_EnableCurrentTopo, 0x5f1aa66c }, + // { NvAPI_Mosaic_GetDisplayViewportsByResolution, 0xdc6dc8d3 }, + // { NvAPI_Mosaic_SetDisplayGrids, 0x4d959a89 }, + // { NvAPI_Mosaic_ValidateDisplayGrids, 0xcf43903d }, + // { NvAPI_Mosaic_EnumDisplayModes, 0x78db97d7 }, + // { NvAPI_Mosaic_EnumDisplayGrids, 0xdf2887af }, + // { NvAPI_GetSupportedMosaicTopologies, 0x410b5c25 }, + // { NvAPI_GetCurrentMosaicTopology, 0xf60852bd }, + // { NvAPI_SetCurrentMosaicTopology, 0xd54b8989 }, + // { NvAPI_EnableCurrentMosaicTopology, 0x74073cc9 }, + // { NvAPI_GSync_EnumSyncDevices, 0xd9639601 }, + // { NvAPI_GSync_QueryCapabilities, 0x44a3f1d1 }, + // { NvAPI_GSync_GetTopology, 0x4562bc38 }, + // { NvAPI_GSync_SetSyncStateSettings, 0x60acdfdd }, + // { NvAPI_GSync_GetControlParameters, 0x16de1c6a }, + // { NvAPI_GSync_SetControlParameters, 0x8bbff88b }, + // { NvAPI_GSync_AdjustSyncDelay, 0x2d11ff51 }, + // { NvAPI_GSync_GetSyncStatus, 0xf1f5b434 }, + // { NvAPI_GSync_GetStatusParameters, 0x70d404ec }, + // { NvAPI_D3D_GetCurrentSLIState, 0x4b708b54 }, + // { NvAPI_D3D9_RegisterResource, 0xa064bdfc }, + // { NvAPI_D3D9_UnregisterResource, 0xbb2b17aa }, + // { NvAPI_D3D9_AliasSurfaceAsTexture, 0xe5ceae41 }, + // { NvAPI_D3D9_StretchRectEx, 0x22de03aa }, + // { NvAPI_D3D9_ClearRT, 0x332d3942 }, + // { NvAPI_D3D_GetObjectHandleForResource, 0xfceac864 }, + // { NvAPI_D3D_SetResourceHint, 0x6c0ed98c }, + // { NvAPI_D3D_BeginResourceRendering, 0x91123d6a }, + // { NvAPI_D3D_EndResourceRendering, 0x37e7191c }, + // { NvAPI_D3D9_GetSurfaceHandle, 0x0f2dd3f2 }, + // { NvAPI_D3D9_VideoSetStereoInfo, 0xb852f4db }, + // { NvAPI_D3D10_SetDepthBoundsTest, 0x4eadf5d2 }, + // { NvAPI_D3D11_CreateDevice, 0x6a16d3a0 }, + // { NvAPI_D3D11_CreateDeviceAndSwapChain, 0xbb939ee5 }, + // { NvAPI_D3D11_SetDepthBoundsTest, 0x7aaf7a04 }, + // { NvAPI_D3D11_IsNvShaderExtnOpCodeSupported, 0x5f68da40 }, + // { NvAPI_D3D11_SetNvShaderExtnSlot, 0x8e90bb9f }, + // { NvAPI_D3D12_SetNvShaderExtnSlotSpace, 0xac2dfeb5 }, + // { NvAPI_D3D12_SetNvShaderExtnSlotSpaceLocalThread, 0x43d867c0 }, + // { NvAPI_D3D11_SetNvShaderExtnSlotLocalThread, 0x0e6482a0 }, + // { NvAPI_D3D11_BeginUAVOverlapEx, 0xba08208a }, + // { NvAPI_D3D11_BeginUAVOverlap, 0x65b93ca8 }, + // { NvAPI_D3D11_EndUAVOverlap, 0x2216a357 }, + // { NvAPI_D3D11_GetResourceHandle, 0x09d52986 }, + // { NvAPI_D3D_SetFPSIndicatorState, 0xa776e8db }, + // { NvAPI_D3D9_Present, 0x05650beb }, + // { NvAPI_D3D9_QueryFrameCount, 0x9083e53a }, + // { NvAPI_D3D9_ResetFrameCount, 0xfa6a0675 }, + // { NvAPI_D3D9_QueryMaxSwapGroup, 0x5995410d }, + // { NvAPI_D3D9_QuerySwapGroup, 0xeba4d232 }, + // { NvAPI_D3D9_JoinSwapGroup, 0x7d44bb54 }, + // { NvAPI_D3D9_BindSwapBarrier, 0x9c39c246 }, + // { NvAPI_D3D_SetVerticalSyncMode, 0x5526cfd1 }, + // { NvAPI_D3D1x_Present, 0x03b845a1 }, + // { NvAPI_D3D1x_QueryFrameCount, 0x9152e055 }, + // { NvAPI_D3D1x_ResetFrameCount, 0xfbbb031a }, + // { NvAPI_D3D1x_QueryMaxSwapGroup, 0x9bb9d68f }, + // { NvAPI_D3D1x_QuerySwapGroup, 0x407f67aa }, + // { NvAPI_D3D1x_JoinSwapGroup, 0x14610cd7 }, + // { NvAPI_D3D1x_BindSwapBarrier, 0x9de8c729 }, + // { NvAPI_D3D12_QueryPresentBarrierSupport, 0xa15faef7 }, + // { NvAPI_D3D12_CreatePresentBarrierClient, 0x4d815de9 }, + // { NvAPI_D3D12_RegisterPresentBarrierResources, 0xd53c9ef0 }, + // { NvAPI_DestroyPresentBarrierClient, 0x3c5c351b }, + // { NvAPI_JoinPresentBarrier, 0x17f6bf82 }, + // { NvAPI_LeavePresentBarrier, 0xc3ec5a7f }, + // { NvAPI_QueryPresentBarrierFrameStatistics, 0x61b844a1 }, + // { NvAPI_D3D12_CreateDDisplayPresentBarrierClient, 0xb5a21987 }, + // { NvAPI_D3D11_CreateRasterizerState, 0xdb8d28af }, + // { NvAPI_D3D_ConfigureAnsel, 0x341c6c7f }, + // { NvAPI_D3D11_CreateTiledTexture2DArray, 0x7886981a }, + // { NvAPI_D3D11_CheckFeatureSupport, 0x106a487e }, + // { NvAPI_D3D11_CreateImplicitMSAATexture2D, 0xb8f79632 }, + // { NvAPI_D3D12_CreateCommittedImplicitMSAATexture2D, 0x24c6a07b }, + // { NvAPI_D3D11_ResolveSubresourceRegion, 0xe6bfedd6 }, + // { NvAPI_D3D12_ResolveSubresourceRegion, 0xc24a15bf }, + // { NvAPI_D3D11_TiledTexture2DArrayGetDesc, 0xf1a2b9d5 }, + // { NvAPI_D3D11_UpdateTileMappings, 0x9a06ea07 }, + // { NvAPI_D3D11_CopyTileMappings, 0xc09ee6bc }, + // { NvAPI_D3D11_TiledResourceBarrier, 0xd6839099 }, + // { NvAPI_D3D11_AliasMSAATexture2DAsNonMSAA, 0xf1c54fc9 }, + // { NvAPI_D3D11_CreateGeometryShaderEx_2, 0x99ed5c1c }, + // { NvAPI_D3D11_CreateVertexShaderEx, 0x0beaa0b2 }, + // { NvAPI_D3D11_CreateHullShaderEx, 0xb53cab00 }, + // { NvAPI_D3D11_CreateDomainShaderEx, 0xa0d7180d }, + // { NvAPI_D3D11_CreatePixelShaderEx_2, 0x4162822b }, + // { NvAPI_D3D11_CreateFastGeometryShaderExplicit, 0x71ab7c9c }, + // { NvAPI_D3D11_CreateFastGeometryShader, 0x525d43be }, + // { NvAPI_D3D11_DecompressView, 0x3a94e822 }, + // { NvAPI_D3D12_CreateGraphicsPipelineState, 0x2fc28856 }, + // { NvAPI_D3D12_CreateComputePipelineState, 0x2762deac }, + // { NvAPI_D3D12_SetDepthBoundsTestValues, 0xb9333fe9 }, + // { NvAPI_D3D12_CreateReservedResource, 0x2c85f101 }, + // { NvAPI_D3D12_CreateHeap, 0x5cb397cf }, + // { NvAPI_D3D12_CreateHeap2, 0x924be9d6 }, + // { NvAPI_D3D12_QueryCpuVisibleVidmem, 0x26322bc3 }, + // { NvAPI_D3D12_ReservedResourceGetDesc, 0x9aa2aabb }, + // { NvAPI_D3D12_UpdateTileMappings, 0xc6017a7d }, + // { NvAPI_D3D12_CopyTileMappings, 0x47f78194 }, + // { NvAPI_D3D12_ResourceAliasingBarrier, 0xb942bab7 }, + // { NvAPI_D3D12_CaptureUAVInfo, 0x6e5ea9db }, + // { NvAPI_D3D11_GetResourceGPUVirtualAddressEx, 0xaf6d14da }, + // { NvAPI_D3D11_EnumerateMetaCommands, 0xc7453ba8 }, + // { NvAPI_D3D11_CreateMetaCommand, 0xf505fba0 }, + // { NvAPI_D3D11_InitializeMetaCommand, 0xaec629e9 }, + // { NvAPI_D3D11_ExecuteMetaCommand, 0x82236c47 }, + // { NvAPI_D3D12_EnumerateMetaCommands, 0xcd9141d8 }, + // { NvAPI_D3D12_CreateMetaCommand, 0xeb29634b }, + // { NvAPI_D3D12_InitializeMetaCommand, 0xa4125399 }, + // { NvAPI_D3D12_ExecuteMetaCommand, 0xde24fc3d }, + // { NvAPI_D3D12_CreateCommittedResource, 0x027e98ae }, + // { NvAPI_D3D12_GetCopyableFootprints, 0xf6305eb5 }, + // { NvAPI_D3D12_CopyTextureRegion, 0x82b91b25 }, + // { NvAPI_D3D12_IsNvShaderExtnOpCodeSupported, 0x3dfacec8 }, + // { NvAPI_D3D12_GetOptimalThreadCountForMesh, 0xb43995cb }, + // { NvAPI_D3D_IsGSyncCapable, 0x9c1eed78 }, + // { NvAPI_D3D_IsGSyncActive, 0xe942b0ff }, + // { NvAPI_D3D12_SetFlipConfig, 0xf3148c42 }, + // { NvAPI_D3D1x_DisableShaderDiskCache, 0xd0cbca7d }, + // { NvAPI_D3D11_MultiGPU_GetCaps, 0xd2d25687 }, + // { NvAPI_D3D11_MultiGPU_Init, 0x017be49e }, + // { NvAPI_D3D11_CreateMultiGPUDevice, 0xbdb20007 }, + // { NvAPI_D3D_QuerySinglePassStereoSupport, 0x6f5f0a6d }, + // { NvAPI_D3D_SetSinglePassStereoMode, 0xa39e6e6e }, + // { NvAPI_D3D12_QuerySinglePassStereoSupport, 0x3b03791b }, + // { NvAPI_D3D12_SetSinglePassStereoMode, 0x83556d87 }, + // { NvAPI_D3D_QueryMultiViewSupport, 0xb6e0a41c }, + // { NvAPI_D3D_SetMultiViewMode, 0x8285c8da }, + // { NvAPI_D3D_QueryModifiedWSupport, 0xcbf9f4f5 }, + // { NvAPI_D3D_SetModifiedWMode, 0x06ea4bf4 }, + // { NvAPI_D3D12_QueryModifiedWSupport, 0x51235248 }, + // { NvAPI_D3D12_SetModifiedWMode, 0xe1fdaba7 }, + // { NvAPI_D3D_CreateLateLatchObject, 0x2db27d09 }, + // { NvAPI_D3D_QueryLateLatchSupport, 0x8ceca0ec }, + // { NvAPI_D3D_RegisterDevice, 0x8c02c4d0 }, + // { NvAPI_D3D11_MultiDrawInstancedIndirect, 0xd4e26bbf }, + // { NvAPI_D3D11_MultiDrawIndexedInstancedIndirect, 0x59e890f9 }, + // { NvAPI_D3D_ImplicitSLIControl, 0x2aede111 }, + // { NvAPI_D3D12_GetNeedsAppFPBlendClamping, 0x6ef4d2d1 }, + // { NvAPI_D3D12_UseDriverHeapPriorities, 0xf0d978a8 }, + // { NvAPI_D3D12_Mosaic_GetCompanionAllocations, 0xa46022c7 }, + // { NvAPI_D3D12_Mosaic_GetViewportAndGpuPartitions, 0xb092b818 }, + // { NvAPI_D3D1x_GetGraphicsCapabilities, 0x52b1499a }, + // { NvAPI_D3D12_GetGraphicsCapabilities, 0x01e87354 }, + // { NvAPI_D3D11_RSSetExclusiveScissorRects, 0xae4d73ef }, + // { NvAPI_D3D11_RSSetViewportsPixelShadingRates, 0x34f7938f }, + // { NvAPI_D3D11_CreateShadingRateResourceView, 0x99ca2dff }, + // { NvAPI_D3D11_RSSetShadingRateResourceView, 0x1b0c2f83 }, + // { NvAPI_D3D11_RSGetPixelShadingRateSampleOrder, 0x092442a1 }, + // { NvAPI_D3D11_RSSetPixelShadingRateSampleOrder, 0xa942373a }, + // { NvAPI_D3D_InitializeVRSHelper, 0x4780d70b }, + // { NvAPI_D3D_InitializeNvGazeHandler, 0x5b3b7479 }, + // { NvAPI_D3D_InitializeSMPAssist, 0x42763d0c }, + // { NvAPI_D3D_QuerySMPAssistSupport, 0xc57921de }, + // { NvAPI_D3D_GetSleepStatus, 0xaef96ca1 }, + // { NvAPI_D3D_SetSleepMode, 0xac1ca9e0 }, + // { NvAPI_D3D_Sleep, 0x852cd1d2 }, + // { NvAPI_D3D_SetReflexSync, 0xb9f6faff }, + // { NvAPI_D3D_GetLatency, 0x1a587f9c }, + // { NvAPI_D3D_SetLatencyMarker, 0xd9984c05 }, + // { NvAPI_D3D12_SetAsyncFrameMarker, 0x13c98f73 }, + // { NvAPI_D3D11_SetAsyncFrameMarker, 0x59c2c510 }, + // { NvAPI_D3D12_NotifyOutOfBandCommandQueue, 0x03d6e8cb }, + // { NvAPI_D3D12_SetCreateCommandQueueLowLatencyHint, 0x548c224f }, + // { NvAPI_D3D12_CreateCubinComputeShaderExV2, 0x299f5fdc }, + // { NvAPI_D3D12_CreateCubinComputeShader, 0x2a2c79e8 }, + // { NvAPI_D3D12_CreateCubinComputeShaderEx, 0x3151211b }, + // { NvAPI_D3D12_CreateCubinComputeShaderWithName, 0x1dc7261f }, + // { NvAPI_D3D12_LaunchCubinShader, 0x5c52bb86 }, + // { NvAPI_D3D12_DestroyCubinComputeShader, 0x7fb785ba }, + // { NvAPI_D3D12_GetCudaMergedTextureSamplerObject, 0x329fe6e0 }, + // { NvAPI_D3D12_GetCudaIndependentDescriptorObject, 0x0ddac234 }, + // { NvAPI_D3D12_GetCudaTextureObject, 0x80403fc9 }, + // { NvAPI_D3D12_GetCudaSurfaceObject, 0x48f5b2ee }, + // { NvAPI_D3D12_IsFatbinPTXSupported, 0x70c07832 }, + // { NvAPI_D3D12_CreateCuModule, 0xad1a677d }, + // { NvAPI_D3D12_EnumFunctionsInModule, 0x7ab88d88 }, + // { NvAPI_D3D12_CreateCuFunction, 0xe2436e22 }, + // { NvAPI_D3D12_LaunchCuKernelChain, 0x24973538 }, + // { NvAPI_D3D12_LaunchCuKernelChainEx, 0x846a9bf0 }, + // { NvAPI_D3D12_DestroyCuModule, 0x41c65285 }, + // { NvAPI_D3D12_DestroyCuFunction, 0xdf295ea6 }, + // { NvAPI_D3D11_CreateCubinComputeShaderExV2, 0xf2c71d48 }, + // { NvAPI_D3D11_CreateCubinComputeShader, 0x0ed98181 }, + // { NvAPI_D3D11_CreateCubinComputeShaderEx, 0x32c2a0f6 }, + // { NvAPI_D3D11_CreateCubinComputeShaderWithName, 0xb672be19 }, + // { NvAPI_D3D11_LaunchCubinShader, 0x427e236d }, + // { NvAPI_D3D11_DestroyCubinComputeShader, 0x01682c86 }, + // { NvAPI_D3D11_IsFatbinPTXSupported, 0x6086bd93 }, + // { NvAPI_D3D11_GetCudaIndependentViewObject, 0x34d2afa8 }, + // { NvAPI_D3D11_GetCudaMergedTextureSamplerObject, 0x5d637d8f }, + // { NvAPI_D3D11_CreateUnorderedAccessView, 0x74a497a1 }, + // { NvAPI_D3D11_CreateShaderResourceView, 0x65cb431e }, + // { NvAPI_D3D11_CreateSamplerState, 0x89eca416 }, + // { NvAPI_D3D11_GetCudaTextureObject, 0x9006fa68 }, + // { NvAPI_D3D11_GetResourceGPUVirtualAddress, 0x1819b423 }, + // { NvAPI_D3D12_GetRaytracingCaps, 0x85a6c2a0 }, + // { NvAPI_D3D12_EnableRaytracingValidation, 0x1de5991b }, + // { NvAPI_D3D12_RegisterRaytracingValidationMessageCallback, 0x8554eb38 }, + // { NvAPI_D3D12_UnregisterRaytracingValidationMessageCallback, 0x26975da6 }, + // { NvAPI_D3D12_FlushRaytracingValidationMessages, 0xb8fb1fcb }, + // { NvAPI_D3D12_GetRaytracingDisplacementMicromapArrayPrebuildInfo, 0xfa99b6de }, + // { NvAPI_D3D12_GetRaytracingOpacityMicromapArrayPrebuildInfo, 0x4726d180 }, + // { NvAPI_D3D12_SetCreatePipelineStateOptions, 0x5c607a27 }, + // { NvAPI_D3D12_CheckDriverMatchingIdentifierEx, 0xafb237d4 }, + // { NvAPI_D3D12_GetRaytracingAccelerationStructurePrebuildInfoEx, 0x8d025b77 }, + // { NvAPI_D3D12_BuildRaytracingOpacityMicromapArray, 0x814f8d11 }, + // { NvAPI_D3D12_RelocateRaytracingOpacityMicromapArray, 0x0425c538 }, + // { NvAPI_D3D12_BuildRaytracingDisplacementMicromapArray, 0x066f569d }, + // { NvAPI_D3D12_RelocateRaytracingDisplacementMicromapArray, 0x1c142308 }, + // { NvAPI_D3D12_EmitRaytracingDisplacementMicromapArrayPostbuildInfo, 0x68b9a790 }, + // { NvAPI_D3D12_EmitRaytracingOpacityMicromapArrayPostbuildInfo, 0x1d9a39b6 }, + // { NvAPI_D3D12_BuildRaytracingAccelerationStructureEx, 0xe24ead45 }, + // { NvAPI_D3D12_QueryWorkstationFeatureProperties, 0xa92ea23a }, + // { NvAPI_D3D12_CreateCommittedRDMABuffer, 0xe78dcb44 }, + // { NvAPI_D3D12_ConvertCooperativeVectorMatrix, 0x0f252cb3 }, + // { NvAPI_D3D12_ConvertCooperativeVectorMatrixMultiple, 0x96ba5235 }, + // { NvAPI_D3D12_GetPhysicalDeviceCooperativeVectorProperties, 0x8f182aec }, + // { NvAPI_D3D12_GetRaytracingMultiIndirectClusterOperationRequirementsInfo, 0x5c9163f4 }, + // { NvAPI_D3D12_RaytracingExecuteMultiIndirectClusterOperation, 0x67c798af }, + // { NvAPI_D3D12_GetRaytracingPartitionedTlasIndirectPrebuildInfo, 0xcdfdc5f2 }, + // { NvAPI_D3D12_BuildRaytracingPartitionedTlasIndirect, 0x7cfc6fc3 }, + // { NvAPI_NGX_GetNGXOverrideState, 0x3fd96fba }, + // { NvAPI_NGX_SetNGXOverrideState, 0xb60fcb4e }, + // { NvAPI_DirectD3D12GraphicsCommandList_Create, 0x74a4e712 }, + // { NvAPI_DirectD3D12GraphicsCommandList_Release, 0x99da3dde }, + // { NvAPI_DirectD3D12GraphicsCommandList_Reset, 0x999c26d8 }, + // { NvAPI_VIO_GetCapabilities, 0x1dc91303 }, + // { NvAPI_VIO_Open, 0x44ee4841 }, + // { NvAPI_VIO_Close, 0xd01bd237 }, + // { NvAPI_VIO_Status, 0x0e6ce4f1 }, + // { NvAPI_VIO_SyncFormatDetect, 0x118d48a3 }, + // { NvAPI_VIO_GetConfig, 0xd34a789b }, + // { NvAPI_VIO_SetConfig, 0x0e4eec07 }, + // { NvAPI_VIO_SetCSC, 0xa1ec8d74 }, + // { NvAPI_VIO_GetCSC, 0x7b0d72a3 }, + // { NvAPI_VIO_SetGamma, 0x964bf452 }, + // { NvAPI_VIO_GetGamma, 0x51d53d06 }, + // { NvAPI_VIO_SetSyncDelay, 0x2697a8d1 }, + // { NvAPI_VIO_GetSyncDelay, 0x462214a9 }, + // { NvAPI_VIO_GetPCIInfo, 0xb981d935 }, + // { NvAPI_VIO_IsRunning, 0x96bd040e }, + // { NvAPI_VIO_Start, 0xcde8e1a3 }, + // { NvAPI_VIO_Stop, 0x6ba2a5d6 }, + // { NvAPI_VIO_IsFrameLockModeCompatible, 0x7bf0a94d }, + // { NvAPI_VIO_EnumDevices, 0xfd7c5557 }, + // { NvAPI_VIO_QueryTopology, 0x869534e2 }, + // { NvAPI_VIO_EnumSignalFormats, 0xead72fe4 }, + // { NvAPI_VIO_EnumDataFormats, 0x221fa8e8 }, + // { NvAPI_Stereo_CreateConfigurationProfileRegistryKey, 0xbe7692ec }, + // { NvAPI_Stereo_DeleteConfigurationProfileRegistryKey, 0xf117b834 }, + // { NvAPI_Stereo_SetConfigurationProfileValue, 0x24409f48 }, + // { NvAPI_Stereo_DeleteConfigurationProfileValue, 0x49bceecf }, + // { NvAPI_Stereo_Enable, 0x239c4545 }, + // { NvAPI_Stereo_Disable, 0x2ec50c2b }, + // { NvAPI_Stereo_IsEnabled, 0x348ff8e1 }, + // { NvAPI_Stereo_GetStereoSupport, 0x296c434d }, + // { NvAPI_Stereo_CreateHandleFromIUnknown, 0xac7e37f4 }, + // { NvAPI_Stereo_DestroyHandle, 0x3a153134 }, + // { NvAPI_Stereo_Activate, 0xf6a1ad68 }, + // { NvAPI_Stereo_Deactivate, 0x2d68de96 }, + // { NvAPI_Stereo_IsActivated, 0x1fb0bc30 }, + // { NvAPI_Stereo_GetSeparation, 0x451f2134 }, + // { NvAPI_Stereo_SetSeparation, 0x5c069fa3 }, + // { NvAPI_Stereo_DecreaseSeparation, 0xda044458 }, + // { NvAPI_Stereo_IncreaseSeparation, 0xc9a8ecec }, + // { NvAPI_Stereo_GetConvergence, 0x4ab00934 }, + // { NvAPI_Stereo_SetConvergence, 0x3dd6b54b }, + // { NvAPI_Stereo_DecreaseConvergence, 0x4c87e317 }, + // { NvAPI_Stereo_IncreaseConvergence, 0xa17daabe }, + // { NvAPI_Stereo_GetFrustumAdjustMode, 0xe6839b43 }, + // { NvAPI_Stereo_SetFrustumAdjustMode, 0x7be27fa2 }, + // { NvAPI_Stereo_CaptureJpegImage, 0x932cb140 }, + // { NvAPI_Stereo_InitActivation, 0xc7177702 }, + // { NvAPI_Stereo_Trigger_Activation, 0x0d6c6cd2 }, + // { NvAPI_Stereo_CapturePngImage, 0x8b7e99b5 }, + // { NvAPI_Stereo_ReverseStereoBlitControl, 0x3cd58f89 }, + // { NvAPI_Stereo_SetNotificationMessage, 0x6b9b409e }, + // { NvAPI_Stereo_SetActiveEye, 0x96eea9f8 }, + // { NvAPI_Stereo_SetDriverMode, 0x5e8f0bec }, + // { NvAPI_Stereo_GetEyeSeparation, 0xce653127 }, + // { NvAPI_Stereo_IsWindowedModeSupported, 0x40c8ed5e }, + // { NvAPI_Stereo_SetSurfaceCreationMode, 0xf5dcfcba }, + // { NvAPI_Stereo_GetSurfaceCreationMode, 0x36f1c736 }, + // { NvAPI_Stereo_Debug_WasLastDrawStereoized, 0xed4416c5 }, + // { NvAPI_Stereo_SetDefaultProfile, 0x44f0ecd1 }, + // { NvAPI_Stereo_GetDefaultProfile, 0x624e21c2 }, + // { NvAPI_D3D1x_CreateSwapChain, 0x1bc21b66 }, + // { NvAPI_D3D9_CreateSwapChain, 0x1a131e09 }, + // { NvAPI_Vulkan_InitLowLatencyDevice, 0x5c1696b6 }, + // { NvAPI_Vulkan_DestroyLowLatencyDevice, 0x11a5932b }, + // { NvAPI_Vulkan_GetSleepStatus, 0xadf966af }, + // { NvAPI_Vulkan_SetSleepMode, 0x2acfd162 }, + // { NvAPI_Vulkan_Sleep, 0x36732b1e }, + // { NvAPI_Vulkan_GetLatency, 0x3233d44a }, + // { NvAPI_Vulkan_SetLatencyMarker, 0xa17d13d6 }, + // { NvAPI_Vulkan_NotifyOutOfBandVkQueue, 0x5d6d3840 }, + // { NvAPI_DRS_CreateSession, 0x0694d52e }, + // { NvAPI_DRS_DestroySession, 0xdad9cff8 }, + // { NvAPI_DRS_LoadSettings, 0x375dbd6b }, + // { NvAPI_DRS_SaveSettings, 0xfcbc7e14 }, + // { NvAPI_DRS_LoadSettingsFromFile, 0xd3ede889 }, + // { NvAPI_DRS_SaveSettingsToFile, 0x2be25df8 }, + // { NvAPI_DRS_CreateProfile, 0xcc176068 }, + // { NvAPI_DRS_DeleteProfile, 0x17093206 }, + // { NvAPI_DRS_SetCurrentGlobalProfile, 0x1c89c5df }, + // { NvAPI_DRS_GetCurrentGlobalProfile, 0x617bff9f }, + // { NvAPI_DRS_GetProfileInfo, 0x61cd6fd6 }, + // { NvAPI_DRS_SetProfileInfo, 0x16abd3a9 }, + // { NvAPI_DRS_FindProfileByName, 0x7e4a9a0b }, + // { NvAPI_DRS_EnumProfiles, 0xbc371ee0 }, + // { NvAPI_DRS_GetNumProfiles, 0x1dae4fbc }, + // { NvAPI_DRS_CreateApplication, 0x4347a9de }, + // { NvAPI_DRS_DeleteApplicationEx, 0xc5ea85a1 }, + // { NvAPI_DRS_DeleteApplication, 0x2c694bc6 }, + // { NvAPI_DRS_GetApplicationInfo, 0xed1f8c69 }, + // { NvAPI_DRS_EnumApplications, 0x7fa2173a }, + // { NvAPI_DRS_FindApplicationByName, 0xeee566b2 }, + // { NvAPI_DRS_SetSetting, 0x577dd202 }, + // { NvAPI_DRS_GetSetting, 0x73bf8338 }, + // { NvAPI_DRS_EnumSettings, 0xae3039da }, + // { NvAPI_DRS_EnumAvailableSettingIds, 0xf020614a }, + // { NvAPI_DRS_EnumAvailableSettingValues, 0x2ec39f90 }, + // { NvAPI_DRS_GetSettingIdFromName, 0xcb7309cd }, + // { NvAPI_DRS_GetSettingNameFromId, 0xd61cbe6e }, + // { NvAPI_DRS_DeleteProfileSetting, 0xe4a26362 }, + // { NvAPI_DRS_RestoreAllDefaults, 0x5927b094 }, + // { NvAPI_DRS_RestoreProfileDefault, 0xfa5f6134 }, + // { NvAPI_DRS_RestoreProfileDefaultSetting, 0x53f0381e }, + // { NvAPI_DRS_GetBaseProfile, 0xda8466a0 }, + // { NvAPI_SYS_GetChipSetInfo, 0x53dabbca }, + // { NvAPI_SYS_GetLidAndDockInfo, 0xcda14d8a }, + // { NvAPI_SYS_GetDisplayIdFromGpuAndOutputId, 0x08f2bab4 }, + // { NvAPI_SYS_GetGpuAndOutputIdFromDisplayId, 0x112ba1a5 }, + // { NvAPI_SYS_GetPhysicalGpuFromDisplayId, 0x9ea74659 }, + // { NvAPI_SYS_GetDisplayDriverInfo, 0x721faceb }, + // { NvAPI_SYS_GetPhysicalGPUs, 0xd3b24d2d }, + // { NvAPI_SYS_GetLogicalGPUs, 0xccfffc10 }, + // { NvAPI_NGX_GetDriverFeatureSupport, 0x6194b19d }, + // { NvAPI_GPU_ClientRegisterForUtilizationSampleUpdates, 0xadeeaf67 }, + // { NvAPI_RegisterRiseCallback, 0x9cfe8f94 }, + // { NvAPI_RequestRise, 0x5047de98 }, + // { NvAPI_UninstallRise, 0xab8d09f6 }, + // Undocumented: + // Not sure what is the deal with this function, but looking at the + // implementation of NvAPI_GPU_CudaEnumComputeCapableGpus it seems to just + // call it with the same argument? + { NvAPI_Unknown_36e39e6b, 0x36e39e6b } + +); + +const NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_CAPABLE: u32 = 1 << 0; +const NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_ENABLE: u32 = 1 << 1; +// const NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_DEDICATED: u32 = 1 << 2; +const NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_RECOMMENDED: u32 = 1 << 3; +const NV_COMPUTE_GPU_TOPOLOGY_CUDA_AVAILABLE: u32 = 1 << 4; +const NV_COMPUTE_GPU_TOPOLOGY_CUDA_CAPABLE: u32 = 1 << 16; +// const NV_COMPUTE_GPU_TOPOLOGY_CUDA_DISABLED: u32 = 1 << 17; +const NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_AVAILABLE: u32 = 1 << 21; + +fn make_nvapi_version(ver: u32) -> u32 { + let size = std::mem::size_of::() as u32; + size | (ver << 16) +} + +#[no_mangle] +pub unsafe extern "C" fn nvapi_QueryInterface(interface: u32) -> *mut c_void { + interface_to_fn(interface).unwrap_or(std::ptr::null_mut()) +} + +#[allow(non_snake_case)] +unsafe extern "C" fn NvAPI_Initialize() -> i32 { + 0 +} + +#[allow(non_snake_case)] +unsafe extern "C" fn NvAPI_Unload() -> i32 { + 0 +} + +#[allow(non_snake_case)] +unsafe extern "C" fn NvAPI_GetDisplayDriverVersion( + _display: NvDisplayHandle, + version: *mut NV_DISPLAY_DRIVER_VERSION, +) -> i32 { + // return 0; + let version = version.as_mut(); + let version = unwrap_or::unwrap_some_or!(version, return _NvAPI_Status_NVAPI_INVALID_ARGUMENT); + if version.version != make_nvapi_version::(1) { + return _NvAPI_Status_NVAPI_INCOMPATIBLE_STRUCT_VERSION; + } + version.drvVersion = 99999; + version.bldChangeListNum = 0; + version.szBuildBranchString.fill(0); + version.szAdapterString.fill(0); + let device_name = b"ZLUDA Graphics Device"; + std::ptr::copy_nonoverlapping( + device_name.as_ptr() as _, + version.szAdapterString.as_mut_ptr() as _, + device_name.len(), + ); + 0 +} + +#[allow(non_snake_case)] +unsafe extern "C" fn NvAPI_GPU_CudaEnumComputeCapableGpus(version_ptr: *mut NvU32) -> i32 { + let version = version_ptr.as_mut(); + let version = unwrap_or::unwrap_some_or!(version, return _NvAPI_Status_NVAPI_INVALID_ARGUMENT); + if *version == make_nvapi_version::(1) { + NvAPI_GPU_CudaEnumComputeCapableGpus_v1( + version_ptr + .cast::() + .as_mut() + .unwrap(), + ) + } else if *version == make_nvapi_version::(2) { + NvAPI_GPU_CudaEnumComputeCapableGpus_v2( + version_ptr + .cast::() + .as_mut() + .unwrap(), + ) + } else { + _NvAPI_Status_NVAPI_INCOMPATIBLE_STRUCT_VERSION + } +} + +#[allow(non_snake_case)] +unsafe fn NvAPI_GPU_CudaEnumComputeCapableGpus_v1( + compute_topo: &mut NV_COMPUTE_GPU_TOPOLOGY_V1, +) -> i32 { + compute_topo.gpuCount = 1; + compute_topo.computeGpus[0] = NV_COMPUTE_GPU_TOPOLOGY_V1__bindgen_ty_1 { + hPhysicalGpu: 1 as _, + flags: NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_CAPABLE + | NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_ENABLE + | NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_RECOMMENDED + | NV_COMPUTE_GPU_TOPOLOGY_CUDA_AVAILABLE + | NV_COMPUTE_GPU_TOPOLOGY_CUDA_CAPABLE + | NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_AVAILABLE, + }; + 0 +} + +#[repr(transparent)] +struct NvComputeGpuSync(NV_COMPUTE_GPU); + +unsafe impl Sync for NvComputeGpuSync {} + +#[allow(non_snake_case)] +unsafe fn NvAPI_GPU_CudaEnumComputeCapableGpus_v2( + compute_topo: &mut NV_COMPUTE_GPU_TOPOLOGY_V2, +) -> i32 { + static mut FAKE_GPU: NvComputeGpuSync = NvComputeGpuSync(NV_COMPUTE_GPU { + hPhysicalGpu: 1 as _, + flags: NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_CAPABLE + | NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_ENABLE + | NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_RECOMMENDED + | NV_COMPUTE_GPU_TOPOLOGY_CUDA_AVAILABLE + | NV_COMPUTE_GPU_TOPOLOGY_CUDA_CAPABLE + | NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_AVAILABLE, + }); + compute_topo.gpuCount = 1; + compute_topo.computeGpus = (&raw mut FAKE_GPU).cast(); + 0 +} + +#[allow(non_snake_case)] +unsafe extern "C" fn NvAPI_GetGPUIDfromPhysicalGPU( + physical_gpu: NvPhysicalGpuHandle, + gpu_id: *mut NvU32, +) -> i32 { + if physical_gpu != 1 as _ { + return _NvAPI_Status_NVAPI_INVALID_ARGUMENT; + } + let gpu_id = gpu_id.as_mut(); + let gpu_id = unwrap_or::unwrap_some_or!(gpu_id, return _NvAPI_Status_NVAPI_INVALID_ARGUMENT); + *gpu_id = 1; + 0 +} + +#[allow(non_snake_case)] +unsafe extern "C" fn NvAPI_GetPhysicalGPUFromGPUID( + gpu_id: NvU32, + physical_gpu: *mut NvPhysicalGpuHandle, +) -> i32 { + if gpu_id != 1 { + return _NvAPI_Status_NVAPI_INVALID_ARGUMENT; + } + let physical_gpu = physical_gpu.as_mut(); + let physical_gpu = + unwrap_or::unwrap_some_or!(physical_gpu, return _NvAPI_Status_NVAPI_INVALID_ARGUMENT); + *physical_gpu = 1 as _; + 0 +} + +#[allow(non_snake_case)] +unsafe extern "C" fn NvAPI_SYS_GetDriverAndBranchVersion( + driver_version: *mut NvU32, + build_branch_string: *mut NvAPI_ShortString, +) -> i32 { + let driver_version = driver_version.as_mut(); + let driver_version = + unwrap_or::unwrap_some_or!(driver_version, return _NvAPI_Status_NVAPI_INVALID_ARGUMENT); + let build_branch_string = build_branch_string.as_mut(); + let build_branch_string = unwrap_or::unwrap_some_or!( + build_branch_string, + return _NvAPI_Status_NVAPI_INVALID_ARGUMENT + ); + *driver_version = 99999; + build_branch_string.fill(0); + let version_string = b"r999_99"; + std::ptr::copy_nonoverlapping( + version_string.as_ptr().cast(), + build_branch_string.as_mut_ptr(), + version_string.len(), + ); + 0 +} + +#[allow(non_snake_case)] +unsafe extern "C" fn NvAPI_Unknown_36e39e6b(compute_topo: *mut NV_COMPUTE_GPU_TOPOLOGY_V2) -> i32 { + let compute_topo = compute_topo.as_mut(); + let compute_topo = + unwrap_or::unwrap_some_or!(compute_topo, return _NvAPI_Status_NVAPI_INVALID_ARGUMENT); + NvAPI_GPU_CudaEnumComputeCapableGpus_v2(compute_topo) +} diff --git a/nvapi/src/nvapi.rs b/nvapi/src/nvapi.rs new file mode 100644 index 000000000..718bd0a38 --- /dev/null +++ b/nvapi/src/nvapi.rs @@ -0,0 +1,19879 @@ +// bindgen nvapi.h -o nvapi.rs --no-layout-tests --allowlist-type "Nv.*" --allowlist-type "NV_.*" +/* automatically generated by rust-bindgen 0.72.1 */ + +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8).offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { + byte | mask + } else { + byte & !mask + } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8).offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::()); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::()); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +pub type DWORD = ::std::os::raw::c_ulong; +pub type ULONG_PTR = ::std::os::raw::c_ulonglong; +pub type SIZE_T = ULONG_PTR; +pub type LONG = ::std::os::raw::c_long; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _LUID { + pub LowPart: DWORD, + pub HighPart: LONG, +} +pub type LUID = _LUID; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MEMORY_RANGE { + pub BaseAddress: *mut ::std::os::raw::c_void, + pub Length: SIZE_T, +} +pub type NV_MEMORY_RANGE = _NV_MEMORY_RANGE; +pub type NvU64 = ::std::os::raw::c_ulonglong; +pub type NvS64 = ::std::os::raw::c_longlong; +pub type NvS32 = ::std::os::raw::c_int; +pub type NvU32 = ::std::os::raw::c_uint; +pub type NvS16 = ::std::os::raw::c_short; +pub type NvU16 = ::std::os::raw::c_ushort; +pub type NvU8 = ::std::os::raw::c_uchar; +pub type NvS8 = ::std::os::raw::c_schar; +pub type NvF32 = f32; +pub type NvF64 = f64; +pub type NvBool = NvU8; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_RECT { + pub left: NvU32, + pub top: NvU32, + pub right: NvU32, + pub bottom: NvU32, +} +pub type NV_RECT = _NV_RECT; +#[doc = "! \\addtogroup nvapihandles\n! NVAPI Handles - These handles are retrieved from various calls and passed in to others in NvAPI\n! These are meant to be opaque types. Do not assume they correspond to indices, HDCs,\n! display indexes or anything else.\n!\n! Most handles remain valid until a display re-configuration (display mode set) or GPU\n! reconfiguration (going into or out of SLI modes) occurs. If NVAPI_HANDLE_INVALIDATED\n! is received by an app, it should discard all handles, and re-enumerate them.\n! @{"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvLogicalGpuHandle__ { + pub unused: ::std::os::raw::c_int, +} +#[doc = "! \\addtogroup nvapihandles\n! NVAPI Handles - These handles are retrieved from various calls and passed in to others in NvAPI\n! These are meant to be opaque types. Do not assume they correspond to indices, HDCs,\n! display indexes or anything else.\n!\n! Most handles remain valid until a display re-configuration (display mode set) or GPU\n! reconfiguration (going into or out of SLI modes) occurs. If NVAPI_HANDLE_INVALIDATED\n! is received by an app, it should discard all handles, and re-enumerate them.\n! @{"] +pub type NvLogicalGpuHandle = *mut NvLogicalGpuHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvPhysicalGpuHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvPhysicalGpuHandle = *mut NvPhysicalGpuHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvDisplayHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvDisplayHandle = *mut NvDisplayHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvMonitorHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvMonitorHandle = *mut NvMonitorHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvUnAttachedDisplayHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvUnAttachedDisplayHandle = *mut NvUnAttachedDisplayHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvVisualComputingDeviceHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvVisualComputingDeviceHandle = *mut NvVisualComputingDeviceHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvEventHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvEventHandle = *mut NvEventHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvHICHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvHICHandle = *mut NvHICHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvGSyncDeviceHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvGSyncDeviceHandle = *mut NvGSyncDeviceHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvVioHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvVioHandle = *mut NvVioHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvTransitionHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvTransitionHandle = *mut NvTransitionHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvAudioHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvAudioHandle = *mut NvAudioHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Nv3DVPContextHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type Nv3DVPContextHandle = *mut Nv3DVPContextHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Nv3DVPTransceiverHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type Nv3DVPTransceiverHandle = *mut Nv3DVPTransceiverHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Nv3DVPGlassesHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type Nv3DVPGlassesHandle = *mut Nv3DVPGlassesHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvPcfClientHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvPcfClientHandle = *mut NvPcfClientHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvSourceHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvSourceHandle = *mut NvSourceHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvTargetHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvTargetHandle = *mut NvTargetHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvPresentBarrierClientHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvPresentBarrierClientHandle = *mut NvPresentBarrierClientHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvSBox { + pub sX: NvS32, + pub sY: NvS32, + pub sWidth: NvS32, + pub sHeight: NvS32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvGUID { + pub data1: NvU32, + pub data2: NvU16, + pub data3: NvU16, + pub data4: [NvU8; 8usize], +} +pub type NvLUID = NvGUID; +pub type NvAPI_String = [::std::os::raw::c_char; 4096usize]; +pub type NvAPI_LongString = [::std::os::raw::c_char; 256usize]; +pub type NvAPI_ShortString = [::std::os::raw::c_char; 64usize]; +pub type NvAPI_UnicodeShortString = [NvU16; 64usize]; +#[doc = "!< Success. Request is completed."] +pub const _NvAPI_Status_NVAPI_OK: _NvAPI_Status = 0; +#[doc = "!< Generic error"] +pub const _NvAPI_Status_NVAPI_ERROR: _NvAPI_Status = -1; +#[doc = "!< NVAPI support library cannot be loaded."] +pub const _NvAPI_Status_NVAPI_LIBRARY_NOT_FOUND: _NvAPI_Status = -2; +#[doc = "!< not implemented in current driver installation"] +pub const _NvAPI_Status_NVAPI_NO_IMPLEMENTATION: _NvAPI_Status = -3; +#[doc = "!< NvAPI_Initialize has not been called (successfully)"] +pub const _NvAPI_Status_NVAPI_API_NOT_INITIALIZED: _NvAPI_Status = -4; +#[doc = "!< The argument/parameter value is not valid or NULL."] +pub const _NvAPI_Status_NVAPI_INVALID_ARGUMENT: _NvAPI_Status = -5; +#[doc = "!< No NVIDIA display driver, or NVIDIA GPU driving a display, was found."] +pub const _NvAPI_Status_NVAPI_NVIDIA_DEVICE_NOT_FOUND: _NvAPI_Status = -6; +#[doc = "!< No more items to enumerate"] +pub const _NvAPI_Status_NVAPI_END_ENUMERATION: _NvAPI_Status = -7; +#[doc = "!< Invalid handle"] +pub const _NvAPI_Status_NVAPI_INVALID_HANDLE: _NvAPI_Status = -8; +#[doc = "!< An argument's structure version is not supported"] +pub const _NvAPI_Status_NVAPI_INCOMPATIBLE_STRUCT_VERSION: _NvAPI_Status = -9; +#[doc = "!< The handle is no longer valid (likely due to GPU or display re-configuration)"] +pub const _NvAPI_Status_NVAPI_HANDLE_INVALIDATED: _NvAPI_Status = -10; +#[doc = "!< No NVIDIA OpenGL context is current (but needs to be)"] +pub const _NvAPI_Status_NVAPI_OPENGL_CONTEXT_NOT_CURRENT: _NvAPI_Status = -11; +#[doc = "!< An invalid pointer, usually NULL, was passed as a parameter"] +pub const _NvAPI_Status_NVAPI_INVALID_POINTER: _NvAPI_Status = -14; +#[doc = "!< OpenGL Expert is not supported by the current drivers"] +pub const _NvAPI_Status_NVAPI_NO_GL_EXPERT: _NvAPI_Status = -12; +#[doc = "!< OpenGL Expert is supported, but driver instrumentation is currently disabled"] +pub const _NvAPI_Status_NVAPI_INSTRUMENTATION_DISABLED: _NvAPI_Status = -13; +#[doc = "!< OpenGL does not support Nsight"] +pub const _NvAPI_Status_NVAPI_NO_GL_NSIGHT: _NvAPI_Status = -15; +#[doc = "!< Expected a logical GPU handle for one or more parameters"] +pub const _NvAPI_Status_NVAPI_EXPECTED_LOGICAL_GPU_HANDLE: _NvAPI_Status = -100; +#[doc = "!< Expected a physical GPU handle for one or more parameters"] +pub const _NvAPI_Status_NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE: _NvAPI_Status = -101; +#[doc = "!< Expected an NV display handle for one or more parameters"] +pub const _NvAPI_Status_NVAPI_EXPECTED_DISPLAY_HANDLE: _NvAPI_Status = -102; +#[doc = "!< The combination of parameters is not valid."] +pub const _NvAPI_Status_NVAPI_INVALID_COMBINATION: _NvAPI_Status = -103; +#[doc = "!< Requested feature is not supported in the selected GPU"] +pub const _NvAPI_Status_NVAPI_NOT_SUPPORTED: _NvAPI_Status = -104; +#[doc = "!< No port ID was found for the I2C transaction"] +pub const _NvAPI_Status_NVAPI_PORTID_NOT_FOUND: _NvAPI_Status = -105; +#[doc = "!< Expected an unattached display handle as one of the input parameters."] +pub const _NvAPI_Status_NVAPI_EXPECTED_UNATTACHED_DISPLAY_HANDLE: _NvAPI_Status = -106; +#[doc = "!< Invalid perf level"] +pub const _NvAPI_Status_NVAPI_INVALID_PERF_LEVEL: _NvAPI_Status = -107; +#[doc = "!< Device is busy; request not fulfilled"] +pub const _NvAPI_Status_NVAPI_DEVICE_BUSY: _NvAPI_Status = -108; +#[doc = "!< NV persist file is not found"] +pub const _NvAPI_Status_NVAPI_NV_PERSIST_FILE_NOT_FOUND: _NvAPI_Status = -109; +#[doc = "!< NV persist data is not found"] +pub const _NvAPI_Status_NVAPI_PERSIST_DATA_NOT_FOUND: _NvAPI_Status = -110; +#[doc = "!< Expected a TV output display"] +pub const _NvAPI_Status_NVAPI_EXPECTED_TV_DISPLAY: _NvAPI_Status = -111; +#[doc = "!< Expected a TV output on the D Connector - HDTV_EIAJ4120."] +pub const _NvAPI_Status_NVAPI_EXPECTED_TV_DISPLAY_ON_DCONNECTOR: _NvAPI_Status = -112; +#[doc = "!< SLI is not active on this device."] +pub const _NvAPI_Status_NVAPI_NO_ACTIVE_SLI_TOPOLOGY: _NvAPI_Status = -113; +#[doc = "!< Setup of SLI rendering mode is not possible right now."] +pub const _NvAPI_Status_NVAPI_SLI_RENDERING_MODE_NOTALLOWED: _NvAPI_Status = -114; +#[doc = "!< Expected a digital flat panel."] +pub const _NvAPI_Status_NVAPI_EXPECTED_DIGITAL_FLAT_PANEL: _NvAPI_Status = -115; +#[doc = "!< Argument exceeds the expected size."] +pub const _NvAPI_Status_NVAPI_ARGUMENT_EXCEED_MAX_SIZE: _NvAPI_Status = -116; +#[doc = "!< Inhibit is ON due to one of the flags in NV_GPU_DISPLAY_CHANGE_INHIBIT or SLI active."] +pub const _NvAPI_Status_NVAPI_DEVICE_SWITCHING_NOT_ALLOWED: _NvAPI_Status = -117; +#[doc = "!< Testing of clocks is not supported."] +pub const _NvAPI_Status_NVAPI_TESTING_CLOCKS_NOT_SUPPORTED: _NvAPI_Status = -118; +#[doc = "!< The specified underscan config is from an unknown source (e.g. INF)"] +pub const _NvAPI_Status_NVAPI_UNKNOWN_UNDERSCAN_CONFIG: _NvAPI_Status = -119; +#[doc = "!< Timeout while reconfiguring GPUs"] +pub const _NvAPI_Status_NVAPI_TIMEOUT_RECONFIGURING_GPU_TOPO: _NvAPI_Status = -120; +#[doc = "!< Requested data was not found"] +pub const _NvAPI_Status_NVAPI_DATA_NOT_FOUND: _NvAPI_Status = -121; +#[doc = "!< Expected an analog display"] +pub const _NvAPI_Status_NVAPI_EXPECTED_ANALOG_DISPLAY: _NvAPI_Status = -122; +#[doc = "!< No SLI video bridge is present"] +pub const _NvAPI_Status_NVAPI_NO_VIDLINK: _NvAPI_Status = -123; +#[doc = "!< NVAPI requires a reboot for the settings to take effect"] +pub const _NvAPI_Status_NVAPI_REQUIRES_REBOOT: _NvAPI_Status = -124; +#[doc = "!< The function is not supported with the current Hybrid mode."] +pub const _NvAPI_Status_NVAPI_INVALID_HYBRID_MODE: _NvAPI_Status = -125; +#[doc = "!< The target types are not all the same"] +pub const _NvAPI_Status_NVAPI_MIXED_TARGET_TYPES: _NvAPI_Status = -126; +#[doc = "!< The function is not supported from 32-bit on a 64-bit system."] +pub const _NvAPI_Status_NVAPI_SYSWOW64_NOT_SUPPORTED: _NvAPI_Status = -127; +#[doc = "!< There is no implicit GPU topology active. Use NVAPI_SetHybridMode to change topology."] +pub const _NvAPI_Status_NVAPI_IMPLICIT_SET_GPU_TOPOLOGY_CHANGE_NOT_ALLOWED: _NvAPI_Status = -128; +#[doc = "!< Prompt the user to close all non-migratable applications."] +pub const _NvAPI_Status_NVAPI_REQUEST_USER_TO_CLOSE_NON_MIGRATABLE_APPS: _NvAPI_Status = -129; +#[doc = "!< Could not allocate sufficient memory to complete the call."] +pub const _NvAPI_Status_NVAPI_OUT_OF_MEMORY: _NvAPI_Status = -130; +#[doc = "!< The previous operation that is transferring information to or from this surface is incomplete."] +pub const _NvAPI_Status_NVAPI_WAS_STILL_DRAWING: _NvAPI_Status = -131; +#[doc = "!< The file was not found."] +pub const _NvAPI_Status_NVAPI_FILE_NOT_FOUND: _NvAPI_Status = -132; +#[doc = "!< There are too many unique instances of a particular type of state object."] +pub const _NvAPI_Status_NVAPI_TOO_MANY_UNIQUE_STATE_OBJECTS: _NvAPI_Status = -133; +#[doc = "!< The method call is invalid. For example, a method's parameter may not be a valid pointer."] +pub const _NvAPI_Status_NVAPI_INVALID_CALL: _NvAPI_Status = -134; +#[doc = "!< d3d10_1.dll cannot be loaded."] +pub const _NvAPI_Status_NVAPI_D3D10_1_LIBRARY_NOT_FOUND: _NvAPI_Status = -135; +#[doc = "!< Couldn't find the function in the loaded DLL."] +pub const _NvAPI_Status_NVAPI_FUNCTION_NOT_FOUND: _NvAPI_Status = -136; +#[doc = "!< The application will require Administrator privileges to access this API.\n!< The application can be elevated to a higher permission level by selecting \"Run as Administrator\"."] +pub const _NvAPI_Status_NVAPI_INVALID_USER_PRIVILEGE: _NvAPI_Status = -137; +#[doc = "!< The handle corresponds to GDIPrimary."] +pub const _NvAPI_Status_NVAPI_EXPECTED_NON_PRIMARY_DISPLAY_HANDLE: _NvAPI_Status = -138; +#[doc = "!< Setting Physx GPU requires that the GPU is compute-capable."] +pub const _NvAPI_Status_NVAPI_EXPECTED_COMPUTE_GPU_HANDLE: _NvAPI_Status = -139; +#[doc = "!< The Stereo part of NVAPI failed to initialize completely. Check if the stereo driver is installed."] +pub const _NvAPI_Status_NVAPI_STEREO_NOT_INITIALIZED: _NvAPI_Status = -140; +#[doc = "!< Access to stereo-related registry keys or values has failed."] +pub const _NvAPI_Status_NVAPI_STEREO_REGISTRY_ACCESS_FAILED: _NvAPI_Status = -141; +#[doc = "!< The given registry profile type is not supported."] +pub const _NvAPI_Status_NVAPI_STEREO_REGISTRY_PROFILE_TYPE_NOT_SUPPORTED: _NvAPI_Status = -142; +#[doc = "!< The given registry value is not supported."] +pub const _NvAPI_Status_NVAPI_STEREO_REGISTRY_VALUE_NOT_SUPPORTED: _NvAPI_Status = -143; +#[doc = "!< Stereo is not enabled and the function needed it to execute completely."] +pub const _NvAPI_Status_NVAPI_STEREO_NOT_ENABLED: _NvAPI_Status = -144; +#[doc = "!< Stereo is not turned on and the function needed it to execute completely."] +pub const _NvAPI_Status_NVAPI_STEREO_NOT_TURNED_ON: _NvAPI_Status = -145; +#[doc = "!< Invalid device interface."] +pub const _NvAPI_Status_NVAPI_STEREO_INVALID_DEVICE_INTERFACE: _NvAPI_Status = -146; +#[doc = "!< Separation percentage or JPEG image capture quality is out of [0-100] range."] +pub const _NvAPI_Status_NVAPI_STEREO_PARAMETER_OUT_OF_RANGE: _NvAPI_Status = -147; +#[doc = "!< The given frustum adjust mode is not supported."] +pub const _NvAPI_Status_NVAPI_STEREO_FRUSTUM_ADJUST_MODE_NOT_SUPPORTED: _NvAPI_Status = -148; +#[doc = "!< The mosaic topology is not possible given the current state of the hardware."] +pub const _NvAPI_Status_NVAPI_TOPO_NOT_POSSIBLE: _NvAPI_Status = -149; +#[doc = "!< An attempt to do a display resolution mode change has failed."] +pub const _NvAPI_Status_NVAPI_MODE_CHANGE_FAILED: _NvAPI_Status = -150; +#[doc = "!< d3d11.dll/d3d11_beta.dll cannot be loaded."] +pub const _NvAPI_Status_NVAPI_D3D11_LIBRARY_NOT_FOUND: _NvAPI_Status = -151; +#[doc = "!< Address is outside of valid range."] +pub const _NvAPI_Status_NVAPI_INVALID_ADDRESS: _NvAPI_Status = -152; +#[doc = "!< The pre-allocated string is too small to hold the result."] +pub const _NvAPI_Status_NVAPI_STRING_TOO_SMALL: _NvAPI_Status = -153; +#[doc = "!< The input does not match any of the available devices."] +pub const _NvAPI_Status_NVAPI_MATCHING_DEVICE_NOT_FOUND: _NvAPI_Status = -154; +#[doc = "!< Driver is running."] +pub const _NvAPI_Status_NVAPI_DRIVER_RUNNING: _NvAPI_Status = -155; +#[doc = "!< Driver is not running."] +pub const _NvAPI_Status_NVAPI_DRIVER_NOTRUNNING: _NvAPI_Status = -156; +#[doc = "!< A driver reload is required to apply these settings."] +pub const _NvAPI_Status_NVAPI_ERROR_DRIVER_RELOAD_REQUIRED: _NvAPI_Status = -157; +#[doc = "!< Intended setting is not allowed."] +pub const _NvAPI_Status_NVAPI_SET_NOT_ALLOWED: _NvAPI_Status = -158; +#[doc = "!< Information can't be returned due to \"advanced display topology\"."] +pub const _NvAPI_Status_NVAPI_ADVANCED_DISPLAY_TOPOLOGY_REQUIRED: _NvAPI_Status = -159; +#[doc = "!< Setting is not found."] +pub const _NvAPI_Status_NVAPI_SETTING_NOT_FOUND: _NvAPI_Status = -160; +#[doc = "!< Setting size is too large."] +pub const _NvAPI_Status_NVAPI_SETTING_SIZE_TOO_LARGE: _NvAPI_Status = -161; +#[doc = "!< There are too many settings for a profile."] +pub const _NvAPI_Status_NVAPI_TOO_MANY_SETTINGS_IN_PROFILE: _NvAPI_Status = -162; +#[doc = "!< Profile is not found."] +pub const _NvAPI_Status_NVAPI_PROFILE_NOT_FOUND: _NvAPI_Status = -163; +#[doc = "!< Profile name is duplicated."] +pub const _NvAPI_Status_NVAPI_PROFILE_NAME_IN_USE: _NvAPI_Status = -164; +#[doc = "!< Profile name is empty."] +pub const _NvAPI_Status_NVAPI_PROFILE_NAME_EMPTY: _NvAPI_Status = -165; +#[doc = "!< Application not found in the Profile."] +pub const _NvAPI_Status_NVAPI_EXECUTABLE_NOT_FOUND: _NvAPI_Status = -166; +#[doc = "!< Application already exists in the other profile."] +pub const _NvAPI_Status_NVAPI_EXECUTABLE_ALREADY_IN_USE: _NvAPI_Status = -167; +#[doc = "!< Data Type mismatch"] +pub const _NvAPI_Status_NVAPI_DATATYPE_MISMATCH: _NvAPI_Status = -168; +#[doc = "!< The profile passed as parameter has been removed and is no longer valid."] +pub const _NvAPI_Status_NVAPI_PROFILE_REMOVED: _NvAPI_Status = -169; +#[doc = "!< An unregistered resource was passed as a parameter."] +pub const _NvAPI_Status_NVAPI_UNREGISTERED_RESOURCE: _NvAPI_Status = -170; +#[doc = "!< The DisplayId corresponds to a display which is not within the normal outputId range."] +pub const _NvAPI_Status_NVAPI_ID_OUT_OF_RANGE: _NvAPI_Status = -171; +#[doc = "!< Display topology is not valid so the driver cannot do a mode set on this configuration."] +pub const _NvAPI_Status_NVAPI_DISPLAYCONFIG_VALIDATION_FAILED: _NvAPI_Status = -172; +#[doc = "!< Display Port Multi-Stream topology has been changed."] +pub const _NvAPI_Status_NVAPI_DPMST_CHANGED: _NvAPI_Status = -173; +#[doc = "!< Input buffer is insufficient to hold the contents."] +pub const _NvAPI_Status_NVAPI_INSUFFICIENT_BUFFER: _NvAPI_Status = -174; +#[doc = "!< No access to the caller."] +pub const _NvAPI_Status_NVAPI_ACCESS_DENIED: _NvAPI_Status = -175; +#[doc = "!< The requested action cannot be performed without Mosaic being enabled."] +pub const _NvAPI_Status_NVAPI_MOSAIC_NOT_ACTIVE: _NvAPI_Status = -176; +#[doc = "!< The surface is relocated away from video memory."] +pub const _NvAPI_Status_NVAPI_SHARE_RESOURCE_RELOCATED: _NvAPI_Status = -177; +#[doc = "!< The user should disable DWM before calling NvAPI."] +pub const _NvAPI_Status_NVAPI_REQUEST_USER_TO_DISABLE_DWM: _NvAPI_Status = -178; +#[doc = "!< D3D device status is D3DERR_DEVICELOST or D3DERR_DEVICENOTRESET - the user has to reset the device."] +pub const _NvAPI_Status_NVAPI_D3D_DEVICE_LOST: _NvAPI_Status = -179; +#[doc = "!< The requested action cannot be performed in the current state."] +pub const _NvAPI_Status_NVAPI_INVALID_CONFIGURATION: _NvAPI_Status = -180; +#[doc = "!< Call failed as stereo handshake not completed."] +pub const _NvAPI_Status_NVAPI_STEREO_HANDSHAKE_NOT_DONE: _NvAPI_Status = -181; +#[doc = "!< The path provided was too short to determine the correct NVDRS_APPLICATION"] +pub const _NvAPI_Status_NVAPI_EXECUTABLE_PATH_IS_AMBIGUOUS: _NvAPI_Status = -182; +#[doc = "!< Default stereo profile is not currently defined"] +pub const _NvAPI_Status_NVAPI_DEFAULT_STEREO_PROFILE_IS_NOT_DEFINED: _NvAPI_Status = -183; +#[doc = "!< Default stereo profile does not exist"] +pub const _NvAPI_Status_NVAPI_DEFAULT_STEREO_PROFILE_DOES_NOT_EXIST: _NvAPI_Status = -184; +#[doc = "!< A cluster is already defined with the given configuration."] +pub const _NvAPI_Status_NVAPI_CLUSTER_ALREADY_EXISTS: _NvAPI_Status = -185; +#[doc = "!< The input display id is not that of a multi stream enabled connector or a display device in a multi stream topology"] +pub const _NvAPI_Status_NVAPI_DPMST_DISPLAY_ID_EXPECTED: _NvAPI_Status = -186; +#[doc = "!< The input display id is not valid or the monitor associated to it does not support the current operation"] +pub const _NvAPI_Status_NVAPI_INVALID_DISPLAY_ID: _NvAPI_Status = -187; +#[doc = "!< While playing secure audio stream, stream goes out of sync"] +pub const _NvAPI_Status_NVAPI_STREAM_IS_OUT_OF_SYNC: _NvAPI_Status = -188; +#[doc = "!< Older audio driver version than required"] +pub const _NvAPI_Status_NVAPI_INCOMPATIBLE_AUDIO_DRIVER: _NvAPI_Status = -189; +#[doc = "!< Value already set, setting again not allowed."] +pub const _NvAPI_Status_NVAPI_VALUE_ALREADY_SET: _NvAPI_Status = -190; +#[doc = "!< Requested operation timed out"] +pub const _NvAPI_Status_NVAPI_TIMEOUT: _NvAPI_Status = -191; +#[doc = "!< The requested workstation feature set has incomplete driver internal allocation resources"] +pub const _NvAPI_Status_NVAPI_GPU_WORKSTATION_FEATURE_INCOMPLETE: _NvAPI_Status = -192; +#[doc = "!< Call failed because InitActivation was not called."] +pub const _NvAPI_Status_NVAPI_STEREO_INIT_ACTIVATION_NOT_DONE: _NvAPI_Status = -193; +#[doc = "!< The requested action cannot be performed without Sync being enabled."] +pub const _NvAPI_Status_NVAPI_SYNC_NOT_ACTIVE: _NvAPI_Status = -194; +#[doc = "!< The requested action cannot be performed without Sync Master being enabled."] +pub const _NvAPI_Status_NVAPI_SYNC_MASTER_NOT_FOUND: _NvAPI_Status = -195; +#[doc = "!< Invalid displays passed in the NV_GSYNC_DISPLAY pointer."] +pub const _NvAPI_Status_NVAPI_INVALID_SYNC_TOPOLOGY: _NvAPI_Status = -196; +#[doc = "!< The specified signing algorithm is not supported. Either an incorrect value was entered or the current installed driver/hardware does not support the input value."] +pub const _NvAPI_Status_NVAPI_ECID_SIGN_ALGO_UNSUPPORTED: _NvAPI_Status = -197; +#[doc = "!< The encrypted public key verification has failed."] +pub const _NvAPI_Status_NVAPI_ECID_KEY_VERIFICATION_FAILED: _NvAPI_Status = -198; +#[doc = "!< The device's firmware is out of date."] +pub const _NvAPI_Status_NVAPI_FIRMWARE_OUT_OF_DATE: _NvAPI_Status = -199; +#[doc = "!< The device's firmware is not supported."] +pub const _NvAPI_Status_NVAPI_FIRMWARE_REVISION_NOT_SUPPORTED: _NvAPI_Status = -200; +#[doc = "!< The caller is not authorized to modify the License."] +pub const _NvAPI_Status_NVAPI_LICENSE_CALLER_AUTHENTICATION_FAILED: _NvAPI_Status = -201; +#[doc = "!< The user tried to use a deferred context without registering the device first"] +pub const _NvAPI_Status_NVAPI_D3D_DEVICE_NOT_REGISTERED: _NvAPI_Status = -202; +#[doc = "!< Head or SourceId was not reserved for the VR Display before doing the Modeset or the dedicated display."] +pub const _NvAPI_Status_NVAPI_RESOURCE_NOT_ACQUIRED: _NvAPI_Status = -203; +#[doc = "!< Provided timing is not supported."] +pub const _NvAPI_Status_NVAPI_TIMING_NOT_SUPPORTED: _NvAPI_Status = -204; +#[doc = "!< HDCP Encryption Failed for the device. Would be applicable when the device is HDCP Capable."] +pub const _NvAPI_Status_NVAPI_HDCP_ENCRYPTION_FAILED: _NvAPI_Status = -205; +#[doc = "!< Provided mode is over sink device pclk limitation."] +pub const _NvAPI_Status_NVAPI_PCLK_LIMITATION_FAILED: _NvAPI_Status = -206; +#[doc = "!< No connector on GPU found."] +pub const _NvAPI_Status_NVAPI_NO_CONNECTOR_FOUND: _NvAPI_Status = -207; +#[doc = "!< When a non-HDCP capable HMD is connected, we would inform user by this code."] +pub const _NvAPI_Status_NVAPI_HDCP_DISABLED: _NvAPI_Status = -208; +#[doc = "!< Atleast an API is still being called"] +pub const _NvAPI_Status_NVAPI_API_IN_USE: _NvAPI_Status = -209; +#[doc = "!< No display found on Nvidia GPU(s)."] +pub const _NvAPI_Status_NVAPI_NVIDIA_DISPLAY_NOT_FOUND: _NvAPI_Status = -210; +#[doc = "!< Priv security violation, improper access to a secured register."] +pub const _NvAPI_Status_NVAPI_PRIV_SEC_VIOLATION: _NvAPI_Status = -211; +#[doc = "!< NVAPI cannot be called by this vendor"] +pub const _NvAPI_Status_NVAPI_INCORRECT_VENDOR: _NvAPI_Status = -212; +#[doc = "!< DirectMode Display is already in use"] +pub const _NvAPI_Status_NVAPI_DISPLAY_IN_USE: _NvAPI_Status = -213; +#[doc = "!< The Config is having Non-NVidia GPU with Non-HDCP HMD connected"] +pub const _NvAPI_Status_NVAPI_UNSUPPORTED_CONFIG_NON_HDCP_HMD: _NvAPI_Status = -214; +#[doc = "!< GPU's Max Display Limit has Reached"] +pub const _NvAPI_Status_NVAPI_MAX_DISPLAY_LIMIT_REACHED: _NvAPI_Status = -215; +#[doc = "!< DirectMode not Enabled on the Display"] +pub const _NvAPI_Status_NVAPI_INVALID_DIRECT_MODE_DISPLAY: _NvAPI_Status = -216; +#[doc = "!< GPU is in debug mode, OC is NOT allowed."] +pub const _NvAPI_Status_NVAPI_GPU_IN_DEBUG_MODE: _NvAPI_Status = -217; +#[doc = "!< No NvAPI context was found for this D3D object"] +pub const _NvAPI_Status_NVAPI_D3D_CONTEXT_NOT_FOUND: _NvAPI_Status = -218; +#[doc = "!< there is version mismatch between stereo driver and dx driver"] +pub const _NvAPI_Status_NVAPI_STEREO_VERSION_MISMATCH: _NvAPI_Status = -219; +#[doc = "!< GPU is not powered and so the request cannot be completed."] +pub const _NvAPI_Status_NVAPI_GPU_NOT_POWERED: _NvAPI_Status = -220; +#[doc = "!< The display driver update in progress."] +pub const _NvAPI_Status_NVAPI_ERROR_DRIVER_RELOAD_IN_PROGRESS: _NvAPI_Status = -221; +#[doc = "!< Wait for HW resources allocation"] +pub const _NvAPI_Status_NVAPI_WAIT_FOR_HW_RESOURCE: _NvAPI_Status = -222; +#[doc = "!< operation requires further HDCP action"] +pub const _NvAPI_Status_NVAPI_REQUIRE_FURTHER_HDCP_ACTION: _NvAPI_Status = -223; +#[doc = "!< Dynamic Mux transition failure"] +pub const _NvAPI_Status_NVAPI_DISPLAY_MUX_TRANSITION_FAILED: _NvAPI_Status = -224; +#[doc = "!< Invalid DSC version"] +pub const _NvAPI_Status_NVAPI_INVALID_DSC_VERSION: _NvAPI_Status = -225; +#[doc = "!< Invalid DSC slice count"] +pub const _NvAPI_Status_NVAPI_INVALID_DSC_SLICECOUNT: _NvAPI_Status = -226; +#[doc = "!< Invalid DSC output BPP"] +pub const _NvAPI_Status_NVAPI_INVALID_DSC_OUTPUT_BPP: _NvAPI_Status = -227; +#[doc = "!< There was an error while loading nvapi.dll from the driver store."] +pub const _NvAPI_Status_NVAPI_FAILED_TO_LOAD_FROM_DRIVER_STORE: _NvAPI_Status = -228; +#[doc = "!< OpenGL does not export Vulkan fake extensions"] +pub const _NvAPI_Status_NVAPI_NO_VULKAN: _NvAPI_Status = -229; +#[doc = "!< A request for NvTOPPs telemetry CData has already been made and is pending a response."] +pub const _NvAPI_Status_NVAPI_REQUEST_PENDING: _NvAPI_Status = -230; +#[doc = "!< Operation cannot be performed because the resource is in use."] +pub const _NvAPI_Status_NVAPI_RESOURCE_IN_USE: _NvAPI_Status = -231; +#[doc = "!< Device kernel image is invalid"] +pub const _NvAPI_Status_NVAPI_INVALID_IMAGE: _NvAPI_Status = -232; +#[doc = "!< PTX JIT compilation failed"] +pub const _NvAPI_Status_NVAPI_INVALID_PTX: _NvAPI_Status = -233; +#[doc = "!< Uncorrectable NVLink error was detected during the execution"] +pub const _NvAPI_Status_NVAPI_NVLINK_UNCORRECTABLE: _NvAPI_Status = -234; +#[doc = "!< PTX JIT compiler library was not found."] +pub const _NvAPI_Status_NVAPI_JIT_COMPILER_NOT_FOUND: _NvAPI_Status = -235; +#[doc = "!< Device kernel source is invalid."] +pub const _NvAPI_Status_NVAPI_INVALID_SOURCE: _NvAPI_Status = -236; +#[doc = "!< While executing a kernel, the device encountered an illegal instruction."] +pub const _NvAPI_Status_NVAPI_ILLEGAL_INSTRUCTION: _NvAPI_Status = -237; +#[doc = "!< While executing a kernel, the device program counter wrapped its address space"] +pub const _NvAPI_Status_NVAPI_INVALID_PC: _NvAPI_Status = -238; +#[doc = "!< An exception occurred on the device while executing a kernel"] +pub const _NvAPI_Status_NVAPI_LAUNCH_FAILED: _NvAPI_Status = -239; +#[doc = "!< Attempted operation is not permitted."] +pub const _NvAPI_Status_NVAPI_NOT_PERMITTED: _NvAPI_Status = -240; +#[doc = "!< The callback function has already been registered."] +pub const _NvAPI_Status_NVAPI_CALLBACK_ALREADY_REGISTERED: _NvAPI_Status = -241; +#[doc = "!< The callback function is not found or not registered."] +pub const _NvAPI_Status_NVAPI_CALLBACK_NOT_FOUND: _NvAPI_Status = -242; +#[doc = "!< Invalid Wire Format for the VR HMD"] +pub const _NvAPI_Status_NVAPI_INVALID_OUTPUT_WIRE_FORMAT: _NvAPI_Status = -243; +#[doc = "! NvAPI Status Values\n! All NvAPI functions return one of these codes.\n! \\ingroup nvapistatus"] +pub type _NvAPI_Status = ::std::os::raw::c_int; +#[doc = "! NvAPI Status Values\n! All NvAPI functions return one of these codes.\n! \\ingroup nvapistatus"] +pub use self::_NvAPI_Status as NvAPI_Status; +#[doc = "! \\ingroup driverapi\n! Used in NvAPI_GPU_GetMemoryInfo()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_DISPLAY_DRIVER_MEMORY_INFO_V1 { + #[doc = "!< Version info"] + pub version: NvU32, + #[doc = "!< Size(in kb) of the physical framebuffer."] + pub dedicatedVideoMemory: NvU32, + #[doc = "!< Size(in kb) of the available physical framebuffer for allocating video memory surfaces."] + pub availableDedicatedVideoMemory: NvU32, + #[doc = "!< Size(in kb) of system memory the driver allocates at load time."] + pub systemVideoMemory: NvU32, + #[doc = "!< Size(in kb) of shared system memory that driver is allowed to commit for surfaces across all allocations."] + pub sharedSystemMemory: NvU32, +} +#[doc = "! \\ingroup driverapi\n! Used in NvAPI_GPU_GetMemoryInfo()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_DISPLAY_DRIVER_MEMORY_INFO_V2 { + #[doc = "!< Version info"] + pub version: NvU32, + #[doc = "!< Size(in kb) of the physical framebuffer."] + pub dedicatedVideoMemory: NvU32, + #[doc = "!< Size(in kb) of the available physical framebuffer for allocating video memory surfaces."] + pub availableDedicatedVideoMemory: NvU32, + #[doc = "!< Size(in kb) of system memory the driver allocates at load time."] + pub systemVideoMemory: NvU32, + #[doc = "!< Size(in kb) of shared system memory that driver is allowed to commit for surfaces across all allocations."] + pub sharedSystemMemory: NvU32, + #[doc = "!< Size(in kb) of the current available physical framebuffer for allocating video memory surfaces."] + pub curAvailableDedicatedVideoMemory: NvU32, +} +#[doc = "! \\ingroup driverapi\n! Used in NvAPI_GPU_GetMemoryInfo()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_DISPLAY_DRIVER_MEMORY_INFO_V3 { + #[doc = "!< Version info"] + pub version: NvU32, + #[doc = "!< Size(in kb) of the physical framebuffer."] + pub dedicatedVideoMemory: NvU32, + #[doc = "!< Size(in kb) of the available physical framebuffer for allocating video memory surfaces."] + pub availableDedicatedVideoMemory: NvU32, + #[doc = "!< Size(in kb) of system memory the driver allocates at load time."] + pub systemVideoMemory: NvU32, + #[doc = "!< Size(in kb) of shared system memory that driver is allowed to commit for surfaces across all allocations."] + pub sharedSystemMemory: NvU32, + #[doc = "!< Size(in kb) of the current available physical framebuffer for allocating video memory surfaces."] + pub curAvailableDedicatedVideoMemory: NvU32, + #[doc = "!< Size(in kb) of the total size of memory released as a result of the evictions."] + pub dedicatedVideoMemoryEvictionsSize: NvU32, + #[doc = "!< Indicates the number of eviction events that caused an allocation to be removed from dedicated video memory to free GPU\n!< video memory to make room for other allocations."] + pub dedicatedVideoMemoryEvictionCount: NvU32, +} +#[doc = "! \\ingroup driverapi"] +pub type NV_DISPLAY_DRIVER_MEMORY_INFO = NV_DISPLAY_DRIVER_MEMORY_INFO_V3; +#[doc = "! \\ingroup driverapi\n! Used in NvAPI_GPU_GetMemoryInfoEx()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_MEMORY_INFO_EX_V1 { + #[doc = "!< Structure version"] + pub version: NvU32, + #[doc = "!< Size(in bytes) of the physical framebuffer. Refers to the dedicated video memory on discrete GPUs."] + pub dedicatedVideoMemory: NvU64, + #[doc = "!< Size(in bytes) of the available physical framebuffer for allocating video memory surfaces."] + pub availableDedicatedVideoMemory: NvU64, + #[doc = "!< Size(in bytes) of system memory the driver allocates at load time. It is a substitute for dedicated video memory.\n!< Typically used with integrated GPUs that do not have dedicated video memory."] + pub systemVideoMemory: NvU64, + #[doc = "!< Size(in bytes) of shared system memory that driver is allowed to commit for surfaces across all allocations.\n!< On discrete GPUs, it is used to utilize system memory for various operations. It does not need to be reserved during boot.\n!< It may be used by both GPU and CPU, and has an \"on-demand\" type of usage."] + pub sharedSystemMemory: NvU64, + #[doc = "!< Size(in bytes) of the current available physical framebuffer for allocating video memory surfaces."] + pub curAvailableDedicatedVideoMemory: NvU64, + #[doc = "!< Size(in bytes) of the total size of memory released as a result of the evictions."] + pub dedicatedVideoMemoryEvictionsSize: NvU64, + #[doc = "!< Indicates the number of eviction events that caused an allocation to be removed from dedicated video memory to free GPU\n!< video memory to make room for other allocations."] + pub dedicatedVideoMemoryEvictionCount: NvU64, + #[doc = "!< Size(in bytes) of the total size of memory allocated as a result of the promotions."] + pub dedicatedVideoMemoryPromotionsSize: NvU64, + #[doc = "!< Indicates the number of promotion events that caused an allocation to be promoted to dedicated video memory"] + pub dedicatedVideoMemoryPromotionCount: NvU64, +} +#[doc = "! \\ingroup driverapi"] +pub type NV_GPU_MEMORY_INFO_EX = NV_GPU_MEMORY_INFO_EX_V1; +#[doc = "! \\ingroup dx\n! Used in NvAPI_D3D10_GetCurrentSLIState(), and NvAPI_D3D_GetCurrentSLIState()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GET_CURRENT_SLI_STATE_V1 { + #[doc = "!< Structure version"] + pub version: NvU32, + #[doc = "!< [OUT] The maximum possible value of numAFRGroups"] + pub maxNumAFRGroups: NvU32, + #[doc = "!< [OUT] The number of AFR groups enabled in the system"] + pub numAFRGroups: NvU32, + #[doc = "!< [OUT] The AFR group index for the frame currently being rendered"] + pub currentAFRIndex: NvU32, + #[doc = "!< [OUT] What the AFR group index will be for the next frame (i.e. after calling Present)"] + pub nextFrameAFRIndex: NvU32, + #[doc = "!< [OUT] The AFR group index that was used for the previous frame (~0 if more than one frame has not been rendered yet)"] + pub previousFrameAFRIndex: NvU32, + #[doc = "!< [OUT] Boolean: Is this frame the first time running on the current AFR group"] + pub bIsCurAFRGroupNew: NvU32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GET_CURRENT_SLI_STATE_V2 { + #[doc = "!< Structure version"] + pub version: NvU32, + #[doc = "!< [OUT] The maximum possible value of numAFRGroups"] + pub maxNumAFRGroups: NvU32, + #[doc = "!< [OUT] The number of AFR groups enabled in the system"] + pub numAFRGroups: NvU32, + #[doc = "!< [OUT] The AFR group index for the frame currently being rendered"] + pub currentAFRIndex: NvU32, + #[doc = "!< [OUT] What the AFR group index will be for the next frame (i.e. after calling Present)"] + pub nextFrameAFRIndex: NvU32, + #[doc = "!< [OUT] The AFR group index that was used for the previous frame (~0 if more than one frame has not been rendered yet)"] + pub previousFrameAFRIndex: NvU32, + #[doc = "!< [OUT] Boolean: Is this frame the first time running on the current AFR group"] + pub bIsCurAFRGroupNew: NvU32, + #[doc = "!< [OUT] The number of GPUs used in VR-SLI. If it is 0 VR-SLI is not active"] + pub numVRSLIGpus: NvU32, +} +pub const _NV_StereoActiveEye_NVAPI_STEREO_EYE_RIGHT: _NV_StereoActiveEye = 1; +pub const _NV_StereoActiveEye_NVAPI_STEREO_EYE_LEFT: _NV_StereoActiveEye = 2; +pub const _NV_StereoActiveEye_NVAPI_STEREO_EYE_MONO: _NV_StereoActiveEye = 3; +#[doc = "! \\ingroup stereoapi"] +pub type _NV_StereoActiveEye = ::std::os::raw::c_int; +#[doc = "! \\ingroup stereoapi"] +pub use self::_NV_StereoActiveEye as NV_STEREO_ACTIVE_EYE; +pub const _NV_StereoDriverMode_NVAPI_STEREO_DRIVER_MODE_AUTOMATIC: _NV_StereoDriverMode = 0; +pub const _NV_StereoDriverMode_NVAPI_STEREO_DRIVER_MODE_DIRECT: _NV_StereoDriverMode = 2; +#[doc = "! \\ingroup stereoapi"] +pub type _NV_StereoDriverMode = ::std::os::raw::c_int; +#[doc = "! \\ingroup stereoapi"] +pub use self::_NV_StereoDriverMode as NV_STEREO_DRIVER_MODE; +pub const _NV_DP_LINK_RATE_NV_DP_1_62GBPS: _NV_DP_LINK_RATE = 6; +pub const _NV_DP_LINK_RATE_NV_DP_2_70GBPS: _NV_DP_LINK_RATE = 10; +pub const _NV_DP_LINK_RATE_NV_DP_5_40GBPS: _NV_DP_LINK_RATE = 20; +pub const _NV_DP_LINK_RATE_NV_DP_8_10GBPS: _NV_DP_LINK_RATE = 30; +pub const _NV_DP_LINK_RATE_NV_EDP_2_16GBPS: _NV_DP_LINK_RATE = 8; +pub const _NV_DP_LINK_RATE_NV_EDP_2_43GBPS: _NV_DP_LINK_RATE = 9; +pub const _NV_DP_LINK_RATE_NV_EDP_3_24GBPS: _NV_DP_LINK_RATE = 12; +pub const _NV_DP_LINK_RATE_NV_EDP_4_32GBPS: _NV_DP_LINK_RATE = 16; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub type _NV_DP_LINK_RATE = ::std::os::raw::c_int; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub use self::_NV_DP_LINK_RATE as NV_DP_LINK_RATE; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_1_62Gbps: _NV_DP2X_LINK_RATE = 162; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_2_16Gbps: _NV_DP2X_LINK_RATE = 216; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_2_43Gbps: _NV_DP2X_LINK_RATE = 243; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_2_50Gbps: _NV_DP2X_LINK_RATE = 250; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_2_70Gbps: _NV_DP2X_LINK_RATE = 270; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_3_24Gbps: _NV_DP2X_LINK_RATE = 324; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_4_32Gbps: _NV_DP2X_LINK_RATE = 432; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_5_40Gbps: _NV_DP2X_LINK_RATE = 540; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_6_75Gbps: _NV_DP2X_LINK_RATE = 675; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_8_10Gbps: _NV_DP2X_LINK_RATE = 810; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_10_0Gbps: _NV_DP2X_LINK_RATE = 1000; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_13_5Gbps: _NV_DP2X_LINK_RATE = 1350; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_20_0Gbps: _NV_DP2X_LINK_RATE = 2000; +pub type _NV_DP2X_LINK_RATE = ::std::os::raw::c_int; +pub use self::_NV_DP2X_LINK_RATE as NV_DP2X_LINK_RATE; +pub const _NV_DP_LANE_COUNT_NV_DP_1_LANE: _NV_DP_LANE_COUNT = 1; +pub const _NV_DP_LANE_COUNT_NV_DP_2_LANE: _NV_DP_LANE_COUNT = 2; +pub const _NV_DP_LANE_COUNT_NV_DP_4_LANE: _NV_DP_LANE_COUNT = 4; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub type _NV_DP_LANE_COUNT = ::std::os::raw::c_int; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub use self::_NV_DP_LANE_COUNT as NV_DP_LANE_COUNT; +pub const _NV_DP_COLOR_FORMAT_NV_DP_COLOR_FORMAT_RGB: _NV_DP_COLOR_FORMAT = 0; +pub const _NV_DP_COLOR_FORMAT_NV_DP_COLOR_FORMAT_YCbCr422: _NV_DP_COLOR_FORMAT = 1; +pub const _NV_DP_COLOR_FORMAT_NV_DP_COLOR_FORMAT_YCbCr444: _NV_DP_COLOR_FORMAT = 2; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub type _NV_DP_COLOR_FORMAT = ::std::os::raw::c_int; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub use self::_NV_DP_COLOR_FORMAT as NV_DP_COLOR_FORMAT; +pub const _NV_DP_COLORIMETRY_NV_DP_COLORIMETRY_RGB: _NV_DP_COLORIMETRY = 0; +pub const _NV_DP_COLORIMETRY_NV_DP_COLORIMETRY_YCbCr_ITU601: _NV_DP_COLORIMETRY = 1; +pub const _NV_DP_COLORIMETRY_NV_DP_COLORIMETRY_YCbCr_ITU709: _NV_DP_COLORIMETRY = 2; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub type _NV_DP_COLORIMETRY = ::std::os::raw::c_int; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub use self::_NV_DP_COLORIMETRY as NV_DP_COLORIMETRY; +pub const _NV_DP_DYNAMIC_RANGE_NV_DP_DYNAMIC_RANGE_VESA: _NV_DP_DYNAMIC_RANGE = 0; +pub const _NV_DP_DYNAMIC_RANGE_NV_DP_DYNAMIC_RANGE_CEA: _NV_DP_DYNAMIC_RANGE = 1; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub type _NV_DP_DYNAMIC_RANGE = ::std::os::raw::c_int; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub use self::_NV_DP_DYNAMIC_RANGE as NV_DP_DYNAMIC_RANGE; +pub const _NV_DP_BPC_NV_DP_BPC_DEFAULT: _NV_DP_BPC = 0; +pub const _NV_DP_BPC_NV_DP_BPC_6: _NV_DP_BPC = 1; +pub const _NV_DP_BPC_NV_DP_BPC_8: _NV_DP_BPC = 2; +pub const _NV_DP_BPC_NV_DP_BPC_10: _NV_DP_BPC = 3; +pub const _NV_DP_BPC_NV_DP_BPC_12: _NV_DP_BPC = 4; +pub const _NV_DP_BPC_NV_DP_BPC_16: _NV_DP_BPC = 5; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub type _NV_DP_BPC = ::std::os::raw::c_int; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub use self::_NV_DP_BPC as NV_DP_BPC; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_EDID_V1 { + pub version: NvU32, + pub EDID_Data: [NvU8; 256usize], +} +#[doc = "! Used in NvAPI_GPU_GetEDID()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_EDID_V2 { + #[doc = "!< Structure version"] + pub version: NvU32, + pub EDID_Data: [NvU8; 256usize], + pub sizeofEDID: NvU32, +} +#[doc = "! Used in NvAPI_GPU_GetEDID()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_EDID_V3 { + #[doc = "!< Structure version"] + pub version: NvU32, + pub EDID_Data: [NvU8; 256usize], + pub sizeofEDID: NvU32, + #[doc = "!< ID which always returned in a monotonically increasing counter.\n!< Across a split-EDID read we need to verify that all calls returned the same edidId.\n!< This counter is incremented if we get the updated EDID."] + pub edidId: NvU32, + #[doc = "!< Which 256-byte page of the EDID we want to read. Start at 0.\n!< If the read succeeds with edidSize > NV_EDID_DATA_SIZE,\n!< call back again with offset+256 until we have read the entire buffer"] + pub offset: NvU32, +} +#[doc = "! Used in NvAPI_GPU_GetEDID()"] +pub type NV_EDID = NV_EDID_V3; +#[doc = "!< the EDID which is actively used by the driver, it could be _RAW/_COOKED/_FORCED/_INF."] +pub const NV_EDID_FLAG_NV_EDID_FLAG_DEFAULT: NV_EDID_FLAG = 0; +#[doc = "!< the EDID which is not modified by the driver. If there's no _FORCED edid engaged, it\n!< will be the unmodified monitor EDID from the I2C bus. Otherwise it is original _FORCED edid."] +pub const NV_EDID_FLAG_NV_EDID_FLAG_RAW: NV_EDID_FLAG = 1; +#[doc = "!< the EDID has been modified by the driver for compatibility"] +pub const NV_EDID_FLAG_NV_EDID_FLAG_COOKED: NV_EDID_FLAG = 2; +#[doc = "!< the EDID is forced by the end-user over s/w interface,"] +pub const NV_EDID_FLAG_NV_EDID_FLAG_FORCED: NV_EDID_FLAG = 3; +#[doc = "!< the EDID is from monitor INF"] +pub const NV_EDID_FLAG_NV_EDID_FLAG_INF: NV_EDID_FLAG = 4; +#[doc = "!< the EDID is from the monitor over I2C bus without any modification."] +pub const NV_EDID_FLAG_NV_EDID_FLAG_HW: NV_EDID_FLAG = 5; +pub type NV_EDID_FLAG = ::std::os::raw::c_int; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_VGA_15_PIN: _NV_GPU_CONNECTOR_TYPE = 0; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_TV_COMPOSITE: _NV_GPU_CONNECTOR_TYPE = 16; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_TV_SVIDEO: _NV_GPU_CONNECTOR_TYPE = 17; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_TV_HDTV_COMPONENT: _NV_GPU_CONNECTOR_TYPE = 19; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_TV_SCART: _NV_GPU_CONNECTOR_TYPE = 20; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_TV_COMPOSITE_SCART_ON_EIAJ4120: + _NV_GPU_CONNECTOR_TYPE = 22; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_TV_HDTV_EIAJ4120: _NV_GPU_CONNECTOR_TYPE = 23; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_PC_POD_HDTV_YPRPB: _NV_GPU_CONNECTOR_TYPE = 24; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_PC_POD_SVIDEO: _NV_GPU_CONNECTOR_TYPE = 25; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_PC_POD_COMPOSITE: _NV_GPU_CONNECTOR_TYPE = 26; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DVI_I_TV_SVIDEO: _NV_GPU_CONNECTOR_TYPE = 32; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DVI_I_TV_COMPOSITE: _NV_GPU_CONNECTOR_TYPE = + 33; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DVI_I: _NV_GPU_CONNECTOR_TYPE = 48; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DVI_D: _NV_GPU_CONNECTOR_TYPE = 49; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_ADC: _NV_GPU_CONNECTOR_TYPE = 50; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_LFH_DVI_I_1: _NV_GPU_CONNECTOR_TYPE = 56; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_LFH_DVI_I_2: _NV_GPU_CONNECTOR_TYPE = 57; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_SPWG: _NV_GPU_CONNECTOR_TYPE = 64; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_OEM: _NV_GPU_CONNECTOR_TYPE = 65; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DISPLAYPORT_EXTERNAL: _NV_GPU_CONNECTOR_TYPE = + 70; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DISPLAYPORT_INTERNAL: _NV_GPU_CONNECTOR_TYPE = + 71; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DISPLAYPORT_MINI_EXT: _NV_GPU_CONNECTOR_TYPE = + 72; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_HDMI_A: _NV_GPU_CONNECTOR_TYPE = 97; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_HDMI_C_MINI: _NV_GPU_CONNECTOR_TYPE = 99; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_LFH_DISPLAYPORT_1: _NV_GPU_CONNECTOR_TYPE = + 100; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_LFH_DISPLAYPORT_2: _NV_GPU_CONNECTOR_TYPE = + 101; +#[doc = "!< Deprecated."] +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_VIRTUAL_WFD: _NV_GPU_CONNECTOR_TYPE = 112; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_USB_C: _NV_GPU_CONNECTOR_TYPE = 113; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_UNKNOWN: _NV_GPU_CONNECTOR_TYPE = -1; +#[doc = "! \\ingroup gpu\n! Used in NV_GPU_CONNECTOR_DATA"] +pub type _NV_GPU_CONNECTOR_TYPE = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpu\n! Used in NV_GPU_CONNECTOR_DATA"] +pub use self::_NV_GPU_CONNECTOR_TYPE as NV_GPU_CONNECTOR_TYPE; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_NONE: _NV_DISPLAY_TV_FORMAT = 0; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_NTSCM: _NV_DISPLAY_TV_FORMAT = 1; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_NTSCJ: _NV_DISPLAY_TV_FORMAT = 2; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_PALM: _NV_DISPLAY_TV_FORMAT = 4; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_PALBDGH: _NV_DISPLAY_TV_FORMAT = 8; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_PALN: _NV_DISPLAY_TV_FORMAT = 16; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_PALNC: _NV_DISPLAY_TV_FORMAT = 32; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_576i: _NV_DISPLAY_TV_FORMAT = 256; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_480i: _NV_DISPLAY_TV_FORMAT = 512; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_ED_480p: _NV_DISPLAY_TV_FORMAT = 1024; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_ED_576p: _NV_DISPLAY_TV_FORMAT = 2048; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_720p: _NV_DISPLAY_TV_FORMAT = 4096; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_1080i: _NV_DISPLAY_TV_FORMAT = 8192; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_1080p: _NV_DISPLAY_TV_FORMAT = 16384; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_720p50: _NV_DISPLAY_TV_FORMAT = 32768; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_1080p24: _NV_DISPLAY_TV_FORMAT = 65536; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_1080i50: _NV_DISPLAY_TV_FORMAT = 131072; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_1080p50: _NV_DISPLAY_TV_FORMAT = 262144; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp30: _NV_DISPLAY_TV_FORMAT = 524288; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp30_3840: _NV_DISPLAY_TV_FORMAT = 524288; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp25: _NV_DISPLAY_TV_FORMAT = 1048576; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp25_3840: _NV_DISPLAY_TV_FORMAT = + 1048576; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp24: _NV_DISPLAY_TV_FORMAT = 2097152; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp24_3840: _NV_DISPLAY_TV_FORMAT = + 2097152; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp24_SMPTE: _NV_DISPLAY_TV_FORMAT = + 4194304; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp50_3840: _NV_DISPLAY_TV_FORMAT = + 8388608; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp60_3840: _NV_DISPLAY_TV_FORMAT = + 9437184; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp30_4096: _NV_DISPLAY_TV_FORMAT = + 10485760; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp25_4096: _NV_DISPLAY_TV_FORMAT = + 11534336; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp24_4096: _NV_DISPLAY_TV_FORMAT = + 12582912; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp50_4096: _NV_DISPLAY_TV_FORMAT = + 13631488; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp60_4096: _NV_DISPLAY_TV_FORMAT = + 14680064; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp24_7680: _NV_DISPLAY_TV_FORMAT = + 16777216; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp25_7680: _NV_DISPLAY_TV_FORMAT = + 33554432; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp30_7680: _NV_DISPLAY_TV_FORMAT = + 67108864; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp48_7680: _NV_DISPLAY_TV_FORMAT = + 134217728; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp50_7680: _NV_DISPLAY_TV_FORMAT = + 150994944; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp60_7680: _NV_DISPLAY_TV_FORMAT = + 167772160; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp100_7680: _NV_DISPLAY_TV_FORMAT = + 184549376; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp120_7680: _NV_DISPLAY_TV_FORMAT = + 201326592; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp48_3840: _NV_DISPLAY_TV_FORMAT = + 218103808; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp48_4096: _NV_DISPLAY_TV_FORMAT = + 234881024; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp100_4096: _NV_DISPLAY_TV_FORMAT = + 251658240; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp100_3840: _NV_DISPLAY_TV_FORMAT = + 268435456; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp120_4096: _NV_DISPLAY_TV_FORMAT = + 285212672; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp120_3840: _NV_DISPLAY_TV_FORMAT = + 301989888; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp100_5120: _NV_DISPLAY_TV_FORMAT = + 318767104; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp120_5120: _NV_DISPLAY_TV_FORMAT = + 335544320; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp24_5120: _NV_DISPLAY_TV_FORMAT = + 352321536; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp25_5120: _NV_DISPLAY_TV_FORMAT = + 369098752; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp30_5120: _NV_DISPLAY_TV_FORMAT = + 385875968; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp48_5120: _NV_DISPLAY_TV_FORMAT = + 402653184; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp50_5120: _NV_DISPLAY_TV_FORMAT = + 419430400; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp60_5120: _NV_DISPLAY_TV_FORMAT = + 536870912; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp24_10240: _NV_DISPLAY_TV_FORMAT = + 553648128; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp25_10240: _NV_DISPLAY_TV_FORMAT = + 570425344; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp30_10240: _NV_DISPLAY_TV_FORMAT = + 587202560; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp48_10240: _NV_DISPLAY_TV_FORMAT = + 603979776; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp50_10240: _NV_DISPLAY_TV_FORMAT = + 620756992; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp60_10240: _NV_DISPLAY_TV_FORMAT = + 637534208; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp100_10240: _NV_DISPLAY_TV_FORMAT = + 654311424; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp120_10240: _NV_DISPLAY_TV_FORMAT = + 671088640; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_OTHER: _NV_DISPLAY_TV_FORMAT = 805306368; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_ED_OTHER: _NV_DISPLAY_TV_FORMAT = 1073741824; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_OTHER: _NV_DISPLAY_TV_FORMAT = 1342177280; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_ANY: _NV_DISPLAY_TV_FORMAT = -2147483648; +#[doc = "! \\ingroup tvapi\n! Used in NV_DISPLAY_TV_OUTPUT_INFO"] +pub type _NV_DISPLAY_TV_FORMAT = ::std::os::raw::c_int; +#[doc = "! \\ingroup tvapi\n! Used in NV_DISPLAY_TV_OUTPUT_INFO"] +pub use self::_NV_DISPLAY_TV_FORMAT as NV_DISPLAY_TV_FORMAT; +pub const _NV_TARGET_VIEW_MODE_NV_VIEW_MODE_STANDARD: _NV_TARGET_VIEW_MODE = 0; +pub const _NV_TARGET_VIEW_MODE_NV_VIEW_MODE_CLONE: _NV_TARGET_VIEW_MODE = 1; +pub const _NV_TARGET_VIEW_MODE_NV_VIEW_MODE_HSPAN: _NV_TARGET_VIEW_MODE = 2; +pub const _NV_TARGET_VIEW_MODE_NV_VIEW_MODE_VSPAN: _NV_TARGET_VIEW_MODE = 3; +pub const _NV_TARGET_VIEW_MODE_NV_VIEW_MODE_DUALVIEW: _NV_TARGET_VIEW_MODE = 4; +pub const _NV_TARGET_VIEW_MODE_NV_VIEW_MODE_MULTIVIEW: _NV_TARGET_VIEW_MODE = 5; +#[doc = "! Used in NvAPI_SetView()."] +pub type _NV_TARGET_VIEW_MODE = ::std::os::raw::c_int; +#[doc = "! Used in NvAPI_SetView()."] +pub use self::_NV_TARGET_VIEW_MODE as NV_TARGET_VIEW_MODE; +#[doc = "!< No change"] +pub const _NV_SCALING_NV_SCALING_DEFAULT: _NV_SCALING = 0; +#[doc = "!< Balanced - Full Screen"] +pub const _NV_SCALING_NV_SCALING_GPU_SCALING_TO_CLOSEST: _NV_SCALING = 1; +#[doc = "!< Force GPU - Full Screen"] +pub const _NV_SCALING_NV_SCALING_GPU_SCALING_TO_NATIVE: _NV_SCALING = 2; +#[doc = "!< Force GPU - Centered\\No Scaling"] +pub const _NV_SCALING_NV_SCALING_GPU_SCANOUT_TO_NATIVE: _NV_SCALING = 3; +#[doc = "!< Force GPU - Aspect Ratio"] +pub const _NV_SCALING_NV_SCALING_GPU_SCALING_TO_ASPECT_SCANOUT_TO_NATIVE: _NV_SCALING = 5; +#[doc = "!< Balanced - Aspect Ratio"] +pub const _NV_SCALING_NV_SCALING_GPU_SCALING_TO_ASPECT_SCANOUT_TO_CLOSEST: _NV_SCALING = 6; +#[doc = "!< Balanced - Centered\\No Scaling"] +pub const _NV_SCALING_NV_SCALING_GPU_SCANOUT_TO_CLOSEST: _NV_SCALING = 7; +#[doc = "!< Force GPU - Integer Scaling"] +pub const _NV_SCALING_NV_SCALING_GPU_INTEGER_ASPECT_SCALING: _NV_SCALING = 8; +pub const _NV_SCALING_NV_SCALING_MONITOR_SCALING: _NV_SCALING = 1; +pub const _NV_SCALING_NV_SCALING_ADAPTER_SCALING: _NV_SCALING = 2; +pub const _NV_SCALING_NV_SCALING_CENTERED: _NV_SCALING = 3; +pub const _NV_SCALING_NV_SCALING_ASPECT_SCALING: _NV_SCALING = 5; +#[doc = "!< For future use"] +pub const _NV_SCALING_NV_SCALING_CUSTOMIZED: _NV_SCALING = 255; +#[doc = "! Scaling modes - used in NvAPI_SetViewEx().\n! \\ingroup dispcontrol"] +pub type _NV_SCALING = ::std::os::raw::c_int; +#[doc = "! Scaling modes - used in NvAPI_SetViewEx().\n! \\ingroup dispcontrol"] +pub use self::_NV_SCALING as NV_SCALING; +pub const _NV_ROTATE_NV_ROTATE_0: _NV_ROTATE = 0; +pub const _NV_ROTATE_NV_ROTATE_90: _NV_ROTATE = 1; +pub const _NV_ROTATE_NV_ROTATE_180: _NV_ROTATE = 2; +pub const _NV_ROTATE_NV_ROTATE_270: _NV_ROTATE = 3; +pub const _NV_ROTATE_NV_ROTATE_IGNORED: _NV_ROTATE = 4; +#[doc = "! \\ingroup dispcontrol"] +pub type _NV_ROTATE = ::std::os::raw::c_int; +#[doc = "! \\ingroup dispcontrol"] +pub use self::_NV_ROTATE as NV_ROTATE; +#[doc = "!< unknown. Driver will choose one as following value."] +pub const _NV_FORMAT_NV_FORMAT_UNKNOWN: _NV_FORMAT = 0; +#[doc = "!< for 8bpp mode"] +pub const _NV_FORMAT_NV_FORMAT_P8: _NV_FORMAT = 41; +#[doc = "!< for 16bpp mode"] +pub const _NV_FORMAT_NV_FORMAT_R5G6B5: _NV_FORMAT = 23; +#[doc = "!< for 32bpp mode"] +pub const _NV_FORMAT_NV_FORMAT_A8R8G8B8: _NV_FORMAT = 21; +#[doc = "!< for 64bpp(floating point) mode."] +pub const _NV_FORMAT_NV_FORMAT_A16B16G16R16F: _NV_FORMAT = 113; +#[doc = "! Color formats- used in NvAPI_SetViewEx().\n! \\ingroup dispcontrol"] +pub type _NV_FORMAT = ::std::os::raw::c_int; +#[doc = "! Color formats- used in NvAPI_SetViewEx().\n! \\ingroup dispcontrol"] +pub use self::_NV_FORMAT as NV_FORMAT; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_VIEWPORTF { + #[doc = "!< x-coordinate of the viewport top-left point"] + pub x: f32, + #[doc = "!< y-coordinate of the viewport top-left point"] + pub y: f32, + #[doc = "!< Width of the viewport"] + pub w: f32, + #[doc = "!< Height of the viewport"] + pub h: f32, +} +#[doc = "!< get the current timing"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_CURRENT: _NV_TIMING_OVERRIDE = 0; +#[doc = "!< the timing the driver will use based the current policy"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_AUTO: _NV_TIMING_OVERRIDE = 1; +#[doc = "!< EDID timing"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_EDID: _NV_TIMING_OVERRIDE = 2; +#[doc = "!< VESA DMT timing"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_DMT: _NV_TIMING_OVERRIDE = 3; +#[doc = "!< VESA DMT timing with reduced blanking"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_DMT_RB: _NV_TIMING_OVERRIDE = 4; +#[doc = "!< VESA CVT timing"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_CVT: _NV_TIMING_OVERRIDE = 5; +#[doc = "!< VESA CVT timing with reduced blanking"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_CVT_RB: _NV_TIMING_OVERRIDE = 6; +#[doc = "!< VESA GTF timing"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_GTF: _NV_TIMING_OVERRIDE = 7; +#[doc = "!< EIA 861x pre-defined timing"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_EIA861: _NV_TIMING_OVERRIDE = 8; +#[doc = "!< analog SD/HDTV timing"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_ANALOG_TV: _NV_TIMING_OVERRIDE = 9; +#[doc = "!< NV custom timings"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_CUST: _NV_TIMING_OVERRIDE = 10; +#[doc = "!< NV pre-defined timing (basically the PsF timings)"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_NV_PREDEFINED: _NV_TIMING_OVERRIDE = 11; +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_NV_PSF: _NV_TIMING_OVERRIDE = 11; +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_NV_ASPR: _NV_TIMING_OVERRIDE = 12; +#[doc = "!< Override for SDI timing"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_SDI: _NV_TIMING_OVERRIDE = 13; +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVRRIDE_MAX: _NV_TIMING_OVERRIDE = 14; +#[doc = "! \\ingroup dispcontrol\n! The timing override is not supported yet; must be set to _AUTO. \\n"] +pub type _NV_TIMING_OVERRIDE = ::std::os::raw::c_int; +#[doc = "! \\ingroup dispcontrol\n! The timing override is not supported yet; must be set to _AUTO. \\n"] +pub use self::_NV_TIMING_OVERRIDE as NV_TIMING_OVERRIDE; +#[doc = "! \\ingroup dispcontrol\n! NVIDIA-specific timing extras \\n\n! Used in NV_TIMING."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct tagNV_TIMINGEXT { + #[doc = "!< Reserved for NVIDIA hardware-based enhancement, such as double-scan."] + pub flag: NvU32, + #[doc = "!< Logical refresh rate to present"] + pub rr: NvU16, + #[doc = "!< Physical vertical refresh rate in 0.001Hz"] + pub rrx1k: NvU32, + #[doc = "!< Display aspect ratio Hi(aspect):horizontal-aspect, Low(aspect):vertical-aspect"] + pub aspect: NvU32, + #[doc = "!< Bit-wise pixel repetition factor: 0x1:no pixel repetition; 0x2:each pixel repeats twice horizontally,.."] + pub rep: NvU16, + #[doc = "!< Timing standard"] + pub status: NvU32, + #[doc = "!< Timing name"] + pub name: [NvU8; 40usize], +} +#[doc = "! \\ingroup dispcontrol\n! NVIDIA-specific timing extras \\n\n! Used in NV_TIMING."] +pub type NV_TIMINGEXT = tagNV_TIMINGEXT; +#[doc = "! \\ingroup dispcontrol\n!The very basic timing structure based on the VESA standard:\n! \\code\n! |<----------------------------htotal--------------------------->|\n! ---------\"active\" video-------->|<-------blanking------>|<-----\n! |<-------hvisible-------->|<-hb->|<-hfp->|<-hsw->|<-hbp->|<-hb->|\n! --------- -+-------------------------+ | | | | |\n! A A | | | | | | |\n! : : | | | | | | |\n! : : | | | | | | |\n! :vertical| addressable video | | | | | |\n! : visible| | | | | | |\n! : : | | | | | | |\n! : : | | | | | | |\n! vertical V | | | | | | |\n! total --+-------------------------+ | | | | |\n! : vb border | | | | |\n! : -----------------------------------+ | | | |\n! : vfp front porch | | | |\n! : -------------------------------------------+ | | |\n! : vsw sync width | | |\n! : ---------------------------------------------------+ | |\n! : vbp back porch | |\n! : -----------------------------------------------------------+ |\n! V vb border |\n! ---------------------------------------------------------------------------+\n! \\endcode"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_TIMING { + #[doc = "!< horizontal visible"] + pub HVisible: NvU16, + #[doc = "!< horizontal border"] + pub HBorder: NvU16, + #[doc = "!< horizontal front porch"] + pub HFrontPorch: NvU16, + #[doc = "!< horizontal sync width"] + pub HSyncWidth: NvU16, + #[doc = "!< horizontal total"] + pub HTotal: NvU16, + #[doc = "!< horizontal sync polarity: 1-negative, 0-positive"] + pub HSyncPol: NvU8, + #[doc = "!< vertical visible"] + pub VVisible: NvU16, + #[doc = "!< vertical border"] + pub VBorder: NvU16, + #[doc = "!< vertical front porch"] + pub VFrontPorch: NvU16, + #[doc = "!< vertical sync width"] + pub VSyncWidth: NvU16, + #[doc = "!< vertical total"] + pub VTotal: NvU16, + #[doc = "!< vertical sync polarity: 1-negative, 0-positive"] + pub VSyncPol: NvU8, + #[doc = "!< 1-interlaced, 0-progressive"] + pub interlaced: NvU16, + #[doc = "!< pixel clock in 10 kHz"] + pub pclk: NvU32, + pub etc: NV_TIMINGEXT, +} +#[doc = "! \\ingroup dispcontrol\n!The very basic timing structure based on the VESA standard:\n! \\code\n! |<----------------------------htotal--------------------------->|\n! ---------\"active\" video-------->|<-------blanking------>|<-----\n! |<-------hvisible-------->|<-hb->|<-hfp->|<-hsw->|<-hbp->|<-hb->|\n! --------- -+-------------------------+ | | | | |\n! A A | | | | | | |\n! : : | | | | | | |\n! : : | | | | | | |\n! :vertical| addressable video | | | | | |\n! : visible| | | | | | |\n! : : | | | | | | |\n! : : | | | | | | |\n! vertical V | | | | | | |\n! total --+-------------------------+ | | | | |\n! : vb border | | | | |\n! : -----------------------------------+ | | | |\n! : vfp front porch | | | |\n! : -------------------------------------------+ | | |\n! : vsw sync width | | |\n! : ---------------------------------------------------+ | |\n! : vbp back porch | |\n! : -----------------------------------------------------------+ |\n! V vb border |\n! ---------------------------------------------------------------------------+\n! \\endcode"] +pub type NV_TIMING = _NV_TIMING; +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_SetView() and NvAPI_GetView()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_VIEW_TARGET_INFO { + #[doc = "!< (IN) structure version"] + pub version: NvU32, + #[doc = "!< (IN) target count"] + pub count: NvU32, + pub target: [NV_VIEW_TARGET_INFO__bindgen_ty_1; 2usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_VIEW_TARGET_INFO__bindgen_ty_1 { + #[doc = "!< (IN/OUT) Device mask"] + pub deviceMask: NvU32, + #[doc = "!< (IN/OUT) Source ID - values will be based on the number of heads exposed per GPU."] + pub sourceId: NvU32, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +impl NV_VIEW_TARGET_INFO__bindgen_ty_1 { + #[inline] + pub fn bPrimary(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bPrimary(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bPrimary_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bPrimary_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bInterlaced(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bInterlaced(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bInterlaced_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bInterlaced_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bGDIPrimary(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_bGDIPrimary(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bGDIPrimary_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bGDIPrimary_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bForceModeSet(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_bForceModeSet(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bForceModeSet_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bForceModeSet_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bPrimary: NvU32, + bInterlaced: NvU32, + bGDIPrimary: NvU32, + bForceModeSet: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bPrimary: u32 = unsafe { ::std::mem::transmute(bPrimary) }; + bPrimary as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bInterlaced: u32 = unsafe { ::std::mem::transmute(bInterlaced) }; + bInterlaced as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let bGDIPrimary: u32 = unsafe { ::std::mem::transmute(bGDIPrimary) }; + bGDIPrimary as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let bForceModeSet: u32 = unsafe { ::std::mem::transmute(bForceModeSet) }; + bForceModeSet as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PATH_INFO."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_DISPLAY_PATH { + #[doc = "!< (IN) Device mask"] + pub deviceMask: NvU32, + #[doc = "!< (IN) Values will be based on the number of heads exposed per GPU(0, 1?)"] + pub sourceId: NvU32, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + #[doc = "!< (IN) Specify connector type. For TV only."] + pub connector: NV_GPU_CONNECTOR_TYPE, + #[doc = "!< (IN) Width of the mode"] + pub width: NvU32, + #[doc = "!< (IN) Height of the mode"] + pub height: NvU32, + #[doc = "!< (IN) Depth of the mode"] + pub depth: NvU32, + #[doc = "!< Color format if it needs to be specified. Not used now."] + pub colorFormat: NV_FORMAT, + #[doc = "!< (IN) Rotation setting."] + pub rotation: NV_ROTATE, + #[doc = "!< (IN) Scaling setting"] + pub scaling: NV_SCALING, + #[doc = "!< (IN) Refresh rate of the mode"] + pub refreshRate: NvU32, + pub _bitfield_align_2: [u8; 0], + pub _bitfield_2: __BindgenBitfieldUnit<[u8; 1usize]>, + #[doc = "!< (IN) To choose the last TV format set this value to NV_DISPLAY_TV_FORMAT_NONE"] + pub tvFormat: NV_DISPLAY_TV_FORMAT, + #[doc = "!< (IN/OUT) X-offset of this display on the Windows desktop"] + pub posx: NvU32, + #[doc = "!< (IN/OUT) Y-offset of this display on the Windows desktop"] + pub posy: NvU32, + pub _bitfield_align_3: [u32; 0], + pub _bitfield_3: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl NV_DISPLAY_PATH { + #[inline] + pub fn bPrimary(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bPrimary(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bPrimary_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bPrimary_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1(bPrimary: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bPrimary: u32 = unsafe { ::std::mem::transmute(bPrimary) }; + bPrimary as u64 + }); + __bindgen_bitfield_unit + } + #[inline] + pub fn interlaced(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_interlaced(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_2.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn interlaced_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_2), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_interlaced_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_2(interlaced: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let interlaced: u32 = unsafe { ::std::mem::transmute(interlaced) }; + interlaced as u64 + }); + __bindgen_bitfield_unit + } + #[inline] + pub fn bGDIPrimary(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_3.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bGDIPrimary(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_3.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bGDIPrimary_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_3), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bGDIPrimary_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_3), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bForceModeSet(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_3.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bForceModeSet(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_3.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bForceModeSet_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_3), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bForceModeSet_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_3), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bFocusDisplay(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_3.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_bFocusDisplay(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_3.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bFocusDisplay_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_3), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bFocusDisplay_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_3), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn gpuId(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_3.get(3usize, 24u8) as u32) } + } + #[inline] + pub fn set_gpuId(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_3.set(3usize, 24u8, val as u64) + } + } + #[inline] + pub unsafe fn gpuId_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_3), + 3usize, + 24u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_gpuId_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_3), + 3usize, + 24u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_3( + bGDIPrimary: NvU32, + bForceModeSet: NvU32, + bFocusDisplay: NvU32, + gpuId: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bGDIPrimary: u32 = unsafe { ::std::mem::transmute(bGDIPrimary) }; + bGDIPrimary as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bForceModeSet: u32 = unsafe { ::std::mem::transmute(bForceModeSet) }; + bForceModeSet as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let bFocusDisplay: u32 = unsafe { ::std::mem::transmute(bFocusDisplay) }; + bFocusDisplay as u64 + }); + __bindgen_bitfield_unit.set(3usize, 24u8, { + let gpuId: u32 = unsafe { ::std::mem::transmute(gpuId) }; + gpuId as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_SetViewEx() and NvAPI_GetViewEx()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_DISPLAY_PATH_INFO_V3 { + #[doc = "!< (IN) Structure version"] + pub version: NvU32, + #[doc = "!< (IN) Path count"] + pub count: NvU32, + pub path: [NV_DISPLAY_PATH; 2usize], +} +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_SetViewEx() and NvAPI_GetViewEx()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_DISPLAY_PATH_INFO { + #[doc = "!< (IN) Structure version"] + pub version: NvU32, + #[doc = "!< (IN) Path count"] + pub count: NvU32, + pub path: [NV_DISPLAY_PATH; 4usize], +} +#[doc = "\n! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_POSITION { + pub x: NvS32, + pub y: NvS32, +} +#[doc = "\n! \\ingroup dispcontrol"] +pub type NV_POSITION = _NV_POSITION; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_RESOLUTION { + pub width: NvU32, + pub height: NvU32, + pub colorDepth: NvU32, +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_RESOLUTION = _NV_RESOLUTION; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO_V1 { + pub version: NvU32, + #[doc = "!< (IN) rotation setting."] + pub rotation: NV_ROTATE, + #[doc = "!< (IN) scaling setting."] + pub scaling: NV_SCALING, + #[doc = "!< (IN) Non-interlaced Refresh Rate of the mode, multiplied by 1000, 0 = ignored\n!< This is the value which driver reports to the OS."] + pub refreshRate1K: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Specify connector type. For TV only, ignored if tvFormat == NV_DISPLAY_TV_FORMAT_NONE"] + pub connector: NV_GPU_CONNECTOR_TYPE, + #[doc = "!< (IN) to choose the last TV format set this value to NV_DISPLAY_TV_FORMAT_NONE\n!< In case of NvAPI_DISP_GetDisplayConfig(), this field will indicate the currently applied TV format;\n!< if no TV format is applied, this field will have NV_DISPLAY_TV_FORMAT_NONE value.\n!< In case of NvAPI_DISP_SetDisplayConfig(), this field should only be set in case of TVs;\n!< for other displays this field will be ignored and resolution & refresh rate specified in input will be used to apply the TV format."] + pub tvFormat: NV_DISPLAY_TV_FORMAT, + #[doc = "!< Ignored if timingOverride == NV_TIMING_OVERRIDE_CURRENT"] + pub timingOverride: NV_TIMING_OVERRIDE, + #[doc = "!< Scan out timing, valid only if timingOverride == NV_TIMING_OVERRIDE_CUST\n!< The value NV_TIMING::NV_TIMINGEXT::rrx1k is obtained from the EDID. The driver may\n!< tweak this value for HDTV, stereo, etc., before reporting it to the OS."] + pub timing: NV_TIMING, +} +impl _NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO_V1 { + #[inline] + pub fn interlaced(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_interlaced(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn interlaced_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_interlaced_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn primary(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_primary(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn primary_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_primary_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reservedBit1(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_reservedBit1(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn reservedBit1_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reservedBit1_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn disableVirtualModeSupport(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_disableVirtualModeSupport(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn disableVirtualModeSupport_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_disableVirtualModeSupport_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isPreferredUnscaledTarget(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_isPreferredUnscaledTarget(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isPreferredUnscaledTarget_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isPreferredUnscaledTarget_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 27u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 27u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 27u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + interlaced: NvU32, + primary: NvU32, + reservedBit1: NvU32, + disableVirtualModeSupport: NvU32, + isPreferredUnscaledTarget: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let interlaced: u32 = unsafe { ::std::mem::transmute(interlaced) }; + interlaced as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let primary: u32 = unsafe { ::std::mem::transmute(primary) }; + primary as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let reservedBit1: u32 = unsafe { ::std::mem::transmute(reservedBit1) }; + reservedBit1 as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let disableVirtualModeSupport: u32 = + unsafe { ::std::mem::transmute(disableVirtualModeSupport) }; + disableVirtualModeSupport as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let isPreferredUnscaledTarget: u32 = + unsafe { ::std::mem::transmute(isPreferredUnscaledTarget) }; + isPreferredUnscaledTarget as u64 + }); + __bindgen_bitfield_unit.set(5usize, 27u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO_V1 = + _NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO_V1; +#[doc = "! \\ingroup dispcontrol"] +pub type NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO = NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO_V1; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_DISPLAYCONFIG_PATH_TARGET_INFO_V1 { + #[doc = "!< Display ID"] + pub displayId: NvU32, + #[doc = "!< May be NULL if no advanced settings are required. NULL for Non-NVIDIA Display."] + pub details: *mut NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO, +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_DISPLAYCONFIG_PATH_TARGET_INFO_V1 = _NV_DISPLAYCONFIG_PATH_TARGET_INFO_V1; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_DISPLAYCONFIG_PATH_TARGET_INFO_V2 { + #[doc = "!< Display ID"] + pub displayId: NvU32, + #[doc = "!< May be NULL if no advanced settings are required"] + pub details: *mut NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO, + #[doc = "!< Windows CCD target ID. Must be present only for non-NVIDIA adapter, for NVIDIA adapter this parameter is ignored."] + pub targetId: NvU32, +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_DISPLAYCONFIG_PATH_TARGET_INFO_V2 = _NV_DISPLAYCONFIG_PATH_TARGET_INFO_V2; +#[doc = "! \\ingroup dispcontrol\n! As version is not defined for this structure, we will be using version of NV_DISPLAYCONFIG_PATH_INFO"] +pub type NV_DISPLAYCONFIG_PATH_TARGET_INFO = NV_DISPLAYCONFIG_PATH_TARGET_INFO_V2; +pub const _NV_DISPLAYCONFIG_SPANNING_ORIENTATION_NV_DISPLAYCONFIG_SPAN_NONE: + _NV_DISPLAYCONFIG_SPANNING_ORIENTATION = 0; +pub const _NV_DISPLAYCONFIG_SPANNING_ORIENTATION_NV_DISPLAYCONFIG_SPAN_HORIZONTAL: + _NV_DISPLAYCONFIG_SPANNING_ORIENTATION = 1; +pub const _NV_DISPLAYCONFIG_SPANNING_ORIENTATION_NV_DISPLAYCONFIG_SPAN_VERTICAL: + _NV_DISPLAYCONFIG_SPANNING_ORIENTATION = 2; +#[doc = "! \\ingroup dispcontrol"] +pub type _NV_DISPLAYCONFIG_SPANNING_ORIENTATION = ::std::os::raw::c_int; +#[doc = "! \\ingroup dispcontrol"] +pub use self::_NV_DISPLAYCONFIG_SPANNING_ORIENTATION as NV_DISPLAYCONFIG_SPANNING_ORIENTATION; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1 { + pub resolution: NV_RESOLUTION, + #[doc = "!< Ignored at present, must be NV_FORMAT_UNKNOWN (0)"] + pub colorFormat: NV_FORMAT, + #[doc = "!< Is all positions are 0 or invalid, displays will be automatically\n!< positioned from left to right with GDI Primary at 0,0, and all\n!< other displays in the order of the path array."] + pub position: NV_POSITION, + #[doc = "!< Spanning is only supported on XP"] + pub spanningOrientation: NV_DISPLAYCONFIG_SPANNING_ORIENTATION, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl _NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1 { + #[inline] + pub fn bGDIPrimary(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bGDIPrimary(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bGDIPrimary_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bGDIPrimary_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bSLIFocus(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bSLIFocus(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bSLIFocus_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bSLIFocus_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 30u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 30u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 30u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bGDIPrimary: NvU32, + bSLIFocus: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bGDIPrimary: u32 = unsafe { ::std::mem::transmute(bGDIPrimary) }; + bGDIPrimary as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bSLIFocus: u32 = unsafe { ::std::mem::transmute(bSLIFocus) }; + bSLIFocus as u64 + }); + __bindgen_bitfield_unit.set(2usize, 30u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1 = _NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_DISPLAYCONFIG_PATH_INFO_V1 { + pub version: NvU32, + #[doc = "!< This field is reserved. There is ongoing debate if we need this field.\n!< Identifies sourceIds used by Windows. If all sourceIds are 0,\n!< these will be computed automatically."] + pub reserved_sourceId: NvU32, + #[doc = "!< Number of elements in targetInfo array"] + pub targetInfoCount: NvU32, + pub targetInfo: *mut NV_DISPLAYCONFIG_PATH_TARGET_INFO_V1, + #[doc = "!< May be NULL if mode info is not important"] + pub sourceModeInfo: *mut NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1, +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_DISPLAYCONFIG_PATH_INFO_V1 = _NV_DISPLAYCONFIG_PATH_INFO_V1; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_DISPLAYCONFIG_PATH_INFO { + pub version: NvU32, + pub __bindgen_anon_1: _NV_DISPLAYCONFIG_PATH_INFO__bindgen_ty_1, + #[doc = "!< Number of elements in targetInfo array"] + pub targetInfoCount: NvU32, + pub targetInfo: *mut NV_DISPLAYCONFIG_PATH_TARGET_INFO_V2, + #[doc = "!< May be NULL if mode info is not important"] + pub sourceModeInfo: *mut NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Used by Non-NVIDIA adapter for pointer to OS Adapter of LUID\n!< type, type casted to void *."] + pub pOSAdapterID: *mut ::std::os::raw::c_void, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union _NV_DISPLAYCONFIG_PATH_INFO__bindgen_ty_1 { + #[doc = "!< Identifies sourceId used by Windows CCD. This can be optionally set."] + pub sourceId: NvU32, + #[doc = "!< Only for compatibility"] + pub reserved_sourceId: NvU32, +} +impl _NV_DISPLAYCONFIG_PATH_INFO { + #[inline] + pub fn IsNonNVIDIAAdapter(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_IsNonNVIDIAAdapter(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn IsNonNVIDIAAdapter_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_IsNonNVIDIAAdapter_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + IsNonNVIDIAAdapter: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let IsNonNVIDIAAdapter: u32 = unsafe { ::std::mem::transmute(IsNonNVIDIAAdapter) }; + IsNonNVIDIAAdapter as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_DISPLAYCONFIG_PATH_INFO_V2 = _NV_DISPLAYCONFIG_PATH_INFO; +#[doc = "! \\ingroup dispcontrol"] +pub type NV_DISPLAYCONFIG_PATH_INFO = NV_DISPLAYCONFIG_PATH_INFO_V2; +#[doc = "! \\ingroup dispcontrol"] +pub type NV_DISPLAYCONFIG_SOURCE_MODE_INFO = NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1; +pub const _NV_DISPLAYCONFIG_FLAGS_NV_DISPLAYCONFIG_VALIDATE_ONLY: _NV_DISPLAYCONFIG_FLAGS = 1; +pub const _NV_DISPLAYCONFIG_FLAGS_NV_DISPLAYCONFIG_SAVE_TO_PERSISTENCE: _NV_DISPLAYCONFIG_FLAGS = 2; +#[doc = "!< Driver reload is permitted if necessary"] +pub const _NV_DISPLAYCONFIG_FLAGS_NV_DISPLAYCONFIG_DRIVER_RELOAD_ALLOWED: _NV_DISPLAYCONFIG_FLAGS = + 4; +#[doc = "!< Refresh OS mode list."] +pub const _NV_DISPLAYCONFIG_FLAGS_NV_DISPLAYCONFIG_FORCE_MODE_ENUMERATION: _NV_DISPLAYCONFIG_FLAGS = + 8; +#[doc = "!< Tell OS to avoid optimizing CommitVidPn call during a modeset"] +pub const _NV_DISPLAYCONFIG_FLAGS_NV_FORCE_COMMIT_VIDPN: _NV_DISPLAYCONFIG_FLAGS = 16; +#[doc = "! \\ingroup dispcontrol"] +pub type _NV_DISPLAYCONFIG_FLAGS = ::std::os::raw::c_int; +#[doc = "! \\ingroup dispcontrol"] +pub use self::_NV_DISPLAYCONFIG_FLAGS as NV_DISPLAYCONFIG_FLAGS; +pub type NvAPI_UnicodeString = [NvU16; 2048usize]; +pub type NvAPI_LPCWSTR = *const NvU16; +pub const _NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID_NVAPI_GPU_PERF_VOLTAGE_INFO_DOMAIN_CORE: + _NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID = 0; +pub const _NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID_NVAPI_GPU_PERF_VOLTAGE_INFO_DOMAIN_UNDEFINED: + _NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID = 16; +#[doc = "! \\ingroup gpuclock"] +pub type _NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpuclock"] +pub use self::_NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID as NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID; +pub const _NV_GPU_PUBLIC_CLOCK_ID_NVAPI_GPU_PUBLIC_CLOCK_GRAPHICS: _NV_GPU_PUBLIC_CLOCK_ID = 0; +pub const _NV_GPU_PUBLIC_CLOCK_ID_NVAPI_GPU_PUBLIC_CLOCK_MEMORY: _NV_GPU_PUBLIC_CLOCK_ID = 4; +pub const _NV_GPU_PUBLIC_CLOCK_ID_NVAPI_GPU_PUBLIC_CLOCK_PROCESSOR: _NV_GPU_PUBLIC_CLOCK_ID = 7; +pub const _NV_GPU_PUBLIC_CLOCK_ID_NVAPI_GPU_PUBLIC_CLOCK_VIDEO: _NV_GPU_PUBLIC_CLOCK_ID = 8; +pub const _NV_GPU_PUBLIC_CLOCK_ID_NVAPI_GPU_PUBLIC_CLOCK_UNDEFINED: _NV_GPU_PUBLIC_CLOCK_ID = 32; +#[doc = "! \\ingroup gpuclock"] +pub type _NV_GPU_PUBLIC_CLOCK_ID = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpuclock"] +pub use self::_NV_GPU_PUBLIC_CLOCK_ID as NV_GPU_PUBLIC_CLOCK_ID; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P0: _NV_GPU_PERF_PSTATE_ID = 0; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P1: _NV_GPU_PERF_PSTATE_ID = 1; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P2: _NV_GPU_PERF_PSTATE_ID = 2; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P3: _NV_GPU_PERF_PSTATE_ID = 3; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P4: _NV_GPU_PERF_PSTATE_ID = 4; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P5: _NV_GPU_PERF_PSTATE_ID = 5; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P6: _NV_GPU_PERF_PSTATE_ID = 6; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P7: _NV_GPU_PERF_PSTATE_ID = 7; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P8: _NV_GPU_PERF_PSTATE_ID = 8; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P9: _NV_GPU_PERF_PSTATE_ID = 9; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P10: _NV_GPU_PERF_PSTATE_ID = 10; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P11: _NV_GPU_PERF_PSTATE_ID = 11; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P12: _NV_GPU_PERF_PSTATE_ID = 12; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P13: _NV_GPU_PERF_PSTATE_ID = 13; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P14: _NV_GPU_PERF_PSTATE_ID = 14; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P15: _NV_GPU_PERF_PSTATE_ID = 15; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_UNDEFINED: _NV_GPU_PERF_PSTATE_ID = 16; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_ALL: _NV_GPU_PERF_PSTATE_ID = 17; +#[doc = "! \\addtogroup gpupstate\n! @{"] +pub type _NV_GPU_PERF_PSTATE_ID = ::std::os::raw::c_int; +#[doc = "! \\addtogroup gpupstate\n! @{"] +pub use self::_NV_GPU_PERF_PSTATE_ID as NV_GPU_PERF_PSTATE_ID; +#[doc = "! Clock domains that use single frequency value within given pstate"] +pub const NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID_NVAPI_GPU_PERF_PSTATE20_CLOCK_TYPE_SINGLE: + NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID = 0; +#[doc = "! Clock domains that allow range of frequency values within given pstate"] +pub const NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID_NVAPI_GPU_PERF_PSTATE20_CLOCK_TYPE_RANGE: + NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID = 1; +#[doc = "! Used to identify clock type"] +pub type NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID = ::std::os::raw::c_int; +#[doc = "! Used to describe both voltage and frequency deltas"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PERF_PSTATES20_PARAM_DELTA { + #[doc = "! Value of parameter delta (in respective units [kHz, uV])"] + pub value: NvS32, + pub valueRange: NV_GPU_PERF_PSTATES20_PARAM_DELTA__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PERF_PSTATES20_PARAM_DELTA__bindgen_ty_1 { + #[doc = "! Min value allowed for parameter delta (in respective units [kHz, uV])"] + pub min: NvS32, + #[doc = "! Max value allowed for parameter delta (in respective units [kHz, uV])"] + pub max: NvS32, +} +#[doc = "! Used to describe single clock entry"] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct NV_GPU_PSTATE20_CLOCK_ENTRY_V1 { + #[doc = "! ID of the clock domain"] + pub domainId: NV_GPU_PUBLIC_CLOCK_ID, + #[doc = "! Clock type ID"] + pub typeId: NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "! Current frequency delta from nominal settings in (kHz)"] + pub freqDelta_kHz: NV_GPU_PERF_PSTATES20_PARAM_DELTA, + pub data: NV_GPU_PSTATE20_CLOCK_ENTRY_V1__bindgen_ty_1, +} +#[doc = "! Clock domain type dependant information"] +#[repr(C)] +#[derive(Copy, Clone)] +pub union NV_GPU_PSTATE20_CLOCK_ENTRY_V1__bindgen_ty_1 { + pub single: NV_GPU_PSTATE20_CLOCK_ENTRY_V1__bindgen_ty_1__bindgen_ty_1, + pub range: NV_GPU_PSTATE20_CLOCK_ENTRY_V1__bindgen_ty_1__bindgen_ty_2, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PSTATE20_CLOCK_ENTRY_V1__bindgen_ty_1__bindgen_ty_1 { + #[doc = "! Clock frequency within given pstate in (kHz)"] + pub freq_kHz: NvU32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PSTATE20_CLOCK_ENTRY_V1__bindgen_ty_1__bindgen_ty_2 { + #[doc = "! Min clock frequency within given pstate in (kHz)"] + pub minFreq_kHz: NvU32, + #[doc = "! Max clock frequency within given pstate in (kHz)"] + pub maxFreq_kHz: NvU32, + #[doc = "! Voltage domain ID and value range in (uV) required for this clock"] + pub domainId: NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID, + pub minVoltage_uV: NvU32, + pub maxVoltage_uV: NvU32, +} +impl NV_GPU_PSTATE20_CLOCK_ENTRY_V1 { + #[inline] + pub fn bIsEditable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsEditable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsEditable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsEditable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsEditable: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsEditable: u32 = unsafe { ::std::mem::transmute(bIsEditable) }; + bIsEditable as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! Used to describe single base voltage entry"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY_V1 { + #[doc = "! ID of the voltage domain"] + pub domainId: NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "! Current base voltage settings in [uV]"] + pub volt_uV: NvU32, + pub voltDelta_uV: NV_GPU_PERF_PSTATES20_PARAM_DELTA, +} +impl NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY_V1 { + #[inline] + pub fn bIsEditable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsEditable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsEditable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsEditable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsEditable: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsEditable: u32 = unsafe { ::std::mem::transmute(bIsEditable) }; + bIsEditable as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! Used in NvAPI_GPU_GetPstates20() interface call."] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct NV_GPU_PERF_PSTATES20_INFO_V1 { + #[doc = "! Version info of the structure (NV_GPU_PERF_PSTATES20_INFO_VER)"] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "! Number of populated pstates"] + pub numPstates: NvU32, + #[doc = "! Number of populated clocks (per pstate)"] + pub numClocks: NvU32, + #[doc = "! Number of populated base voltages (per pstate)"] + pub numBaseVoltages: NvU32, + pub pstates: [NV_GPU_PERF_PSTATES20_INFO_V1__bindgen_ty_1; 16usize], +} +#[doc = "! Performance state (P-State) settings\n! Valid index range is 0 to numPstates-1"] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct NV_GPU_PERF_PSTATES20_INFO_V1__bindgen_ty_1 { + #[doc = "! ID of the P-State"] + pub pstateId: NV_GPU_PERF_PSTATE_ID, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "! Array of clock entries\n! Valid index range is 0 to numClocks-1"] + pub clocks: [NV_GPU_PSTATE20_CLOCK_ENTRY_V1; 8usize], + #[doc = "! Array of baseVoltage entries\n! Valid index range is 0 to numBaseVoltages-1"] + pub baseVoltages: [NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY_V1; 4usize], +} +impl NV_GPU_PERF_PSTATES20_INFO_V1__bindgen_ty_1 { + #[inline] + pub fn bIsEditable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsEditable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsEditable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsEditable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsEditable: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsEditable: u32 = unsafe { ::std::mem::transmute(bIsEditable) }; + bIsEditable as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +impl NV_GPU_PERF_PSTATES20_INFO_V1 { + #[inline] + pub fn bIsEditable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsEditable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsEditable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsEditable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsEditable: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsEditable: u32 = unsafe { ::std::mem::transmute(bIsEditable) }; + bIsEditable as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! Used in NvAPI_GPU_GetPstates20() interface call."] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_PERF_PSTATES20_INFO_V2 { + #[doc = "! Version info of the structure (NV_GPU_PERF_PSTATES20_INFO_VER)"] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "! Number of populated pstates"] + pub numPstates: NvU32, + #[doc = "! Number of populated clocks (per pstate)"] + pub numClocks: NvU32, + #[doc = "! Number of populated base voltages (per pstate)"] + pub numBaseVoltages: NvU32, + pub pstates: [_NV_GPU_PERF_PSTATES20_INFO_V2__bindgen_ty_1; 16usize], + pub ov: _NV_GPU_PERF_PSTATES20_INFO_V2__bindgen_ty_2, +} +#[doc = "! Performance state (P-State) settings\n! Valid index range is 0 to numPstates-1"] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_PERF_PSTATES20_INFO_V2__bindgen_ty_1 { + #[doc = "! ID of the P-State"] + pub pstateId: NV_GPU_PERF_PSTATE_ID, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "! Array of clock entries\n! Valid index range is 0 to numClocks-1"] + pub clocks: [NV_GPU_PSTATE20_CLOCK_ENTRY_V1; 8usize], + #[doc = "! Array of baseVoltage entries\n! Valid index range is 0 to numBaseVoltages-1"] + pub baseVoltages: [NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY_V1; 4usize], +} +impl _NV_GPU_PERF_PSTATES20_INFO_V2__bindgen_ty_1 { + #[inline] + pub fn bIsEditable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsEditable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsEditable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsEditable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsEditable: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsEditable: u32 = unsafe { ::std::mem::transmute(bIsEditable) }; + bIsEditable as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! OV settings - Please refer to NVIDIA over-volting recommendation to understand impact of this functionality\n! Valid index range is 0 to numVoltages-1"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_PERF_PSTATES20_INFO_V2__bindgen_ty_2 { + #[doc = "! Number of populated voltages"] + pub numVoltages: NvU32, + #[doc = "! Array of voltage entries\n! Valid index range is 0 to numVoltages-1"] + pub voltages: [NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY_V1; 4usize], +} +impl _NV_GPU_PERF_PSTATES20_INFO_V2 { + #[inline] + pub fn bIsEditable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsEditable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsEditable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsEditable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsEditable: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsEditable: u32 = unsafe { ::std::mem::transmute(bIsEditable) }; + bIsEditable as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! Used in NvAPI_GPU_GetPstates20() interface call."] +pub type NV_GPU_PERF_PSTATES20_INFO_V2 = _NV_GPU_PERF_PSTATES20_INFO_V2; +#[doc = "! Used in NvAPI_GPU_GetPstates20() interface call."] +pub type NV_GPU_PERF_PSTATES20_INFO = NV_GPU_PERF_PSTATES20_INFO_V2; +#[doc = "! \\ingroup driverapi\n! Used in NvAPI_GetDisplayDriverVersion()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_DISPLAY_DRIVER_VERSION { + pub version: NvU32, + pub drvVersion: NvU32, + pub bldChangeListNum: NvU32, + pub szBuildBranchString: NvAPI_ShortString, + pub szAdapterString: NvAPI_ShortString, +} +pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_UNINITIALIZED: NV_MONITOR_CONN_TYPE = 0; +pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_VGA: NV_MONITOR_CONN_TYPE = 1; +pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_COMPONENT: NV_MONITOR_CONN_TYPE = 2; +pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_SVIDEO: NV_MONITOR_CONN_TYPE = 3; +pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_HDMI: NV_MONITOR_CONN_TYPE = 4; +pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_DVI: NV_MONITOR_CONN_TYPE = 5; +pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_LVDS: NV_MONITOR_CONN_TYPE = 6; +pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_DP: NV_MONITOR_CONN_TYPE = 7; +pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_COMPOSITE: NV_MONITOR_CONN_TYPE = 8; +pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_UNKNOWN: NV_MONITOR_CONN_TYPE = -1; +#[doc = "! \\ingroup gpu"] +pub type NV_MONITOR_CONN_TYPE = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_DISPLAYIDS { + pub version: NvU32, + #[doc = "!< out: vga, tv, dvi, hdmi and dp. This is reserved for future use and clients should not rely on this information. Instead get the\n!< GPU connector type from NvAPI_GPU_GetConnectorInfo/NvAPI_GPU_GetConnectorInfoEx"] + pub connectorType: NV_MONITOR_CONN_TYPE, + #[doc = "!< this is a unique identifier for each device"] + pub displayId: NvU32, + pub _bitfield_align_1: [u16; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl _NV_GPU_DISPLAYIDS { + #[inline] + pub fn isDynamic(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isDynamic(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isDynamic_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isDynamic_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMultiStreamRootNode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMultiStreamRootNode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMultiStreamRootNode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMultiStreamRootNode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isActive(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_isActive(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isActive_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isActive_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isCluster(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_isCluster(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isCluster_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isCluster_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isOSVisible(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_isOSVisible(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isOSVisible_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isOSVisible_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isWFD(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_isWFD(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isWFD_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isWFD_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isConnected(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } + } + #[inline] + pub fn set_isConnected(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isConnected_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 6usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isConnected_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reservedInternal(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 10u8) as u32) } + } + #[inline] + pub fn set_reservedInternal(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 10u8, val as u64) + } + } + #[inline] + pub unsafe fn reservedInternal_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 7usize, + 10u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reservedInternal_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 7usize, + 10u8, + val as u64, + ) + } + } + #[inline] + pub fn isPhysicallyConnected(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) } + } + #[inline] + pub fn set_isPhysicallyConnected(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(17usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isPhysicallyConnected_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 17usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isPhysicallyConnected_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 17usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 14u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(18usize, 14u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 18usize, + 14u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 18usize, + 14u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isDynamic: NvU32, + isMultiStreamRootNode: NvU32, + isActive: NvU32, + isCluster: NvU32, + isOSVisible: NvU32, + isWFD: NvU32, + isConnected: NvU32, + reservedInternal: NvU32, + isPhysicallyConnected: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isDynamic: u32 = unsafe { ::std::mem::transmute(isDynamic) }; + isDynamic as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isMultiStreamRootNode: u32 = + unsafe { ::std::mem::transmute(isMultiStreamRootNode) }; + isMultiStreamRootNode as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let isActive: u32 = unsafe { ::std::mem::transmute(isActive) }; + isActive as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let isCluster: u32 = unsafe { ::std::mem::transmute(isCluster) }; + isCluster as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let isOSVisible: u32 = unsafe { ::std::mem::transmute(isOSVisible) }; + isOSVisible as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let isWFD: u32 = unsafe { ::std::mem::transmute(isWFD) }; + isWFD as u64 + }); + __bindgen_bitfield_unit.set(6usize, 1u8, { + let isConnected: u32 = unsafe { ::std::mem::transmute(isConnected) }; + isConnected as u64 + }); + __bindgen_bitfield_unit.set(7usize, 10u8, { + let reservedInternal: u32 = unsafe { ::std::mem::transmute(reservedInternal) }; + reservedInternal as u64 + }); + __bindgen_bitfield_unit.set(17usize, 1u8, { + let isPhysicallyConnected: u32 = + unsafe { ::std::mem::transmute(isPhysicallyConnected) }; + isPhysicallyConnected as u64 + }); + __bindgen_bitfield_unit.set(18usize, 14u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup gpu"] +pub type NV_GPU_DISPLAYIDS = _NV_GPU_DISPLAYIDS; +pub const NV_SYSTEM_TYPE_NV_SYSTEM_TYPE_UNKNOWN: NV_SYSTEM_TYPE = 0; +pub const NV_SYSTEM_TYPE_NV_SYSTEM_TYPE_LAPTOP: NV_SYSTEM_TYPE = 1; +pub const NV_SYSTEM_TYPE_NV_SYSTEM_TYPE_DESKTOP: NV_SYSTEM_TYPE = 2; +#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetSystemType()"] +pub type NV_SYSTEM_TYPE = ::std::os::raw::c_int; +pub const _NV_GPU_OUTPUT_TYPE_NVAPI_GPU_OUTPUT_UNKNOWN: _NV_GPU_OUTPUT_TYPE = 0; +#[doc = "!< CRT display device"] +pub const _NV_GPU_OUTPUT_TYPE_NVAPI_GPU_OUTPUT_CRT: _NV_GPU_OUTPUT_TYPE = 1; +#[doc = "!< Digital Flat Panel display device"] +pub const _NV_GPU_OUTPUT_TYPE_NVAPI_GPU_OUTPUT_DFP: _NV_GPU_OUTPUT_TYPE = 2; +#[doc = "!< TV display device"] +pub const _NV_GPU_OUTPUT_TYPE_NVAPI_GPU_OUTPUT_TV: _NV_GPU_OUTPUT_TYPE = 3; +#[doc = "! \\ingroup gpu\n! used in NvAPI_GPU_GetOutputType()"] +pub type _NV_GPU_OUTPUT_TYPE = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpu\n! used in NvAPI_GPU_GetOutputType()"] +pub use self::_NV_GPU_OUTPUT_TYPE as NV_GPU_OUTPUT_TYPE; +pub const _NV_GPU_TYPE_NV_SYSTEM_TYPE_GPU_UNKNOWN: _NV_GPU_TYPE = 0; +#[doc = "!< Integrated GPU"] +pub const _NV_GPU_TYPE_NV_SYSTEM_TYPE_IGPU: _NV_GPU_TYPE = 1; +#[doc = "!< Discrete GPU"] +pub const _NV_GPU_TYPE_NV_SYSTEM_TYPE_DGPU: _NV_GPU_TYPE = 2; +#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetGPUType()."] +pub type _NV_GPU_TYPE = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetGPUType()."] +pub use self::_NV_GPU_TYPE as NV_GPU_TYPE; +pub const _NV_GPU_BUS_TYPE_NVAPI_GPU_BUS_TYPE_UNDEFINED: _NV_GPU_BUS_TYPE = 0; +pub const _NV_GPU_BUS_TYPE_NVAPI_GPU_BUS_TYPE_PCI: _NV_GPU_BUS_TYPE = 1; +pub const _NV_GPU_BUS_TYPE_NVAPI_GPU_BUS_TYPE_AGP: _NV_GPU_BUS_TYPE = 2; +pub const _NV_GPU_BUS_TYPE_NVAPI_GPU_BUS_TYPE_PCI_EXPRESS: _NV_GPU_BUS_TYPE = 3; +pub const _NV_GPU_BUS_TYPE_NVAPI_GPU_BUS_TYPE_FPCI: _NV_GPU_BUS_TYPE = 4; +pub const _NV_GPU_BUS_TYPE_NVAPI_GPU_BUS_TYPE_AXI: _NV_GPU_BUS_TYPE = 5; +#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetBusType()"] +pub type _NV_GPU_BUS_TYPE = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetBusType()"] +pub use self::_NV_GPU_BUS_TYPE as NV_GPU_BUS_TYPE; +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_BOARD_INFO { + #[doc = "!< structure version"] + pub version: NvU32, + #[doc = "!< Board Serial Number"] + pub BoardNum: [NvU8; 16usize], +} +#[doc = "! \\ingroup gpu"] +pub type NV_BOARD_INFO_V1 = _NV_BOARD_INFO; +#[doc = "! \\ingroup gpu"] +pub type NV_BOARD_INFO = NV_BOARD_INFO_V1; +#[doc = "! Used in NvAPI_GPU_GetArchInfo()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_ARCH_INFO_V1 { + pub version: NvU32, + pub architecture: NvU32, + pub implementation: NvU32, + pub revision: NvU32, +} +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_T2X: _NV_GPU_ARCHITECTURE_ID = -536870880; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_T3X: _NV_GPU_ARCHITECTURE_ID = -536870864; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_T4X: _NV_GPU_ARCHITECTURE_ID = -536870848; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_T12X: _NV_GPU_ARCHITECTURE_ID = -536870848; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_NV40: _NV_GPU_ARCHITECTURE_ID = 64; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_NV50: _NV_GPU_ARCHITECTURE_ID = 80; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_G78: _NV_GPU_ARCHITECTURE_ID = 96; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_G80: _NV_GPU_ARCHITECTURE_ID = 128; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_G90: _NV_GPU_ARCHITECTURE_ID = 144; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GT200: _NV_GPU_ARCHITECTURE_ID = 160; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GF100: _NV_GPU_ARCHITECTURE_ID = 192; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GF110: _NV_GPU_ARCHITECTURE_ID = 208; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GK100: _NV_GPU_ARCHITECTURE_ID = 224; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GK110: _NV_GPU_ARCHITECTURE_ID = 240; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GK200: _NV_GPU_ARCHITECTURE_ID = 256; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GM000: _NV_GPU_ARCHITECTURE_ID = 272; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GM200: _NV_GPU_ARCHITECTURE_ID = 288; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GP100: _NV_GPU_ARCHITECTURE_ID = 304; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GV100: _NV_GPU_ARCHITECTURE_ID = 320; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GV110: _NV_GPU_ARCHITECTURE_ID = 336; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_TU100: _NV_GPU_ARCHITECTURE_ID = 352; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GA100: _NV_GPU_ARCHITECTURE_ID = 368; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_AD100: _NV_GPU_ARCHITECTURE_ID = 400; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GB200: _NV_GPU_ARCHITECTURE_ID = 432; +#[doc = "! NV_GPU_ARCH_INFO() values to identify Architecture level for the GPU."] +pub type _NV_GPU_ARCHITECTURE_ID = ::std::os::raw::c_int; +#[doc = "! NV_GPU_ARCH_INFO() values to identify Architecture level for the GPU."] +pub use self::_NV_GPU_ARCHITECTURE_ID as NV_GPU_ARCHITECTURE_ID; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_T20: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_T30: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_T35: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 5; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_T40: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_T124: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV40: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV41: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 1; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV42: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV43: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 3; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV44: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV44A: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 10; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV46: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV47: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 7; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV49: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 9; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV4B: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 11; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV4C: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 12; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV4E: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 14; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV50: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV63: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 3; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV67: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 7; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_G84: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_G86: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_G92: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_G94: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_G96: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_G98: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 8; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT200: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT212: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT214: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT215: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 3; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT216: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 5; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT218: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 8; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_MCP77: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 10; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT21C: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 11; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_MCP79: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 12; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT21A: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 13; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_MCP89: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 15; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF100: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF104: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF106: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 3; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF108: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 1; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF110: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF116: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF117: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 7; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF118: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 8; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF119: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 9; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GK104: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GK106: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GK107: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 7; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GK20A: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 10; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GK110: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GK208: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 8; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GM204: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GM206: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP100: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP000: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 1; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP102: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP104: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP106: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP107: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 7; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP108: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 8; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GV100: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GV10B: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 11; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU100: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU102: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU104: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU106: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU116: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 8; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU117: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 7; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU000: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 1; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GA100: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GA102: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GA104: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_AD102: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_AD103: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 3; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_AD104: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GB202: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; +#[doc = "! NV_GPU_ARCH_INFO() values to identify GPU Architecture Implementation."] +pub type _NV_GPU_ARCH_IMPLEMENTATION_ID = ::std::os::raw::c_int; +#[doc = "! NV_GPU_ARCH_INFO() values to identify GPU Architecture Implementation."] +pub use self::_NV_GPU_ARCH_IMPLEMENTATION_ID as NV_GPU_ARCH_IMPLEMENTATION_ID; +#[doc = "!< QT chip"] +pub const _NV_GPU_CHIP_REVISION_NV_GPU_CHIP_REV_EMULATION_QT: _NV_GPU_CHIP_REVISION = 0; +#[doc = "!< FPGA implementation of the chipset"] +pub const _NV_GPU_CHIP_REVISION_NV_GPU_CHIP_REV_EMULATION_FPGA: _NV_GPU_CHIP_REVISION = 1; +#[doc = "!< First silicon chipset revision"] +pub const _NV_GPU_CHIP_REVISION_NV_GPU_CHIP_REV_A01: _NV_GPU_CHIP_REVISION = 17; +#[doc = "!< Second Silicon chipset revision"] +pub const _NV_GPU_CHIP_REVISION_NV_GPU_CHIP_REV_A02: _NV_GPU_CHIP_REVISION = 18; +#[doc = "!< Third Silicon chipset revision"] +pub const _NV_GPU_CHIP_REVISION_NV_GPU_CHIP_REV_A03: _NV_GPU_CHIP_REVISION = 19; +#[doc = "!< Unknown chip revision"] +pub const _NV_GPU_CHIP_REVISION_NV_GPU_CHIP_REV_UNKNOWN: _NV_GPU_CHIP_REVISION = -1; +pub type _NV_GPU_CHIP_REVISION = ::std::os::raw::c_int; +pub use self::_NV_GPU_CHIP_REVISION as NV_GPU_CHIP_REVISION; +#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetArchInfo()"] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct NV_GPU_ARCH_INFO_V2 { + pub version: NvU32, + pub __bindgen_anon_1: NV_GPU_ARCH_INFO_V2__bindgen_ty_1, + pub __bindgen_anon_2: NV_GPU_ARCH_INFO_V2__bindgen_ty_2, + pub __bindgen_anon_3: NV_GPU_ARCH_INFO_V2__bindgen_ty_3, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union NV_GPU_ARCH_INFO_V2__bindgen_ty_1 { + #[doc = "!< architecture and architecture_id are the same. The former is NvU32 while the latter is an enum made for readability."] + pub architecture: NvU32, + #[doc = "!< specifies the architecture level for the GPU."] + pub architecture_id: NV_GPU_ARCHITECTURE_ID, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union NV_GPU_ARCH_INFO_V2__bindgen_ty_2 { + #[doc = "!< implementation and implementation_id are the same. The former is NvU32 while the latter is an enum made for readability."] + pub implementation: NvU32, + #[doc = "!< specifies the implementation of the architecture for the GPU."] + pub implementation_id: NV_GPU_ARCH_IMPLEMENTATION_ID, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union NV_GPU_ARCH_INFO_V2__bindgen_ty_3 { + #[doc = "!< revision and revision_id are the same. The former is NvU32 while the latter is an enum made for readability."] + pub revision: NvU32, + #[doc = "!< specifies the architecture revision of the GPU."] + pub revision_id: NV_GPU_CHIP_REVISION, +} +#[doc = "! \\ingroup gpu"] +pub type NV_GPU_ARCH_INFO = NV_GPU_ARCH_INFO_V2; +#[doc = "!< Set i2cSpeedKhz to I2C_SPEED_DEFAULT if default I2C speed is to be chosen, ie.use the current frequency setting."] +pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_DEFAULT: NV_I2C_SPEED = 0; +pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_3KHZ: NV_I2C_SPEED = 1; +pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_10KHZ: NV_I2C_SPEED = 2; +pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_33KHZ: NV_I2C_SPEED = 3; +pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_100KHZ: NV_I2C_SPEED = 4; +pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_200KHZ: NV_I2C_SPEED = 5; +pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_400KHZ: NV_I2C_SPEED = 6; +pub type NV_I2C_SPEED = ::std::os::raw::c_int; +#[doc = "! Used in NvAPI_I2CRead() and NvAPI_I2CWrite()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_I2C_INFO_V1 { + #[doc = "!< The structure version."] + pub version: NvU32, + #[doc = "!< The Display Mask of the concerned display."] + pub displayMask: NvU32, + #[doc = "!< This flag indicates either the DDC port (TRUE) or the communication port\n!< (FALSE) of the concerned display."] + pub bIsDDCPort: NvU8, + #[doc = "!< The address of the I2C slave. The address should be shifted left by one. For\n!< example, the I2C address 0x50, often used for reading EDIDs, would be stored\n!< here as 0xA0. This matches the position within the byte sent by the master, as\n!< the last bit is reserved to specify the read or write direction."] + pub i2cDevAddress: NvU8, + #[doc = "!< The I2C target register address. May be NULL, which indicates no register\n!< address should be sent."] + pub pbI2cRegAddress: *mut NvU8, + #[doc = "!< The size in bytes of target register address. If pbI2cRegAddress is NULL, this\n!< field must be 0."] + pub regAddrSize: NvU32, + #[doc = "!< The buffer of data which is to be read or written (depending on the command)."] + pub pbData: *mut NvU8, + #[doc = "!< The size of the data buffer, pbData, to be read or written."] + pub cbSize: NvU32, + #[doc = "!< The target speed of the transaction (between 28Kbps to 40Kbps; not guaranteed)."] + pub i2cSpeed: NvU32, +} +#[doc = "! Used in NvAPI_I2CRead() and NvAPI_I2CWrite()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_I2C_INFO_V2 { + #[doc = "!< The structure version."] + pub version: NvU32, + #[doc = "!< The Display Mask of the concerned display."] + pub displayMask: NvU32, + #[doc = "!< This flag indicates either the DDC port (TRUE) or the communication port\n!< (FALSE) of the concerned display."] + pub bIsDDCPort: NvU8, + #[doc = "!< The address of the I2C slave. The address should be shifted left by one. For\n!< example, the I2C address 0x50, often used for reading EDIDs, would be stored\n!< here as 0xA0. This matches the position within the byte sent by the master, as\n!< the last bit is reserved to specify the read or write direction."] + pub i2cDevAddress: NvU8, + #[doc = "!< The I2C target register address. May be NULL, which indicates no register\n!< address should be sent."] + pub pbI2cRegAddress: *mut NvU8, + #[doc = "!< The size in bytes of target register address. If pbI2cRegAddress is NULL, this\n!< field must be 0."] + pub regAddrSize: NvU32, + #[doc = "!< The buffer of data which is to be read or written (depending on the command)."] + pub pbData: *mut NvU8, + #[doc = "!< The size of the data buffer, pbData, to be read or written."] + pub cbSize: NvU32, + #[doc = "!< Deprecated, Must be set to NVAPI_I2C_SPEED_DEPRECATED."] + pub i2cSpeed: NvU32, + #[doc = "!< The target speed of the transaction in (kHz) (Chosen from the enum NV_I2C_SPEED)."] + pub i2cSpeedKhz: NV_I2C_SPEED, +} +#[doc = "! Used in NvAPI_I2CRead() and NvAPI_I2CWrite()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_I2C_INFO_V3 { + #[doc = "!< The structure version."] + pub version: NvU32, + #[doc = "!< The Display Mask of the concerned display."] + pub displayMask: NvU32, + #[doc = "!< This flag indicates either the DDC port (TRUE) or the communication port\n!< (FALSE) of the concerned display."] + pub bIsDDCPort: NvU8, + #[doc = "!< The address of the I2C slave. The address should be shifted left by one. For\n!< example, the I2C address 0x50, often used for reading EDIDs, would be stored\n!< here as 0xA0. This matches the position within the byte sent by the master, as\n!< the last bit is reserved to specify the read or write direction."] + pub i2cDevAddress: NvU8, + #[doc = "!< The I2C target register address. May be NULL, which indicates no register\n!< address should be sent."] + pub pbI2cRegAddress: *mut NvU8, + #[doc = "!< The size in bytes of target register address. If pbI2cRegAddress is NULL, this\n!< field must be 0."] + pub regAddrSize: NvU32, + #[doc = "!< The buffer of data which is to be read or written (depending on the command)."] + pub pbData: *mut NvU8, + #[doc = "!< The size of the data buffer, pbData, to be read or written."] + pub cbSize: NvU32, + #[doc = "!< Deprecated, Must be set to NVAPI_I2C_SPEED_DEPRECATED."] + pub i2cSpeed: NvU32, + #[doc = "!< The target speed of the transaction in (kHz) (Chosen from the enum NV_I2C_SPEED)."] + pub i2cSpeedKhz: NV_I2C_SPEED, + #[doc = "!< The portid on which device is connected (remember to set bIsPortIdSet if this value is set)\n!< Optional for pre-Kepler"] + pub portId: NvU8, + #[doc = "!< set this flag on if and only if portid value is set"] + pub bIsPortIdSet: NvU32, +} +#[doc = "! Used in NvAPI_I2CRead() and NvAPI_I2CWrite()"] +pub type NV_I2C_INFO = NV_I2C_INFO_V3; +pub const _NV_GPU_HDCP_FUSE_STATE_NV_GPU_HDCP_FUSE_STATE_UNKNOWN: _NV_GPU_HDCP_FUSE_STATE = 0; +pub const _NV_GPU_HDCP_FUSE_STATE_NV_GPU_HDCP_FUSE_STATE_DISABLED: _NV_GPU_HDCP_FUSE_STATE = 1; +pub const _NV_GPU_HDCP_FUSE_STATE_NV_GPU_HDCP_FUSE_STATE_ENABLED: _NV_GPU_HDCP_FUSE_STATE = 2; +#[doc = "! HDCP fuse states - used in NV_GPU_GET_HDCP_SUPPORT_STATUS"] +pub type _NV_GPU_HDCP_FUSE_STATE = ::std::os::raw::c_int; +#[doc = "! HDCP fuse states - used in NV_GPU_GET_HDCP_SUPPORT_STATUS"] +pub use self::_NV_GPU_HDCP_FUSE_STATE as NV_GPU_HDCP_FUSE_STATE; +pub const _NV_GPU_HDCP_KEY_SOURCE_NV_GPU_HDCP_KEY_SOURCE_UNKNOWN: _NV_GPU_HDCP_KEY_SOURCE = 0; +pub const _NV_GPU_HDCP_KEY_SOURCE_NV_GPU_HDCP_KEY_SOURCE_NONE: _NV_GPU_HDCP_KEY_SOURCE = 1; +pub const _NV_GPU_HDCP_KEY_SOURCE_NV_GPU_HDCP_KEY_SOURCE_CRYPTO_ROM: _NV_GPU_HDCP_KEY_SOURCE = 2; +pub const _NV_GPU_HDCP_KEY_SOURCE_NV_GPU_HDCP_KEY_SOURCE_SBIOS: _NV_GPU_HDCP_KEY_SOURCE = 3; +pub const _NV_GPU_HDCP_KEY_SOURCE_NV_GPU_HDCP_KEY_SOURCE_I2C_ROM: _NV_GPU_HDCP_KEY_SOURCE = 4; +pub const _NV_GPU_HDCP_KEY_SOURCE_NV_GPU_HDCP_KEY_SOURCE_FUSES: _NV_GPU_HDCP_KEY_SOURCE = 5; +#[doc = "! HDCP key sources - used in NV_GPU_GET_HDCP_SUPPORT_STATUS"] +pub type _NV_GPU_HDCP_KEY_SOURCE = ::std::os::raw::c_int; +#[doc = "! HDCP key sources - used in NV_GPU_GET_HDCP_SUPPORT_STATUS"] +pub use self::_NV_GPU_HDCP_KEY_SOURCE as NV_GPU_HDCP_KEY_SOURCE; +pub const _NV_GPU_HDCP_KEY_SOURCE_STATE_NV_GPU_HDCP_KEY_SOURCE_STATE_UNKNOWN: + _NV_GPU_HDCP_KEY_SOURCE_STATE = 0; +pub const _NV_GPU_HDCP_KEY_SOURCE_STATE_NV_GPU_HDCP_KEY_SOURCE_STATE_ABSENT: + _NV_GPU_HDCP_KEY_SOURCE_STATE = 1; +pub const _NV_GPU_HDCP_KEY_SOURCE_STATE_NV_GPU_HDCP_KEY_SOURCE_STATE_PRESENT: + _NV_GPU_HDCP_KEY_SOURCE_STATE = 2; +#[doc = "! HDCP key source states - used in NV_GPU_GET_HDCP_SUPPORT_STATUS"] +pub type _NV_GPU_HDCP_KEY_SOURCE_STATE = ::std::os::raw::c_int; +#[doc = "! HDCP key source states - used in NV_GPU_GET_HDCP_SUPPORT_STATUS"] +pub use self::_NV_GPU_HDCP_KEY_SOURCE_STATE as NV_GPU_HDCP_KEY_SOURCE_STATE; +#[doc = "! HDPC support status - used in NvAPI_GPU_GetHDCPSupportStatus()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_GET_HDCP_SUPPORT_STATUS { + pub version: NvU32, + #[doc = "! Structure version constucted by macro #NV_GPU_GET_HDCP_SUPPORT_STATUS"] + pub hdcpFuseState: NV_GPU_HDCP_FUSE_STATE, + #[doc = "! GPU's HDCP fuse state"] + pub hdcpKeySource: NV_GPU_HDCP_KEY_SOURCE, + #[doc = "! GPU's HDCP key source"] + pub hdcpKeySourceState: NV_GPU_HDCP_KEY_SOURCE_STATE, +} +#[doc = "! @}"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_COMPUTE_GPU_TOPOLOGY_V1 { + #[doc = "!< Structure version"] + pub version: NvU32, + #[doc = "!< Total number of compute-capable GPUs"] + pub gpuCount: NvU32, + #[doc = "!< Array of compute-capable physical GPUs."] + pub computeGpus: [NV_COMPUTE_GPU_TOPOLOGY_V1__bindgen_ty_1; 8usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_COMPUTE_GPU_TOPOLOGY_V1__bindgen_ty_1 { + #[doc = "!< Compute-capable physical GPU handle"] + pub hPhysicalGpu: NvPhysicalGpuHandle, + #[doc = "!< One or more flags from \\ref nvcomp_gpu_top"] + pub flags: NvU32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COMPUTE_GPU { + #[doc = "!< Compute-capable physical GPU handle"] + pub hPhysicalGpu: NvPhysicalGpuHandle, + #[doc = "!< One or more flags from \\ref nvcomp_gpu_top"] + pub flags: NvU32, +} +pub type NV_COMPUTE_GPU = _NV_COMPUTE_GPU; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COMPUTE_GPU_TOPOLOGY_V2 { + #[doc = "!< Structure version"] + pub version: NvU32, + #[doc = "!< Size of array"] + pub gpuCount: NvU32, + #[doc = "!< Array of compute-capable physical GPUs (allocate memory of size of Physical gpuCount of system)."] + pub computeGpus: *mut NV_COMPUTE_GPU, +} +pub type NV_COMPUTE_GPU_TOPOLOGY_V2 = _NV_COMPUTE_GPU_TOPOLOGY_V2; +pub type NV_COMPUTE_GPU_TOPOLOGY = NV_COMPUTE_GPU_TOPOLOGY_V2; +pub const _NV_ECC_CONFIGURATION_NV_ECC_CONFIGURATION_NOT_SUPPORTED: _NV_ECC_CONFIGURATION = 0; +#[doc = "!< Changes require a POST to take effect"] +pub const _NV_ECC_CONFIGURATION_NV_ECC_CONFIGURATION_DEFERRED: _NV_ECC_CONFIGURATION = 1; +#[doc = "!< Changes can optionally be made to take effect immediately"] +pub const _NV_ECC_CONFIGURATION_NV_ECC_CONFIGURATION_IMMEDIATE: _NV_ECC_CONFIGURATION = 2; +#[doc = "! \\addtogroup gpuecc\n! Used in NV_GPU_ECC_STATUS_INFO."] +pub type _NV_ECC_CONFIGURATION = ::std::os::raw::c_int; +#[doc = "! \\addtogroup gpuecc\n! Used in NV_GPU_ECC_STATUS_INFO."] +pub use self::_NV_ECC_CONFIGURATION as NV_ECC_CONFIGURATION; +#[doc = "! \\ingroup gpuecc\n! Used in NvAPI_GPU_GetECCStatusInfo()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_ECC_STATUS_INFO { + #[doc = "!< Structure version"] + pub version: NvU32, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + #[doc = "!< Supported ECC memory feature configuration options"] + pub configurationOptions: NV_ECC_CONFIGURATION, + pub _bitfield_align_2: [u8; 0], + pub _bitfield_2: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +impl NV_GPU_ECC_STATUS_INFO { + #[inline] + pub fn isSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1(isSupported: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isSupported: u32 = unsafe { ::std::mem::transmute(isSupported) }; + isSupported as u64 + }); + __bindgen_bitfield_unit + } + #[inline] + pub fn isEnabled(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isEnabled(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_2.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isEnabled_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_2), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isEnabled_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_2(isEnabled: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isEnabled: u32 = unsafe { ::std::mem::transmute(isEnabled) }; + isEnabled as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup gpuecc\n! Used in NvAPI_GPU_GetECCErrorInfo()/"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_ECC_ERROR_INFO { + #[doc = "!< Structure version"] + pub version: NvU32, + pub current: NV_GPU_ECC_ERROR_INFO__bindgen_ty_1, + pub aggregate: NV_GPU_ECC_ERROR_INFO__bindgen_ty_2, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_ECC_ERROR_INFO__bindgen_ty_1 { + #[doc = "!< Number of single-bit ECC errors detected since last boot"] + pub singleBitErrors: NvU64, + #[doc = "!< Number of double-bit ECC errors detected since last boot"] + pub doubleBitErrors: NvU64, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_ECC_ERROR_INFO__bindgen_ty_2 { + #[doc = "!< Number of single-bit ECC errors detected since last counter reset"] + pub singleBitErrors: NvU64, + #[doc = "!< Number of double-bit ECC errors detected since last counter reset"] + pub doubleBitErrors: NvU64, +} +#[doc = "! \\ingroup gpuecc\n! Used in NvAPI_GPU_GetECCConfigurationInfo()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_ECC_CONFIGURATION_INFO { + pub version: NvU32, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +impl NV_GPU_ECC_CONFIGURATION_INFO { + #[inline] + pub fn isEnabled(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isEnabled(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isEnabled_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isEnabled_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isEnabledByDefault(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isEnabledByDefault(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isEnabledByDefault_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isEnabledByDefault_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isEnabled: NvU32, + isEnabledByDefault: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isEnabled: u32 = unsafe { ::std::mem::transmute(isEnabled) }; + isEnabled as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isEnabledByDefault: u32 = unsafe { ::std::mem::transmute(isEnabledByDefault) }; + isEnabledByDefault as u64 + }); + __bindgen_bitfield_unit + } +} +pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_NONE: NV_QSYNC_EVENT = 0; +pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_SYNC_LOSS: NV_QSYNC_EVENT = 1; +pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_SYNC_GAIN: NV_QSYNC_EVENT = 2; +pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_HOUSESYNC_GAIN: NV_QSYNC_EVENT = 3; +pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_HOUSESYNC_LOSS: NV_QSYNC_EVENT = 4; +pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_RJ45_GAIN: NV_QSYNC_EVENT = 5; +pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_RJ45_LOSS: NV_QSYNC_EVENT = 6; +pub type NV_QSYNC_EVENT = ::std::os::raw::c_int; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_QSYNC_EVENT_DATA { + pub qsyncEvent: NV_QSYNC_EVENT, + pub reserved: [NvU32; 7usize], +} +#[doc = "! Callback for QSYNC event"] +pub type NVAPI_CALLBACK_QSYNCEVENT = ::std::option::Option< + unsafe extern "C" fn( + qyncEventData: NV_QSYNC_EVENT_DATA, + callbackParam: *mut ::std::os::raw::c_void, + ), +>; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_DISPLAY_OUTPUT_MODE_CHANGE_EVENT_DATA { + #[doc = "!< displayId of the display"] + pub displayId: NvU32, + #[doc = "!< display output mode"] + pub outputMode: NvU32, +} +pub type NV_DISPLAY_OUTPUT_MODE_CHANGE_EVENT_DATA = _NV_DISPLAY_OUTPUT_MODE_CHANGE_EVENT_DATA; +#[doc = "! Callback for Display Output Mode change events"] +pub type NVAPI_CALLBACK_DISPLAY_OUTPUT_MODE_CHANGE_EVENT = ::std::option::Option< + unsafe extern "C" fn( + pEventData: *mut NV_DISPLAY_OUTPUT_MODE_CHANGE_EVENT_DATA, + callbackParam: *mut ::std::os::raw::c_void, + ), +>; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_DISPLAY_COLORIMETRY_CHANGE_EVENT_DATA { + #[doc = "!< displayId of the monitor"] + pub displayId: NvU32, + #[doc = "!< min luminance, cd/m^2"] + pub min_luminance: f32, + #[doc = "!< max 100% frame luminance, cd/m^2"] + pub max_full_frame_luminance: f32, + #[doc = "!< max 10% frame luminance, cd/m^2"] + pub max_luminance: f32, + #[doc = "!< HDR brightness luminance scaling factor applied by GPU on output pixels"] + pub hdrBrightnessLuminanceScalingFactor: f32, + #[doc = "!< red primary chromaticity coordinate x"] + pub red_primary_x: f32, + #[doc = "!< red primary chromaticity coordinate y"] + pub red_primary_y: f32, + #[doc = "!< green primary chromaticity coordinate x"] + pub green_primary_x: f32, + #[doc = "!< green primary chromaticity coordinate y"] + pub green_primary_y: f32, + #[doc = "!< blue primary chromaticity coordinate x"] + pub blue_primary_x: f32, + #[doc = "!< blue primary chromaticity coordinate y"] + pub blue_primary_y: f32, + #[doc = "!< white point chromaticity coordinate x"] + pub white_point_x: f32, + #[doc = "!< white point chromaticity coordinate y"] + pub white_point_y: f32, +} +pub type NV_DISPLAY_COLORIMETRY_CHANGE_EVENT_DATA = _NV_DISPLAY_COLORIMETRY_CHANGE_EVENT_DATA; +#[doc = "! Callback for Display Colorimetry change events"] +pub type NVAPI_CALLBACK_DISPLAY_COLORIMETRY_CHANGE_EVENT = ::std::option::Option< + unsafe extern "C" fn( + pEventData: *mut NV_DISPLAY_COLORIMETRY_CHANGE_EVENT_DATA, + callbackParam: *mut ::std::os::raw::c_void, + ), +>; +pub const NV_EVENT_TYPE_NV_EVENT_TYPE_NONE: NV_EVENT_TYPE = 0; +pub const NV_EVENT_TYPE_NV_EVENT_TYPE_QSYNC: NV_EVENT_TYPE = 6; +pub const NV_EVENT_TYPE_NV_EVENT_TYPE_DISPLAY_OUTPUT_MODE_CHANGE: NV_EVENT_TYPE = 103; +pub const NV_EVENT_TYPE_NV_EVENT_TYPE_DISPLAY_COLORIMETRY_CHANGE: NV_EVENT_TYPE = 104; +#[doc = "! Enum for Event IDs"] +pub type NV_EVENT_TYPE = ::std::os::raw::c_int; +#[doc = "! Core NV_EVENT_REGISTER_CALLBACK structure declaration"] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct NV_EVENT_REGISTER_CALLBACK { + #[doc = "!< version field to ensure minimum version compatibility"] + pub version: NvU32, + #[doc = "!< ID of the event being sent"] + pub eventId: NV_EVENT_TYPE, + #[doc = "!< This value will be passed back to the callback function when an event occurs"] + pub callbackParam: *mut ::std::os::raw::c_void, + pub nvCallBackFunc: NV_EVENT_REGISTER_CALLBACK__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union NV_EVENT_REGISTER_CALLBACK__bindgen_ty_1 { + #[doc = "!< Callback function pointer for QSYNC events"] + pub nvQSYNCEventCallback: NVAPI_CALLBACK_QSYNCEVENT, + #[doc = "!< Callback function pointer for Display Output Mode change events"] + pub nvDisplayOutputModeChangeEventCallback: NVAPI_CALLBACK_DISPLAY_OUTPUT_MODE_CHANGE_EVENT, + #[doc = "!< Callback function pointer for Display Colorimetry change events"] + pub nvDisplayColorimetryChangeEventCallback: NVAPI_CALLBACK_DISPLAY_COLORIMETRY_CHANGE_EVENT, +} +#[doc = "!< NVIDIA RTX VR Ready"] +pub const _NV_GPU_WORKSTATION_FEATURE_TYPE_NV_GPU_WORKSTATION_FEATURE_TYPE_NVIDIA_RTX_VR_READY: + _NV_GPU_WORKSTATION_FEATURE_TYPE = 1; +#[doc = "!< DEPRECATED name - do not use"] +pub const _NV_GPU_WORKSTATION_FEATURE_TYPE_NV_GPU_WORKSTATION_FEATURE_TYPE_QUADRO_VR_READY: + _NV_GPU_WORKSTATION_FEATURE_TYPE = 1; +pub const _NV_GPU_WORKSTATION_FEATURE_TYPE_NV_GPU_WORKSTATION_FEATURE_TYPE_PROVIZ: + _NV_GPU_WORKSTATION_FEATURE_TYPE = 2; +#[doc = "! \\ingroup gpu"] +pub type _NV_GPU_WORKSTATION_FEATURE_TYPE = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpu"] +pub use self::_NV_GPU_WORKSTATION_FEATURE_TYPE as NV_GPU_WORKSTATION_FEATURE_TYPE; +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_SCANOUT_INTENSITY_DATA_V1 { + #[doc = "!< version of this structure"] + pub version: NvU32, + #[doc = "!< width of the input texture"] + pub width: NvU32, + #[doc = "!< height of the input texture"] + pub height: NvU32, + #[doc = "!< array of floating values building an intensity RGB texture"] + pub blendingTexture: *mut f32, +} +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_SCANOUT_INTENSITY_DATA_V2 { + #[doc = "!< version of this structure"] + pub version: NvU32, + #[doc = "!< width of the input texture"] + pub width: NvU32, + #[doc = "!< height of the input texture"] + pub height: NvU32, + #[doc = "!< array of floating values building an intensity RGB texture"] + pub blendingTexture: *mut f32, + #[doc = "!< array of floating values building an offset texture"] + pub offsetTexture: *mut f32, + #[doc = "!< number of channels per pixel in the offset texture"] + pub offsetTexChannels: NvU32, +} +#[doc = "! \\ingroup gpu"] +pub type NV_SCANOUT_INTENSITY_DATA = NV_SCANOUT_INTENSITY_DATA_V2; +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_SCANOUT_INTENSITY_STATE_DATA { + #[doc = "!< version of this structure"] + pub version: NvU32, + #[doc = "!< intensity is enabled or not"] + pub bEnabled: NvU32, +} +#[doc = "! \\ingroup gpu"] +pub type NV_SCANOUT_INTENSITY_STATE_DATA = _NV_SCANOUT_INTENSITY_STATE_DATA; +pub const NV_GPU_WARPING_VERTICE_FORMAT_NV_GPU_WARPING_VERTICE_FORMAT_TRIANGLESTRIP_XYUVRQ: + NV_GPU_WARPING_VERTICE_FORMAT = 0; +pub const NV_GPU_WARPING_VERTICE_FORMAT_NV_GPU_WARPING_VERTICE_FORMAT_TRIANGLES_XYUVRQ: + NV_GPU_WARPING_VERTICE_FORMAT = 1; +#[doc = "! \\ingroup gpu"] +pub type NV_GPU_WARPING_VERTICE_FORMAT = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_SCANOUT_WARPING_DATA { + #[doc = "!< version of this structure"] + pub version: NvU32, + #[doc = "!< width of the input texture"] + pub vertices: *mut f32, + #[doc = "!< format of the input vertices"] + pub vertexFormat: NV_GPU_WARPING_VERTICE_FORMAT, + #[doc = "!< number of the input vertices"] + pub numVertices: ::std::os::raw::c_int, + #[doc = "!< rectangle in desktop coordinates describing the source area for the warping"] + pub textureRect: *mut NvSBox, +} +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_SCANOUT_WARPING_STATE_DATA { + #[doc = "!< version of this structure"] + pub version: NvU32, + #[doc = "!< warping is enabled or not"] + pub bEnabled: NvU32, +} +#[doc = "! \\ingroup gpu"] +pub type NV_SCANOUT_WARPING_STATE_DATA = _NV_SCANOUT_WARPING_STATE_DATA; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_WARPING_RESAMPLING_METHOD : NV_GPU_SCANOUT_COMPOSITION_PARAMETER = 0 ; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_SCANOUT_INTENSITY_METHOD : NV_GPU_SCANOUT_COMPOSITION_PARAMETER = 1 ; +pub type NV_GPU_SCANOUT_COMPOSITION_PARAMETER = ::std::os::raw::c_int; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_SET_TO_DEFAULT : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 0 ; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BILINEAR : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 256 ; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_TRIANGULAR : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 257 ; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_BELL_SHAPED : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 258 ; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_BSPLINE : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 259 ; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_ADAPTIVE_TRIANGULAR : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 260 ; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_ADAPTIVE_BELL_SHAPED : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 261 ; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_ADAPTIVE_BSPLINE : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 262 ; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_SCANOUT_INTENSITY_NO_GAMMA : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 512 ; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_SCANOUT_INTENSITY_COLOR_GAMMA : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 513 ; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_SCANOUT_INTENSITY_COLOR_AND_OFFSET_GAMMA : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 514 ; +#[doc = "! This enum defines a collection of scanout composition values that can be used to configure\n! the supported scanout composition settings"] +pub type NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetScanoutConfigurationEx()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_SCANOUT_INFORMATION { + #[doc = "!< Structure version, needs to be initialized with NV_SCANOUT_INFORMATION_VER."] + pub version: NvU32, + #[doc = "!< Operating system display device rect in desktop coordinates displayId is scanning out from."] + pub sourceDesktopRect: NvSBox, + #[doc = "!< Area inside the sourceDesktopRect which is scanned out to the display."] + pub sourceViewportRect: NvSBox, + #[doc = "!< Area inside the rect described by targetDisplayWidth/Height sourceViewportRect is scanned out to."] + pub targetViewportRect: NvSBox, + #[doc = "!< Horizontal size of the active resolution scanned out to the display."] + pub targetDisplayWidth: NvU32, + #[doc = "!< Vertical size of the active resolution scanned out to the display."] + pub targetDisplayHeight: NvU32, + #[doc = "!< If targets are cloned views of the sourceDesktopRect the cloned targets have an importance assigned (0:primary,1 secondary,...)."] + pub cloneImportance: NvU32, + #[doc = "!< Rotation performed between the sourceViewportRect and the targetViewportRect."] + pub sourceToTargetRotation: NV_ROTATE, +} +#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetScanoutConfigurationEx()."] +pub type NV_SCANOUT_INFORMATION = _NV_SCANOUT_INFORMATION; +#[doc = "!< Represents Bare Metal GPU"] +pub const _NV_VIRTUALIZATION_MODE_NV_VIRTUALIZATION_MODE_NONE: _NV_VIRTUALIZATION_MODE = 0; +#[doc = "!< Represents GPU-Passthrough"] +pub const _NV_VIRTUALIZATION_MODE_NV_VIRTUALIZATION_MODE_NMOS: _NV_VIRTUALIZATION_MODE = 1; +#[doc = "!< Represents vGPU inside virtual machine"] +pub const _NV_VIRTUALIZATION_MODE_NV_VIRTUALIZATION_MODE_VGX: _NV_VIRTUALIZATION_MODE = 2; +#[doc = "!< Represents VGX hypervisor in vGPU mode"] +pub const _NV_VIRTUALIZATION_MODE_NV_VIRTUALIZATION_MODE_HOST_VGPU: _NV_VIRTUALIZATION_MODE = 3; +#[doc = "! \\ingroup gpu"] +pub type _NV_VIRTUALIZATION_MODE = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpu"] +pub use self::_NV_VIRTUALIZATION_MODE as NV_VIRTUALIZATION_MODE; +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_VIRTUALIZATION_INFO { + #[doc = "!< Structure version"] + pub version: NvU32, + #[doc = "!< one of NV_VIRTUALIZATION_MODE."] + pub virtualizationMode: NV_VIRTUALIZATION_MODE, + #[doc = "!< reserved for future use. Should be set to ZERO."] + pub reserved: NvU32, +} +#[doc = "! \\ingroup gpu"] +pub type NV_GPU_VIRTUALIZATION_INFO_V1 = _NV_GPU_VIRTUALIZATION_INFO; +#[doc = "! \\ingroup gpu"] +pub type NV_GPU_VIRTUALIZATION_INFO = NV_GPU_VIRTUALIZATION_INFO_V1; +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LOGICAL_GPU_DATA_V1 { + #[doc = "!< [in] Structure version."] + pub version: NvU32, + #[doc = "!< [out] Returns OS-AdapterId. User must send memory buffer of size atleast equal to the size of LUID structure before calling the NVAPI."] + pub pOSAdapterId: *mut ::std::os::raw::c_void, + #[doc = "!< [out] Number of physical GPU handles associated with the specified logical GPU handle."] + pub physicalGpuCount: NvU32, + #[doc = "!< [out] This array will be filled with physical GPU handles associated with the given logical GPU handle.\n!< The array index refers to the Physical Gpu Index (Idx).\n!< Idx value is the same as D3D11 MultiGPUDevice GPU index, D3D12 node index, OpenGL GL_NV_gpu_multicast GPU index.\n!< When converted to a bit mask (1 << Idx), it matches:\n!< 1. Vulkan deviceNodeMask in VkPhysicalDeviceIDProperties\n!< 2. CUDA deviceNodeMask returned by cuDeviceGetLuid"] + pub physicalGpuHandles: [NvPhysicalGpuHandle; 64usize], + #[doc = "!< Reserved for future use. Should be set to ZERO."] + pub reserved: [NvU32; 8usize], +} +#[doc = "! \\ingroup gpu"] +pub type NV_LOGICAL_GPU_DATA_V1 = _NV_LOGICAL_GPU_DATA_V1; +#[doc = "! \\ingroup gpu"] +pub type NV_LOGICAL_GPU_DATA = NV_LOGICAL_GPU_DATA_V1; +#[doc = "! License string"] +pub type NvAPI_LicenseString = [::std::os::raw::c_char; 128usize]; +pub const _NV_LICENSE_FEATURE_TYPE_NV_LICENSE_FEATURE_UNKNOWN: _NV_LICENSE_FEATURE_TYPE = 0; +pub const _NV_LICENSE_FEATURE_TYPE_NV_LICENSE_FEATURE_VGPU: _NV_LICENSE_FEATURE_TYPE = 1; +pub const _NV_LICENSE_FEATURE_TYPE_NV_LICENSE_FEATURE_NVIDIA_RTX: _NV_LICENSE_FEATURE_TYPE = 2; +#[doc = "!< DEPRECATED name - do not use"] +pub const _NV_LICENSE_FEATURE_TYPE_NV_LICENSE_FEATURE_QUADRO: _NV_LICENSE_FEATURE_TYPE = 2; +pub const _NV_LICENSE_FEATURE_TYPE_NV_LICENSE_FEATURE_GAMING: _NV_LICENSE_FEATURE_TYPE = 3; +pub const _NV_LICENSE_FEATURE_TYPE_NV_LICENSE_FEATURE_COMPUTE: _NV_LICENSE_FEATURE_TYPE = 4; +#[doc = "! Used in NV_LICENSE_FEATURE_DETAILS"] +pub type _NV_LICENSE_FEATURE_TYPE = ::std::os::raw::c_int; +#[doc = "! Used in NV_LICENSE_FEATURE_DETAILS"] +pub use self::_NV_LICENSE_FEATURE_TYPE as NV_LICENSE_FEATURE_TYPE; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LICENSE_EXPIRY_DETAILS { + #[doc = "!< Year value of license expiry"] + pub year: NvU32, + #[doc = "!< Month value of license expiry"] + pub month: NvU16, + #[doc = "!< Day value of license expiry"] + pub day: NvU16, + #[doc = "!< Hour value of license expiry"] + pub hour: NvU16, + #[doc = "!< Minutes value of license expiry"] + pub min: NvU16, + #[doc = "!< Seconds value of license expiry"] + pub sec: NvU16, + #[doc = "!< License expiry status"] + pub status: NvU8, +} +pub type NV_LICENSE_EXPIRY_DETAILS = _NV_LICENSE_EXPIRY_DETAILS; +#[doc = "! Used in NV_LICENSABLE_FEATURES"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LICENSE_FEATURE_DETAILS_V1 { + #[doc = "!< IN - Structure version."] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Feature code that corresponds to the licensable feature."] + pub featureCode: NV_LICENSE_FEATURE_TYPE, + #[doc = "!< Deprecated"] + pub licenseInfo: NvAPI_LicenseString, +} +impl _NV_LICENSE_FEATURE_DETAILS_V1 { + #[inline] + pub fn isEnabled(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isEnabled(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isEnabled_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isEnabled_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isEnabled: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isEnabled: u32 = unsafe { ::std::mem::transmute(isEnabled) }; + isEnabled as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! Used in NV_LICENSABLE_FEATURES"] +pub type NV_LICENSE_FEATURE_DETAILS_V1 = _NV_LICENSE_FEATURE_DETAILS_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LICENSE_FEATURE_DETAILS_V2 { + #[doc = "!< Unused."] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Feature code that corresponds to the licensable feature."] + pub featureCode: NV_LICENSE_FEATURE_TYPE, + #[doc = "!< Deprecated"] + pub licenseInfo: NvAPI_LicenseString, + #[doc = "!< Nvidia Grid licensable product name."] + pub productName: NvAPI_LicenseString, +} +impl _NV_LICENSE_FEATURE_DETAILS_V2 { + #[inline] + pub fn isEnabled(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isEnabled(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isEnabled_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isEnabled_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isEnabled: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isEnabled: u32 = unsafe { ::std::mem::transmute(isEnabled) }; + isEnabled as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_LICENSE_FEATURE_DETAILS_V2 = _NV_LICENSE_FEATURE_DETAILS_V2; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LICENSE_FEATURE_DETAILS_V3 { + #[doc = "!< Unused."] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Feature code that corresponds to the licensable feature."] + pub featureCode: NV_LICENSE_FEATURE_TYPE, + #[doc = "!< Deprecated"] + pub licenseInfo: NvAPI_LicenseString, + #[doc = "!< Nvidia Grid licensable product name."] + pub productName: NvAPI_LicenseString, +} +impl _NV_LICENSE_FEATURE_DETAILS_V3 { + #[inline] + pub fn isEnabled(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isEnabled(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isEnabled_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isEnabled_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isFeatureEnabled(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isFeatureEnabled(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isFeatureEnabled_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isFeatureEnabled_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 30u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 30u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 30u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isEnabled: NvU32, + isFeatureEnabled: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isEnabled: u32 = unsafe { ::std::mem::transmute(isEnabled) }; + isEnabled as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isFeatureEnabled: u32 = unsafe { ::std::mem::transmute(isFeatureEnabled) }; + isFeatureEnabled as u64 + }); + __bindgen_bitfield_unit.set(2usize, 30u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_LICENSE_FEATURE_DETAILS_V3 = _NV_LICENSE_FEATURE_DETAILS_V3; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LICENSE_FEATURE_DETAILS_V4 { + #[doc = "!< Unused."] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Feature code that corresponds to the licensable feature."] + pub featureCode: NV_LICENSE_FEATURE_TYPE, + #[doc = "!< Deprecated"] + pub licenseInfo: NvAPI_LicenseString, + #[doc = "!< Nvidia Grid licensable product name."] + pub productName: NvAPI_LicenseString, + #[doc = "!< License expiry information."] + pub licenseExpiry: NV_LICENSE_EXPIRY_DETAILS, +} +impl _NV_LICENSE_FEATURE_DETAILS_V4 { + #[inline] + pub fn isEnabled(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isEnabled(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isEnabled_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isEnabled_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isFeatureEnabled(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isFeatureEnabled(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isFeatureEnabled_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isFeatureEnabled_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 30u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 30u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 30u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isEnabled: NvU32, + isFeatureEnabled: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isEnabled: u32 = unsafe { ::std::mem::transmute(isEnabled) }; + isEnabled as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isFeatureEnabled: u32 = unsafe { ::std::mem::transmute(isFeatureEnabled) }; + isFeatureEnabled as u64 + }); + __bindgen_bitfield_unit.set(2usize, 30u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_LICENSE_FEATURE_DETAILS_V4 = _NV_LICENSE_FEATURE_DETAILS_V4; +#[doc = "! Used in NV_LICENSABLE_FEATURES"] +pub type NV_LICENSE_FEATURE_DETAILS = NV_LICENSE_FEATURE_DETAILS_V1; +#[doc = "! Licensable features"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LICENSABLE_FEATURES_V1 { + #[doc = "!< IN - Structure version."] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< The number of licensable features."] + pub licensableFeatureCount: NvU32, + #[doc = "!< Dynamic signature required for Authentication of the components,\n!< signature length limited to NV_LICENSE_SIGNATURE_SIZE"] + pub signature: [NvU8; 128usize], + #[doc = "!< Array of licensable features"] + pub licenseDetails: [NV_LICENSE_FEATURE_DETAILS_V1; 3usize], +} +impl _NV_LICENSABLE_FEATURES_V1 { + #[inline] + pub fn isLicenseSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isLicenseSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isLicenseSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isLicenseSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isLicenseSupported: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isLicenseSupported: u32 = unsafe { ::std::mem::transmute(isLicenseSupported) }; + isLicenseSupported as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! Licensable features"] +pub type NV_LICENSABLE_FEATURES_V1 = _NV_LICENSABLE_FEATURES_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LICENSABLE_FEATURES_V2 { + #[doc = "!< IN - Structure version."] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< The number of licensable features."] + pub licensableFeatureCount: NvU32, + #[doc = "!< Dynamic signature required for Authentication of the components,\n!< signature length limited to NV_LICENSE_SIGNATURE_SIZE"] + pub signature: [NvU8; 128usize], + #[doc = "!< Array of licensable features"] + pub licenseDetails: [NV_LICENSE_FEATURE_DETAILS_V2; 3usize], +} +impl _NV_LICENSABLE_FEATURES_V2 { + #[inline] + pub fn isLicenseSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isLicenseSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isLicenseSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isLicenseSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isLicenseSupported: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isLicenseSupported: u32 = unsafe { ::std::mem::transmute(isLicenseSupported) }; + isLicenseSupported as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_LICENSABLE_FEATURES_V2 = _NV_LICENSABLE_FEATURES_V2; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LICENSABLE_FEATURES_V3 { + #[doc = "!< IN - Structure version."] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< The number of licensable features."] + pub licensableFeatureCount: NvU32, + #[doc = "!< Dynamic signature required for Authentication of the components,\n!< signature length limited to NV_LICENSE_SIGNATURE_SIZE"] + pub signature: [NvU8; 128usize], + #[doc = "!< Array of licensable features"] + pub licenseDetails: [NV_LICENSE_FEATURE_DETAILS_V3; 3usize], +} +impl _NV_LICENSABLE_FEATURES_V3 { + #[inline] + pub fn isLicenseSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isLicenseSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isLicenseSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isLicenseSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isLicenseSupported: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isLicenseSupported: u32 = unsafe { ::std::mem::transmute(isLicenseSupported) }; + isLicenseSupported as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_LICENSABLE_FEATURES_V3 = _NV_LICENSABLE_FEATURES_V3; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LICENSABLE_FEATURES_V4 { + #[doc = "!< IN - Structure version."] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< The number of licensable features."] + pub licensableFeatureCount: NvU32, + #[doc = "!< Dynamic signature required for Authentication of the components,\n!< signature length limited to NV_LICENSE_SIGNATURE_SIZE"] + pub signature: [NvU8; 128usize], + #[doc = "!< Array of licensable features"] + pub licenseDetails: [NV_LICENSE_FEATURE_DETAILS_V4; 3usize], +} +impl _NV_LICENSABLE_FEATURES_V4 { + #[inline] + pub fn isLicenseSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isLicenseSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isLicenseSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isLicenseSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isLicenseSupported: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isLicenseSupported: u32 = unsafe { ::std::mem::transmute(isLicenseSupported) }; + isLicenseSupported as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_LICENSABLE_FEATURES_V4 = _NV_LICENSABLE_FEATURES_V4; +pub type NV_LICENSABLE_FEATURES = NV_LICENSABLE_FEATURES_V4; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_ENCODER_STATISTICS_V1 { + #[doc = "!< [in] Structure version value."] + pub version: NvU32, + #[doc = "!< [out] Count of active encoder sessions."] + pub sessionsCount: NvU32, + #[doc = "!< [out] Trailing average FPS of all active sessions."] + pub averageFps: NvU32, + #[doc = "!< [out] Encode latency in microseconds."] + pub averageLatency: NvU32, +} +pub type NV_ENCODER_STATISTICS_V1 = _NV_ENCODER_STATISTICS_V1; +pub type NV_ENCODER_STATISTICS = NV_ENCODER_STATISTICS_V1; +pub const _NV_ENCODER_TYPE_NV_ENCODER_H264: _NV_ENCODER_TYPE = 0; +pub const _NV_ENCODER_TYPE_NV_ENCODER_HEVC: _NV_ENCODER_TYPE = 1; +pub const _NV_ENCODER_TYPE_NV_ENCODER_UNKNOWN: _NV_ENCODER_TYPE = -1; +pub type _NV_ENCODER_TYPE = ::std::os::raw::c_int; +pub use self::_NV_ENCODER_TYPE as NV_ENCODER_TYPE; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_ENCODER_PER_SESSION_INFO_V1 { + #[doc = "!< Unique session ID."] + pub sessionId: NvU32, + #[doc = "!< Owning process ID."] + pub processId: NvU32, + #[doc = "!< Owning vGPU instance ID (only valid on vGPU hosts, otherwise zero)."] + pub vgpuInstance: NvU32, + #[doc = "!< Video encoder type."] + pub codecType: NV_ENCODER_TYPE, + #[doc = "!< Current encode horizontal resolution."] + pub hResolution: NvU32, + #[doc = "!< Current encode vertical resolution."] + pub vResolution: NvU32, + #[doc = "!< Moving average encode frames per second."] + pub averageEncodeFps: NvU32, + #[doc = "!< Moving average encode latency in microseconds."] + pub averageEncodeLatency: NvU32, +} +pub type NV_ENCODER_PER_SESSION_INFO_V1 = _NV_ENCODER_PER_SESSION_INFO_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_ENCODER_SESSIONS_INFO_V1 { + #[doc = "!< [in] Structure version value."] + pub version: NvU32, + #[doc = "!< [out] Count of active encoder sessions."] + pub sessionsCount: NvU32, + #[doc = "!< [out] Array of session info. Caller should allocate memory for this field before making\n!< the NvAPI_GPU_GetEncoderSessionsInfo() call, memory allocated should be of\n!< size = sizeof(NV_ENCODER_PER_SESSION_INFO_V1) * NV_ENCODER_SESSION_INFO_MAX_ENTRIES_V1."] + pub pSessionInfo: *mut NV_ENCODER_PER_SESSION_INFO_V1, +} +pub type NV_ENCODER_SESSIONS_INFO_V1 = _NV_ENCODER_SESSIONS_INFO_V1; +pub type NV_ENCODER_SESSIONS_INFO = NV_ENCODER_SESSIONS_INFO_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_INFO_V1 { + #[doc = "!< Structure Version."] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl _NV_GPU_INFO_V1 { + #[inline] + pub fn bIsExternalGpu(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsExternalGpu(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsExternalGpu_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsExternalGpu_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsExternalGpu: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsExternalGpu: u32 = unsafe { ::std::mem::transmute(bIsExternalGpu) }; + bIsExternalGpu as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_GPU_INFO_V1 = _NV_GPU_INFO_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_INFO_V2 { + #[doc = "!< Structure Version."] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Reserved for future use"] + pub reserved1: NvU64, + #[doc = "!< Number of \"Ray Tracing Cores\" supported by the GPU."] + pub rayTracingCores: NvU32, + #[doc = "!< Number of \"Tensor Cores\" supported by the GPU."] + pub tensorCores: NvU32, + #[doc = "!< Reserved for future use."] + pub reserved2: [NvU32; 14usize], +} +impl _NV_GPU_INFO_V2 { + #[inline] + pub fn bIsExternalGpu(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsExternalGpu(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsExternalGpu_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsExternalGpu_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved0(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved0(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved0_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved0_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsExternalGpu: NvU32, + reserved0: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsExternalGpu: u32 = unsafe { ::std::mem::transmute(bIsExternalGpu) }; + bIsExternalGpu as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved0: u32 = unsafe { ::std::mem::transmute(reserved0) }; + reserved0 as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_GPU_INFO_V2 = _NV_GPU_INFO_V2; +pub type NV_GPU_INFO = NV_GPU_INFO_V2; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_VR_READY_V1 { + #[doc = "!< Structure Version."] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl _NV_GPU_VR_READY_V1 { + #[inline] + pub fn isVRReady(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isVRReady(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isVRReady_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isVRReady_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isVRReady: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isVRReady: u32 = unsafe { ::std::mem::transmute(isVRReady) }; + isVRReady as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_GPU_VR_READY_V1 = _NV_GPU_VR_READY_V1; +pub type NV_GPU_VR_READY = NV_GPU_VR_READY_V1; +pub const _NV_ADAPTER_TYPE_NV_ADAPTER_TYPE_UNKNOWN: _NV_ADAPTER_TYPE = 0; +pub const _NV_ADAPTER_TYPE_NV_ADAPTER_TYPE_WDDM: _NV_ADAPTER_TYPE = 1; +pub const _NV_ADAPTER_TYPE_NV_ADAPTER_TYPE_MCDM: _NV_ADAPTER_TYPE = 2; +pub const _NV_ADAPTER_TYPE_NV_ADAPTER_TYPE_TCC: _NV_ADAPTER_TYPE = 4; +pub const _NV_ADAPTER_TYPE_NV_ADAPTER_TYPE_LAST: _NV_ADAPTER_TYPE = -1; +pub type _NV_ADAPTER_TYPE = ::std::os::raw::c_int; +pub use self::_NV_ADAPTER_TYPE as NV_ADAPTER_TYPE; +#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetGspFeatures()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_GSP_INFO_V1 { + #[doc = "!< [in] Structure version"] + pub version: NvU32, + #[doc = "!< [out] Contains GSP firmware version"] + pub firmwareVersion: [NvU8; 64usize], + #[doc = "!< Reserved for future use"] + pub reserved: NvU32, +} +#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetGspFeatures()."] +pub type NV_GPU_GSP_INFO_V1 = _NV_GPU_GSP_INFO_V1; +#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetGspFeatures()."] +pub type NV_GPU_GSP_INFO = NV_GPU_GSP_INFO_V1; +#[doc = "! \\fn NvAPI_GPU_GetUUID(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_UUID *pGpuUuid)\n! DESCRIPTION: This function returns the GPU UUID for the specified physical GPU handle.\n! The UUID is returned in GUID format (16 bytes).\n!\n! SUPPORTED OS: Windows 10 and higher\n!\n!\n! TCC_SUPPORTED\n!\n! MCDM_SUPPORTED\n!\n! \\since Release: 595\n!\n! \\param [in] hPhysicalGpu Physical GPU handle to get UUID for\n! \\param [in,out] pGpuUuid Pointer to structure that will receive the GPU UUID\n!\n! \\retval NVAPI_OK Request completed successfully\n! \\return This API can return any of the error codes enumerated in #NvAPI_Status.\n!\n! \\ingroup gpu\n\n! Used in NvAPI_GPU_GetUUID()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_UUID_V1 { + pub version: NvU32, + pub uuid: [NvU8; 16usize], +} +#[doc = "! \\fn NvAPI_GPU_GetUUID(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_UUID *pGpuUuid)\n! DESCRIPTION: This function returns the GPU UUID for the specified physical GPU handle.\n! The UUID is returned in GUID format (16 bytes).\n!\n! SUPPORTED OS: Windows 10 and higher\n!\n!\n! TCC_SUPPORTED\n!\n! MCDM_SUPPORTED\n!\n! \\since Release: 595\n!\n! \\param [in] hPhysicalGpu Physical GPU handle to get UUID for\n! \\param [in,out] pGpuUuid Pointer to structure that will receive the GPU UUID\n!\n! \\retval NVAPI_OK Request completed successfully\n! \\return This API can return any of the error codes enumerated in #NvAPI_Status.\n!\n! \\ingroup gpu\n\n! Used in NvAPI_GPU_GetUUID()"] +pub type NV_GPU_UUID_V1 = _NV_GPU_UUID_V1; +#[doc = "! \\fn NvAPI_GPU_GetUUID(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_UUID *pGpuUuid)\n! DESCRIPTION: This function returns the GPU UUID for the specified physical GPU handle.\n! The UUID is returned in GUID format (16 bytes).\n!\n! SUPPORTED OS: Windows 10 and higher\n!\n!\n! TCC_SUPPORTED\n!\n! MCDM_SUPPORTED\n!\n! \\since Release: 595\n!\n! \\param [in] hPhysicalGpu Physical GPU handle to get UUID for\n! \\param [in,out] pGpuUuid Pointer to structure that will receive the GPU UUID\n!\n! \\retval NVAPI_OK Request completed successfully\n! \\return This API can return any of the error codes enumerated in #NvAPI_Status.\n!\n! \\ingroup gpu\n\n! Used in NvAPI_GPU_GetUUID()"] +pub type NV_GPU_UUID = NV_GPU_UUID_V1; +#[doc = "! \\ingroup gpupstate\n! Used in NvAPI_GPU_GetPstatesInfoEx()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PERF_PSTATES_INFO_V1 { + pub version: NvU32, + #[doc = "!< - bit 0 indicates if perfmon is enabled or not\n!< - bit 1 indicates if dynamic Pstate is capable or not\n!< - bit 2 indicates if dynamic Pstate is enable or not\n!< - all other bits must be set to 0"] + pub flags: NvU32, + #[doc = "!< The number of available p-states"] + pub numPstates: NvU32, + #[doc = "!< The number of clock domains supported by each P-State"] + pub numClocks: NvU32, + pub pstates: [NV_GPU_PERF_PSTATES_INFO_V1__bindgen_ty_1; 16usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PERF_PSTATES_INFO_V1__bindgen_ty_1 { + #[doc = "!< ID of the p-state."] + pub pstateId: NV_GPU_PERF_PSTATE_ID, + #[doc = "!< - bit 0 indicates if the PCIE limit is GEN1 or GEN2\n!< - bit 1 indicates if the Pstate is overclocked or not\n!< - bit 2 indicates if the Pstate is overclockable or not\n!< - all other bits must be set to 0"] + pub flags: NvU32, + pub clocks: [NV_GPU_PERF_PSTATES_INFO_V1__bindgen_ty_1__bindgen_ty_1; 32usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PERF_PSTATES_INFO_V1__bindgen_ty_1__bindgen_ty_1 { + #[doc = "!< ID of the clock domain"] + pub domainId: NV_GPU_PUBLIC_CLOCK_ID, + #[doc = "!< Reserved. Must be set to 0"] + pub flags: NvU32, + #[doc = "!< Clock frequency in kHz"] + pub freq: NvU32, +} +#[doc = "! \\ingroup gpupstate"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PERF_PSTATES_INFO_V2 { + pub version: NvU32, + #[doc = "!< - bit 0 indicates if perfmon is enabled or not\n!< - bit 1 indicates if dynamic Pstate is capable or not\n!< - bit 2 indicates if dynamic Pstate is enable or not\n!< - all other bits must be set to 0"] + pub flags: NvU32, + #[doc = "!< The number of available p-states"] + pub numPstates: NvU32, + #[doc = "!< The number of clock domains supported by each P-State"] + pub numClocks: NvU32, + pub numVoltages: NvU32, + #[doc = "!< Valid index range is 0 to numVoltages-1"] + pub pstates: [NV_GPU_PERF_PSTATES_INFO_V2__bindgen_ty_1; 16usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PERF_PSTATES_INFO_V2__bindgen_ty_1 { + #[doc = "!< ID of the p-state."] + pub pstateId: NV_GPU_PERF_PSTATE_ID, + #[doc = "!< - bit 0 indicates if the PCIE limit is GEN1 or GEN2\n!< - bit 1 indicates if the Pstate is overclocked or not\n!< - bit 2 indicates if the Pstate is overclockable or not\n!< - all other bits must be set to 0"] + pub flags: NvU32, + pub clocks: [NV_GPU_PERF_PSTATES_INFO_V2__bindgen_ty_1__bindgen_ty_1; 32usize], + pub voltages: [NV_GPU_PERF_PSTATES_INFO_V2__bindgen_ty_1__bindgen_ty_2; 16usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PERF_PSTATES_INFO_V2__bindgen_ty_1__bindgen_ty_1 { + pub domainId: NV_GPU_PUBLIC_CLOCK_ID, + #[doc = "!< bit 0 indicates if this clock is overclockable\n!< all other bits must be set to 0"] + pub flags: NvU32, + pub freq: NvU32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PERF_PSTATES_INFO_V2__bindgen_ty_1__bindgen_ty_2 { + #[doc = "!< ID of the voltage domain, containing flags and mvolt info"] + pub domainId: NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID, + #[doc = "!< Reserved for future use. Must be set to 0"] + pub flags: NvU32, + #[doc = "!< Voltage in mV"] + pub mvolt: NvU32, +} +#[doc = "! \\ingroup gpupstate"] +pub type NV_GPU_PERF_PSTATES_INFO = NV_GPU_PERF_PSTATES_INFO_V2; +#[doc = "! \\ingroup gpupstate\n! Used in NvAPI_GPU_GetDynamicPstatesInfoEx()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_DYNAMIC_PSTATES_INFO_EX { + #[doc = "!< Structure version"] + pub version: NvU32, + #[doc = "!< bit 0 indicates if the dynamic Pstate is enabled or not"] + pub flags: NvU32, + pub utilization: [NV_GPU_DYNAMIC_PSTATES_INFO_EX__bindgen_ty_1; 8usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_DYNAMIC_PSTATES_INFO_EX__bindgen_ty_1 { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + #[doc = "!< Percentage of time where the domain is considered busy in the last 1 second interval"] + pub percentage: NvU32, +} +impl NV_GPU_DYNAMIC_PSTATES_INFO_EX__bindgen_ty_1 { + #[inline] + pub fn bIsPresent(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsPresent(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsPresent_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsPresent_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1(bIsPresent: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsPresent: u32 = unsafe { ::std::mem::transmute(bIsPresent) }; + bIsPresent as u64 + }); + __bindgen_bitfield_unit + } +} +pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_NONE: NV_THERMAL_TARGET = 0; +#[doc = "!< GPU core temperature requires NvPhysicalGpuHandle"] +pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_GPU: NV_THERMAL_TARGET = 1; +#[doc = "!< GPU memory temperature requires NvPhysicalGpuHandle"] +pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_MEMORY: NV_THERMAL_TARGET = 2; +#[doc = "!< GPU power supply temperature requires NvPhysicalGpuHandle"] +pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_POWER_SUPPLY: NV_THERMAL_TARGET = 4; +#[doc = "!< GPU board ambient temperature requires NvPhysicalGpuHandle"] +pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_BOARD: NV_THERMAL_TARGET = 8; +#[doc = "!< Visual Computing Device Board temperature requires NvVisualComputingDeviceHandle"] +pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_VCD_BOARD: NV_THERMAL_TARGET = 9; +#[doc = "!< Visual Computing Device Inlet temperature requires NvVisualComputingDeviceHandle"] +pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_VCD_INLET: NV_THERMAL_TARGET = 10; +#[doc = "!< Visual Computing Device Outlet temperature requires NvVisualComputingDeviceHandle"] +pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_VCD_OUTLET: NV_THERMAL_TARGET = 11; +pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_ALL: NV_THERMAL_TARGET = 15; +pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_UNKNOWN: NV_THERMAL_TARGET = -1; +#[doc = "! \\ingroup gputhermal\n! Used in NV_GPU_THERMAL_SETTINGS"] +pub type NV_THERMAL_TARGET = ::std::os::raw::c_int; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_NONE: NV_THERMAL_CONTROLLER = 0; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_GPU_INTERNAL: NV_THERMAL_CONTROLLER = 1; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_ADM1032: NV_THERMAL_CONTROLLER = 2; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_MAX6649: NV_THERMAL_CONTROLLER = 3; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_MAX1617: NV_THERMAL_CONTROLLER = 4; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_LM99: NV_THERMAL_CONTROLLER = 5; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_LM89: NV_THERMAL_CONTROLLER = 6; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_LM64: NV_THERMAL_CONTROLLER = 7; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_ADT7473: NV_THERMAL_CONTROLLER = 8; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_SBMAX6649: NV_THERMAL_CONTROLLER = 9; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_VBIOSEVT: NV_THERMAL_CONTROLLER = 10; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_OS: NV_THERMAL_CONTROLLER = 11; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_UNKNOWN: NV_THERMAL_CONTROLLER = -1; +#[doc = "! \\ingroup gputhermal\n! Used in NV_GPU_THERMAL_SETTINGS"] +pub type NV_THERMAL_CONTROLLER = ::std::os::raw::c_int; +#[doc = "! \\ingroup gputhermal\n! Used in NvAPI_GPU_GetThermalSettings()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_THERMAL_SETTINGS_V1 { + #[doc = "!< structure version"] + pub version: NvU32, + #[doc = "!< number of associated thermal sensors"] + pub count: NvU32, + pub sensor: [NV_GPU_THERMAL_SETTINGS_V1__bindgen_ty_1; 3usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_THERMAL_SETTINGS_V1__bindgen_ty_1 { + #[doc = "!< internal, ADM1032, MAX6649..."] + pub controller: NV_THERMAL_CONTROLLER, + #[doc = "!< The min default temperature value of the thermal sensor in degree Celsius"] + pub defaultMinTemp: NvU32, + #[doc = "!< The max default temperature value of the thermal sensor in degree Celsius"] + pub defaultMaxTemp: NvU32, + #[doc = "!< The current temperature value of the thermal sensor in degree Celsius"] + pub currentTemp: NvU32, + #[doc = "!< Thermal sensor targeted @ GPU, memory, chipset, powersupply, Visual Computing Device, etc."] + pub target: NV_THERMAL_TARGET, +} +#[doc = "! \\ingroup gputhermal"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_THERMAL_SETTINGS_V2 { + #[doc = "!< structure version"] + pub version: NvU32, + #[doc = "!< number of associated thermal sensors"] + pub count: NvU32, + pub sensor: [NV_GPU_THERMAL_SETTINGS_V2__bindgen_ty_1; 3usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_THERMAL_SETTINGS_V2__bindgen_ty_1 { + #[doc = "!< internal, ADM1032, MAX6649..."] + pub controller: NV_THERMAL_CONTROLLER, + #[doc = "!< Minimum default temperature value of the thermal sensor in degree Celsius"] + pub defaultMinTemp: NvS32, + #[doc = "!< Maximum default temperature value of the thermal sensor in degree Celsius"] + pub defaultMaxTemp: NvS32, + #[doc = "!< Current temperature value of the thermal sensor in degree Celsius"] + pub currentTemp: NvS32, + #[doc = "!< Thermal sensor targeted - GPU, memory, chipset, powersupply, Visual Computing Device, etc"] + pub target: NV_THERMAL_TARGET, +} +#[doc = "! \\ingroup gputhermal"] +pub type NV_GPU_THERMAL_SETTINGS = NV_GPU_THERMAL_SETTINGS_V2; +#[doc = "! \\ingroup gpuclock\n! Used in NvAPI_GPU_GetAllClockFrequencies()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_CLOCK_FREQUENCIES_V1 { + #[doc = "!< Structure version"] + pub version: NvU32, + #[doc = "!< These bits are reserved for future use."] + pub reserved: NvU32, + pub domain: [NV_GPU_CLOCK_FREQUENCIES_V1__bindgen_ty_1; 32usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_CLOCK_FREQUENCIES_V1__bindgen_ty_1 { + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Clock frequency (kHz)"] + pub frequency: NvU32, +} +impl NV_GPU_CLOCK_FREQUENCIES_V1__bindgen_ty_1 { + #[inline] + pub fn bIsPresent(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsPresent(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsPresent_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsPresent_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsPresent: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsPresent: u32 = unsafe { ::std::mem::transmute(bIsPresent) }; + bIsPresent as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub const NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE_NV_GPU_CLOCK_FREQUENCIES_CURRENT_FREQ: + NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE = 0; +pub const NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE_NV_GPU_CLOCK_FREQUENCIES_BASE_CLOCK: + NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE = 1; +pub const NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE_NV_GPU_CLOCK_FREQUENCIES_BOOST_CLOCK: + NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE = 2; +pub const NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE_NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE_NUM: + NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE = 3; +#[doc = "! \\ingroup gpuclock\n! Used in NvAPI_GPU_GetAllClockFrequencies()"] +pub type NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpuclock\n! Used in NvAPI_GPU_GetAllClockFrequencies()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_CLOCK_FREQUENCIES_V2 { + #[doc = "!< Structure version"] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + pub domain: [NV_GPU_CLOCK_FREQUENCIES_V2__bindgen_ty_1; 32usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_CLOCK_FREQUENCIES_V2__bindgen_ty_1 { + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Clock frequency (kHz)"] + pub frequency: NvU32, +} +impl NV_GPU_CLOCK_FREQUENCIES_V2__bindgen_ty_1 { + #[inline] + pub fn bIsPresent(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsPresent(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsPresent_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsPresent_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsPresent: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsPresent: u32 = unsafe { ::std::mem::transmute(bIsPresent) }; + bIsPresent as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +impl NV_GPU_CLOCK_FREQUENCIES_V2 { + #[inline] + pub fn ClockType(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32) } + } + #[inline] + pub fn set_ClockType(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn ClockType_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 4u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_ClockType_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 20u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 20u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 20u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 20u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved1(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u32) } + } + #[inline] + pub fn set_reserved1(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(24usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved1_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 24usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved1_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 24usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + ClockType: NvU32, + reserved: NvU32, + reserved1: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 4u8, { + let ClockType: u32 = unsafe { ::std::mem::transmute(ClockType) }; + ClockType as u64 + }); + __bindgen_bitfield_unit.set(4usize, 20u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit.set(24usize, 8u8, { + let reserved1: u32 = unsafe { ::std::mem::transmute(reserved1) }; + reserved1 as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup gpuclock\n! Used in NvAPI_GPU_GetAllClockFrequencies()"] +pub type NV_GPU_CLOCK_FREQUENCIES = NV_GPU_CLOCK_FREQUENCIES_V2; +pub const _NV_GPU_ILLUMINATION_ATTRIB_NV_GPU_IA_LOGO_BRIGHTNESS: _NV_GPU_ILLUMINATION_ATTRIB = 0; +pub const _NV_GPU_ILLUMINATION_ATTRIB_NV_GPU_IA_SLI_BRIGHTNESS: _NV_GPU_ILLUMINATION_ATTRIB = 1; +#[doc = "! \\ingroup gpu"] +pub type _NV_GPU_ILLUMINATION_ATTRIB = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpu"] +pub use self::_NV_GPU_ILLUMINATION_ATTRIB as NV_GPU_ILLUMINATION_ATTRIB; +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_QUERY_ILLUMINATION_SUPPORT_PARM_V1 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< The handle of the GPU that you are checking for the specified attribute.\n!< note that this is the GPU that is managing the attribute.\n!< Only a single GPU can manage an given attribute on a given HW element,\n!< regardless of how many are attatched.\n!< I.E. only one GPU will be used to control the brightness of the LED on an SLI bridge,\n!< regardless of how many are physicaly attached.\n!< You enumerate thru the GPUs with this call to determine which GPU is managing the attribute."] + pub hPhysicalGpu: NvPhysicalGpuHandle, + #[doc = "!< An enumeration value specifying the Illumination attribute to be querried.\n!< refer to enum \\ref NV_GPU_ILLUMINATION_ATTRIB."] + pub Attribute: NV_GPU_ILLUMINATION_ATTRIB, + #[doc = "!< A boolean indicating if the attribute is supported."] + pub bSupported: NvU32, +} +#[doc = "! \\ingroup gpu"] +pub type NV_GPU_QUERY_ILLUMINATION_SUPPORT_PARM_V1 = _NV_GPU_QUERY_ILLUMINATION_SUPPORT_PARM_V1; +#[doc = "! \\ingroup gpu"] +pub type NV_GPU_QUERY_ILLUMINATION_SUPPORT_PARM = NV_GPU_QUERY_ILLUMINATION_SUPPORT_PARM_V1; +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_GET_ILLUMINATION_PARM_V1 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< The handle of the GPU that you are checking for the specified attribute.\n!< Note that this is the GPU that is managing the attribute.\n!< Only a single GPU can manage an given attribute on a given HW element,\n!< regardless of how many are attatched.\n!< I.E. only one GPU will be used to control the brightness of the LED on an SLI bridge,\n!< regardless of how many are physicaly attached.\n!< You enumerate thru the GPUs with this call to determine which GPU is managing the attribute."] + pub hPhysicalGpu: NvPhysicalGpuHandle, + #[doc = "!< An enumeration value specifying the Illumination attribute to be querried.\n!< refer to enum \\ref NV_GPU_ILLUMINATION_ATTRIB."] + pub Attribute: NV_GPU_ILLUMINATION_ATTRIB, + #[doc = "!< A DWORD that will contain the current value of the specified attribute."] + pub Value: NvU32, +} +#[doc = "! \\ingroup gpu"] +pub type NV_GPU_GET_ILLUMINATION_PARM_V1 = _NV_GPU_GET_ILLUMINATION_PARM_V1; +#[doc = "! \\ingroup gpu"] +pub type NV_GPU_GET_ILLUMINATION_PARM = NV_GPU_GET_ILLUMINATION_PARM_V1; +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_SET_ILLUMINATION_PARM_V1 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< The handle of the GPU that you are checking for the specified attribute.\n!< Note that this is the GPU that is managing the attribute.\n!< Only a single GPU can manage an given attribute on a given HW element,\n!< regardless of how many are attatched.\n!< I.E. only one GPU will be used to control the brightness of the LED on an SLI bridge,\n!< regardless of how many are physicaly attached.\n!< You enumerate thru the GPUs with this call to determine which GPU is managing the attribute."] + pub hPhysicalGpu: NvPhysicalGpuHandle, + #[doc = "!< An enumeration value specifying the Illumination attribute to be querried.\n!< refer to enum \\ref NV_GPU_ILLUMINATION_ATTRIB."] + pub Attribute: NV_GPU_ILLUMINATION_ATTRIB, + #[doc = "!< A DWORD containing the new value for the specified attribute.\n!< This should be specified as a percentage of the full range of the attribute\n!< (0-100; 0 = off, 100 = full brightness)\n!< If a value is specified outside this range, NVAPI_INVALID_ARGUMENT will be returned."] + pub Value: NvU32, +} +#[doc = "! \\ingroup gpu"] +pub type NV_GPU_SET_ILLUMINATION_PARM_V1 = _NV_GPU_SET_ILLUMINATION_PARM_V1; +#[doc = "! \\ingroup gpu"] +pub type NV_GPU_SET_ILLUMINATION_PARM = NV_GPU_SET_ILLUMINATION_PARM_V1; +pub const NV_GPU_CLIENT_ILLUM_CTRL_MODE_NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB: + NV_GPU_CLIENT_ILLUM_CTRL_MODE = 0; +pub const NV_GPU_CLIENT_ILLUM_CTRL_MODE_NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB: + NV_GPU_CLIENT_ILLUM_CTRL_MODE = 1; +pub const NV_GPU_CLIENT_ILLUM_CTRL_MODE_NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL: + NV_GPU_CLIENT_ILLUM_CTRL_MODE = 0; +pub const NV_GPU_CLIENT_ILLUM_CTRL_MODE_NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR: + NV_GPU_CLIENT_ILLUM_CTRL_MODE = 1; +pub const NV_GPU_CLIENT_ILLUM_CTRL_MODE_NV_GPU_CLIENT_ILLUM_CTRL_MODE_INVALID: + NV_GPU_CLIENT_ILLUM_CTRL_MODE = 255; +#[doc = " Enumeration of control modes that can be applied to Illumination Zones."] +pub type NV_GPU_CLIENT_ILLUM_CTRL_MODE = ::std::os::raw::c_int; +pub const NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_GPU_TOP_0: + NV_GPU_CLIENT_ILLUM_ZONE_LOCATION = 0; +pub const NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_GPU_FRONT_0: + NV_GPU_CLIENT_ILLUM_ZONE_LOCATION = 8; +pub const NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_GPU_BACK_0: + NV_GPU_CLIENT_ILLUM_ZONE_LOCATION = 12; +pub const NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_SLI_TOP_0: + NV_GPU_CLIENT_ILLUM_ZONE_LOCATION = 32; +pub const NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_INVALID: + NV_GPU_CLIENT_ILLUM_ZONE_LOCATION = -1; +#[doc = " Enumeration of locations where an Illumination Zone might be present.\n Encoding used -\n 1:0 - Number specifier (0)\n 4:2 - Location (TOP)\n 7:5 - Type (GPU/SLI)"] +pub type NV_GPU_CLIENT_ILLUM_ZONE_LOCATION = ::std::os::raw::c_int; +pub const NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_INVALID: + NV_GPU_CLIENT_ILLUM_DEVICE_TYPE = 0; +pub const NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_MCUV10: + NV_GPU_CLIENT_ILLUM_DEVICE_TYPE = 1; +pub const NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_GPIO_PWM_RGBW_V10: + NV_GPU_CLIENT_ILLUM_DEVICE_TYPE = 2; +pub const NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_GPIO_PWM_SINGLE_COLOR_V10 : NV_GPU_CLIENT_ILLUM_DEVICE_TYPE = 3 ; +#[doc = " Enumeration of ILLUM_DEVICEs."] +pub type NV_GPU_CLIENT_ILLUM_DEVICE_TYPE = ::std::os::raw::c_int; +pub const NV_GPU_CLIENT_ILLUM_ZONE_TYPE_NV_GPU_CLIENT_ILLUM_ZONE_TYPE_INVALID: + NV_GPU_CLIENT_ILLUM_ZONE_TYPE = 0; +pub const NV_GPU_CLIENT_ILLUM_ZONE_TYPE_NV_GPU_CLIENT_ILLUM_ZONE_TYPE_RGB: + NV_GPU_CLIENT_ILLUM_ZONE_TYPE = 1; +pub const NV_GPU_CLIENT_ILLUM_ZONE_TYPE_NV_GPU_CLIENT_ILLUM_ZONE_TYPE_COLOR_FIXED: + NV_GPU_CLIENT_ILLUM_ZONE_TYPE = 2; +pub const NV_GPU_CLIENT_ILLUM_ZONE_TYPE_NV_GPU_CLIENT_ILLUM_ZONE_TYPE_RGBW: + NV_GPU_CLIENT_ILLUM_ZONE_TYPE = 3; +pub const NV_GPU_CLIENT_ILLUM_ZONE_TYPE_NV_GPU_CLIENT_ILLUM_ZONE_TYPE_SINGLE_COLOR: + NV_GPU_CLIENT_ILLUM_ZONE_TYPE = 4; +#[doc = " Enumeration of ILLUM_ZONEs."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_TYPE = ::std::os::raw::c_int; +pub const NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE_NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_HALF_HALT : NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE = 0 ; +pub const NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE_NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_FULL_HALT : NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE = 1 ; +pub const NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE_NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_FULL_REPEAT : NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE = 2 ; +pub const NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE_NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_INVALID : NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE = 255 ; +#[doc = " Enumeration of Cycle types for piecewise linear control mode."] +pub type NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE = ::std::os::raw::c_int; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1\n Describes the static information of illumination device type MCUV10."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_MCUV10 { + #[doc = " I2C Device Index: Pointing to the illumination device in I2C Devices Table."] + pub i2cDevIdx: NvU8, +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1\n Describes the static information of illumination device type MCUV10."] +pub type NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_MCUV10 = _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_MCUV10; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1\n Describes the static information of illum device type GPIO_PWM_RGBW."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_RGBW { + #[doc = " Red drive GPIO pin."] + pub gpioPinRed: NvU8, + #[doc = " Green drive GPIO pin."] + pub gpioPinGreen: NvU8, + #[doc = " Blue drive GPIO pin."] + pub gpioPinBlue: NvU8, + #[doc = " White drive GPIO pin."] + pub gpioPinWhite: NvU8, +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1\n Describes the static information of illum device type GPIO_PWM_RGBW."] +pub type NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_RGBW = + _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_RGBW; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1\n Describes the static information of illum device type GPIO_PWM_SINGLE_COLOR."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_SINGLE_COLOR { + #[doc = " Single Color GPIO pin."] + pub gpioPinSingleColor: NvU8, +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1\n Describes the static information of illum device type GPIO_PWM_SINGLE_COLOR."] +pub type NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_SINGLE_COLOR = + _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_SINGLE_COLOR; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1 { + #[doc = " Type of the illumination device."] + pub type_: NV_GPU_CLIENT_ILLUM_DEVICE_TYPE, + #[doc = " Supported control modes for this illumination device."] + pub ctrlModeMask: NvU32, + pub data: _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1__bindgen_ty_1, + #[doc = " Reserved for future."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Union of illumination device info data. Interpreted as per\n @ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1::type"] +#[repr(C)] +#[derive(Copy, Clone)] +pub union _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1__bindgen_ty_1 { + pub mcuv10: NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_MCUV10, + pub gpioPwmRgbwv10: NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_RGBW, + pub gpioPwmSingleColorv10: NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_SINGLE_COLOR, + #[doc = " Reserved bytes for possible future extension of this struct."] + pub rsvd: [NvU8; 64usize], +} +pub type NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1 = _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_PARAMS_V1 { + #[doc = " Version of structure. Must always be first member."] + pub version: NvU32, + #[doc = " Number of illumination devices present."] + pub numIllumDevices: NvU32, + #[doc = " Reserved bytes for possible future extension of this struct."] + pub rsvd: [NvU8; 64usize], + pub devices: [NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1; 32usize], +} +pub type NV_GPU_CLIENT_ILLUM_DEVICE_INFO_PARAMS_V1 = _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_PARAMS_V1; +pub type NV_GPU_CLIENT_ILLUM_DEVICE_INFO_PARAMS = NV_GPU_CLIENT_ILLUM_DEVICE_INFO_PARAMS_V1; +#[doc = " Structure representing the data required for synchronization."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_CLIENT_ILLUM_DEVICE_SYNC_V1 { + #[doc = " Boolean representing the need for synchronization."] + pub bSync: NvBool, + #[doc = " Time stamp value required for synchronization."] + pub timeStampms: NvU64, + #[doc = " Reserved for future."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Structure representing the device control parameters of each ILLUM_DEVICE."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_V1 { + #[doc = " Type of the illum device."] + pub type_: NV_GPU_CLIENT_ILLUM_DEVICE_TYPE, + #[doc = " Structure containing the synchronization data for the illumination device."] + pub syncData: NV_GPU_CLIENT_ILLUM_DEVICE_SYNC_V1, + #[doc = " Reserved for future."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Structure representing the device control parameters of each ILLUM_DEVICE."] +pub type NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL = NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_V1; +#[doc = " Structure representing the control parameters of ILLUM_DEVICE-s."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_PARAMS_V1 { + #[doc = " Version of structure. Must always be first member."] + pub version: NvU32, + #[doc = " Number of illumination devices present."] + pub numIllumDevices: NvU32, + #[doc = " Reserved bytes for possible future extension of this struct."] + pub rsvd: [NvU8; 64usize], + pub devices: [NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_V1; 32usize], +} +#[doc = " Structure representing the control parameters of ILLUM_DEVICE-s."] +pub type NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_PARAMS = NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_PARAMS_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGB { + pub rsvd: NvU8, +} +pub type NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGB = _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGB; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1\n Describes the static information of illum zone type RGBW."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGBW { + pub rsvd: NvU8, +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1\n Describes the static information of illum zone type RGBW."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGBW = _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGBW; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1\n Describes the static information of illum zone type SINGLE_COLOR."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_SINGLE_COLOR { + pub rsvd: NvU8, +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1\n Describes the static information of illum zone type SINGLE_COLOR."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_SINGLE_COLOR = + _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_SINGLE_COLOR; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1 { + pub type_: NV_GPU_CLIENT_ILLUM_ZONE_TYPE, + #[doc = " Index pointing to an Illumination Device that controls this zone."] + pub illumDeviceIdx: NvU8, + #[doc = " Provider index for representing logical to physical zone mapping."] + pub provIdx: NvU8, + #[doc = " Location of the zone on the board."] + pub zoneLocation: NV_GPU_CLIENT_ILLUM_ZONE_LOCATION, + pub data: _NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1__bindgen_ty_1, + pub rsvd: [NvU8; 64usize], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union _NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1__bindgen_ty_1 { + pub rgb: NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGB, + pub rgbw: NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGBW, + pub singleColor: NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_SINGLE_COLOR, + #[doc = " Reserved bytes for possible future extension of this struct."] + pub rsvd: [NvU8; 64usize], +} +pub type NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1 = _NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_INFO_PARAMS_V1 { + #[doc = " Version of structure. Must always be first member."] + pub version: NvU32, + #[doc = " Number of illumination zones present."] + pub numIllumZones: NvU32, + #[doc = " Reserved bytes for possible future extension of this struct."] + pub rsvd: [NvU8; 64usize], + pub zones: [NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1; 32usize], +} +pub type NV_GPU_CLIENT_ILLUM_ZONE_INFO_PARAMS_V1 = _NV_GPU_CLIENT_ILLUM_ZONE_INFO_PARAMS_V1; +pub type NV_GPU_CLIENT_ILLUM_ZONE_INFO_PARAMS = NV_GPU_CLIENT_ILLUM_ZONE_INFO_PARAMS_V1; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB\n Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB_PARAMS { + #[doc = " Red compenent of color applied to the zone."] + pub colorR: NvU8, + #[doc = " Green compenent of color applied to the zone."] + pub colorG: NvU8, + #[doc = " Blue compenent of color applied to the zone."] + pub colorB: NvU8, + #[doc = " Brightness perecentage value of the zone."] + pub brightnessPct: NvU8, +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB\n Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB_PARAMS = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB_PARAMS; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB { + #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] + pub rgbParams: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB_PARAMS, +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB; +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR { + #[doc = " Type of cycle effect to apply."] + pub cycleType: NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE, + #[doc = " Number of times to repeat function within group period."] + pub grpCount: NvU8, + #[doc = " Time in ms to transition from color A to color B."] + pub riseTimems: NvU16, + #[doc = " Time in ms to transition from color B to color A."] + pub fallTimems: NvU16, + #[doc = " Time in ms to remain at color A before color A to color B transition."] + pub ATimems: NvU16, + #[doc = " Time in ms to remain at color B before color B to color A transition."] + pub BTimems: NvU16, + #[doc = " Time in ms to remain idle before next group of repeated function cycles."] + pub grpIdleTimems: NvU16, + #[doc = " Time in ms to offset the cycle relative to other zones."] + pub phaseOffsetms: NvU16, +} +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB { + #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] + pub rgbParams: [NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB_PARAMS; 2usize], + pub piecewiseLinearData: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR, +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illumination zone of type\n \\ref NV_GPU_CLIENT_ILLUM_ZONE_TYPE_RGB."] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB { + pub data: _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB__bindgen_ty_1, + #[doc = " Reserved for future."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Union of illumination zone control data for zone of type NV_GPU_CLIENT_ILLUM_ZONE_TYPE_RGB.\n Interpreted as per ctrlMode."] +#[repr(C)] +#[derive(Copy, Clone)] +pub union _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB__bindgen_ty_1 { + pub manualRGB: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB, + pub piecewiseLinearRGB: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB, + #[doc = " Reserved bytes for possible future extension of this struct."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illumination zone of type\n \\ref NV_GPU_CLIENT_ILLUM_ZONE_TYPE_RGB."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB = _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB; +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED\n Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_RGB."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED_PARAMS { + #[doc = " Brightness percentage value of the zone."] + pub brightnessPct: NvU8, +} +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED\n Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_RGB."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED_PARAMS = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED_PARAMS; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED { + #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] + pub colorFixedParams: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED_PARAMS, +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_COLOR_FIXED { + #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] + pub colorFixedParams: [NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED_PARAMS; 2usize], + pub piecewiseLinearData: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR, +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_COLOR_FIXED = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_COLOR_FIXED; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illum zone of type\n \\ref NV_GPU_CLIENT_ILLUM_ZONE_TYPE_COLOR_FIXED."] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED { + pub data: _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED__bindgen_ty_1, + #[doc = " Reserved for future."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Union of illum zone control data for zone of type NV_GPU_CLIENT_ILLUM_ZONE_TYPE_COLOR_FIXED.\n Interpreted as per ctrlMode."] +#[repr(C)] +#[derive(Copy, Clone)] +pub union _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED__bindgen_ty_1 { + pub manualColorFixed: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED, + pub piecewiseLinearColorFixed: + NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_COLOR_FIXED, + #[doc = " Reserved bytes for possible future extension of this struct."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illum zone of type\n \\ref NV_GPU_CLIENT_ILLUM_ZONE_TYPE_COLOR_FIXED."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW\n Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGBW."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW_PARAMS { + #[doc = " Red component of color applied to the zone."] + pub colorR: NvU8, + #[doc = " Green component of color applied to the zone."] + pub colorG: NvU8, + #[doc = " Blue component of color applied to the zone."] + pub colorB: NvU8, + #[doc = " White component of color applied to the zone."] + pub colorW: NvU8, + #[doc = " Brightness percentage value of the zone."] + pub brightnessPct: NvU8, +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW\n Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGBW."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW_PARAMS = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW_PARAMS; +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_RGBW\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_RGBW."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW { + #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_RGBW."] + pub rgbwParams: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW_PARAMS, +} +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_RGBW\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_RGBW."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW; +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_RGBW\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGBW."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGBW { + #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGBW."] + pub rgbwParams: [NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW_PARAMS; 2usize], + pub piecewiseLinearData: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR, +} +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_RGBW\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGBW."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGBW = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGBW; +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illum zone of type\n \\ref NV_GPU_ILLUM_ZONE_TYPE_RGBW."] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW { + pub data: _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW__bindgen_ty_1, + #[doc = " Reserved for future."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Union of illum zone control data for zone of type NV_GPU_ILLUM_ZONE_TYPE_RGBW.\n Interpreted as per ctrlMode."] +#[repr(C)] +#[derive(Copy, Clone)] +pub union _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW__bindgen_ty_1 { + pub manualRGBW: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW, + pub piecewiseLinearRGBW: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGBW, + #[doc = " Reserved bytes for possible future extension of this struct."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illum zone of type\n \\ref NV_GPU_ILLUM_ZONE_TYPE_RGBW."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW = _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW; +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR\n Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_SINGLE_COLOR."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR_PARAMS { + #[doc = " Brightness percentage value of the zone."] + pub brightnessPct: NvU8, +} +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR\n Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_SINGLE_COLOR."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR_PARAMS = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR_PARAMS; +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_SINGLE_COLOR."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR { + #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_SINGLE_COLOR."] + pub singleColorParams: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR_PARAMS, +} +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_SINGLE_COLOR."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR; +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_SINGLE_COLOR."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_SINGLE_COLOR { + #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_SINGLE_COLOR."] + pub singleColorParams: + [NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR_PARAMS; 2usize], + pub piecewiseLinearData: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR, +} +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_SINGLE_COLOR."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_SINGLE_COLOR = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_SINGLE_COLOR; +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illum zone of type\n \\ref NV_GPU_ILLUM_ZONE_TYPE_SINGLE_COLOR."] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR { + pub data: _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR__bindgen_ty_1, + #[doc = " Reserved for future."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Union of illum zone control data for zone of type NV_GPU_ILLUM_ZONE_TYPE_SINGLE_COLOR.\n Interpreted as per ctrlMode."] +#[repr(C)] +#[derive(Copy, Clone)] +pub union _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR__bindgen_ty_1 { + pub manualSingleColor: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR, + pub piecewiseLinearSingleColor: + NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_SINGLE_COLOR, + #[doc = " Reserved bytes for possible future extension of this struct."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illum zone of type\n \\ref NV_GPU_ILLUM_ZONE_TYPE_SINGLE_COLOR."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1 { + pub type_: NV_GPU_CLIENT_ILLUM_ZONE_TYPE, + pub ctrlMode: NV_GPU_CLIENT_ILLUM_CTRL_MODE, + pub data: _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1__bindgen_ty_1, + pub rsvd: [NvU8; 64usize], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1__bindgen_ty_1 { + pub rgb: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB, + pub colorFixed: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED, + pub rgbw: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW, + pub singleColor: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR, + pub rsvd: [NvU8; 64usize], +} +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1 = _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS_V1 { + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = " Number of illumination zones present."] + pub numIllumZonesControl: NvU32, + #[doc = " Reserved bytes for possible future extension of this struct."] + pub rsvd: [NvU8; 64usize], + pub zones: [NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1; 32usize], +} +impl _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS_V1 { + #[inline] + pub fn bDefault(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bDefault(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bDefault_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bDefault_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn rsvdField(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_rsvdField(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn rsvdField_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_rsvdField_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bDefault: NvU32, + rsvdField: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bDefault: u32 = unsafe { ::std::mem::transmute(bDefault) }; + bDefault as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let rsvdField: u32 = unsafe { ::std::mem::transmute(rsvdField) }; + rsvdField as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS_V1 = _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS_V1; +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS = NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS_V1; +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_GetDisplayPortInfo()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_DISPLAY_PORT_INFO_V1 { + #[doc = "!< Structure version"] + pub version: NvU32, + #[doc = "!< DPCD version of the monitor"] + pub dpcd_ver: NvU32, + #[doc = "!< Maximum supported link rate"] + pub maxLinkRate: NV_DP_LINK_RATE, + #[doc = "!< Maximum supported lane count"] + pub maxLaneCount: NV_DP_LANE_COUNT, + #[doc = "!< Current link rate"] + pub curLinkRate: NV_DP_LINK_RATE, + #[doc = "!< Current lane count"] + pub curLaneCount: NV_DP_LANE_COUNT, + #[doc = "!< Current color format"] + pub colorFormat: NV_DP_COLOR_FORMAT, + #[doc = "!< Dynamic range"] + pub dynamicRange: NV_DP_DYNAMIC_RANGE, + #[doc = "!< Ignored in RGB space"] + pub colorimetry: NV_DP_COLORIMETRY, + #[doc = "!< Current bit-per-component"] + pub bpc: NV_DP_BPC, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl _NV_DISPLAY_PORT_INFO_V1 { + #[inline] + pub fn isDp(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isDp(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isDp_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isDp_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isInternalDp(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isInternalDp(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isInternalDp_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isInternalDp_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isColorCtrlSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_isColorCtrlSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isColorCtrlSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isColorCtrlSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is6BPCSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_is6BPCSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is6BPCSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is6BPCSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is8BPCSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_is8BPCSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is8BPCSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is8BPCSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is10BPCSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_is10BPCSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is10BPCSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is10BPCSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is12BPCSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } + } + #[inline] + pub fn set_is12BPCSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is12BPCSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 6usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is12BPCSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is16BPCSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } + } + #[inline] + pub fn set_is16BPCSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is16BPCSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 7usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is16BPCSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 7usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isYCrCb420Supported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) } + } + #[inline] + pub fn set_isYCrCb420Supported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isYCrCb420Supported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 8usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isYCrCb420Supported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 8usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isYCrCb422Supported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) } + } + #[inline] + pub fn set_isYCrCb422Supported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(9usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isYCrCb422Supported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 9usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isYCrCb422Supported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 9usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isYCrCb444Supported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) } + } + #[inline] + pub fn set_isYCrCb444Supported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(10usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isYCrCb444Supported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 10usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isYCrCb444Supported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 10usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isRgb444SupportedOnCurrentMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) } + } + #[inline] + pub fn set_isRgb444SupportedOnCurrentMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(11usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isRgb444SupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 11usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isRgb444SupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 11usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isYCbCr444SupportedOnCurrentMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) } + } + #[inline] + pub fn set_isYCbCr444SupportedOnCurrentMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(12usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isYCbCr444SupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 12usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isYCbCr444SupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 12usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isYCbCr422SupportedOnCurrentMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) } + } + #[inline] + pub fn set_isYCbCr422SupportedOnCurrentMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(13usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isYCbCr422SupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 13usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isYCbCr422SupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 13usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isYCbCr420SupportedOnCurrentMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) } + } + #[inline] + pub fn set_isYCbCr420SupportedOnCurrentMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(14usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isYCbCr420SupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 14usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isYCbCr420SupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 14usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is6BPCSupportedOnCurrentMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) } + } + #[inline] + pub fn set_is6BPCSupportedOnCurrentMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(15usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is6BPCSupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 15usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is6BPCSupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 15usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is8BPCSupportedOnCurrentMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) } + } + #[inline] + pub fn set_is8BPCSupportedOnCurrentMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(16usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is8BPCSupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 16usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is8BPCSupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 16usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is10BPCSupportedOnCurrentMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) } + } + #[inline] + pub fn set_is10BPCSupportedOnCurrentMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(17usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is10BPCSupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 17usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is10BPCSupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 17usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is12BPCSupportedOnCurrentMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) } + } + #[inline] + pub fn set_is12BPCSupportedOnCurrentMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(18usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is12BPCSupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 18usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is12BPCSupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 18usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is16BPCSupportedOnCurrentMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u32) } + } + #[inline] + pub fn set_is16BPCSupportedOnCurrentMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(19usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is16BPCSupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 19usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is16BPCSupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 19usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonxvYCC601Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonxvYCC601Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(20usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonxvYCC601Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 20usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonxvYCC601Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 20usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonxvYCC709Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonxvYCC709Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(21usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonxvYCC709Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 21usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonxvYCC709Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 21usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonsYCC601Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonsYCC601Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(22usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonsYCC601Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 22usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonsYCC601Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 22usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonAdobeYCC601Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonAdobeYCC601Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(23usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonAdobeYCC601Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 23usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonAdobeYCC601Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 23usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonAdobeRGBCapable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonAdobeRGBCapable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(24usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonAdobeRGBCapable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 24usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonAdobeRGBCapable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 24usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonBT2020RGBCapable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonBT2020RGBCapable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(25usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonBT2020RGBCapable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 25usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonBT2020RGBCapable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 25usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonBT2020YCCCapable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonBT2020YCCCapable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(26usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonBT2020YCCCapable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 26usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonBT2020YCCCapable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 26usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonBT2020cYCCCapable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonBT2020cYCCCapable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(27usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonBT2020cYCCCapable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 27usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonBT2020cYCCCapable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 27usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 4u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(28usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 28usize, + 4u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 28usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isDp: NvU32, + isInternalDp: NvU32, + isColorCtrlSupported: NvU32, + is6BPCSupported: NvU32, + is8BPCSupported: NvU32, + is10BPCSupported: NvU32, + is12BPCSupported: NvU32, + is16BPCSupported: NvU32, + isYCrCb420Supported: NvU32, + isYCrCb422Supported: NvU32, + isYCrCb444Supported: NvU32, + isRgb444SupportedOnCurrentMode: NvU32, + isYCbCr444SupportedOnCurrentMode: NvU32, + isYCbCr422SupportedOnCurrentMode: NvU32, + isYCbCr420SupportedOnCurrentMode: NvU32, + is6BPCSupportedOnCurrentMode: NvU32, + is8BPCSupportedOnCurrentMode: NvU32, + is10BPCSupportedOnCurrentMode: NvU32, + is12BPCSupportedOnCurrentMode: NvU32, + is16BPCSupportedOnCurrentMode: NvU32, + isMonxvYCC601Capable: NvU32, + isMonxvYCC709Capable: NvU32, + isMonsYCC601Capable: NvU32, + isMonAdobeYCC601Capable: NvU32, + isMonAdobeRGBCapable: NvU32, + isMonBT2020RGBCapable: NvU32, + isMonBT2020YCCCapable: NvU32, + isMonBT2020cYCCCapable: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isDp: u32 = unsafe { ::std::mem::transmute(isDp) }; + isDp as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isInternalDp: u32 = unsafe { ::std::mem::transmute(isInternalDp) }; + isInternalDp as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let isColorCtrlSupported: u32 = unsafe { ::std::mem::transmute(isColorCtrlSupported) }; + isColorCtrlSupported as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let is6BPCSupported: u32 = unsafe { ::std::mem::transmute(is6BPCSupported) }; + is6BPCSupported as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let is8BPCSupported: u32 = unsafe { ::std::mem::transmute(is8BPCSupported) }; + is8BPCSupported as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let is10BPCSupported: u32 = unsafe { ::std::mem::transmute(is10BPCSupported) }; + is10BPCSupported as u64 + }); + __bindgen_bitfield_unit.set(6usize, 1u8, { + let is12BPCSupported: u32 = unsafe { ::std::mem::transmute(is12BPCSupported) }; + is12BPCSupported as u64 + }); + __bindgen_bitfield_unit.set(7usize, 1u8, { + let is16BPCSupported: u32 = unsafe { ::std::mem::transmute(is16BPCSupported) }; + is16BPCSupported as u64 + }); + __bindgen_bitfield_unit.set(8usize, 1u8, { + let isYCrCb420Supported: u32 = unsafe { ::std::mem::transmute(isYCrCb420Supported) }; + isYCrCb420Supported as u64 + }); + __bindgen_bitfield_unit.set(9usize, 1u8, { + let isYCrCb422Supported: u32 = unsafe { ::std::mem::transmute(isYCrCb422Supported) }; + isYCrCb422Supported as u64 + }); + __bindgen_bitfield_unit.set(10usize, 1u8, { + let isYCrCb444Supported: u32 = unsafe { ::std::mem::transmute(isYCrCb444Supported) }; + isYCrCb444Supported as u64 + }); + __bindgen_bitfield_unit.set(11usize, 1u8, { + let isRgb444SupportedOnCurrentMode: u32 = + unsafe { ::std::mem::transmute(isRgb444SupportedOnCurrentMode) }; + isRgb444SupportedOnCurrentMode as u64 + }); + __bindgen_bitfield_unit.set(12usize, 1u8, { + let isYCbCr444SupportedOnCurrentMode: u32 = + unsafe { ::std::mem::transmute(isYCbCr444SupportedOnCurrentMode) }; + isYCbCr444SupportedOnCurrentMode as u64 + }); + __bindgen_bitfield_unit.set(13usize, 1u8, { + let isYCbCr422SupportedOnCurrentMode: u32 = + unsafe { ::std::mem::transmute(isYCbCr422SupportedOnCurrentMode) }; + isYCbCr422SupportedOnCurrentMode as u64 + }); + __bindgen_bitfield_unit.set(14usize, 1u8, { + let isYCbCr420SupportedOnCurrentMode: u32 = + unsafe { ::std::mem::transmute(isYCbCr420SupportedOnCurrentMode) }; + isYCbCr420SupportedOnCurrentMode as u64 + }); + __bindgen_bitfield_unit.set(15usize, 1u8, { + let is6BPCSupportedOnCurrentMode: u32 = + unsafe { ::std::mem::transmute(is6BPCSupportedOnCurrentMode) }; + is6BPCSupportedOnCurrentMode as u64 + }); + __bindgen_bitfield_unit.set(16usize, 1u8, { + let is8BPCSupportedOnCurrentMode: u32 = + unsafe { ::std::mem::transmute(is8BPCSupportedOnCurrentMode) }; + is8BPCSupportedOnCurrentMode as u64 + }); + __bindgen_bitfield_unit.set(17usize, 1u8, { + let is10BPCSupportedOnCurrentMode: u32 = + unsafe { ::std::mem::transmute(is10BPCSupportedOnCurrentMode) }; + is10BPCSupportedOnCurrentMode as u64 + }); + __bindgen_bitfield_unit.set(18usize, 1u8, { + let is12BPCSupportedOnCurrentMode: u32 = + unsafe { ::std::mem::transmute(is12BPCSupportedOnCurrentMode) }; + is12BPCSupportedOnCurrentMode as u64 + }); + __bindgen_bitfield_unit.set(19usize, 1u8, { + let is16BPCSupportedOnCurrentMode: u32 = + unsafe { ::std::mem::transmute(is16BPCSupportedOnCurrentMode) }; + is16BPCSupportedOnCurrentMode as u64 + }); + __bindgen_bitfield_unit.set(20usize, 1u8, { + let isMonxvYCC601Capable: u32 = unsafe { ::std::mem::transmute(isMonxvYCC601Capable) }; + isMonxvYCC601Capable as u64 + }); + __bindgen_bitfield_unit.set(21usize, 1u8, { + let isMonxvYCC709Capable: u32 = unsafe { ::std::mem::transmute(isMonxvYCC709Capable) }; + isMonxvYCC709Capable as u64 + }); + __bindgen_bitfield_unit.set(22usize, 1u8, { + let isMonsYCC601Capable: u32 = unsafe { ::std::mem::transmute(isMonsYCC601Capable) }; + isMonsYCC601Capable as u64 + }); + __bindgen_bitfield_unit.set(23usize, 1u8, { + let isMonAdobeYCC601Capable: u32 = + unsafe { ::std::mem::transmute(isMonAdobeYCC601Capable) }; + isMonAdobeYCC601Capable as u64 + }); + __bindgen_bitfield_unit.set(24usize, 1u8, { + let isMonAdobeRGBCapable: u32 = unsafe { ::std::mem::transmute(isMonAdobeRGBCapable) }; + isMonAdobeRGBCapable as u64 + }); + __bindgen_bitfield_unit.set(25usize, 1u8, { + let isMonBT2020RGBCapable: u32 = + unsafe { ::std::mem::transmute(isMonBT2020RGBCapable) }; + isMonBT2020RGBCapable as u64 + }); + __bindgen_bitfield_unit.set(26usize, 1u8, { + let isMonBT2020YCCCapable: u32 = + unsafe { ::std::mem::transmute(isMonBT2020YCCCapable) }; + isMonBT2020YCCCapable as u64 + }); + __bindgen_bitfield_unit.set(27usize, 1u8, { + let isMonBT2020cYCCCapable: u32 = + unsafe { ::std::mem::transmute(isMonBT2020cYCCCapable) }; + isMonBT2020cYCCCapable as u64 + }); + __bindgen_bitfield_unit.set(28usize, 4u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_GetDisplayPortInfo()."] +pub type NV_DISPLAY_PORT_INFO_V1 = _NV_DISPLAY_PORT_INFO_V1; +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_GetDisplayPortInfo()."] +pub type NV_DISPLAY_PORT_INFO = NV_DISPLAY_PORT_INFO_V1; +#[doc = "! \\ingroup dispcontrol\n! DisplayPort configuration settings - used in NvAPI_SetDisplayPort()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_DISPLAY_PORT_CONFIG { + #[doc = "!< Structure version - 2 is the latest"] + pub version: NvU32, + #[doc = "!< Link rate"] + pub linkRate: NV_DP_LINK_RATE, + #[doc = "!< Lane count"] + pub laneCount: NV_DP_LANE_COUNT, + #[doc = "!< Color format to set"] + pub colorFormat: NV_DP_COLOR_FORMAT, + #[doc = "!< Dynamic range"] + pub dynamicRange: NV_DP_DYNAMIC_RANGE, + #[doc = "!< Ignored in RGB space"] + pub colorimetry: NV_DP_COLORIMETRY, + #[doc = "!< Bit-per-component"] + pub bpc: NV_DP_BPC, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +impl NV_DISPLAY_PORT_CONFIG { + #[inline] + pub fn isHPD(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isHPD(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isHPD_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isHPD_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isSetDeferred(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isSetDeferred(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isSetDeferred_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isSetDeferred_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isChromaLpfOff(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_isChromaLpfOff(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isChromaLpfOff_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isChromaLpfOff_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isDitherOff(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_isDitherOff(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isDitherOff_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isDitherOff_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn testLinkTrain(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_testLinkTrain(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn testLinkTrain_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_testLinkTrain_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn testColorChange(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_testColorChange(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn testColorChange_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_testColorChange_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isHPD: NvU32, + isSetDeferred: NvU32, + isChromaLpfOff: NvU32, + isDitherOff: NvU32, + testLinkTrain: NvU32, + testColorChange: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isHPD: u32 = unsafe { ::std::mem::transmute(isHPD) }; + isHPD as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isSetDeferred: u32 = unsafe { ::std::mem::transmute(isSetDeferred) }; + isSetDeferred as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let isChromaLpfOff: u32 = unsafe { ::std::mem::transmute(isChromaLpfOff) }; + isChromaLpfOff as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let isDitherOff: u32 = unsafe { ::std::mem::transmute(isDitherOff) }; + isDitherOff as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let testLinkTrain: u32 = unsafe { ::std::mem::transmute(testLinkTrain) }; + testLinkTrain as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let testColorChange: u32 = unsafe { ::std::mem::transmute(testColorChange) }; + testColorChange as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_GetHDMISupportInfo()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDMI_SUPPORT_INFO_V1 { + #[doc = "!< Structure version"] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Revision number of the EDID 861 extension"] + pub EDID861ExtRev: NvU32, +} +impl _NV_HDMI_SUPPORT_INFO_V1 { + #[inline] + pub fn isGpuHDMICapable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isGpuHDMICapable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isGpuHDMICapable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isGpuHDMICapable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonUnderscanCapable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonUnderscanCapable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonUnderscanCapable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonUnderscanCapable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonBasicAudioCapable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonBasicAudioCapable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonBasicAudioCapable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonBasicAudioCapable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonYCbCr444Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonYCbCr444Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonYCbCr444Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonYCbCr444Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonYCbCr422Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonYCbCr422Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonYCbCr422Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonYCbCr422Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonxvYCC601Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonxvYCC601Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonxvYCC601Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonxvYCC601Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonxvYCC709Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonxvYCC709Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonxvYCC709Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 6usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonxvYCC709Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonHDMI(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonHDMI(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonHDMI_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 7usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonHDMI_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 7usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 24u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 24u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 8usize, + 24u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 8usize, + 24u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isGpuHDMICapable: NvU32, + isMonUnderscanCapable: NvU32, + isMonBasicAudioCapable: NvU32, + isMonYCbCr444Capable: NvU32, + isMonYCbCr422Capable: NvU32, + isMonxvYCC601Capable: NvU32, + isMonxvYCC709Capable: NvU32, + isMonHDMI: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isGpuHDMICapable: u32 = unsafe { ::std::mem::transmute(isGpuHDMICapable) }; + isGpuHDMICapable as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isMonUnderscanCapable: u32 = + unsafe { ::std::mem::transmute(isMonUnderscanCapable) }; + isMonUnderscanCapable as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let isMonBasicAudioCapable: u32 = + unsafe { ::std::mem::transmute(isMonBasicAudioCapable) }; + isMonBasicAudioCapable as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let isMonYCbCr444Capable: u32 = unsafe { ::std::mem::transmute(isMonYCbCr444Capable) }; + isMonYCbCr444Capable as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let isMonYCbCr422Capable: u32 = unsafe { ::std::mem::transmute(isMonYCbCr422Capable) }; + isMonYCbCr422Capable as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let isMonxvYCC601Capable: u32 = unsafe { ::std::mem::transmute(isMonxvYCC601Capable) }; + isMonxvYCC601Capable as u64 + }); + __bindgen_bitfield_unit.set(6usize, 1u8, { + let isMonxvYCC709Capable: u32 = unsafe { ::std::mem::transmute(isMonxvYCC709Capable) }; + isMonxvYCC709Capable as u64 + }); + __bindgen_bitfield_unit.set(7usize, 1u8, { + let isMonHDMI: u32 = unsafe { ::std::mem::transmute(isMonHDMI) }; + isMonHDMI as u64 + }); + __bindgen_bitfield_unit.set(8usize, 24u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_GetHDMISupportInfo()."] +pub type NV_HDMI_SUPPORT_INFO_V1 = _NV_HDMI_SUPPORT_INFO_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDMI_SUPPORT_INFO_V2 { + #[doc = "!< Structure version"] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Revision number of the EDID 861 extension"] + pub EDID861ExtRev: NvU32, +} +impl _NV_HDMI_SUPPORT_INFO_V2 { + #[inline] + pub fn isGpuHDMICapable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isGpuHDMICapable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isGpuHDMICapable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isGpuHDMICapable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonUnderscanCapable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonUnderscanCapable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonUnderscanCapable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonUnderscanCapable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonBasicAudioCapable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonBasicAudioCapable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonBasicAudioCapable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonBasicAudioCapable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonYCbCr444Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonYCbCr444Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonYCbCr444Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonYCbCr444Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonYCbCr422Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonYCbCr422Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonYCbCr422Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonYCbCr422Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonxvYCC601Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonxvYCC601Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonxvYCC601Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonxvYCC601Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonxvYCC709Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonxvYCC709Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonxvYCC709Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 6usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonxvYCC709Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonHDMI(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonHDMI(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonHDMI_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 7usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonHDMI_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 7usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonsYCC601Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonsYCC601Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonsYCC601Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 8usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonsYCC601Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 8usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonAdobeYCC601Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonAdobeYCC601Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(9usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonAdobeYCC601Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 9usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonAdobeYCC601Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 9usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonAdobeRGBCapable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonAdobeRGBCapable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(10usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonAdobeRGBCapable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 10usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonAdobeRGBCapable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 10usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 21u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(11usize, 21u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 11usize, + 21u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 11usize, + 21u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isGpuHDMICapable: NvU32, + isMonUnderscanCapable: NvU32, + isMonBasicAudioCapable: NvU32, + isMonYCbCr444Capable: NvU32, + isMonYCbCr422Capable: NvU32, + isMonxvYCC601Capable: NvU32, + isMonxvYCC709Capable: NvU32, + isMonHDMI: NvU32, + isMonsYCC601Capable: NvU32, + isMonAdobeYCC601Capable: NvU32, + isMonAdobeRGBCapable: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isGpuHDMICapable: u32 = unsafe { ::std::mem::transmute(isGpuHDMICapable) }; + isGpuHDMICapable as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isMonUnderscanCapable: u32 = + unsafe { ::std::mem::transmute(isMonUnderscanCapable) }; + isMonUnderscanCapable as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let isMonBasicAudioCapable: u32 = + unsafe { ::std::mem::transmute(isMonBasicAudioCapable) }; + isMonBasicAudioCapable as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let isMonYCbCr444Capable: u32 = unsafe { ::std::mem::transmute(isMonYCbCr444Capable) }; + isMonYCbCr444Capable as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let isMonYCbCr422Capable: u32 = unsafe { ::std::mem::transmute(isMonYCbCr422Capable) }; + isMonYCbCr422Capable as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let isMonxvYCC601Capable: u32 = unsafe { ::std::mem::transmute(isMonxvYCC601Capable) }; + isMonxvYCC601Capable as u64 + }); + __bindgen_bitfield_unit.set(6usize, 1u8, { + let isMonxvYCC709Capable: u32 = unsafe { ::std::mem::transmute(isMonxvYCC709Capable) }; + isMonxvYCC709Capable as u64 + }); + __bindgen_bitfield_unit.set(7usize, 1u8, { + let isMonHDMI: u32 = unsafe { ::std::mem::transmute(isMonHDMI) }; + isMonHDMI as u64 + }); + __bindgen_bitfield_unit.set(8usize, 1u8, { + let isMonsYCC601Capable: u32 = unsafe { ::std::mem::transmute(isMonsYCC601Capable) }; + isMonsYCC601Capable as u64 + }); + __bindgen_bitfield_unit.set(9usize, 1u8, { + let isMonAdobeYCC601Capable: u32 = + unsafe { ::std::mem::transmute(isMonAdobeYCC601Capable) }; + isMonAdobeYCC601Capable as u64 + }); + __bindgen_bitfield_unit.set(10usize, 1u8, { + let isMonAdobeRGBCapable: u32 = unsafe { ::std::mem::transmute(isMonAdobeRGBCapable) }; + isMonAdobeRGBCapable as u64 + }); + __bindgen_bitfield_unit.set(11usize, 21u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_HDMI_SUPPORT_INFO_V2 = _NV_HDMI_SUPPORT_INFO_V2; +pub type NV_HDMI_SUPPORT_INFO = NV_HDMI_SUPPORT_INFO_V2; +#[doc = "!< Returns the fields in the infoframe with values set by the manufacturer - NVIDIA/OEM."] +pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_GET_DEFAULT: NV_INFOFRAME_CMD = 0; +#[doc = "!< Sets the fields in the infoframe to auto, and infoframe to the default infoframe for use in a set."] +pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_RESET: NV_INFOFRAME_CMD = 1; +#[doc = "!< Get the current infoframe state."] +pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_GET: NV_INFOFRAME_CMD = 2; +#[doc = "!< Set the current infoframe state (flushed to the monitor), the values are one time and do not persist."] +pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_SET: NV_INFOFRAME_CMD = 3; +#[doc = "!< Get the override infoframe state, non-override fields will be set to value = AUTO, overridden fields will have the current override values."] +pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_GET_OVERRIDE: NV_INFOFRAME_CMD = 4; +#[doc = "!< Set the override infoframe state, non-override fields will be set to value = AUTO, other values indicate override; persist across modeset/reboot"] +pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_SET_OVERRIDE: NV_INFOFRAME_CMD = 5; +#[doc = "!< get properties associated with infoframe (each of the infoframe type will have properties)"] +pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_GET_PROPERTY: NV_INFOFRAME_CMD = 6; +#[doc = "!< set properties associated with infoframe"] +pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_SET_PROPERTY: NV_INFOFRAME_CMD = 7; +#[doc = "! \\ingroup dispcontrol"] +pub type NV_INFOFRAME_CMD = ::std::os::raw::c_int; +#[doc = "!< Driver determines whether to send infoframes."] +pub const NV_INFOFRAME_PROPERTY_MODE_NV_INFOFRAME_PROPERTY_MODE_AUTO: NV_INFOFRAME_PROPERTY_MODE = + 0; +#[doc = "!< Driver always sends infoframe."] +pub const NV_INFOFRAME_PROPERTY_MODE_NV_INFOFRAME_PROPERTY_MODE_ENABLE: NV_INFOFRAME_PROPERTY_MODE = + 1; +#[doc = "!< Driver never sends infoframe."] +pub const NV_INFOFRAME_PROPERTY_MODE_NV_INFOFRAME_PROPERTY_MODE_DISABLE: + NV_INFOFRAME_PROPERTY_MODE = 2; +#[doc = "!< Driver only sends infoframe when client requests it via infoframe escape call."] +pub const NV_INFOFRAME_PROPERTY_MODE_NV_INFOFRAME_PROPERTY_MODE_ALLOW_OVERRIDE: + NV_INFOFRAME_PROPERTY_MODE = 3; +pub type NV_INFOFRAME_PROPERTY_MODE = ::std::os::raw::c_int; +pub const NV_INFOFRAME_PROPERTY_BLACKLIST_NV_INFOFRAME_PROPERTY_BLACKLIST_FALSE: + NV_INFOFRAME_PROPERTY_BLACKLIST = 0; +pub const NV_INFOFRAME_PROPERTY_BLACKLIST_NV_INFOFRAME_PROPERTY_BLACKLIST_TRUE: + NV_INFOFRAME_PROPERTY_BLACKLIST = 1; +#[doc = "! Returns whether the current monitor is in blacklist or force this monitor to be in blacklist."] +pub type NV_INFOFRAME_PROPERTY_BLACKLIST = ::std::os::raw::c_int; +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct NV_INFOFRAME_PROPERTY { + pub _bitfield_align_1: [u16; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl NV_INFOFRAME_PROPERTY { + #[inline] + pub fn mode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32) } + } + #[inline] + pub fn set_mode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn mode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 4u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_mode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn blackList(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 2u8) as u32) } + } + #[inline] + pub fn set_blackList(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn blackList_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_blackList_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 10u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 10u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 6usize, + 10u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 10u8, + val as u64, + ) + } + } + #[inline] + pub fn version(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 8u8) as u32) } + } + #[inline] + pub fn set_version(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(16usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn version_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 16usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_version_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 16usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn length(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u32) } + } + #[inline] + pub fn set_length(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(24usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn length_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 24usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_length_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 24usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + mode: NvU32, + blackList: NvU32, + reserved: NvU32, + version: NvU32, + length: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 4u8, { + let mode: u32 = unsafe { ::std::mem::transmute(mode) }; + mode as u64 + }); + __bindgen_bitfield_unit.set(4usize, 2u8, { + let blackList: u32 = unsafe { ::std::mem::transmute(blackList) }; + blackList as u64 + }); + __bindgen_bitfield_unit.set(6usize, 10u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit.set(16usize, 8u8, { + let version: u32 = unsafe { ::std::mem::transmute(version) }; + version as u64 + }); + __bindgen_bitfield_unit.set(24usize, 8u8, { + let length: u32 = unsafe { ::std::mem::transmute(length) }; + length as u64 + }); + __bindgen_bitfield_unit + } +} +pub const NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_NODATA: + NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO = 0; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_OVERSCAN: + NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO = 1; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_UNDERSCAN: + NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO = 2; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_FUTURE: + NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO = 3; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_AUTO: + NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO = 7; +#[doc = "! Byte1 related"] +pub type NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_NOT_PRESENT: + NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA = 0; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_VERTICAL_PRESENT : NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_HORIZONTAL_PRESENT : NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_BOTH_PRESENT: + NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA = 3; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_AUTO: + NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA = 7; +pub type NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO_NV_INFOFRAME_FIELD_VALUE_AVI_AFI_ABSENT: + NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO = 0; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO_NV_INFOFRAME_FIELD_VALUE_AVI_AFI_PRESENT: + NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO = 1; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO_NV_INFOFRAME_FIELD_VALUE_AVI_AFI_AUTO: + NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO = 3; +pub type NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_RGB: + NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT = 0; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_YCbCr422 : NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_YCbCr444 : NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_FUTURE : NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_AUTO: + NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT = 7; +pub type NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_F17_NV_INFOFRAME_FIELD_VALUE_AVI_F17_FALSE: + NV_INFOFRAME_FIELD_VALUE_AVI_F17 = 0; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_F17_NV_INFOFRAME_FIELD_VALUE_AVI_F17_TRUE: + NV_INFOFRAME_FIELD_VALUE_AVI_F17 = 1; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_F17_NV_INFOFRAME_FIELD_VALUE_AVI_F17_AUTO: + NV_INFOFRAME_FIELD_VALUE_AVI_F17 = 3; +pub type NV_INFOFRAME_FIELD_VALUE_AVI_F17 = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NO_AFD : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE01 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE02 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE03 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_LETTERBOX_GT16x9 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 4 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE05 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 5 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE06 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 6 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE07 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 7 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_EQUAL_CODEDFRAME : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 8 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_CENTER_4x3 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 9 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_CENTER_16x9 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 10 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_CENTER_14x9 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 11 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE12 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 12 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_4x3_ON_14x9 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 13 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_16x9_ON_14x9 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 14 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_16x9_ON_4x3 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 15 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 31 ; +#[doc = "! Byte2 related"] +pub type NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_NO_DATA : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_4x3 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_16x9 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_FUTURE : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME = 7 ; +pub type NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_NO_DATA : NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_SMPTE_170M : NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_ITUR_BT709 : NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_USE_EXTENDED_COLORIMETRY : NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_AUTO: + NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY = 7; +pub type NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_NO_DATA : NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_HORIZONTAL : NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_VERTICAL : NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_BOTH : NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING = 7 ; +#[doc = "! Byte 3 related"] +pub type NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_DEFAULT : NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_LIMITED_RANGE : NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_FULL_RANGE : NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_RESERVED : NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION = 7 ; +pub type NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_XVYCC601 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_XVYCC709 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_SYCC601 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_ADOBEYCC601 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_ADOBERGB : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 4 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_RESERVED05 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 5 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_RESERVED06 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 6 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_RESERVED07 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 7 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 15 ; +pub type NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ITC_NV_INFOFRAME_FIELD_VALUE_AVI_ITC_VIDEO_CONTENT: + NV_INFOFRAME_FIELD_VALUE_AVI_ITC = 0; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ITC_NV_INFOFRAME_FIELD_VALUE_AVI_ITC_ITCONTENT: + NV_INFOFRAME_FIELD_VALUE_AVI_ITC = 1; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ITC_NV_INFOFRAME_FIELD_VALUE_AVI_ITC_AUTO: + NV_INFOFRAME_FIELD_VALUE_AVI_ITC = 3; +pub type NV_INFOFRAME_FIELD_VALUE_AVI_ITC = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NONE : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X02 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X03 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X04 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X05 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 4 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X06 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 5 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X07 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 6 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X08 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 7 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X09 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 8 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X10 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 9 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED10 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 10 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED11 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 11 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED12 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 12 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED13 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 13 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED14 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 14 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED15 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 15 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 31 ; +#[doc = "! Byte 4 related"] +pub type NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_GRAPHICS : NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_PHOTO : NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_CINEMA : NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_GAME: + NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE = 3; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_AUTO: + NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE = 7; +pub type NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_LIMITED_RANGE : NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_FULL_RANGE : NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_RESERVED02 : NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_RESERVED03 : NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION = 7 ; +pub type NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION = ::std::os::raw::c_int; +#[doc = "! Adding an Auto bit to each field"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_INFOFRAME_VIDEO { + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 23usize]>, +} +impl NV_INFOFRAME_VIDEO { + #[inline] + pub fn vic(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) } + } + #[inline] + pub fn set_vic(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn vic_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_vic_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn pixelRepeat(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 5u8) as u32) } + } + #[inline] + pub fn set_pixelRepeat(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 5u8, val as u64) + } + } + #[inline] + pub unsafe fn pixelRepeat_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 8usize, + 5u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_pixelRepeat_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 8usize, + 5u8, + val as u64, + ) + } + } + #[inline] + pub fn colorSpace(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 3u8) as u32) } + } + #[inline] + pub fn set_colorSpace(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(13usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn colorSpace_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 13usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_colorSpace_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 13usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn colorimetry(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 3u8) as u32) } + } + #[inline] + pub fn set_colorimetry(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(16usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn colorimetry_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 16usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_colorimetry_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 16usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn extendedColorimetry(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 4u8) as u32) } + } + #[inline] + pub fn set_extendedColorimetry(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(19usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn extendedColorimetry_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 19usize, + 4u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_extendedColorimetry_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 19usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn rgbQuantizationRange(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 3u8) as u32) } + } + #[inline] + pub fn set_rgbQuantizationRange(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(23usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn rgbQuantizationRange_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 23usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_rgbQuantizationRange_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 23usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn yccQuantizationRange(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 3u8) as u32) } + } + #[inline] + pub fn set_yccQuantizationRange(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(26usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn yccQuantizationRange_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 26usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_yccQuantizationRange_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 26usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn itContent(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 2u8) as u32) } + } + #[inline] + pub fn set_itContent(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(29usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn itContent_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 29usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_itContent_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 29usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn contentTypes(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 3u8) as u32) } + } + #[inline] + pub fn set_contentTypes(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(32usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn contentTypes_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 32usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_contentTypes_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 32usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn scanInfo(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(35usize, 3u8) as u32) } + } + #[inline] + pub fn set_scanInfo(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(35usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn scanInfo_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 35usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_scanInfo_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 35usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn activeFormatInfoPresent(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(38usize, 2u8) as u32) } + } + #[inline] + pub fn set_activeFormatInfoPresent(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(38usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn activeFormatInfoPresent_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 38usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_activeFormatInfoPresent_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 38usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn activeFormatAspectRatio(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(40usize, 5u8) as u32) } + } + #[inline] + pub fn set_activeFormatAspectRatio(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(40usize, 5u8, val as u64) + } + } + #[inline] + pub unsafe fn activeFormatAspectRatio_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 40usize, + 5u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_activeFormatAspectRatio_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 40usize, + 5u8, + val as u64, + ) + } + } + #[inline] + pub fn picAspectRatio(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(45usize, 3u8) as u32) } + } + #[inline] + pub fn set_picAspectRatio(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(45usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn picAspectRatio_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 45usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_picAspectRatio_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 45usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn nonuniformScaling(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 3u8) as u32) } + } + #[inline] + pub fn set_nonuniformScaling(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(48usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn nonuniformScaling_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 48usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_nonuniformScaling_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 48usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn barInfo(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(51usize, 3u8) as u32) } + } + #[inline] + pub fn set_barInfo(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(51usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn barInfo_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 51usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_barInfo_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 51usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn top_bar(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(64usize, 17u8) as u32) } + } + #[inline] + pub fn set_top_bar(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(64usize, 17u8, val as u64) + } + } + #[inline] + pub unsafe fn top_bar_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 64usize, + 17u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_top_bar_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 64usize, + 17u8, + val as u64, + ) + } + } + #[inline] + pub fn bottom_bar(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(96usize, 17u8) as u32) } + } + #[inline] + pub fn set_bottom_bar(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(96usize, 17u8, val as u64) + } + } + #[inline] + pub unsafe fn bottom_bar_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 96usize, + 17u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bottom_bar_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 96usize, + 17u8, + val as u64, + ) + } + } + #[inline] + pub fn left_bar(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(128usize, 17u8) as u32) } + } + #[inline] + pub fn set_left_bar(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(128usize, 17u8, val as u64) + } + } + #[inline] + pub unsafe fn left_bar_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 128usize, + 17u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_left_bar_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 128usize, + 17u8, + val as u64, + ) + } + } + #[inline] + pub fn right_bar(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(160usize, 17u8) as u32) } + } + #[inline] + pub fn set_right_bar(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(160usize, 17u8, val as u64) + } + } + #[inline] + pub unsafe fn right_bar_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 160usize, + 17u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_right_bar_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 160usize, + 17u8, + val as u64, + ) + } + } + #[inline] + pub fn Future17(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(177usize, 2u8) as u32) } + } + #[inline] + pub fn set_Future17(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(177usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn Future17_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 177usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_Future17_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 177usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn Future47(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(179usize, 2u8) as u32) } + } + #[inline] + pub fn set_Future47(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(179usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn Future47_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 179usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_Future47_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 179usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + vic: NvU32, + pixelRepeat: NvU32, + colorSpace: NvU32, + colorimetry: NvU32, + extendedColorimetry: NvU32, + rgbQuantizationRange: NvU32, + yccQuantizationRange: NvU32, + itContent: NvU32, + contentTypes: NvU32, + scanInfo: NvU32, + activeFormatInfoPresent: NvU32, + activeFormatAspectRatio: NvU32, + picAspectRatio: NvU32, + nonuniformScaling: NvU32, + barInfo: NvU32, + top_bar: NvU32, + bottom_bar: NvU32, + left_bar: NvU32, + right_bar: NvU32, + Future17: NvU32, + Future47: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 23usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 23usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 8u8, { + let vic: u32 = unsafe { ::std::mem::transmute(vic) }; + vic as u64 + }); + __bindgen_bitfield_unit.set(8usize, 5u8, { + let pixelRepeat: u32 = unsafe { ::std::mem::transmute(pixelRepeat) }; + pixelRepeat as u64 + }); + __bindgen_bitfield_unit.set(13usize, 3u8, { + let colorSpace: u32 = unsafe { ::std::mem::transmute(colorSpace) }; + colorSpace as u64 + }); + __bindgen_bitfield_unit.set(16usize, 3u8, { + let colorimetry: u32 = unsafe { ::std::mem::transmute(colorimetry) }; + colorimetry as u64 + }); + __bindgen_bitfield_unit.set(19usize, 4u8, { + let extendedColorimetry: u32 = unsafe { ::std::mem::transmute(extendedColorimetry) }; + extendedColorimetry as u64 + }); + __bindgen_bitfield_unit.set(23usize, 3u8, { + let rgbQuantizationRange: u32 = unsafe { ::std::mem::transmute(rgbQuantizationRange) }; + rgbQuantizationRange as u64 + }); + __bindgen_bitfield_unit.set(26usize, 3u8, { + let yccQuantizationRange: u32 = unsafe { ::std::mem::transmute(yccQuantizationRange) }; + yccQuantizationRange as u64 + }); + __bindgen_bitfield_unit.set(29usize, 2u8, { + let itContent: u32 = unsafe { ::std::mem::transmute(itContent) }; + itContent as u64 + }); + __bindgen_bitfield_unit.set(32usize, 3u8, { + let contentTypes: u32 = unsafe { ::std::mem::transmute(contentTypes) }; + contentTypes as u64 + }); + __bindgen_bitfield_unit.set(35usize, 3u8, { + let scanInfo: u32 = unsafe { ::std::mem::transmute(scanInfo) }; + scanInfo as u64 + }); + __bindgen_bitfield_unit.set(38usize, 2u8, { + let activeFormatInfoPresent: u32 = + unsafe { ::std::mem::transmute(activeFormatInfoPresent) }; + activeFormatInfoPresent as u64 + }); + __bindgen_bitfield_unit.set(40usize, 5u8, { + let activeFormatAspectRatio: u32 = + unsafe { ::std::mem::transmute(activeFormatAspectRatio) }; + activeFormatAspectRatio as u64 + }); + __bindgen_bitfield_unit.set(45usize, 3u8, { + let picAspectRatio: u32 = unsafe { ::std::mem::transmute(picAspectRatio) }; + picAspectRatio as u64 + }); + __bindgen_bitfield_unit.set(48usize, 3u8, { + let nonuniformScaling: u32 = unsafe { ::std::mem::transmute(nonuniformScaling) }; + nonuniformScaling as u64 + }); + __bindgen_bitfield_unit.set(51usize, 3u8, { + let barInfo: u32 = unsafe { ::std::mem::transmute(barInfo) }; + barInfo as u64 + }); + __bindgen_bitfield_unit.set(64usize, 17u8, { + let top_bar: u32 = unsafe { ::std::mem::transmute(top_bar) }; + top_bar as u64 + }); + __bindgen_bitfield_unit.set(96usize, 17u8, { + let bottom_bar: u32 = unsafe { ::std::mem::transmute(bottom_bar) }; + bottom_bar as u64 + }); + __bindgen_bitfield_unit.set(128usize, 17u8, { + let left_bar: u32 = unsafe { ::std::mem::transmute(left_bar) }; + left_bar as u64 + }); + __bindgen_bitfield_unit.set(160usize, 17u8, { + let right_bar: u32 = unsafe { ::std::mem::transmute(right_bar) }; + right_bar as u64 + }); + __bindgen_bitfield_unit.set(177usize, 2u8, { + let Future17: u32 = unsafe { ::std::mem::transmute(Future17) }; + Future17 as u64 + }); + __bindgen_bitfield_unit.set(179usize, 2u8, { + let Future47: u32 = unsafe { ::std::mem::transmute(Future47) }; + Future47 as u64 + }); + __bindgen_bitfield_unit + } +} +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_IN_HEADER : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_2 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_3 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_4 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_5 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 4 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_6 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 5 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_7 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 6 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_8 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 7 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 15 ; +#[doc = "! Byte 1 related"] +pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_IN_HEADER : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_PCM : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_AC3 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_MPEG1 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_MP3 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 4 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_MPEG2 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 5 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_AACLC : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 6 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_DTS : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 7 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_ATRAC : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 8 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_DSD : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 9 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_EAC3 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 10 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_DTSHD : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 11 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_MLP : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 12 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_DST : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 13 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_WMAPRO : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 14 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_USE_CODING_EXTENSION_TYPE : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 15 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 31 ; +pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_IN_HEADER : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_16BITS : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_20BITS : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_24BITS : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE = 7 ; +#[doc = "! Byte 2 related"] +pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_IN_HEADER : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_32000HZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_44100HZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_48000HZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_88200KHZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 4 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_96000KHZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 5 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_176400KHZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 6 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_192000KHZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 7 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 15 ; +pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_USE_CODING_TYPE : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_HEAAC : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_HEAACV2 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_MPEGSURROUND : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE04 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 4 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE05 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 5 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE06 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 6 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE07 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 7 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE08 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 8 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE09 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 9 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE10 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 10 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE11 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 11 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE12 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 12 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE13 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 13 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE14 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 14 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE15 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 15 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE16 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 16 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE17 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 17 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE18 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 18 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE19 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 19 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE20 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 20 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE21 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 21 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE22 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 22 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE23 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 23 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE24 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 24 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE25 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 25 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE26 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 26 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE27 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 27 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE28 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 28 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE29 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 29 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE30 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 30 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE31 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 31 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 63 ; +#[doc = "! Byte 3 related"] +pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_X_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_X_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_X_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_X_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_RC_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 4 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_RC_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 5 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_RC_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 6 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_RC_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 7 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_RR_RL_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 8 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_RR_RL_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 9 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 10 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 11 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_RC_RR_RL_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 12 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_RC_RR_RL_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 13 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_RC_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 14 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_RC_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 15 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_RRC_RLC_RR_RL_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 16 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_RRC_RLC_RR_RL_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 17 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_RRC_RLC_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 18 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_RRC_RLC_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 19 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_X_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 20 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_X_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 21 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_X_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 22 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_X_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 23 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_RC_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 24 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_RC_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 25 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_RC_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 26 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_RC_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 27 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_RR_RL_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 28 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_RR_RL_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 29 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 30 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 31 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_FCH_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 32 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_FCH_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 33 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_X_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 34 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_X_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 35 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRH_FLH_RR_RL_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 36 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRH_FLH_RR_RL_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 37 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRW_FLW_RR_RL_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 38 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRW_FLW_RR_RL_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 39 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_RC_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 40 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_RC_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 41 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FCH_RC_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 42 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FCH_RC_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 43 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_FCH_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 44 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_FCH_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 45 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRH_FLH_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 46 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRH_FLH_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 47 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRW_FLW_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 48 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRW_FLW_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 49 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 511 ; +#[doc = "! Byte 4 related"] +pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_NO_DATA : NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_0DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_PLUS10DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_RESERVED03 : NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL = 7 ; +#[doc = "! Byte 5 related"] +pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_0DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_1DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_2DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_3DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_4DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 4 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_5DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 5 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_6DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 6 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_7DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 7 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_8DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 8 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_9DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 9 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_10DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 10 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_11DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 11 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_12DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 12 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_13DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 13 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_14DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 14 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_15DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 15 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 31 ; +pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_PERMITTED : NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_PROHIBITED : NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_AUTO: + NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX = 3; +pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX = ::std::os::raw::c_int; +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct NV_INFOFRAME_AUDIO { + pub _bitfield_align_1: [u16; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 14usize]>, + pub __bindgen_padding_0: u16, +} +impl NV_INFOFRAME_AUDIO { + #[inline] + pub fn codingType(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 5u8) as u32) } + } + #[inline] + pub fn set_codingType(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 5u8, val as u64) + } + } + #[inline] + pub unsafe fn codingType_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 5u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_codingType_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 5u8, + val as u64, + ) + } + } + #[inline] + pub fn codingExtensionType(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 6u8) as u32) } + } + #[inline] + pub fn set_codingExtensionType(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 6u8, val as u64) + } + } + #[inline] + pub unsafe fn codingExtensionType_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 6u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_codingExtensionType_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 6u8, + val as u64, + ) + } + } + #[inline] + pub fn sampleSize(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 3u8) as u32) } + } + #[inline] + pub fn set_sampleSize(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(11usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn sampleSize_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 11usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_sampleSize_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 11usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn sampleRate(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 4u8) as u32) } + } + #[inline] + pub fn set_sampleRate(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(14usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn sampleRate_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 14usize, + 4u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_sampleRate_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 14usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn channelCount(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 4u8) as u32) } + } + #[inline] + pub fn set_channelCount(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(18usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn channelCount_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 18usize, + 4u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_channelCount_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 18usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn speakerPlacement(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 9u8) as u32) } + } + #[inline] + pub fn set_speakerPlacement(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(22usize, 9u8, val as u64) + } + } + #[inline] + pub unsafe fn speakerPlacement_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 22usize, + 9u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_speakerPlacement_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 22usize, + 9u8, + val as u64, + ) + } + } + #[inline] + pub fn downmixInhibit(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 2u8) as u32) } + } + #[inline] + pub fn set_downmixInhibit(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(32usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn downmixInhibit_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 32usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_downmixInhibit_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 32usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn lfePlaybackLevel(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(34usize, 3u8) as u32) } + } + #[inline] + pub fn set_lfePlaybackLevel(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(34usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn lfePlaybackLevel_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 34usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_lfePlaybackLevel_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 34usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn levelShift(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(37usize, 5u8) as u32) } + } + #[inline] + pub fn set_levelShift(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(37usize, 5u8, val as u64) + } + } + #[inline] + pub unsafe fn levelShift_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 37usize, + 5u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_levelShift_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 37usize, + 5u8, + val as u64, + ) + } + } + #[inline] + pub fn Future12(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(42usize, 2u8) as u32) } + } + #[inline] + pub fn set_Future12(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(42usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn Future12_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 42usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_Future12_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 42usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn Future2x(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(44usize, 4u8) as u32) } + } + #[inline] + pub fn set_Future2x(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(44usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn Future2x_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 44usize, + 4u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_Future2x_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 44usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn Future3x(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 4u8) as u32) } + } + #[inline] + pub fn set_Future3x(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(48usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn Future3x_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 48usize, + 4u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_Future3x_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 48usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn Future52(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(52usize, 2u8) as u32) } + } + #[inline] + pub fn set_Future52(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(52usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn Future52_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 52usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_Future52_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 52usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn Future6(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(54usize, 9u8) as u32) } + } + #[inline] + pub fn set_Future6(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(54usize, 9u8, val as u64) + } + } + #[inline] + pub unsafe fn Future6_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 54usize, + 9u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_Future6_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 54usize, + 9u8, + val as u64, + ) + } + } + #[inline] + pub fn Future7(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(64usize, 9u8) as u32) } + } + #[inline] + pub fn set_Future7(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(64usize, 9u8, val as u64) + } + } + #[inline] + pub unsafe fn Future7_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 64usize, + 9u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_Future7_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 64usize, + 9u8, + val as u64, + ) + } + } + #[inline] + pub fn Future8(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(73usize, 9u8) as u32) } + } + #[inline] + pub fn set_Future8(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(73usize, 9u8, val as u64) + } + } + #[inline] + pub unsafe fn Future8_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 73usize, + 9u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_Future8_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 73usize, + 9u8, + val as u64, + ) + } + } + #[inline] + pub fn Future9(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(82usize, 9u8) as u32) } + } + #[inline] + pub fn set_Future9(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(82usize, 9u8, val as u64) + } + } + #[inline] + pub unsafe fn Future9_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 82usize, + 9u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_Future9_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 82usize, + 9u8, + val as u64, + ) + } + } + #[inline] + pub fn Future10(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(96usize, 9u8) as u32) } + } + #[inline] + pub fn set_Future10(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(96usize, 9u8, val as u64) + } + } + #[inline] + pub unsafe fn Future10_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 96usize, + 9u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_Future10_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 96usize, + 9u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + codingType: NvU32, + codingExtensionType: NvU32, + sampleSize: NvU32, + sampleRate: NvU32, + channelCount: NvU32, + speakerPlacement: NvU32, + downmixInhibit: NvU32, + lfePlaybackLevel: NvU32, + levelShift: NvU32, + Future12: NvU32, + Future2x: NvU32, + Future3x: NvU32, + Future52: NvU32, + Future6: NvU32, + Future7: NvU32, + Future8: NvU32, + Future9: NvU32, + Future10: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 14usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 14usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 5u8, { + let codingType: u32 = unsafe { ::std::mem::transmute(codingType) }; + codingType as u64 + }); + __bindgen_bitfield_unit.set(5usize, 6u8, { + let codingExtensionType: u32 = unsafe { ::std::mem::transmute(codingExtensionType) }; + codingExtensionType as u64 + }); + __bindgen_bitfield_unit.set(11usize, 3u8, { + let sampleSize: u32 = unsafe { ::std::mem::transmute(sampleSize) }; + sampleSize as u64 + }); + __bindgen_bitfield_unit.set(14usize, 4u8, { + let sampleRate: u32 = unsafe { ::std::mem::transmute(sampleRate) }; + sampleRate as u64 + }); + __bindgen_bitfield_unit.set(18usize, 4u8, { + let channelCount: u32 = unsafe { ::std::mem::transmute(channelCount) }; + channelCount as u64 + }); + __bindgen_bitfield_unit.set(22usize, 9u8, { + let speakerPlacement: u32 = unsafe { ::std::mem::transmute(speakerPlacement) }; + speakerPlacement as u64 + }); + __bindgen_bitfield_unit.set(32usize, 2u8, { + let downmixInhibit: u32 = unsafe { ::std::mem::transmute(downmixInhibit) }; + downmixInhibit as u64 + }); + __bindgen_bitfield_unit.set(34usize, 3u8, { + let lfePlaybackLevel: u32 = unsafe { ::std::mem::transmute(lfePlaybackLevel) }; + lfePlaybackLevel as u64 + }); + __bindgen_bitfield_unit.set(37usize, 5u8, { + let levelShift: u32 = unsafe { ::std::mem::transmute(levelShift) }; + levelShift as u64 + }); + __bindgen_bitfield_unit.set(42usize, 2u8, { + let Future12: u32 = unsafe { ::std::mem::transmute(Future12) }; + Future12 as u64 + }); + __bindgen_bitfield_unit.set(44usize, 4u8, { + let Future2x: u32 = unsafe { ::std::mem::transmute(Future2x) }; + Future2x as u64 + }); + __bindgen_bitfield_unit.set(48usize, 4u8, { + let Future3x: u32 = unsafe { ::std::mem::transmute(Future3x) }; + Future3x as u64 + }); + __bindgen_bitfield_unit.set(52usize, 2u8, { + let Future52: u32 = unsafe { ::std::mem::transmute(Future52) }; + Future52 as u64 + }); + __bindgen_bitfield_unit.set(54usize, 9u8, { + let Future6: u32 = unsafe { ::std::mem::transmute(Future6) }; + Future6 as u64 + }); + __bindgen_bitfield_unit.set(64usize, 9u8, { + let Future7: u32 = unsafe { ::std::mem::transmute(Future7) }; + Future7 as u64 + }); + __bindgen_bitfield_unit.set(73usize, 9u8, { + let Future8: u32 = unsafe { ::std::mem::transmute(Future8) }; + Future8 as u64 + }); + __bindgen_bitfield_unit.set(82usize, 9u8, { + let Future9: u32 = unsafe { ::std::mem::transmute(Future9) }; + Future9 as u64 + }); + __bindgen_bitfield_unit.set(96usize, 9u8, { + let Future10: u32 = unsafe { ::std::mem::transmute(Future10) }; + Future10 as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct NV_INFOFRAME_DATA { + #[doc = "!< version of this structure"] + pub version: NvU32, + #[doc = "!< size of this structure"] + pub size: NvU16, + #[doc = "!< The actions to perform from NV_INFOFRAME_CMD"] + pub cmd: NvU8, + #[doc = "!< type of infoframe"] + pub type_: NvU8, + pub infoframe: NV_INFOFRAME_DATA__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union NV_INFOFRAME_DATA__bindgen_ty_1 { + #[doc = "!< This is NVIDIA-specific and corresponds to the property cmds and associated infoframe."] + pub property: NV_INFOFRAME_PROPERTY, + pub audio: NV_INFOFRAME_AUDIO, + pub video: NV_INFOFRAME_VIDEO, +} +pub const NV_COLOR_CMD_NV_COLOR_CMD_GET: NV_COLOR_CMD = 1; +pub const NV_COLOR_CMD_NV_COLOR_CMD_SET: NV_COLOR_CMD = 2; +pub const NV_COLOR_CMD_NV_COLOR_CMD_IS_SUPPORTED_COLOR: NV_COLOR_CMD = 3; +pub const NV_COLOR_CMD_NV_COLOR_CMD_GET_DEFAULT: NV_COLOR_CMD = 4; +pub type NV_COLOR_CMD = ::std::os::raw::c_int; +pub const NV_COLOR_FORMAT_NV_COLOR_FORMAT_RGB: NV_COLOR_FORMAT = 0; +pub const NV_COLOR_FORMAT_NV_COLOR_FORMAT_YUV422: NV_COLOR_FORMAT = 1; +pub const NV_COLOR_FORMAT_NV_COLOR_FORMAT_YUV444: NV_COLOR_FORMAT = 2; +pub const NV_COLOR_FORMAT_NV_COLOR_FORMAT_YUV420: NV_COLOR_FORMAT = 3; +pub const NV_COLOR_FORMAT_NV_COLOR_FORMAT_DEFAULT: NV_COLOR_FORMAT = 254; +pub const NV_COLOR_FORMAT_NV_COLOR_FORMAT_AUTO: NV_COLOR_FORMAT = 255; +#[doc = "! See Table 14 of CEA-861E. Not all of this is supported by the GPU."] +pub type NV_COLOR_FORMAT = ::std::os::raw::c_int; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_RGB: NV_COLOR_COLORIMETRY = 0; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_YCC601: NV_COLOR_COLORIMETRY = 1; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_YCC709: NV_COLOR_COLORIMETRY = 2; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_XVYCC601: NV_COLOR_COLORIMETRY = 3; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_XVYCC709: NV_COLOR_COLORIMETRY = 4; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_SYCC601: NV_COLOR_COLORIMETRY = 5; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_ADOBEYCC601: NV_COLOR_COLORIMETRY = 6; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_ADOBERGB: NV_COLOR_COLORIMETRY = 7; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_BT2020RGB: NV_COLOR_COLORIMETRY = 8; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_BT2020YCC: NV_COLOR_COLORIMETRY = 9; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_BT2020cYCC: NV_COLOR_COLORIMETRY = 10; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_DEFAULT: NV_COLOR_COLORIMETRY = 254; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_AUTO: NV_COLOR_COLORIMETRY = 255; +pub type NV_COLOR_COLORIMETRY = ::std::os::raw::c_int; +pub const _NV_DYNAMIC_RANGE_NV_DYNAMIC_RANGE_VESA: _NV_DYNAMIC_RANGE = 0; +pub const _NV_DYNAMIC_RANGE_NV_DYNAMIC_RANGE_CEA: _NV_DYNAMIC_RANGE = 1; +pub const _NV_DYNAMIC_RANGE_NV_DYNAMIC_RANGE_AUTO: _NV_DYNAMIC_RANGE = 255; +pub type _NV_DYNAMIC_RANGE = ::std::os::raw::c_int; +pub use self::_NV_DYNAMIC_RANGE as NV_DYNAMIC_RANGE; +pub const _NV_BPC_NV_BPC_DEFAULT: _NV_BPC = 0; +pub const _NV_BPC_NV_BPC_6: _NV_BPC = 1; +pub const _NV_BPC_NV_BPC_8: _NV_BPC = 2; +pub const _NV_BPC_NV_BPC_10: _NV_BPC = 3; +pub const _NV_BPC_NV_BPC_12: _NV_BPC = 4; +pub const _NV_BPC_NV_BPC_16: _NV_BPC = 5; +pub type _NV_BPC = ::std::os::raw::c_int; +pub use self::_NV_BPC as NV_BPC; +#[doc = "!< app/nvcpl make decision to select the desire color format"] +pub const _NV_COLOR_SELECTION_POLICY_NV_COLOR_SELECTION_POLICY_USER: _NV_COLOR_SELECTION_POLICY = 0; +#[doc = "!< driver/ OS make decision to select the best color format"] +pub const _NV_COLOR_SELECTION_POLICY_NV_COLOR_SELECTION_POLICY_BEST_QUALITY: + _NV_COLOR_SELECTION_POLICY = 1; +pub const _NV_COLOR_SELECTION_POLICY_NV_COLOR_SELECTION_POLICY_DEFAULT: _NV_COLOR_SELECTION_POLICY = + 1; +pub const _NV_COLOR_SELECTION_POLICY_NV_COLOR_SELECTION_POLICY_UNKNOWN: _NV_COLOR_SELECTION_POLICY = + 255; +pub type _NV_COLOR_SELECTION_POLICY = ::std::os::raw::c_int; +pub use self::_NV_COLOR_SELECTION_POLICY as NV_COLOR_SELECTION_POLICY; +pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_DEFAULT: _NV_DESKTOP_COLOR_DEPTH = 0; +pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_8BPC: _NV_DESKTOP_COLOR_DEPTH = 1; +pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_10BPC: _NV_DESKTOP_COLOR_DEPTH = 2; +pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_16BPC_FLOAT: _NV_DESKTOP_COLOR_DEPTH = 3; +pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_16BPC_FLOAT_WCG: _NV_DESKTOP_COLOR_DEPTH = + 4; +pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_16BPC_FLOAT_HDR: _NV_DESKTOP_COLOR_DEPTH = + 5; +pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_MAX_VALUE: _NV_DESKTOP_COLOR_DEPTH = 5; +pub type _NV_DESKTOP_COLOR_DEPTH = ::std::os::raw::c_int; +pub use self::_NV_DESKTOP_COLOR_DEPTH as NV_DESKTOP_COLOR_DEPTH; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COLOR_DATA_V1 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Size of this structure"] + pub size: NvU16, + pub cmd: NvU8, + pub data: _NV_COLOR_DATA_V1__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COLOR_DATA_V1__bindgen_ty_1 { + #[doc = "!< One of NV_COLOR_FORMAT enum values."] + pub colorFormat: NvU8, + #[doc = "!< One of NV_COLOR_COLORIMETRY enum values."] + pub colorimetry: NvU8, +} +pub type NV_COLOR_DATA_V1 = _NV_COLOR_DATA_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COLOR_DATA_V2 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Size of this structure"] + pub size: NvU16, + pub cmd: NvU8, + pub data: _NV_COLOR_DATA_V2__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COLOR_DATA_V2__bindgen_ty_1 { + #[doc = "!< One of NV_COLOR_FORMAT enum values."] + pub colorFormat: NvU8, + #[doc = "!< One of NV_COLOR_COLORIMETRY enum values."] + pub colorimetry: NvU8, + #[doc = "!< One of NV_DYNAMIC_RANGE enum values."] + pub dynamicRange: NvU8, +} +pub type NV_COLOR_DATA_V2 = _NV_COLOR_DATA_V2; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COLOR_DATA_V3 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Size of this structure"] + pub size: NvU16, + pub cmd: NvU8, + pub data: _NV_COLOR_DATA_V3__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COLOR_DATA_V3__bindgen_ty_1 { + #[doc = "!< One of NV_COLOR_FORMAT enum values."] + pub colorFormat: NvU8, + #[doc = "!< One of NV_COLOR_COLORIMETRY enum values."] + pub colorimetry: NvU8, + #[doc = "!< One of NV_DYNAMIC_RANGE enum values."] + pub dynamicRange: NvU8, + #[doc = "!< One of NV_BPC enum values."] + pub bpc: NV_BPC, +} +pub type NV_COLOR_DATA_V3 = _NV_COLOR_DATA_V3; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COLOR_DATA_V4 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Size of this structure"] + pub size: NvU16, + pub cmd: NvU8, + pub data: _NV_COLOR_DATA_V4__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COLOR_DATA_V4__bindgen_ty_1 { + #[doc = "!< One of NV_COLOR_FORMAT enum values."] + pub colorFormat: NvU8, + #[doc = "!< One of NV_COLOR_COLORIMETRY enum values."] + pub colorimetry: NvU8, + #[doc = "!< One of NV_DYNAMIC_RANGE enum values."] + pub dynamicRange: NvU8, + #[doc = "!< One of NV_BPC enum values."] + pub bpc: NV_BPC, + #[doc = "!< One of the color selection policy"] + pub colorSelectionPolicy: NV_COLOR_SELECTION_POLICY, +} +pub type NV_COLOR_DATA_V4 = _NV_COLOR_DATA_V4; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COLOR_DATA_V5 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Size of this structure"] + pub size: NvU16, + pub cmd: NvU8, + pub data: _NV_COLOR_DATA_V5__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COLOR_DATA_V5__bindgen_ty_1 { + #[doc = "!< One of NV_COLOR_FORMAT enum values."] + pub colorFormat: NvU8, + #[doc = "!< One of NV_COLOR_COLORIMETRY enum values."] + pub colorimetry: NvU8, + #[doc = "!< One of NV_DYNAMIC_RANGE enum values."] + pub dynamicRange: NvU8, + #[doc = "!< One of NV_BPC enum values."] + pub bpc: NV_BPC, + #[doc = "!< One of the color selection policy"] + pub colorSelectionPolicy: NV_COLOR_SELECTION_POLICY, + #[doc = "!< One of NV_DESKTOP_COLOR_DEPTH enum values."] + pub depth: NV_DESKTOP_COLOR_DEPTH, +} +pub type NV_COLOR_DATA_V5 = _NV_COLOR_DATA_V5; +pub type NV_COLOR_DATA = NV_COLOR_DATA_V5; +#[doc = "!< Tells the type of structure used to define the Static Metadata Descriptor block."] +pub const NV_STATIC_METADATA_DESCRIPTOR_ID_NV_STATIC_METADATA_TYPE_1: + NV_STATIC_METADATA_DESCRIPTOR_ID = 0; +#[doc = "! @}"] +pub type NV_STATIC_METADATA_DESCRIPTOR_ID = ::std::os::raw::c_int; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_CAPABILITIES_V1 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Static Metadata Descriptor Id (0 for static metadata type 1)"] + pub static_metadata_descriptor_id: NV_STATIC_METADATA_DESCRIPTOR_ID, + pub display_data: _NV_HDR_CAPABILITIES_V1__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_CAPABILITIES_V1__bindgen_ty_1 { + #[doc = "!< x coordinate of color primary 0 (e.g. Red) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x0: NvU16, + #[doc = "!< y coordinate of color primary 0 (e.g. Red) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y0: NvU16, + #[doc = "!< x coordinate of color primary 1 (e.g. Green) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x1: NvU16, + #[doc = "!< y coordinate of color primary 1 (e.g. Green) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y1: NvU16, + #[doc = "!< x coordinate of color primary 2 (e.g. Blue) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x2: NvU16, + #[doc = "!< y coordinate of color primary 2 (e.g. Blue) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y2: NvU16, + #[doc = "!< x coordinate of white point of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_x: NvU16, + #[doc = "!< y coordinate of white point of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_y: NvU16, + #[doc = "!< Maximum display luminance = desired max luminance of HDR content ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] + pub desired_content_max_luminance: NvU16, + #[doc = "!< Minimum display luminance = desired min luminance of HDR content ([0x0001-0xFFFF] = [1.0 - 6.55350] cd/m^2)"] + pub desired_content_min_luminance: NvU16, + #[doc = "!< Desired maximum Frame-Average Light Level (MaxFALL) of HDR content ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] + pub desired_content_max_frame_average_luminance: NvU16, +} +impl _NV_HDR_CAPABILITIES_V1 { + #[inline] + pub fn isST2084EotfSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isST2084EotfSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isST2084EotfSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isST2084EotfSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isTraditionalHdrGammaSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isTraditionalHdrGammaSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isTraditionalHdrGammaSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isTraditionalHdrGammaSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isEdrSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_isEdrSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isEdrSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isEdrSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn driverExpandDefaultHdrParameters(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_driverExpandDefaultHdrParameters(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn driverExpandDefaultHdrParameters_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_driverExpandDefaultHdrParameters_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isTraditionalSdrGammaSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_isTraditionalSdrGammaSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isTraditionalSdrGammaSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isTraditionalSdrGammaSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 27u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 27u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 27u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isST2084EotfSupported: NvU32, + isTraditionalHdrGammaSupported: NvU32, + isEdrSupported: NvU32, + driverExpandDefaultHdrParameters: NvU32, + isTraditionalSdrGammaSupported: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isST2084EotfSupported: u32 = + unsafe { ::std::mem::transmute(isST2084EotfSupported) }; + isST2084EotfSupported as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isTraditionalHdrGammaSupported: u32 = + unsafe { ::std::mem::transmute(isTraditionalHdrGammaSupported) }; + isTraditionalHdrGammaSupported as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let isEdrSupported: u32 = unsafe { ::std::mem::transmute(isEdrSupported) }; + isEdrSupported as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let driverExpandDefaultHdrParameters: u32 = + unsafe { ::std::mem::transmute(driverExpandDefaultHdrParameters) }; + driverExpandDefaultHdrParameters as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let isTraditionalSdrGammaSupported: u32 = + unsafe { ::std::mem::transmute(isTraditionalSdrGammaSupported) }; + isTraditionalSdrGammaSupported as u64 + }); + __bindgen_bitfield_unit.set(5usize, 27u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_HDR_CAPABILITIES_V1 = _NV_HDR_CAPABILITIES_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_CAPABILITIES_V2 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Static Metadata Descriptor Id (0 for static metadata type 1)"] + pub static_metadata_descriptor_id: NV_STATIC_METADATA_DESCRIPTOR_ID, + pub display_data: _NV_HDR_CAPABILITIES_V2__bindgen_ty_1, + pub dv_static_metadata: _NV_HDR_CAPABILITIES_V2__bindgen_ty_2, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_CAPABILITIES_V2__bindgen_ty_1 { + #[doc = "!< x coordinate of color primary 0 (e.g. Red) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x0: NvU16, + #[doc = "!< y coordinate of color primary 0 (e.g. Red) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y0: NvU16, + #[doc = "!< x coordinate of color primary 1 (e.g. Green) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x1: NvU16, + #[doc = "!< y coordinate of color primary 1 (e.g. Green) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y1: NvU16, + #[doc = "!< x coordinate of color primary 2 (e.g. Blue) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x2: NvU16, + #[doc = "!< y coordinate of color primary 2 (e.g. Blue) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y2: NvU16, + #[doc = "!< x coordinate of white point of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_x: NvU16, + #[doc = "!< y coordinate of white point of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_y: NvU16, + #[doc = "!< Maximum display luminance = desired max luminance of HDR content ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] + pub desired_content_max_luminance: NvU16, + #[doc = "!< Minimum display luminance = desired min luminance of HDR content ([0x0001-0xFFFF] = [1.0 - 6.55350] cd/m^2)"] + pub desired_content_min_luminance: NvU16, + #[doc = "!< Desired maximum Frame-Average Light Level (MaxFALL) of HDR content ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] + pub desired_content_max_frame_average_luminance: NvU16, +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_CAPABILITIES_V2__bindgen_ty_2 { + pub _bitfield_align_1: [u16; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Represents min luminance level of Sink"] + pub target_min_luminance: NvU16, + #[doc = "!< Represents max luminance level of sink"] + pub target_max_luminance: NvU16, + #[doc = "!< Red primary chromaticity coordinate x"] + pub cc_red_x: NvU16, + #[doc = "!< Red primary chromaticity coordinate y"] + pub cc_red_y: NvU16, + #[doc = "!< Green primary chromaticity coordinate x"] + pub cc_green_x: NvU16, + #[doc = "!< Green primary chromaticity coordinate Y"] + pub cc_green_y: NvU16, + #[doc = "!< Blue primary chromaticity coordinate x"] + pub cc_blue_x: NvU16, + #[doc = "!< Blue primary chromaticity coordinate y"] + pub cc_blue_y: NvU16, + #[doc = "!< White primary chromaticity coordinate x"] + pub cc_white_x: NvU16, + #[doc = "!< White primary chromaticity coordinate y"] + pub cc_white_y: NvU16, +} +impl _NV_HDR_CAPABILITIES_V2__bindgen_ty_2 { + #[inline] + pub fn VSVDB_version(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 3u8) as u32) } + } + #[inline] + pub fn set_VSVDB_version(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn VSVDB_version_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_VSVDB_version_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn dm_version(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 8u8) as u32) } + } + #[inline] + pub fn set_dm_version(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn dm_version_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_dm_version_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn supports_2160p60hz(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) } + } + #[inline] + pub fn set_supports_2160p60hz(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(11usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supports_2160p60hz_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 11usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_supports_2160p60hz_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 11usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn supports_YUV422_12bit(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) } + } + #[inline] + pub fn set_supports_YUV422_12bit(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(12usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supports_YUV422_12bit_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 12usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_supports_YUV422_12bit_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 12usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn supports_global_dimming(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) } + } + #[inline] + pub fn set_supports_global_dimming(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(13usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supports_global_dimming_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 13usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_supports_global_dimming_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 13usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn colorimetry(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) } + } + #[inline] + pub fn set_colorimetry(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(14usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn colorimetry_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 14usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_colorimetry_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 14usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn supports_backlight_control(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 2u8) as u32) } + } + #[inline] + pub fn set_supports_backlight_control(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(15usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn supports_backlight_control_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 15usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_supports_backlight_control_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 15usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn backlt_min_luma(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 2u8) as u32) } + } + #[inline] + pub fn set_backlt_min_luma(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(17usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn backlt_min_luma_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 17usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_backlt_min_luma_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 17usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn interface_supported_by_sink(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 2u8) as u32) } + } + #[inline] + pub fn set_interface_supported_by_sink(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(19usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn interface_supported_by_sink_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 19usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_interface_supported_by_sink_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 19usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn supports_10b_12b_444(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 2u8) as u32) } + } + #[inline] + pub fn set_supports_10b_12b_444(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(21usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn supports_10b_12b_444_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 21usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_supports_10b_12b_444_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 21usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 9u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(23usize, 9u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 23usize, + 9u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 23usize, + 9u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + VSVDB_version: NvU32, + dm_version: NvU32, + supports_2160p60hz: NvU32, + supports_YUV422_12bit: NvU32, + supports_global_dimming: NvU32, + colorimetry: NvU32, + supports_backlight_control: NvU32, + backlt_min_luma: NvU32, + interface_supported_by_sink: NvU32, + supports_10b_12b_444: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 3u8, { + let VSVDB_version: u32 = unsafe { ::std::mem::transmute(VSVDB_version) }; + VSVDB_version as u64 + }); + __bindgen_bitfield_unit.set(3usize, 8u8, { + let dm_version: u32 = unsafe { ::std::mem::transmute(dm_version) }; + dm_version as u64 + }); + __bindgen_bitfield_unit.set(11usize, 1u8, { + let supports_2160p60hz: u32 = unsafe { ::std::mem::transmute(supports_2160p60hz) }; + supports_2160p60hz as u64 + }); + __bindgen_bitfield_unit.set(12usize, 1u8, { + let supports_YUV422_12bit: u32 = + unsafe { ::std::mem::transmute(supports_YUV422_12bit) }; + supports_YUV422_12bit as u64 + }); + __bindgen_bitfield_unit.set(13usize, 1u8, { + let supports_global_dimming: u32 = + unsafe { ::std::mem::transmute(supports_global_dimming) }; + supports_global_dimming as u64 + }); + __bindgen_bitfield_unit.set(14usize, 1u8, { + let colorimetry: u32 = unsafe { ::std::mem::transmute(colorimetry) }; + colorimetry as u64 + }); + __bindgen_bitfield_unit.set(15usize, 2u8, { + let supports_backlight_control: u32 = + unsafe { ::std::mem::transmute(supports_backlight_control) }; + supports_backlight_control as u64 + }); + __bindgen_bitfield_unit.set(17usize, 2u8, { + let backlt_min_luma: u32 = unsafe { ::std::mem::transmute(backlt_min_luma) }; + backlt_min_luma as u64 + }); + __bindgen_bitfield_unit.set(19usize, 2u8, { + let interface_supported_by_sink: u32 = + unsafe { ::std::mem::transmute(interface_supported_by_sink) }; + interface_supported_by_sink as u64 + }); + __bindgen_bitfield_unit.set(21usize, 2u8, { + let supports_10b_12b_444: u32 = unsafe { ::std::mem::transmute(supports_10b_12b_444) }; + supports_10b_12b_444 as u64 + }); + __bindgen_bitfield_unit.set(23usize, 9u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +impl _NV_HDR_CAPABILITIES_V2 { + #[inline] + pub fn isST2084EotfSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isST2084EotfSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isST2084EotfSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isST2084EotfSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isTraditionalHdrGammaSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isTraditionalHdrGammaSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isTraditionalHdrGammaSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isTraditionalHdrGammaSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isEdrSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_isEdrSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isEdrSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isEdrSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn driverExpandDefaultHdrParameters(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_driverExpandDefaultHdrParameters(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn driverExpandDefaultHdrParameters_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_driverExpandDefaultHdrParameters_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isTraditionalSdrGammaSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_isTraditionalSdrGammaSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isTraditionalSdrGammaSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isTraditionalSdrGammaSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isDolbyVisionSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_isDolbyVisionSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isDolbyVisionSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isDolbyVisionSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 26u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 26u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 6usize, + 26u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 26u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isST2084EotfSupported: NvU32, + isTraditionalHdrGammaSupported: NvU32, + isEdrSupported: NvU32, + driverExpandDefaultHdrParameters: NvU32, + isTraditionalSdrGammaSupported: NvU32, + isDolbyVisionSupported: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isST2084EotfSupported: u32 = + unsafe { ::std::mem::transmute(isST2084EotfSupported) }; + isST2084EotfSupported as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isTraditionalHdrGammaSupported: u32 = + unsafe { ::std::mem::transmute(isTraditionalHdrGammaSupported) }; + isTraditionalHdrGammaSupported as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let isEdrSupported: u32 = unsafe { ::std::mem::transmute(isEdrSupported) }; + isEdrSupported as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let driverExpandDefaultHdrParameters: u32 = + unsafe { ::std::mem::transmute(driverExpandDefaultHdrParameters) }; + driverExpandDefaultHdrParameters as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let isTraditionalSdrGammaSupported: u32 = + unsafe { ::std::mem::transmute(isTraditionalSdrGammaSupported) }; + isTraditionalSdrGammaSupported as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let isDolbyVisionSupported: u32 = + unsafe { ::std::mem::transmute(isDolbyVisionSupported) }; + isDolbyVisionSupported as u64 + }); + __bindgen_bitfield_unit.set(6usize, 26u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_HDR_CAPABILITIES_V2 = _NV_HDR_CAPABILITIES_V2; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_CAPABILITIES_V3 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Static Metadata Descriptor Id (0 for static metadata type 1)"] + pub static_metadata_descriptor_id: NV_STATIC_METADATA_DESCRIPTOR_ID, + pub display_data: _NV_HDR_CAPABILITIES_V3__bindgen_ty_1, + pub dv_static_metadata: _NV_HDR_CAPABILITIES_V3__bindgen_ty_2, + pub hdr10plus_vsvdb: _NV_HDR_CAPABILITIES_V3__bindgen_ty_3, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_CAPABILITIES_V3__bindgen_ty_1 { + #[doc = "!< x coordinate of color primary 0 (e.g. Red) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x0: NvU16, + #[doc = "!< y coordinate of color primary 0 (e.g. Red) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y0: NvU16, + #[doc = "!< x coordinate of color primary 1 (e.g. Green) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x1: NvU16, + #[doc = "!< y coordinate of color primary 1 (e.g. Green) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y1: NvU16, + #[doc = "!< x coordinate of color primary 2 (e.g. Blue) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x2: NvU16, + #[doc = "!< y coordinate of color primary 2 (e.g. Blue) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y2: NvU16, + #[doc = "!< x coordinate of white point of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_x: NvU16, + #[doc = "!< y coordinate of white point of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_y: NvU16, + #[doc = "!< Maximum display luminance = desired max luminance of HDR content ([0x0000-0xFFFF] = [0.0 - 65535.0] cd/m^2, in units of 1 cd/m^2)"] + pub desired_content_max_luminance: NvU16, + #[doc = "!< Minimum display luminance = desired min luminance of HDR content ([0x0000-0xFFFF] = [0.0 - 6.55350] cd/m^2, in units of 0.0001 cd/m^2)"] + pub desired_content_min_luminance: NvU16, + #[doc = "!< Desired maximum Frame-Average Light Level (MaxFALL) of HDR content ([0x0000-0xFFFF] = [0.0 - 65535.0] cd/m^2, in units of 1 cd/m^2)"] + pub desired_content_max_frame_average_luminance: NvU16, +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_CAPABILITIES_V3__bindgen_ty_2 { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Represents min luminance level of Sink"] + pub target_min_luminance: NvU16, + #[doc = "!< Represents max luminance level of sink"] + pub target_max_luminance: NvU16, + #[doc = "!< Red primary chromaticity coordinate x"] + pub cc_red_x: NvU16, + #[doc = "!< Red primary chromaticity coordinate y"] + pub cc_red_y: NvU16, + #[doc = "!< Green primary chromaticity coordinate x"] + pub cc_green_x: NvU16, + #[doc = "!< Green primary chromaticity coordinate Y"] + pub cc_green_y: NvU16, + #[doc = "!< Blue primary chromaticity coordinate x"] + pub cc_blue_x: NvU16, + #[doc = "!< Blue primary chromaticity coordinate y"] + pub cc_blue_y: NvU16, + #[doc = "!< White primary chromaticity coordinate x"] + pub cc_white_x: NvU16, + #[doc = "!< White primary chromaticity coordinate y"] + pub cc_white_y: NvU16, +} +impl _NV_HDR_CAPABILITIES_V3__bindgen_ty_2 { + #[inline] + pub fn VSVDB_version(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 3u8) as u32) } + } + #[inline] + pub fn set_VSVDB_version(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn VSVDB_version_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_VSVDB_version_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn dm_version(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 8u8) as u32) } + } + #[inline] + pub fn set_dm_version(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn dm_version_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_dm_version_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn supports_2160p60hz(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) } + } + #[inline] + pub fn set_supports_2160p60hz(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(11usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supports_2160p60hz_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 11usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_supports_2160p60hz_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 11usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn supports_YUV422_12bit(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) } + } + #[inline] + pub fn set_supports_YUV422_12bit(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(12usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supports_YUV422_12bit_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 12usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_supports_YUV422_12bit_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 12usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn supports_global_dimming(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) } + } + #[inline] + pub fn set_supports_global_dimming(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(13usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supports_global_dimming_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 13usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_supports_global_dimming_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 13usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn colorimetry(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) } + } + #[inline] + pub fn set_colorimetry(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(14usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn colorimetry_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 14usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_colorimetry_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 14usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn supports_backlight_control(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 2u8) as u32) } + } + #[inline] + pub fn set_supports_backlight_control(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(15usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn supports_backlight_control_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 15usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_supports_backlight_control_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 15usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn backlt_min_luma(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 2u8) as u32) } + } + #[inline] + pub fn set_backlt_min_luma(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(17usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn backlt_min_luma_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 17usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_backlt_min_luma_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 17usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn interface_supported_by_sink(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 2u8) as u32) } + } + #[inline] + pub fn set_interface_supported_by_sink(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(19usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn interface_supported_by_sink_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 19usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_interface_supported_by_sink_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 19usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn supports_10b_12b_444(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 2u8) as u32) } + } + #[inline] + pub fn set_supports_10b_12b_444(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(21usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn supports_10b_12b_444_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 21usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_supports_10b_12b_444_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 21usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn parity(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u32) } + } + #[inline] + pub fn set_parity(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(23usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn parity_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 23usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_parity_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 23usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(24usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 24usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 24usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + VSVDB_version: NvU32, + dm_version: NvU32, + supports_2160p60hz: NvU32, + supports_YUV422_12bit: NvU32, + supports_global_dimming: NvU32, + colorimetry: NvU32, + supports_backlight_control: NvU32, + backlt_min_luma: NvU32, + interface_supported_by_sink: NvU32, + supports_10b_12b_444: NvU32, + parity: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 3u8, { + let VSVDB_version: u32 = unsafe { ::std::mem::transmute(VSVDB_version) }; + VSVDB_version as u64 + }); + __bindgen_bitfield_unit.set(3usize, 8u8, { + let dm_version: u32 = unsafe { ::std::mem::transmute(dm_version) }; + dm_version as u64 + }); + __bindgen_bitfield_unit.set(11usize, 1u8, { + let supports_2160p60hz: u32 = unsafe { ::std::mem::transmute(supports_2160p60hz) }; + supports_2160p60hz as u64 + }); + __bindgen_bitfield_unit.set(12usize, 1u8, { + let supports_YUV422_12bit: u32 = + unsafe { ::std::mem::transmute(supports_YUV422_12bit) }; + supports_YUV422_12bit as u64 + }); + __bindgen_bitfield_unit.set(13usize, 1u8, { + let supports_global_dimming: u32 = + unsafe { ::std::mem::transmute(supports_global_dimming) }; + supports_global_dimming as u64 + }); + __bindgen_bitfield_unit.set(14usize, 1u8, { + let colorimetry: u32 = unsafe { ::std::mem::transmute(colorimetry) }; + colorimetry as u64 + }); + __bindgen_bitfield_unit.set(15usize, 2u8, { + let supports_backlight_control: u32 = + unsafe { ::std::mem::transmute(supports_backlight_control) }; + supports_backlight_control as u64 + }); + __bindgen_bitfield_unit.set(17usize, 2u8, { + let backlt_min_luma: u32 = unsafe { ::std::mem::transmute(backlt_min_luma) }; + backlt_min_luma as u64 + }); + __bindgen_bitfield_unit.set(19usize, 2u8, { + let interface_supported_by_sink: u32 = + unsafe { ::std::mem::transmute(interface_supported_by_sink) }; + interface_supported_by_sink as u64 + }); + __bindgen_bitfield_unit.set(21usize, 2u8, { + let supports_10b_12b_444: u32 = unsafe { ::std::mem::transmute(supports_10b_12b_444) }; + supports_10b_12b_444 as u64 + }); + __bindgen_bitfield_unit.set(23usize, 1u8, { + let parity: u32 = unsafe { ::std::mem::transmute(parity) }; + parity as u64 + }); + __bindgen_bitfield_unit.set(24usize, 8u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[repr(align(2))] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_CAPABILITIES_V3__bindgen_ty_3 { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>, +} +impl _NV_HDR_CAPABILITIES_V3__bindgen_ty_3 { + #[inline] + pub fn application_version(&self) -> NvU16 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u16) } + } + #[inline] + pub fn set_application_version(&mut self, val: NvU16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn application_version_raw(this: *const Self) -> NvU16 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 2u8, + ) as u16) + } + } + #[inline] + pub unsafe fn set_application_version_raw(this: *mut Self, val: NvU16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn full_frame_peak_luminance_index(&self) -> NvU16 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 2u8) as u16) } + } + #[inline] + pub fn set_full_frame_peak_luminance_index(&mut self, val: NvU16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn full_frame_peak_luminance_index_raw(this: *const Self) -> NvU16 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 2u8, + ) as u16) + } + } + #[inline] + pub unsafe fn set_full_frame_peak_luminance_index_raw(this: *mut Self, val: NvU16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn peak_luminance_index(&self) -> NvU16 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u16) } + } + #[inline] + pub fn set_peak_luminance_index(&mut self, val: NvU16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn peak_luminance_index_raw(this: *const Self) -> NvU16 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 4u8, + ) as u16) + } + } + #[inline] + pub unsafe fn set_peak_luminance_index_raw(this: *mut Self, val: NvU16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU16 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 8u8) as u16) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU16 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 8usize, + 8u8, + ) as u16) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 8usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + application_version: NvU16, + full_frame_peak_luminance_index: NvU16, + peak_luminance_index: NvU16, + reserved: NvU16, + ) -> __BindgenBitfieldUnit<[u8; 2usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 2u8, { + let application_version: u16 = unsafe { ::std::mem::transmute(application_version) }; + application_version as u64 + }); + __bindgen_bitfield_unit.set(2usize, 2u8, { + let full_frame_peak_luminance_index: u16 = + unsafe { ::std::mem::transmute(full_frame_peak_luminance_index) }; + full_frame_peak_luminance_index as u64 + }); + __bindgen_bitfield_unit.set(4usize, 4u8, { + let peak_luminance_index: u16 = unsafe { ::std::mem::transmute(peak_luminance_index) }; + peak_luminance_index as u64 + }); + __bindgen_bitfield_unit.set(8usize, 8u8, { + let reserved: u16 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +impl _NV_HDR_CAPABILITIES_V3 { + #[inline] + pub fn isST2084EotfSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isST2084EotfSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isST2084EotfSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isST2084EotfSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isTraditionalHdrGammaSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isTraditionalHdrGammaSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isTraditionalHdrGammaSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isTraditionalHdrGammaSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isEdrSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_isEdrSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isEdrSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isEdrSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn driverExpandDefaultHdrParameters(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_driverExpandDefaultHdrParameters(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn driverExpandDefaultHdrParameters_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_driverExpandDefaultHdrParameters_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isTraditionalSdrGammaSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_isTraditionalSdrGammaSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isTraditionalSdrGammaSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isTraditionalSdrGammaSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isDolbyVisionSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_isDolbyVisionSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isDolbyVisionSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isDolbyVisionSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isHdr10PlusSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } + } + #[inline] + pub fn set_isHdr10PlusSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isHdr10PlusSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 6usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isHdr10PlusSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isHdr10PlusGamingSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } + } + #[inline] + pub fn set_isHdr10PlusGamingSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isHdr10PlusGamingSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 7usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isHdr10PlusGamingSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 7usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isNvidiaCertifiedDisplay(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) } + } + #[inline] + pub fn set_isNvidiaCertifiedDisplay(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isNvidiaCertifiedDisplay_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 8usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isNvidiaCertifiedDisplay_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 8usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 23u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(9usize, 23u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 9usize, + 23u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 9usize, + 23u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isST2084EotfSupported: NvU32, + isTraditionalHdrGammaSupported: NvU32, + isEdrSupported: NvU32, + driverExpandDefaultHdrParameters: NvU32, + isTraditionalSdrGammaSupported: NvU32, + isDolbyVisionSupported: NvU32, + isHdr10PlusSupported: NvU32, + isHdr10PlusGamingSupported: NvU32, + isNvidiaCertifiedDisplay: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isST2084EotfSupported: u32 = + unsafe { ::std::mem::transmute(isST2084EotfSupported) }; + isST2084EotfSupported as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isTraditionalHdrGammaSupported: u32 = + unsafe { ::std::mem::transmute(isTraditionalHdrGammaSupported) }; + isTraditionalHdrGammaSupported as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let isEdrSupported: u32 = unsafe { ::std::mem::transmute(isEdrSupported) }; + isEdrSupported as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let driverExpandDefaultHdrParameters: u32 = + unsafe { ::std::mem::transmute(driverExpandDefaultHdrParameters) }; + driverExpandDefaultHdrParameters as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let isTraditionalSdrGammaSupported: u32 = + unsafe { ::std::mem::transmute(isTraditionalSdrGammaSupported) }; + isTraditionalSdrGammaSupported as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let isDolbyVisionSupported: u32 = + unsafe { ::std::mem::transmute(isDolbyVisionSupported) }; + isDolbyVisionSupported as u64 + }); + __bindgen_bitfield_unit.set(6usize, 1u8, { + let isHdr10PlusSupported: u32 = unsafe { ::std::mem::transmute(isHdr10PlusSupported) }; + isHdr10PlusSupported as u64 + }); + __bindgen_bitfield_unit.set(7usize, 1u8, { + let isHdr10PlusGamingSupported: u32 = + unsafe { ::std::mem::transmute(isHdr10PlusGamingSupported) }; + isHdr10PlusGamingSupported as u64 + }); + __bindgen_bitfield_unit.set(8usize, 1u8, { + let isNvidiaCertifiedDisplay: u32 = + unsafe { ::std::mem::transmute(isNvidiaCertifiedDisplay) }; + isNvidiaCertifiedDisplay as u64 + }); + __bindgen_bitfield_unit.set(9usize, 23u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_HDR_CAPABILITIES_V3 = _NV_HDR_CAPABILITIES_V3; +pub type NV_HDR_CAPABILITIES = NV_HDR_CAPABILITIES_V3; +#[doc = "!< Get current HDR output configuration"] +pub const NV_HDR_CMD_NV_HDR_CMD_GET: NV_HDR_CMD = 0; +#[doc = "!< Set HDR output configuration"] +pub const NV_HDR_CMD_NV_HDR_CMD_SET: NV_HDR_CMD = 1; +#[doc = "! @}"] +pub type NV_HDR_CMD = ::std::os::raw::c_int; +#[doc = "!< Turn off HDR"] +pub const NV_HDR_MODE_NV_HDR_MODE_OFF: NV_HDR_MODE = 0; +#[doc = "!< Source: CCCS [a.k.a FP16 scRGB, linear, sRGB primaries, [-65504,0, 65504] range, RGB(1,1,1) = 80nits] Output : UHDA HDR [a.k.a HDR10, RGB/YCC 10/12bpc ST2084(PQ) EOTF RGB(1,1,1) = 10000 nits, Rec2020 color primaries, ST2086 static HDR metadata]. This is the only supported production HDR mode."] +pub const NV_HDR_MODE_NV_HDR_MODE_UHDA: NV_HDR_MODE = 2; +#[doc = "!< Experimental mode only, not for production! Source: HDR10 RGB 10bpc Output: HDR10 RGB 10 bpc - signal UHDA HDR mode (PQ + Rec2020) to the sink but send source pixel values unmodified (no PQ or Rec2020 conversions) - assumes source is already in HDR10 format."] +pub const NV_HDR_MODE_NV_HDR_MODE_UHDA_PASSTHROUGH: NV_HDR_MODE = 5; +#[doc = "!< Experimental mode only, not for production! Source: RGB8 Dolby Vision encoded (12 bpc YCbCr422 packed into RGB8) Output: Dolby Vision encoded : Application is to encoded frames in DV format and embed DV dynamic metadata as described in Dolby Vision specification."] +pub const NV_HDR_MODE_NV_HDR_MODE_DOLBY_VISION: NV_HDR_MODE = 7; +#[doc = "!< Do not use! Internal test mode only, to be removed. Source: CCCS (a.k.a FP16 scRGB) Output : EDR (Extended Dynamic Range) - HDR content is tonemapped and gamut mapped to output on regular SDR display set to max luminance ( ~300 nits )."] +pub const NV_HDR_MODE_NV_HDR_MODE_EDR: NV_HDR_MODE = 3; +#[doc = "!< Do not use! Internal test mode only, to be removed. Source: any Output: SDR (Standard Dynamic Range), we continuously send SDR EOTF InfoFrame signaling, HDMI compliance testing."] +pub const NV_HDR_MODE_NV_HDR_MODE_SDR: NV_HDR_MODE = 4; +#[doc = "!< Do not use! Internal test mode only, to be removed. Source: CCCS (a.k.a FP16 scRGB) Output : notebook HDR"] +pub const NV_HDR_MODE_NV_HDR_MODE_UHDA_NB: NV_HDR_MODE = 6; +#[doc = "!< Do not use! Obsolete, to be removed. NV_HDR_MODE_UHDBD == NV_HDR_MODE_UHDA, reflects obsolete pre-UHDA naming convention."] +pub const NV_HDR_MODE_NV_HDR_MODE_UHDBD: NV_HDR_MODE = 2; +pub type NV_HDR_MODE = ::std::os::raw::c_int; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_COLOR_DATA_V1 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Command get/set"] + pub cmd: NV_HDR_CMD, + #[doc = "!< HDR mode"] + pub hdrMode: NV_HDR_MODE, + #[doc = "!< Static Metadata Descriptor Id (0 for static metadata type 1)"] + pub static_metadata_descriptor_id: NV_STATIC_METADATA_DESCRIPTOR_ID, + pub mastering_display_data: _NV_HDR_COLOR_DATA_V1__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_COLOR_DATA_V1__bindgen_ty_1 { + #[doc = "!< x coordinate of color primary 0 (e.g. Red) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x0: NvU16, + #[doc = "!< y coordinate of color primary 0 (e.g. Red) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y0: NvU16, + #[doc = "!< x coordinate of color primary 1 (e.g. Green) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x1: NvU16, + #[doc = "!< y coordinate of color primary 1 (e.g. Green) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y1: NvU16, + #[doc = "!< x coordinate of color primary 2 (e.g. Blue) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x2: NvU16, + #[doc = "!< y coordinate of color primary 2 (e.g. Blue) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y2: NvU16, + #[doc = "!< x coordinate of white point of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_x: NvU16, + #[doc = "!< y coordinate of white point of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_y: NvU16, + #[doc = "!< Maximum display mastering luminance ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] + pub max_display_mastering_luminance: NvU16, + #[doc = "!< Minimum display mastering luminance ([0x0001-0xFFFF] = [1.0 - 6.55350] cd/m^2)"] + pub min_display_mastering_luminance: NvU16, + #[doc = "!< Maximum Content Light level (MaxCLL) ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] + pub max_content_light_level: NvU16, + #[doc = "!< Maximum Frame-Average Light Level (MaxFALL) ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] + pub max_frame_average_light_level: NvU16, +} +pub type NV_HDR_COLOR_DATA_V1 = _NV_HDR_COLOR_DATA_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_COLOR_DATA_V2 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Command get/set"] + pub cmd: NV_HDR_CMD, + #[doc = "!< HDR mode"] + pub hdrMode: NV_HDR_MODE, + #[doc = "!< Static Metadata Descriptor Id (0 for static metadata type 1)"] + pub static_metadata_descriptor_id: NV_STATIC_METADATA_DESCRIPTOR_ID, + pub mastering_display_data: _NV_HDR_COLOR_DATA_V2__bindgen_ty_1, + #[doc = "!< Optional, One of NV_COLOR_FORMAT enum values, if set it will apply requested color format for HDR session"] + pub hdrColorFormat: NV_COLOR_FORMAT, + #[doc = "!< Optional, One of NV_DYNAMIC_RANGE enum values, if set it will apply requested dynamic range for HDR session"] + pub hdrDynamicRange: NV_DYNAMIC_RANGE, + #[doc = "!< Optional, One of NV_BPC enum values, if set it will apply requested color depth\n!< Dolby Vision mode: DV supports specific combinations of colorformat, dynamic range and bpc. Please refer Dolby Vision specification.\n!< If invalid or no combination is passed driver will force default combination of RGB format + full range + 8bpc.\n!< HDR mode: These fields are ignored in hdr mode"] + pub hdrBpc: NV_BPC, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_COLOR_DATA_V2__bindgen_ty_1 { + #[doc = "!< x coordinate of color primary 0 (e.g. Red) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x0: NvU16, + #[doc = "!< y coordinate of color primary 0 (e.g. Red) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y0: NvU16, + #[doc = "!< x coordinate of color primary 1 (e.g. Green) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x1: NvU16, + #[doc = "!< y coordinate of color primary 1 (e.g. Green) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y1: NvU16, + #[doc = "!< x coordinate of color primary 2 (e.g. Blue) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x2: NvU16, + #[doc = "!< y coordinate of color primary 2 (e.g. Blue) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y2: NvU16, + #[doc = "!< x coordinate of white point of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_x: NvU16, + #[doc = "!< y coordinate of white point of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_y: NvU16, + #[doc = "!< Maximum display mastering luminance ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] + pub max_display_mastering_luminance: NvU16, + #[doc = "!< Minimum display mastering luminance ([0x0001-0xFFFF] = [1.0 - 6.55350] cd/m^2)"] + pub min_display_mastering_luminance: NvU16, + #[doc = "!< Maximum Content Light level (MaxCLL) ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] + pub max_content_light_level: NvU16, + #[doc = "!< Maximum Frame-Average Light Level (MaxFALL) ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] + pub max_frame_average_light_level: NvU16, +} +pub type NV_HDR_COLOR_DATA_V2 = _NV_HDR_COLOR_DATA_V2; +pub type NV_HDR_COLOR_DATA = NV_HDR_COLOR_DATA_V2; +#[doc = "!< sRGB IEC 61966-2-1:1999 == DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709"] +pub const _NV_COLORSPACE_TYPE_NV_COLORSPACE_sRGB: _NV_COLORSPACE_TYPE = 0; +#[doc = "!< FP16 linear with sRGB color primaries == DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709"] +pub const _NV_COLORSPACE_TYPE_NV_COLORSPACE_xRGB: _NV_COLORSPACE_TYPE = 1; +#[doc = "!< ITU-R Rec BT.2100 (HDR10) == DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020"] +pub const _NV_COLORSPACE_TYPE_NV_COLORSPACE_REC2100: _NV_COLORSPACE_TYPE = 12; +pub type _NV_COLORSPACE_TYPE = ::std::os::raw::c_int; +pub use self::_NV_COLORSPACE_TYPE as NV_COLORSPACE_TYPE; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_METADATA_V1 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< x coordinate of color primary 0 (e.g. Red) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x0: NvU16, + #[doc = "!< y coordinate of color primary 0 (e.g. Red) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y0: NvU16, + #[doc = "!< x coordinate of color primary 1 (e.g. Green) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x1: NvU16, + #[doc = "!< y coordinate of color primary 1 (e.g. Green) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y1: NvU16, + #[doc = "!< x coordinate of color primary 2 (e.g. Blue) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x2: NvU16, + #[doc = "!< y coordinate of color primary 2 (e.g. Blue) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y2: NvU16, + #[doc = "!< x coordinate of white point of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_x: NvU16, + #[doc = "!< y coordinate of white point of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_y: NvU16, + #[doc = "!< Maximum display mastering luminance ([0x0000-0xFFFF] = [0.0 - 65535.0] cd/m^2, in units of 1 cd/m^2)"] + pub max_display_mastering_luminance: NvU16, + #[doc = "!< Minimum display mastering luminance ([0x0000-0xFFFF] = [0.0 - 6.55350] cd/m^2, in units of 0.0001 cd/m^2)"] + pub min_display_mastering_luminance: NvU16, + #[doc = "!< Maximum Content Light level (MaxCLL) ([0x0000-0xFFFF] = [0.0 - 65535.0] cd/m^2, in units of 1 cd/m^2)"] + pub max_content_light_level: NvU16, + #[doc = "!< Maximum Frame-Average Light Level (MaxFALL) ([0x0000-0xFFFF] = [0.0 - 65535.0] cd/m^2, in units of 1 cd/m^2)"] + pub max_frame_average_light_level: NvU16, +} +pub type NV_HDR_METADATA_V1 = _NV_HDR_METADATA_V1; +pub type NV_HDR_METADATA = NV_HDR_METADATA_V1; +pub const _NV_DISPLAY_OUTPUT_MODE_NV_DISPLAY_OUTPUT_MODE_SDR: _NV_DISPLAY_OUTPUT_MODE = 0; +pub const _NV_DISPLAY_OUTPUT_MODE_NV_DISPLAY_OUTPUT_MODE_HDR10: _NV_DISPLAY_OUTPUT_MODE = 1; +pub const _NV_DISPLAY_OUTPUT_MODE_NV_DISPLAY_OUTPUT_MODE_HDR10PLUS_GAMING: _NV_DISPLAY_OUTPUT_MODE = + 2; +pub type _NV_DISPLAY_OUTPUT_MODE = ::std::os::raw::c_int; +pub use self::_NV_DISPLAY_OUTPUT_MODE as NV_DISPLAY_OUTPUT_MODE; +pub const _NV_HDR_TONEMAPPING_METHOD_NV_HDR_TONEMAPPING_APP: _NV_HDR_TONEMAPPING_METHOD = 0; +pub const _NV_HDR_TONEMAPPING_METHOD_NV_HDR_TONEMAPPING_GPU: _NV_HDR_TONEMAPPING_METHOD = 1; +pub type _NV_HDR_TONEMAPPING_METHOD = ::std::os::raw::c_int; +pub use self::_NV_HDR_TONEMAPPING_METHOD as NV_HDR_TONEMAPPING_METHOD; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_DISPLAY_COLORIMETRY_V1 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< min luminance, cd/m^2"] + pub min_luminance: f32, + #[doc = "!< max 100% frame luminance, cd/m^2"] + pub max_full_frame_luminance: f32, + #[doc = "!< max 10% frame luminance, cd/m^2"] + pub max_luminance: f32, + #[doc = "!< HDR brightness luminance scaling factor applied by GPU on output pixels"] + pub hdrBrightnessLuminanceScalingFactor: f32, + #[doc = "!< red primary chromaticity coordinate x"] + pub red_primary_x: f32, + #[doc = "!< red primary chromaticity coordinate y"] + pub red_primary_y: f32, + #[doc = "!< green primary chromaticity coordinate x"] + pub green_primary_x: f32, + #[doc = "!< green primary chromaticity coordinate y"] + pub green_primary_y: f32, + #[doc = "!< blue primary chromaticity coordinate x"] + pub blue_primary_x: f32, + #[doc = "!< blue primary chromaticity coordinate y"] + pub blue_primary_y: f32, + #[doc = "!< white point chromaticity coordinate x"] + pub white_point_x: f32, + #[doc = "!< white point chromaticity coordinate y"] + pub white_point_y: f32, +} +pub type NV_DISPLAY_COLORIMETRY_V1 = _NV_DISPLAY_COLORIMETRY_V1; +pub type NV_DISPLAY_COLORIMETRY = NV_DISPLAY_COLORIMETRY_V1; +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_DISP_GetTiming()."] +#[repr(C)] +#[repr(align(4))] +#[derive(Copy, Clone)] +pub struct NV_TIMING_FLAG { + pub _bitfield_align_1: [u16; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>, + pub __bindgen_anon_1: NV_TIMING_FLAG__bindgen_ty_1, + pub _bitfield_align_2: [u8; 0], + pub _bitfield_2: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 5usize], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union NV_TIMING_FLAG__bindgen_ty_1 { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>, +} +impl NV_TIMING_FLAG__bindgen_ty_1 { + #[inline] + pub fn tvFormat(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) } + } + #[inline] + pub fn set_tvFormat(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn tvFormat_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_tvFormat_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn ceaId(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 8u8) as u32) } + } + #[inline] + pub fn set_ceaId(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn ceaId_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 8usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_ceaId_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 8usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn nvPsfId(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 8u8) as u32) } + } + #[inline] + pub fn set_nvPsfId(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(16usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn nvPsfId_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 16usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_nvPsfId_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 16usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + tvFormat: NvU32, + ceaId: NvU32, + nvPsfId: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 3usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 8u8, { + let tvFormat: u32 = unsafe { ::std::mem::transmute(tvFormat) }; + tvFormat as u64 + }); + __bindgen_bitfield_unit.set(8usize, 8u8, { + let ceaId: u32 = unsafe { ::std::mem::transmute(ceaId) }; + ceaId as u64 + }); + __bindgen_bitfield_unit.set(16usize, 8u8, { + let nvPsfId: u32 = unsafe { ::std::mem::transmute(nvPsfId) }; + nvPsfId as u64 + }); + __bindgen_bitfield_unit + } +} +impl NV_TIMING_FLAG { + #[inline] + pub fn isInterlaced(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32) } + } + #[inline] + pub fn set_isInterlaced(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn isInterlaced_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 4u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isInterlaced_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved0(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 12u8) as u32) } + } + #[inline] + pub fn set_reserved0(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 12u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved0_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 12u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved0_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 12u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isInterlaced: NvU32, + reserved0: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 2usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 4u8, { + let isInterlaced: u32 = unsafe { ::std::mem::transmute(isInterlaced) }; + isInterlaced as u64 + }); + __bindgen_bitfield_unit.set(4usize, 12u8, { + let reserved0: u32 = unsafe { ::std::mem::transmute(reserved0) }; + reserved0 as u64 + }); + __bindgen_bitfield_unit + } + #[inline] + pub fn scaling(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 8u8) as u32) } + } + #[inline] + pub fn set_scaling(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_2.set(0usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn scaling_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_2), + 0usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_scaling_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 0usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_2(scaling: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 8u8, { + let scaling: u32 = unsafe { ::std::mem::transmute(scaling) }; + scaling as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_DISP_GetTiming()."] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_TIMING_INPUT { + #[doc = "!< (IN) structure version"] + pub version: NvU32, + #[doc = "!< Visible horizontal size"] + pub width: NvU32, + #[doc = "!< Visible vertical size"] + pub height: NvU32, + #[doc = "!< Timing refresh rate"] + pub rr: f32, + #[doc = "!< Flag containing additional info for timing calculation."] + pub flag: NV_TIMING_FLAG, + #[doc = "!< Timing type(formula) to use for calculating the timing"] + pub type_: NV_TIMING_OVERRIDE, +} +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_DISP_GetTiming()."] +pub type NV_TIMING_INPUT = _NV_TIMING_INPUT; +pub const NV_MONITOR_CAPS_TYPE_NV_MONITOR_CAPS_TYPE_HDMI_VSDB: NV_MONITOR_CAPS_TYPE = 4096; +pub const NV_MONITOR_CAPS_TYPE_NV_MONITOR_CAPS_TYPE_HDMI_VCDB: NV_MONITOR_CAPS_TYPE = 4097; +pub const NV_MONITOR_CAPS_TYPE_NV_MONITOR_CAPS_TYPE_GENERIC: NV_MONITOR_CAPS_TYPE = 4098; +#[doc = "! HDMI-related and extended CAPs"] +pub type NV_MONITOR_CAPS_TYPE = ::std::os::raw::c_int; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MONITOR_CAPS_VCDB { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, +} +impl _NV_MONITOR_CAPS_VCDB { + #[inline] + pub fn quantizationRangeYcc(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) } + } + #[inline] + pub fn set_quantizationRangeYcc(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn quantizationRangeYcc_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_quantizationRangeYcc_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn quantizationRangeRgb(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) } + } + #[inline] + pub fn set_quantizationRangeRgb(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn quantizationRangeRgb_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_quantizationRangeRgb_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn scanInfoPreferredVideoFormat(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 2u8) as u8) } + } + #[inline] + pub fn set_scanInfoPreferredVideoFormat(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn scanInfoPreferredVideoFormat_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 2u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_scanInfoPreferredVideoFormat_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn scanInfoITVideoFormats(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 2u8) as u8) } + } + #[inline] + pub fn set_scanInfoITVideoFormats(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn scanInfoITVideoFormats_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 2u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_scanInfoITVideoFormats_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn scanInfoCEVideoFormats(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 2u8) as u8) } + } + #[inline] + pub fn set_scanInfoCEVideoFormats(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn scanInfoCEVideoFormats_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 6usize, + 2u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_scanInfoCEVideoFormats_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + quantizationRangeYcc: NvU8, + quantizationRangeRgb: NvU8, + scanInfoPreferredVideoFormat: NvU8, + scanInfoITVideoFormats: NvU8, + scanInfoCEVideoFormats: NvU8, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let quantizationRangeYcc: u8 = unsafe { ::std::mem::transmute(quantizationRangeYcc) }; + quantizationRangeYcc as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let quantizationRangeRgb: u8 = unsafe { ::std::mem::transmute(quantizationRangeRgb) }; + quantizationRangeRgb as u64 + }); + __bindgen_bitfield_unit.set(2usize, 2u8, { + let scanInfoPreferredVideoFormat: u8 = + unsafe { ::std::mem::transmute(scanInfoPreferredVideoFormat) }; + scanInfoPreferredVideoFormat as u64 + }); + __bindgen_bitfield_unit.set(4usize, 2u8, { + let scanInfoITVideoFormats: u8 = + unsafe { ::std::mem::transmute(scanInfoITVideoFormats) }; + scanInfoITVideoFormats as u64 + }); + __bindgen_bitfield_unit.set(6usize, 2u8, { + let scanInfoCEVideoFormats: u8 = + unsafe { ::std::mem::transmute(scanInfoCEVideoFormats) }; + scanInfoCEVideoFormats as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_MONITOR_CAPS_VCDB = _NV_MONITOR_CAPS_VCDB; +#[doc = "! See NvAPI_DISP_GetMonitorCapabilities()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MONITOR_CAPS_VSDB { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>, + #[doc = "!< Bye 4"] + pub maxTmdsClock: NvU8, + pub _bitfield_align_2: [u8; 0], + pub _bitfield_2: __BindgenBitfieldUnit<[u8; 1usize]>, + #[doc = "!< Byte 6"] + pub videoLatency: NvU8, + #[doc = "!< Byte 7"] + pub audioLatency: NvU8, + #[doc = "!< Byte 8"] + pub interlacedVideoLatency: NvU8, + #[doc = "!< Byte 9"] + pub interlacedAudioLatency: NvU8, + pub _bitfield_align_3: [u8; 0], + pub _bitfield_3: __BindgenBitfieldUnit<[u8; 2usize]>, + #[doc = "!< Keeping maximum length for 3 bits"] + pub hdmi_vic: [NvU8; 7usize], + #[doc = "!< Keeping maximum length for 5 bits"] + pub hdmi_3d: [NvU8; 31usize], +} +impl _NV_MONITOR_CAPS_VSDB { + #[inline] + pub fn sourcePhysicalAddressB(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u8) } + } + #[inline] + pub fn set_sourcePhysicalAddressB(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn sourcePhysicalAddressB_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 4u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_sourcePhysicalAddressB_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn sourcePhysicalAddressA(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u8) } + } + #[inline] + pub fn set_sourcePhysicalAddressA(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn sourcePhysicalAddressA_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 4u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_sourcePhysicalAddressA_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn sourcePhysicalAddressD(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 4u8) as u8) } + } + #[inline] + pub fn set_sourcePhysicalAddressD(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn sourcePhysicalAddressD_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 8usize, + 4u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_sourcePhysicalAddressD_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 8usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn sourcePhysicalAddressC(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 4u8) as u8) } + } + #[inline] + pub fn set_sourcePhysicalAddressC(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(12usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn sourcePhysicalAddressC_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 12usize, + 4u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_sourcePhysicalAddressC_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 12usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn supportDualDviOperation(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u8) } + } + #[inline] + pub fn set_supportDualDviOperation(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(16usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supportDualDviOperation_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 16usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_supportDualDviOperation_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 16usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved6(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 2u8) as u8) } + } + #[inline] + pub fn set_reserved6(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(17usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved6_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 17usize, + 2u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_reserved6_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 17usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn supportDeepColorYCbCr444(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u8) } + } + #[inline] + pub fn set_supportDeepColorYCbCr444(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(19usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supportDeepColorYCbCr444_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 19usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_supportDeepColorYCbCr444_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 19usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn supportDeepColor30bits(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u8) } + } + #[inline] + pub fn set_supportDeepColor30bits(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(20usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supportDeepColor30bits_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 20usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_supportDeepColor30bits_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 20usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn supportDeepColor36bits(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u8) } + } + #[inline] + pub fn set_supportDeepColor36bits(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(21usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supportDeepColor36bits_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 21usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_supportDeepColor36bits_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 21usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn supportDeepColor48bits(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u8) } + } + #[inline] + pub fn set_supportDeepColor48bits(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(22usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supportDeepColor48bits_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 22usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_supportDeepColor48bits_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 22usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn supportAI(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u8) } + } + #[inline] + pub fn set_supportAI(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(23usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supportAI_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 23usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_supportAI_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 23usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + sourcePhysicalAddressB: NvU8, + sourcePhysicalAddressA: NvU8, + sourcePhysicalAddressD: NvU8, + sourcePhysicalAddressC: NvU8, + supportDualDviOperation: NvU8, + reserved6: NvU8, + supportDeepColorYCbCr444: NvU8, + supportDeepColor30bits: NvU8, + supportDeepColor36bits: NvU8, + supportDeepColor48bits: NvU8, + supportAI: NvU8, + ) -> __BindgenBitfieldUnit<[u8; 3usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 4u8, { + let sourcePhysicalAddressB: u8 = + unsafe { ::std::mem::transmute(sourcePhysicalAddressB) }; + sourcePhysicalAddressB as u64 + }); + __bindgen_bitfield_unit.set(4usize, 4u8, { + let sourcePhysicalAddressA: u8 = + unsafe { ::std::mem::transmute(sourcePhysicalAddressA) }; + sourcePhysicalAddressA as u64 + }); + __bindgen_bitfield_unit.set(8usize, 4u8, { + let sourcePhysicalAddressD: u8 = + unsafe { ::std::mem::transmute(sourcePhysicalAddressD) }; + sourcePhysicalAddressD as u64 + }); + __bindgen_bitfield_unit.set(12usize, 4u8, { + let sourcePhysicalAddressC: u8 = + unsafe { ::std::mem::transmute(sourcePhysicalAddressC) }; + sourcePhysicalAddressC as u64 + }); + __bindgen_bitfield_unit.set(16usize, 1u8, { + let supportDualDviOperation: u8 = + unsafe { ::std::mem::transmute(supportDualDviOperation) }; + supportDualDviOperation as u64 + }); + __bindgen_bitfield_unit.set(17usize, 2u8, { + let reserved6: u8 = unsafe { ::std::mem::transmute(reserved6) }; + reserved6 as u64 + }); + __bindgen_bitfield_unit.set(19usize, 1u8, { + let supportDeepColorYCbCr444: u8 = + unsafe { ::std::mem::transmute(supportDeepColorYCbCr444) }; + supportDeepColorYCbCr444 as u64 + }); + __bindgen_bitfield_unit.set(20usize, 1u8, { + let supportDeepColor30bits: u8 = + unsafe { ::std::mem::transmute(supportDeepColor30bits) }; + supportDeepColor30bits as u64 + }); + __bindgen_bitfield_unit.set(21usize, 1u8, { + let supportDeepColor36bits: u8 = + unsafe { ::std::mem::transmute(supportDeepColor36bits) }; + supportDeepColor36bits as u64 + }); + __bindgen_bitfield_unit.set(22usize, 1u8, { + let supportDeepColor48bits: u8 = + unsafe { ::std::mem::transmute(supportDeepColor48bits) }; + supportDeepColor48bits as u64 + }); + __bindgen_bitfield_unit.set(23usize, 1u8, { + let supportAI: u8 = unsafe { ::std::mem::transmute(supportAI) }; + supportAI as u64 + }); + __bindgen_bitfield_unit + } + #[inline] + pub fn cnc0SupportGraphicsTextContent(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 1u8) as u8) } + } + #[inline] + pub fn set_cnc0SupportGraphicsTextContent(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_2.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn cnc0SupportGraphicsTextContent_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_2), + 0usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_cnc0SupportGraphicsTextContent_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn cnc1SupportPhotoContent(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(1usize, 1u8) as u8) } + } + #[inline] + pub fn set_cnc1SupportPhotoContent(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_2.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn cnc1SupportPhotoContent_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_2), + 1usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_cnc1SupportPhotoContent_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn cnc2SupportCinemaContent(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(2usize, 1u8) as u8) } + } + #[inline] + pub fn set_cnc2SupportCinemaContent(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_2.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn cnc2SupportCinemaContent_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_2), + 2usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_cnc2SupportCinemaContent_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn cnc3SupportGameContent(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(3usize, 1u8) as u8) } + } + #[inline] + pub fn set_cnc3SupportGameContent(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_2.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn cnc3SupportGameContent_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_2), + 3usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_cnc3SupportGameContent_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved8(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(4usize, 1u8) as u8) } + } + #[inline] + pub fn set_reserved8(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_2.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved8_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_2), + 4usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_reserved8_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn hasVicEntries(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(5usize, 1u8) as u8) } + } + #[inline] + pub fn set_hasVicEntries(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_2.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn hasVicEntries_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_2), + 5usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_hasVicEntries_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn hasInterlacedLatencyField(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(6usize, 1u8) as u8) } + } + #[inline] + pub fn set_hasInterlacedLatencyField(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_2.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn hasInterlacedLatencyField_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_2), + 6usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_hasInterlacedLatencyField_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 6usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn hasLatencyField(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(7usize, 1u8) as u8) } + } + #[inline] + pub fn set_hasLatencyField(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_2.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn hasLatencyField_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_2), + 7usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_hasLatencyField_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 7usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_2( + cnc0SupportGraphicsTextContent: NvU8, + cnc1SupportPhotoContent: NvU8, + cnc2SupportCinemaContent: NvU8, + cnc3SupportGameContent: NvU8, + reserved8: NvU8, + hasVicEntries: NvU8, + hasInterlacedLatencyField: NvU8, + hasLatencyField: NvU8, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let cnc0SupportGraphicsTextContent: u8 = + unsafe { ::std::mem::transmute(cnc0SupportGraphicsTextContent) }; + cnc0SupportGraphicsTextContent as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let cnc1SupportPhotoContent: u8 = + unsafe { ::std::mem::transmute(cnc1SupportPhotoContent) }; + cnc1SupportPhotoContent as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let cnc2SupportCinemaContent: u8 = + unsafe { ::std::mem::transmute(cnc2SupportCinemaContent) }; + cnc2SupportCinemaContent as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let cnc3SupportGameContent: u8 = + unsafe { ::std::mem::transmute(cnc3SupportGameContent) }; + cnc3SupportGameContent as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let reserved8: u8 = unsafe { ::std::mem::transmute(reserved8) }; + reserved8 as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let hasVicEntries: u8 = unsafe { ::std::mem::transmute(hasVicEntries) }; + hasVicEntries as u64 + }); + __bindgen_bitfield_unit.set(6usize, 1u8, { + let hasInterlacedLatencyField: u8 = + unsafe { ::std::mem::transmute(hasInterlacedLatencyField) }; + hasInterlacedLatencyField as u64 + }); + __bindgen_bitfield_unit.set(7usize, 1u8, { + let hasLatencyField: u8 = unsafe { ::std::mem::transmute(hasLatencyField) }; + hasLatencyField as u64 + }); + __bindgen_bitfield_unit + } + #[inline] + pub fn reserved13(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_3.get(0usize, 7u8) as u8) } + } + #[inline] + pub fn set_reserved13(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_3.set(0usize, 7u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved13_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_3), + 0usize, + 7u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_reserved13_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_3), + 0usize, + 7u8, + val as u64, + ) + } + } + #[inline] + pub fn has3dEntries(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_3.get(7usize, 1u8) as u8) } + } + #[inline] + pub fn set_has3dEntries(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_3.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn has3dEntries_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_3), + 7usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_has3dEntries_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_3), + 7usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn hdmi3dLength(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_3.get(8usize, 5u8) as u8) } + } + #[inline] + pub fn set_hdmi3dLength(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_3.set(8usize, 5u8, val as u64) + } + } + #[inline] + pub unsafe fn hdmi3dLength_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_3), + 8usize, + 5u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_hdmi3dLength_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_3), + 8usize, + 5u8, + val as u64, + ) + } + } + #[inline] + pub fn hdmiVicLength(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_3.get(13usize, 3u8) as u8) } + } + #[inline] + pub fn set_hdmiVicLength(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_3.set(13usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn hdmiVicLength_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_3), + 13usize, + 3u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_hdmiVicLength_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_3), + 13usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_3( + reserved13: NvU8, + has3dEntries: NvU8, + hdmi3dLength: NvU8, + hdmiVicLength: NvU8, + ) -> __BindgenBitfieldUnit<[u8; 2usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 7u8, { + let reserved13: u8 = unsafe { ::std::mem::transmute(reserved13) }; + reserved13 as u64 + }); + __bindgen_bitfield_unit.set(7usize, 1u8, { + let has3dEntries: u8 = unsafe { ::std::mem::transmute(has3dEntries) }; + has3dEntries as u64 + }); + __bindgen_bitfield_unit.set(8usize, 5u8, { + let hdmi3dLength: u8 = unsafe { ::std::mem::transmute(hdmi3dLength) }; + hdmi3dLength as u64 + }); + __bindgen_bitfield_unit.set(13usize, 3u8, { + let hdmiVicLength: u8 = unsafe { ::std::mem::transmute(hdmiVicLength) }; + hdmiVicLength as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! See NvAPI_DISP_GetMonitorCapabilities()."] +pub type NV_MONITOR_CAPS_VSDB = _NV_MONITOR_CAPS_VSDB; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MONITOR_CAPS_GENERIC { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, +} +impl _NV_MONITOR_CAPS_GENERIC { + #[inline] + pub fn supportVRR(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) } + } + #[inline] + pub fn set_supportVRR(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supportVRR_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_supportVRR_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn supportULMB(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) } + } + #[inline] + pub fn set_supportULMB(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supportULMB_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_supportULMB_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isTrueGsync(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) } + } + #[inline] + pub fn set_isTrueGsync(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isTrueGsync_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_isTrueGsync_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isRLACapable(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) } + } + #[inline] + pub fn set_isRLACapable(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isRLACapable_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_isRLACapable_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn currentlyCapableOfVRR(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) } + } + #[inline] + pub fn set_currentlyCapableOfVRR(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn currentlyCapableOfVRR_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_currentlyCapableOfVRR_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isBasicVRR(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) } + } + #[inline] + pub fn set_isBasicVRR(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isBasicVRR_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_isBasicVRR_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 2u8) as u8) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 6usize, + 2u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + supportVRR: NvU8, + supportULMB: NvU8, + isTrueGsync: NvU8, + isRLACapable: NvU8, + currentlyCapableOfVRR: NvU8, + isBasicVRR: NvU8, + reserved: NvU8, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let supportVRR: u8 = unsafe { ::std::mem::transmute(supportVRR) }; + supportVRR as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let supportULMB: u8 = unsafe { ::std::mem::transmute(supportULMB) }; + supportULMB as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let isTrueGsync: u8 = unsafe { ::std::mem::transmute(isTrueGsync) }; + isTrueGsync as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let isRLACapable: u8 = unsafe { ::std::mem::transmute(isRLACapable) }; + isRLACapable as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let currentlyCapableOfVRR: u8 = unsafe { ::std::mem::transmute(currentlyCapableOfVRR) }; + currentlyCapableOfVRR as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let isBasicVRR: u8 = unsafe { ::std::mem::transmute(isBasicVRR) }; + isBasicVRR as u64 + }); + __bindgen_bitfield_unit.set(6usize, 2u8, { + let reserved: u8 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_MONITOR_CAPS_GENERIC = _NV_MONITOR_CAPS_GENERIC; +#[doc = "! See NvAPI_DISP_GetMonitorCapabilities()."] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_MONITOR_CAPABILITIES_V1 { + pub version: NvU32, + pub size: NvU16, + pub infoType: NvU32, + #[doc = "!< Out: VGA, TV, DVI, HDMI, DP"] + pub connectorType: NvU32, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub data: _NV_MONITOR_CAPABILITIES_V1__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union _NV_MONITOR_CAPABILITIES_V1__bindgen_ty_1 { + pub vsdb: NV_MONITOR_CAPS_VSDB, + pub vcdb: NV_MONITOR_CAPS_VCDB, + pub caps: NV_MONITOR_CAPS_GENERIC, +} +impl _NV_MONITOR_CAPABILITIES_V1 { + #[inline] + pub fn bIsValidInfo(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) } + } + #[inline] + pub fn set_bIsValidInfo(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsValidInfo_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_bIsValidInfo_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1(bIsValidInfo: NvU8) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsValidInfo: u8 = unsafe { ::std::mem::transmute(bIsValidInfo) }; + bIsValidInfo as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! See NvAPI_DISP_GetMonitorCapabilities()."] +pub type NV_MONITOR_CAPABILITIES_V1 = _NV_MONITOR_CAPABILITIES_V1; +#[doc = "! See NvAPI_DISP_GetMonitorCapabilities()."] +pub type NV_MONITOR_CAPABILITIES = NV_MONITOR_CAPABILITIES_V1; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MONITOR_COLOR_DATA { + pub version: NvU32, + #[doc = "!< One of the supported color formats"] + pub colorFormat: NV_DP_COLOR_FORMAT, + #[doc = "!< One of the supported bit depths"] + pub backendBitDepths: NV_DP_BPC, +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_MONITOR_COLOR_CAPS_V1 = _NV_MONITOR_COLOR_DATA; +#[doc = "! \\ingroup dispcontrol"] +pub type NV_MONITOR_COLOR_CAPS = NV_MONITOR_COLOR_CAPS_V1; +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_DISP_EnumCustomDisplay() and NvAPI_DISP_TryCustomDisplay()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_CUSTOM_DISPLAY { + pub version: NvU32, + #[doc = "!< Source surface(source mode) width"] + pub width: NvU32, + #[doc = "!< Source surface(source mode) height"] + pub height: NvU32, + #[doc = "!< Source surface color depth.\"0\" means all 8/16/32bpp"] + pub depth: NvU32, + #[doc = "!< Color format (optional)"] + pub colorFormat: NV_FORMAT, + #[doc = "!< For multimon support, should be set to (0,0,1.0,1.0) for now."] + pub srcPartition: NV_VIEWPORTF, + #[doc = "!< Horizontal scaling ratio"] + pub xRatio: f32, + #[doc = "!< Vertical scaling ratio"] + pub yRatio: f32, + #[doc = "!< Timing used to program TMDS/DAC/LVDS/HDMI/TVEncoder, etc."] + pub timing: NV_TIMING, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +impl NV_CUSTOM_DISPLAY { + #[inline] + pub fn hwModeSetOnly(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_hwModeSetOnly(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn hwModeSetOnly_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_hwModeSetOnly_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1(hwModeSetOnly: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let hwModeSetOnly: u32 = unsafe { ::std::mem::transmute(hwModeSetOnly) }; + hwModeSetOnly as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup dispcontrol\n! @{"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_EDID_DATA_V1 { + #[doc = "!< Structure version."] + pub version: NvU32, + #[doc = "!< Pointer to EDID data."] + pub pEDID: *mut NvU8, + #[doc = "!< Size of EDID data."] + pub sizeOfEDID: NvU32, +} +#[doc = "! \\ingroup dispcontrol\n! @{"] +pub type NV_EDID_DATA_V1 = _NV_EDID_DATA_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_EDID_DATA_V2 { + #[doc = "!< Structure version."] + pub version: NvU32, + #[doc = "!< Pointer to EDID data."] + pub pEDID: *mut NvU8, + #[doc = "!< Size of EDID data."] + pub sizeOfEDID: NvU32, + #[doc = "!< Reserved for future use."] + pub reserved: [NvU32; 8usize], +} +pub type NV_EDID_DATA_V2 = _NV_EDID_DATA_V2; +pub type NV_EDID_DATA = NV_EDID_DATA_V2; +#[doc = "! @}"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GET_ADAPTIVE_SYNC_DATA_V1 { + #[doc = "!< [in] structure version"] + pub version: NvU32, + #[doc = "!< [out] maximum frame interval in micro seconds as set previously using NvAPI_DISP_SetAdaptiveSyncData function."] + pub maxFrameInterval: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< [out] Number of times the last flip was shown on the screen"] + pub lastFlipRefreshCount: NvU32, + #[doc = "!< [out] Timestamp for the lastest flip on the screen"] + pub lastFlipTimeStamp: NvU64, + #[doc = "!< reserved for future use."] + pub reservedEx: [NvU32; 4usize], +} +impl _NV_GET_ADAPTIVE_SYNC_DATA_V1 { + #[inline] + pub fn bDisableAdaptiveSync(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bDisableAdaptiveSync(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bDisableAdaptiveSync_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bDisableAdaptiveSync_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bDisableFrameSplitting(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bDisableFrameSplitting(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bDisableFrameSplitting_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bDisableFrameSplitting_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 30u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 30u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 30u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bDisableAdaptiveSync: NvU32, + bDisableFrameSplitting: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bDisableAdaptiveSync: u32 = unsafe { ::std::mem::transmute(bDisableAdaptiveSync) }; + bDisableAdaptiveSync as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bDisableFrameSplitting: u32 = + unsafe { ::std::mem::transmute(bDisableFrameSplitting) }; + bDisableFrameSplitting as u64 + }); + __bindgen_bitfield_unit.set(2usize, 30u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! @}"] +pub type NV_GET_ADAPTIVE_SYNC_DATA_V1 = _NV_GET_ADAPTIVE_SYNC_DATA_V1; +#[doc = "! @}"] +pub type NV_GET_ADAPTIVE_SYNC_DATA = NV_GET_ADAPTIVE_SYNC_DATA_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_SET_ADAPTIVE_SYNC_DATA_V1 { + #[doc = "!< [in] structure version"] + pub version: NvU32, + #[doc = "!< [in] deprecated, please use maxFrameIntervalNs instead\n!< If maxFrameInterval is sent as 0, default values from EDID will be used."] + pub maxFrameInterval: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Ensure the alignment is 8 bytes and reserve it for future use."] + pub reserved1: NvU32, + #[doc = "!< [in] maximum frame interval in nano seconds.\n!< If maxFrameIntervalNs is sent as 0, default values from EDID will be used."] + pub maxFrameIntervalNs: NvU64, + #[doc = "!< reserved for future use."] + pub reservedEx: [NvU32; 4usize], +} +impl _NV_SET_ADAPTIVE_SYNC_DATA_V1 { + #[inline] + pub fn bDisableAdaptiveSync(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bDisableAdaptiveSync(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bDisableAdaptiveSync_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bDisableAdaptiveSync_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bDisableFrameSplitting(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bDisableFrameSplitting(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bDisableFrameSplitting_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bDisableFrameSplitting_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 30u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 30u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 30u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bDisableAdaptiveSync: NvU32, + bDisableFrameSplitting: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bDisableAdaptiveSync: u32 = unsafe { ::std::mem::transmute(bDisableAdaptiveSync) }; + bDisableAdaptiveSync as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bDisableFrameSplitting: u32 = + unsafe { ::std::mem::transmute(bDisableFrameSplitting) }; + bDisableFrameSplitting as u64 + }); + __bindgen_bitfield_unit.set(2usize, 30u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_SET_ADAPTIVE_SYNC_DATA_V1 = _NV_SET_ADAPTIVE_SYNC_DATA_V1; +pub type NV_SET_ADAPTIVE_SYNC_DATA = NV_SET_ADAPTIVE_SYNC_DATA_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GET_VIRTUAL_REFRESH_RATE_DATA_V1 { + #[doc = "!< [in] structure version"] + pub version: NvU32, + #[doc = "!< [out] frame interval in micro seconds if Virtual RR is currently applied"] + pub frameIntervalUs: NvU32, + #[doc = "!< [out] Refresh Rate * 1000"] + pub rrx1k: NvU32, + #[doc = "!< [out] If the content is Gaming"] + pub bIsGamingVrr: NvU32, + #[doc = "!< reserved for future use."] + pub reservedEx: [NvU32; 6usize], +} +pub type NV_GET_VIRTUAL_REFRESH_RATE_DATA_V1 = _NV_GET_VIRTUAL_REFRESH_RATE_DATA_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GET_VIRTUAL_REFRESH_RATE_DATA_V2 { + #[doc = "!< [in] structure version"] + pub version: NvU32, + #[doc = "!< [out] frame interval in micro seconds if Virtual RR is currently applied. This variable is deprecated in V2 and should not be used."] + pub frameIntervalUs: NvU32, + #[doc = "!< [out] Refresh Rate * 1000"] + pub rrx1k: NvU32, + #[doc = "!< [out] If the content is Gaming"] + pub bIsGamingVrr: NvU32, + #[doc = "!< [out] frame interval in nano seconds if Virtual RR is currently applied"] + pub frameIntervalNs: NvU64, + #[doc = "!< reserved for future use."] + pub reservedEx: [NvU32; 4usize], +} +pub type NV_GET_VIRTUAL_REFRESH_RATE_DATA_V2 = _NV_GET_VIRTUAL_REFRESH_RATE_DATA_V2; +pub type NV_GET_VIRTUAL_REFRESH_RATE_DATA = NV_GET_VIRTUAL_REFRESH_RATE_DATA_V2; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_SET_VIRTUAL_REFRESH_RATE_DATA_V1 { + #[doc = "!< [in] structure version"] + pub version: NvU32, + #[doc = "!< [in] frame interval in micro seconds if Virtual RR is currently applied"] + pub frameIntervalUs: NvU32, + #[doc = "!< [in] Refresh Rate * 1000"] + pub rrx1k: NvU32, + #[doc = "!< [in] If the content is Gaming"] + pub bIsGamingVrr: NvU32, + #[doc = "!< reserved for future use."] + pub reservedEx: [NvU32; 6usize], +} +pub type NV_SET_VIRTUAL_REFRESH_RATE_DATA_V1 = _NV_SET_VIRTUAL_REFRESH_RATE_DATA_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_SET_VIRTUAL_REFRESH_RATE_DATA_V2 { + #[doc = "!< [in] structure version"] + pub version: NvU32, + #[doc = "!< [in] frame interval in micro seconds if Virtual RR is currently applied. This variable is deprecated in V2 and should not be used."] + pub frameIntervalUs: NvU32, + #[doc = "!< [in] Refresh Rate * 1000"] + pub rrx1k: NvU32, + #[doc = "!< [in] If the content is Gaming"] + pub bIsGamingVrr: NvU32, + #[doc = "!< [in] frame interval in nano seconds if Virtual RR is currently applied"] + pub frameIntervalNs: NvU64, + #[doc = "!< reserved for future use."] + pub reservedEx: [NvU32; 4usize], +} +pub type NV_SET_VIRTUAL_REFRESH_RATE_DATA_V2 = _NV_SET_VIRTUAL_REFRESH_RATE_DATA_V2; +pub type NV_SET_VIRTUAL_REFRESH_RATE_DATA = NV_SET_VIRTUAL_REFRESH_RATE_DATA_V2; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_SET_PREFERRED_STEREO_DISPLAY_V1 { + #[doc = "!< [in] Structure version"] + pub version: NvU32, + #[doc = "!< [in] Monitor Identifier to be set"] + pub displayId: NvU32, + #[doc = "!< Reserved for future use without adding versioning"] + pub reserved: NvU32, +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_SET_PREFERRED_STEREO_DISPLAY = NV_SET_PREFERRED_STEREO_DISPLAY_V1; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GET_PREFERRED_STEREO_DISPLAY_V1 { + #[doc = "!< [in] Structure version"] + pub version: NvU32, + #[doc = "!< [out] The queried stereo display"] + pub displayId: NvU32, + #[doc = "!< Reserved for future use without adding versioning"] + pub reserved: NvU32, +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_GET_PREFERRED_STEREO_DISPLAY = NV_GET_PREFERRED_STEREO_DISPLAY_V1; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_DISPLAY_ID_INFO_DATA_V1 { + #[doc = "!< [in] Structure version"] + pub version: NvU32, + #[doc = "!< [out] Locally unique ID (LUID) of the display adapter on which the given display is present."] + pub adapterId: LUID, + #[doc = "!< [out] The target identifier of the given display. This is also called AdapterRelativeId."] + pub targetId: NvU32, + #[doc = "!< Reserved for future use."] + pub reserved: [NvU32; 4usize], +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_DISPLAY_ID_INFO_DATA_V1 = _NV_DISPLAY_ID_INFO_DATA_V1; +#[doc = "! \\ingroup dispcontrol"] +pub type NV_DISPLAY_ID_INFO_DATA = NV_DISPLAY_ID_INFO_DATA_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_TARGET_INFO_DATA_V1 { + #[doc = "!< [in] Structure version"] + pub version: NvU32, + #[doc = "!< [in] Locally unique ID (LUID) of the display adapter on which the target is present."] + pub adapterId: LUID, + #[doc = "!< [in] The target identifier. This is also called AdapterRelativeId."] + pub targetId: NvU32, + #[doc = "!< [out] An array of displayIds corresponding to the input adapterId and targetId.\n!< If the input (targetId, adapterId) pair is a display grid (Mosaic/Surround),\n!< then the output contains the displayId of every display that is part of the display grid.\n!< Otherwise, it contains exactly one displayId.\n!< These displayId values are unique to this (targetId, adapterId) pair."] + pub displayId: [NvU32; 128usize], + #[doc = "!< [out] The number of displays returned in displayId array."] + pub displayIdCount: NvU32, + #[doc = "!< Reserved for future use."] + pub reserved: [NvU32; 4usize], +} +pub type NV_TARGET_INFO_DATA_V1 = _NV_TARGET_INFO_DATA_V1; +pub type NV_TARGET_INFO_DATA = NV_TARGET_INFO_DATA_V1; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GET_VRR_INFO_V1 { + #[doc = "!< [in] Structure version"] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Reserved for future use"] + pub reservedEx: [NvU32; 4usize], +} +impl _NV_GET_VRR_INFO_V1 { + #[inline] + pub fn bIsVRREnabled(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsVRREnabled(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsVRREnabled_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsVRREnabled_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsVRRPossible(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsVRRPossible(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsVRRPossible_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsVRRPossible_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsVRRRequested(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsVRRRequested(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsVRRRequested_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsVRRRequested_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsVRRIndicatorEnabled(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsVRRIndicatorEnabled(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsVRRIndicatorEnabled_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsVRRIndicatorEnabled_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsDisplayInVRRMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsDisplayInVRRMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsDisplayInVRRMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsDisplayInVRRMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 27u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 27u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 27u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsVRREnabled: NvU32, + bIsVRRPossible: NvU32, + bIsVRRRequested: NvU32, + bIsVRRIndicatorEnabled: NvU32, + bIsDisplayInVRRMode: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsVRREnabled: u32 = unsafe { ::std::mem::transmute(bIsVRREnabled) }; + bIsVRREnabled as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bIsVRRPossible: u32 = unsafe { ::std::mem::transmute(bIsVRRPossible) }; + bIsVRRPossible as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let bIsVRRRequested: u32 = unsafe { ::std::mem::transmute(bIsVRRRequested) }; + bIsVRRRequested as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let bIsVRRIndicatorEnabled: u32 = + unsafe { ::std::mem::transmute(bIsVRRIndicatorEnabled) }; + bIsVRRIndicatorEnabled as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let bIsDisplayInVRRMode: u32 = unsafe { ::std::mem::transmute(bIsDisplayInVRRMode) }; + bIsDisplayInVRRMode as u64 + }); + __bindgen_bitfield_unit.set(5usize, 27u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_GET_VRR_INFO_V1 = _NV_GET_VRR_INFO_V1; +#[doc = "! \\ingroup dispcontrol"] +pub type NV_GET_VRR_INFO = NV_GET_VRR_INFO_V1; +#[doc = "! This structure defines the topology details."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_MOSAIC_TOPO_DETAILS { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Logical GPU for this topology"] + pub hLogicalGPU: NvLogicalGpuHandle, + #[doc = "!< 0 means topology is valid with the current hardware."] + pub validityMask: NvU32, + #[doc = "!< Number of displays in a row"] + pub rowCount: NvU32, + #[doc = "!< Number of displays in a column"] + pub colCount: NvU32, + pub gpuLayout: [[NV_MOSAIC_TOPO_DETAILS__bindgen_ty_1; 8usize]; 8usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_MOSAIC_TOPO_DETAILS__bindgen_ty_1 { + #[doc = "!< Physical GPU to be used in the topology (0 if GPU missing)"] + pub hPhysicalGPU: NvPhysicalGpuHandle, + #[doc = "!< Connected display target (0 if no display connected)"] + pub displayOutputId: NvU32, + #[doc = "!< Pixels of overlap on left of target: (+overlap, -gap)"] + pub overlapX: NvS32, + #[doc = "!< Pixels of overlap on top of target: (+overlap, -gap)"] + pub overlapY: NvS32, +} +#[doc = "!< All mosaic topologies"] +pub const NV_MOSAIC_TOPO_TYPE_NV_MOSAIC_TOPO_TYPE_ALL: NV_MOSAIC_TOPO_TYPE = 0; +#[doc = "!< Basic Mosaic topologies"] +pub const NV_MOSAIC_TOPO_TYPE_NV_MOSAIC_TOPO_TYPE_BASIC: NV_MOSAIC_TOPO_TYPE = 1; +#[doc = "!< Passive Stereo topologies"] +pub const NV_MOSAIC_TOPO_TYPE_NV_MOSAIC_TOPO_TYPE_PASSIVE_STEREO: NV_MOSAIC_TOPO_TYPE = 2; +#[doc = "!< Not supported at this time"] +pub const NV_MOSAIC_TOPO_TYPE_NV_MOSAIC_TOPO_TYPE_SCALED_CLONE: NV_MOSAIC_TOPO_TYPE = 3; +#[doc = "!< Not supported at this time"] +pub const NV_MOSAIC_TOPO_TYPE_NV_MOSAIC_TOPO_TYPE_PASSIVE_STEREO_SCALED_CLONE: NV_MOSAIC_TOPO_TYPE = + 4; +#[doc = "!< Always leave this at end of the enum"] +pub const NV_MOSAIC_TOPO_TYPE_NV_MOSAIC_TOPO_TYPE_MAX: NV_MOSAIC_TOPO_TYPE = 5; +#[doc = "! These values refer to the different types of Mosaic topologies that are possible. When\n! getting the supported Mosaic topologies, you can specify one of these types to narrow down\n! the returned list to only those that match the given type."] +pub type NV_MOSAIC_TOPO_TYPE = ::std::os::raw::c_int; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_NONE: NV_MOSAIC_TOPO = 0; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_BEGIN_BASIC: NV_MOSAIC_TOPO = 1; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x2_BASIC: NV_MOSAIC_TOPO = 1; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_2x1_BASIC: NV_MOSAIC_TOPO = 2; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x3_BASIC: NV_MOSAIC_TOPO = 3; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_3x1_BASIC: NV_MOSAIC_TOPO = 4; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x4_BASIC: NV_MOSAIC_TOPO = 5; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_4x1_BASIC: NV_MOSAIC_TOPO = 6; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_2x2_BASIC: NV_MOSAIC_TOPO = 7; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_2x3_BASIC: NV_MOSAIC_TOPO = 8; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_2x4_BASIC: NV_MOSAIC_TOPO = 9; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_3x2_BASIC: NV_MOSAIC_TOPO = 10; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_4x2_BASIC: NV_MOSAIC_TOPO = 11; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x5_BASIC: NV_MOSAIC_TOPO = 12; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x6_BASIC: NV_MOSAIC_TOPO = 13; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_7x1_BASIC: NV_MOSAIC_TOPO = 14; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_END_BASIC: NV_MOSAIC_TOPO = 23; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_BEGIN_PASSIVE_STEREO: NV_MOSAIC_TOPO = 24; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x2_PASSIVE_STEREO: NV_MOSAIC_TOPO = 24; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_2x1_PASSIVE_STEREO: NV_MOSAIC_TOPO = 25; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x3_PASSIVE_STEREO: NV_MOSAIC_TOPO = 26; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_3x1_PASSIVE_STEREO: NV_MOSAIC_TOPO = 27; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x4_PASSIVE_STEREO: NV_MOSAIC_TOPO = 28; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_4x1_PASSIVE_STEREO: NV_MOSAIC_TOPO = 29; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_2x2_PASSIVE_STEREO: NV_MOSAIC_TOPO = 30; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_END_PASSIVE_STEREO: NV_MOSAIC_TOPO = 34; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_MAX: NV_MOSAIC_TOPO = 35; +#[doc = "! This is a complete list of supported Mosaic topologies.\n!\n! Using a \"Basic\" topology combines multiple monitors to create a single desktop.\n!\n! Using a \"Passive\" topology combines multiples monitors to create a passive stereo desktop.\n! In passive stereo, two identical topologies combine - one topology is used for the right eye and the other identical //! topology (targeting different displays) is used for the left eye. \\n\n! NOTE: common\\inc\\nvEscDef.h shadows a couple PASSIVE_STEREO enums. If this\n! enum list changes and effects the value of NV_MOSAIC_TOPO_BEGIN_PASSIVE_STEREO\n! please update the corresponding value in nvEscDef.h"] +pub type NV_MOSAIC_TOPO = ::std::os::raw::c_int; +#[doc = "! This is a \"topology brief\" structure. It tells you what you need to know about\n! a topology at a high level. A list of these is returned when you query for the\n! supported Mosaic information.\n!\n! If you need more detailed information about the topology, call\n! NvAPI_Mosaic_GetTopoGroup() with the topology value from this structure."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_MOSAIC_TOPO_BRIEF { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< The topology"] + pub topo: NV_MOSAIC_TOPO, + #[doc = "!< 1 if topo is enabled, else 0"] + pub enabled: NvU32, + #[doc = "!< 1 if topo *can* be enabled, else 0"] + pub isPossible: NvU32, +} +#[doc = "! Basic per-display settings that are used in setting/getting the Mosaic mode"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MOSAIC_DISPLAY_SETTING_V1 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Per-display width"] + pub width: NvU32, + #[doc = "!< Per-display height"] + pub height: NvU32, + #[doc = "!< Bits per pixel"] + pub bpp: NvU32, + #[doc = "!< Display frequency"] + pub freq: NvU32, +} +#[doc = "! Basic per-display settings that are used in setting/getting the Mosaic mode"] +pub type NV_MOSAIC_DISPLAY_SETTING_V1 = _NV_MOSAIC_DISPLAY_SETTING_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_MOSAIC_DISPLAY_SETTING_V2 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Per-display width"] + pub width: NvU32, + #[doc = "!< Per-display height"] + pub height: NvU32, + #[doc = "!< Bits per pixel"] + pub bpp: NvU32, + #[doc = "!< Display frequency"] + pub freq: NvU32, + #[doc = "!< Display frequency in x1k"] + pub rrx1k: NvU32, +} +pub type NV_MOSAIC_DISPLAY_SETTING = NV_MOSAIC_DISPLAY_SETTING_V2; +#[doc = "! This structure is used to contain a list of supported Mosaic topologies\n! along with the display settings that can be used."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MOSAIC_SUPPORTED_TOPO_INFO_V1 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Number of topologies in below array"] + pub topoBriefsCount: NvU32, + #[doc = "!< List of supported topologies with only brief details"] + pub topoBriefs: [NV_MOSAIC_TOPO_BRIEF; 35usize], + #[doc = "!< Number of display settings in below array"] + pub displaySettingsCount: NvU32, + #[doc = "!< List of per display settings possible"] + pub displaySettings: [NV_MOSAIC_DISPLAY_SETTING_V1; 40usize], +} +#[doc = "! This structure is used to contain a list of supported Mosaic topologies\n! along with the display settings that can be used."] +pub type NV_MOSAIC_SUPPORTED_TOPO_INFO_V1 = _NV_MOSAIC_SUPPORTED_TOPO_INFO_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MOSAIC_SUPPORTED_TOPO_INFO_V2 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Number of topologies in below array"] + pub topoBriefsCount: NvU32, + #[doc = "!< List of supported topologies with only brief details"] + pub topoBriefs: [NV_MOSAIC_TOPO_BRIEF; 35usize], + #[doc = "!< Number of display settings in below array"] + pub displaySettingsCount: NvU32, + #[doc = "!< List of per display settings possible"] + pub displaySettings: [NV_MOSAIC_DISPLAY_SETTING_V2; 40usize], +} +pub type NV_MOSAIC_SUPPORTED_TOPO_INFO_V2 = _NV_MOSAIC_SUPPORTED_TOPO_INFO_V2; +pub type NV_MOSAIC_SUPPORTED_TOPO_INFO = NV_MOSAIC_SUPPORTED_TOPO_INFO_V2; +#[doc = "! This structure defines a group of topologies that work together to create one\n! overall layout. All of the supported topologies are represented with this\n! structure.\n!\n! For example, a 'Passive Stereo' topology would be represented with this\n! structure, and would have separate topology details for the left and right eyes.\n! The count would be 2. A 'Basic' topology is also represented by this structure,\n! with a count of 1.\n!\n! The structure is primarily used internally, but is exposed to applications in a\n! read-only fashion because there are some details in it that might be useful\n! (like the number of rows/cols, or connected display information). A user can\n! get the filled-in structure by calling NvAPI_Mosaic_GetTopoGroup().\n!\n! You can then look at the detailed values within the structure. There are no\n! entrypoints which take this structure as input (effectively making it read-only)."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_MOSAIC_TOPO_GROUP { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< The brief details of this topo"] + pub brief: NV_MOSAIC_TOPO_BRIEF, + #[doc = "!< Number of topos in array below"] + pub count: NvU32, + pub topos: [NV_MOSAIC_TOPO_DETAILS; 2usize], +} +#[doc = "! \\ingroup mosaicapi\n! @{"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MOSAIC_GRID_TOPO_DISPLAY_V1 { + #[doc = "!< DisplayID of the display"] + pub displayId: NvU32, + #[doc = "!< (+overlap, -gap)"] + pub overlapX: NvS32, + #[doc = "!< (+overlap, -gap)"] + pub overlapY: NvS32, + #[doc = "!< Rotation of display"] + pub rotation: NV_ROTATE, + #[doc = "!< Reserved, must be 0"] + pub cloneGroup: NvU32, +} +#[doc = "! \\ingroup mosaicapi\n! @{"] +pub type NV_MOSAIC_GRID_TOPO_DISPLAY_V1 = _NV_MOSAIC_GRID_TOPO_DISPLAY_V1; +#[doc = "!< No pixel shift will be applied to this display."] +pub const _NV_PIXEL_SHIFT_TYPE_NV_PIXEL_SHIFT_TYPE_NO_PIXEL_SHIFT: _NV_PIXEL_SHIFT_TYPE = 0; +#[doc = "!< This display will be used to scanout top left pixels in 2x2 PixelShift configuration"] +pub const _NV_PIXEL_SHIFT_TYPE_NV_PIXEL_SHIFT_TYPE_2x2_TOP_LEFT_PIXELS: _NV_PIXEL_SHIFT_TYPE = 1; +#[doc = "!< This display will be used to scanout bottom right pixels in 2x2 PixelShift configuration"] +pub const _NV_PIXEL_SHIFT_TYPE_NV_PIXEL_SHIFT_TYPE_2x2_BOTTOM_RIGHT_PIXELS: _NV_PIXEL_SHIFT_TYPE = + 2; +#[doc = "!< This display will be used to scanout top right pixels in 2x2 PixelShift configuration"] +pub const _NV_PIXEL_SHIFT_TYPE_NV_PIXEL_SHIFT_TYPE_2x2_TOP_RIGHT_PIXELS: _NV_PIXEL_SHIFT_TYPE = 4; +#[doc = "!< This display will be used to scanout bottom left pixels in 2x2 PixelShift configuration"] +pub const _NV_PIXEL_SHIFT_TYPE_NV_PIXEL_SHIFT_TYPE_2x2_BOTTOM_LEFT_PIXELS: _NV_PIXEL_SHIFT_TYPE = 8; +pub type _NV_PIXEL_SHIFT_TYPE = ::std::os::raw::c_int; +pub use self::_NV_PIXEL_SHIFT_TYPE as NV_PIXEL_SHIFT_TYPE; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MOSAIC_GRID_TOPO_DISPLAY_V2 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< DisplayID of the display"] + pub displayId: NvU32, + #[doc = "!< (+overlap, -gap)"] + pub overlapX: NvS32, + #[doc = "!< (+overlap, -gap)"] + pub overlapY: NvS32, + #[doc = "!< Rotation of display"] + pub rotation: NV_ROTATE, + #[doc = "!< Reserved, must be 0"] + pub cloneGroup: NvU32, + #[doc = "!< Type of the pixel shift enabled display"] + pub pixelShiftType: NV_PIXEL_SHIFT_TYPE, +} +pub type NV_MOSAIC_GRID_TOPO_DISPLAY_V2 = _NV_MOSAIC_GRID_TOPO_DISPLAY_V2; +#[doc = "! \\ingroup mosaicapi\n! @{"] +pub type NV_MOSAIC_GRID_TOPO_DISPLAY = NV_MOSAIC_GRID_TOPO_DISPLAY_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MOSAIC_GRID_TOPO_V1 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Number of rows"] + pub rows: NvU32, + #[doc = "!< Number of columns"] + pub columns: NvU32, + #[doc = "!< Number of display details"] + pub displayCount: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Displays are done as [(row * columns) + column]"] + pub displays: [NV_MOSAIC_GRID_TOPO_DISPLAY_V1; 64usize], + #[doc = "!< Display settings"] + pub displaySettings: NV_MOSAIC_DISPLAY_SETTING_V1, +} +impl _NV_MOSAIC_GRID_TOPO_V1 { + #[inline] + pub fn applyWithBezelCorrect(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_applyWithBezelCorrect(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn applyWithBezelCorrect_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_applyWithBezelCorrect_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn immersiveGaming(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_immersiveGaming(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn immersiveGaming_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_immersiveGaming_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn baseMosaic(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_baseMosaic(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn baseMosaic_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_baseMosaic_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn driverReloadAllowed(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_driverReloadAllowed(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn driverReloadAllowed_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_driverReloadAllowed_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn acceleratePrimaryDisplay(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_acceleratePrimaryDisplay(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn acceleratePrimaryDisplay_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_acceleratePrimaryDisplay_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 27u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 27u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 27u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + applyWithBezelCorrect: NvU32, + immersiveGaming: NvU32, + baseMosaic: NvU32, + driverReloadAllowed: NvU32, + acceleratePrimaryDisplay: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let applyWithBezelCorrect: u32 = + unsafe { ::std::mem::transmute(applyWithBezelCorrect) }; + applyWithBezelCorrect as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let immersiveGaming: u32 = unsafe { ::std::mem::transmute(immersiveGaming) }; + immersiveGaming as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let baseMosaic: u32 = unsafe { ::std::mem::transmute(baseMosaic) }; + baseMosaic as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let driverReloadAllowed: u32 = unsafe { ::std::mem::transmute(driverReloadAllowed) }; + driverReloadAllowed as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let acceleratePrimaryDisplay: u32 = + unsafe { ::std::mem::transmute(acceleratePrimaryDisplay) }; + acceleratePrimaryDisplay as u64 + }); + __bindgen_bitfield_unit.set(5usize, 27u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_MOSAIC_GRID_TOPO_V1 = _NV_MOSAIC_GRID_TOPO_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MOSAIC_GRID_TOPO_V2 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Number of rows"] + pub rows: NvU32, + #[doc = "!< Number of columns"] + pub columns: NvU32, + #[doc = "!< Number of display details"] + pub displayCount: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Displays are done as [(row * columns) + column]"] + pub displays: [NV_MOSAIC_GRID_TOPO_DISPLAY_V2; 64usize], + #[doc = "!< Display settings"] + pub displaySettings: NV_MOSAIC_DISPLAY_SETTING_V1, +} +impl _NV_MOSAIC_GRID_TOPO_V2 { + #[inline] + pub fn applyWithBezelCorrect(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_applyWithBezelCorrect(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn applyWithBezelCorrect_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_applyWithBezelCorrect_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn immersiveGaming(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_immersiveGaming(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn immersiveGaming_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_immersiveGaming_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn baseMosaic(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_baseMosaic(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn baseMosaic_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_baseMosaic_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn driverReloadAllowed(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_driverReloadAllowed(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn driverReloadAllowed_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_driverReloadAllowed_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn acceleratePrimaryDisplay(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_acceleratePrimaryDisplay(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn acceleratePrimaryDisplay_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_acceleratePrimaryDisplay_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn pixelShift(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_pixelShift(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn pixelShift_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_pixelShift_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 26u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 26u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 6usize, + 26u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 26u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + applyWithBezelCorrect: NvU32, + immersiveGaming: NvU32, + baseMosaic: NvU32, + driverReloadAllowed: NvU32, + acceleratePrimaryDisplay: NvU32, + pixelShift: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let applyWithBezelCorrect: u32 = + unsafe { ::std::mem::transmute(applyWithBezelCorrect) }; + applyWithBezelCorrect as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let immersiveGaming: u32 = unsafe { ::std::mem::transmute(immersiveGaming) }; + immersiveGaming as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let baseMosaic: u32 = unsafe { ::std::mem::transmute(baseMosaic) }; + baseMosaic as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let driverReloadAllowed: u32 = unsafe { ::std::mem::transmute(driverReloadAllowed) }; + driverReloadAllowed as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let acceleratePrimaryDisplay: u32 = + unsafe { ::std::mem::transmute(acceleratePrimaryDisplay) }; + acceleratePrimaryDisplay as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let pixelShift: u32 = unsafe { ::std::mem::transmute(pixelShift) }; + pixelShift as u64 + }); + __bindgen_bitfield_unit.set(6usize, 26u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_MOSAIC_GRID_TOPO_V2 = _NV_MOSAIC_GRID_TOPO_V2; +pub type NV_MOSAIC_GRID_TOPO = NV_MOSAIC_GRID_TOPO_V2; +#[doc = "! \\ingroup mosaicapi"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_MOSAIC_DISPLAY_TOPO_STATUS { + pub version: NvU32, + #[doc = "!< (OUT) Any of the NV_MOSAIC_DISPLAYTOPO_ERROR_* flags."] + pub errorFlags: NvU32, + #[doc = "!< (OUT) Any of the NV_MOSAIC_DISPLAYTOPO_WARNING_* flags."] + pub warningFlags: NvU32, + #[doc = "!< (OUT) The number of valid entries in the displays array."] + pub displayCount: NvU32, + pub displays: [NV_MOSAIC_DISPLAY_TOPO_STATUS__bindgen_ty_1; 128usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_MOSAIC_DISPLAY_TOPO_STATUS__bindgen_ty_1 { + #[doc = "!< (OUT) The DisplayID of this display."] + pub displayId: NvU32, + #[doc = "!< (OUT) Any of the NV_MOSAIC_DISPLAYCAPS_PROBLEM_* flags."] + pub errorFlags: NvU32, + #[doc = "!< (OUT) Any of the NV_MOSAIC_DISPLAYTOPO_WARNING_* flags."] + pub warningFlags: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl NV_MOSAIC_DISPLAY_TOPO_STATUS__bindgen_ty_1 { + #[inline] + pub fn supportsRotation(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_supportsRotation(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supportsRotation_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_supportsRotation_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + supportsRotation: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let supportsRotation: u32 = unsafe { ::std::mem::transmute(supportsRotation) }; + supportsRotation as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! Used in NvAPI_GetCurrentMosaicTopology() and NvAPI_SetCurrentMosaicTopology()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_MOSAIC_TOPOLOGY { + #[doc = "!< Version number of the mosaic topology"] + pub version: NvU32, + #[doc = "!< Horizontal display count"] + pub rowCount: NvU32, + #[doc = "!< Vertical display count"] + pub colCount: NvU32, + pub gpuLayout: [[NV_MOSAIC_TOPOLOGY__bindgen_ty_1; 8usize]; 8usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_MOSAIC_TOPOLOGY__bindgen_ty_1 { + #[doc = "!< Physical GPU to be used in the topology"] + pub hPhysicalGPU: NvPhysicalGpuHandle, + #[doc = "!< Connected display target"] + pub displayOutputId: NvU32, + #[doc = "!< Pixels of overlap on the left of target: (+overlap, -gap)"] + pub overlapX: NvS32, + #[doc = "!< Pixels of overlap on the top of target: (+overlap, -gap)"] + pub overlapY: NvS32, +} +#[doc = "! Used in NvAPI_GetSupportedMosaicTopologies()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_MOSAIC_SUPPORTED_TOPOLOGIES { + pub version: NvU32, + #[doc = "!< Count of valid topologies"] + pub totalCount: NvU32, + #[doc = "!< Maximum number of topologies"] + pub topos: [NV_MOSAIC_TOPOLOGY; 16usize], +} +#[doc = "! Used in NvAPI_GSync_QueryCapabilities()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GSYNC_CAPABILITIES_V1 { + #[doc = "!< Version of the structure"] + pub version: NvU32, + #[doc = "!< Board ID"] + pub boardId: NvU32, + #[doc = "!< FPGA Revision"] + pub revision: NvU32, + #[doc = "!< Capabilities of the Sync board. Reserved for future use"] + pub capFlags: NvU32, +} +#[doc = "! Used in NvAPI_GSync_QueryCapabilities()."] +pub type NV_GSYNC_CAPABILITIES_V1 = _NV_GSYNC_CAPABILITIES_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GSYNC_CAPABILITIES_V2 { + #[doc = "!< Version of the structure"] + pub version: NvU32, + #[doc = "!< Board ID"] + pub boardId: NvU32, + #[doc = "!< FPGA major revision"] + pub revision: NvU32, + #[doc = "!< Capabilities of the Sync board. Reserved for future use"] + pub capFlags: NvU32, + #[doc = "!< FPGA minor revision"] + pub extendedRevision: NvU32, +} +pub type NV_GSYNC_CAPABILITIES_V2 = _NV_GSYNC_CAPABILITIES_V2; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GSYNC_CAPABILITIES_V3 { + #[doc = "!< Version of the structure"] + pub version: NvU32, + #[doc = "!< Board ID"] + pub boardId: NvU32, + #[doc = "!< FPGA major revision"] + pub revision: NvU32, + #[doc = "!< Capabilities of the Sync board. Reserved for future use"] + pub capFlags: NvU32, + #[doc = "!< FPGA minor revision"] + pub extendedRevision: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< This parameter returns the maximum possible value that can be programmed\n!< for multiplying / dividing house sync. Only valid if bIsMulDivSupported is set to 1."] + pub maxMulDivValue: NvU32, +} +impl _NV_GSYNC_CAPABILITIES_V3 { + #[inline] + pub fn bIsMulDivSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsMulDivSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsMulDivSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsMulDivSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsMulDivSupported: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsMulDivSupported: u32 = unsafe { ::std::mem::transmute(bIsMulDivSupported) }; + bIsMulDivSupported as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_GSYNC_CAPABILITIES_V3 = _NV_GSYNC_CAPABILITIES_V3; +pub type NV_GSYNC_CAPABILITIES = NV_GSYNC_CAPABILITIES_V3; +pub const _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_NONE: + _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR = 0; +pub const _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_PRIMARY: + _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR = 1; +pub const _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_SECONDARY: + _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR = 2; +pub const _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_TERTIARY: + _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR = 3; +pub const _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_QUARTERNARY: + _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR = 4; +#[doc = "! Connector values for a GPU. Used in NV_GSYNC_GPU."] +pub type _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR = ::std::os::raw::c_int; +#[doc = "! Connector values for a GPU. Used in NV_GSYNC_GPU."] +pub use self::_NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR as NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR; +pub const _NVAPI_GSYNC_DISPLAY_SYNC_STATE_NVAPI_GSYNC_DISPLAY_SYNC_STATE_UNSYNCED: + _NVAPI_GSYNC_DISPLAY_SYNC_STATE = 0; +pub const _NVAPI_GSYNC_DISPLAY_SYNC_STATE_NVAPI_GSYNC_DISPLAY_SYNC_STATE_SLAVE: + _NVAPI_GSYNC_DISPLAY_SYNC_STATE = 1; +pub const _NVAPI_GSYNC_DISPLAY_SYNC_STATE_NVAPI_GSYNC_DISPLAY_SYNC_STATE_MASTER: + _NVAPI_GSYNC_DISPLAY_SYNC_STATE = 2; +#[doc = "! Display sync states. Used in NV_GSYNC_DISPLAY."] +pub type _NVAPI_GSYNC_DISPLAY_SYNC_STATE = ::std::os::raw::c_int; +#[doc = "! Display sync states. Used in NV_GSYNC_DISPLAY."] +pub use self::_NVAPI_GSYNC_DISPLAY_SYNC_STATE as NVAPI_GSYNC_DISPLAY_SYNC_STATE; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GSYNC_GPU { + #[doc = "!< Version of the structure"] + pub version: NvU32, + #[doc = "!< GPU handle"] + pub hPhysicalGpu: NvPhysicalGpuHandle, + #[doc = "!< Indicates which connector on the device the GPU is connected to."] + pub connector: NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR, + #[doc = "!< GPU through which hPhysicalGpu is connected to the Sync device (if not directly connected)\n!< - this is NULL otherwise"] + pub hProxyPhysicalGpu: NvPhysicalGpuHandle, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + pub __bindgen_padding_0: u32, +} +impl _NV_GSYNC_GPU { + #[inline] + pub fn isSynced(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isSynced(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isSynced_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isSynced_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1(isSynced: NvU32, reserved: NvU32) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isSynced: u32 = unsafe { ::std::mem::transmute(isSynced) }; + isSynced as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_GSYNC_GPU = _NV_GSYNC_GPU; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GSYNC_DISPLAY { + #[doc = "!< Version of the structure"] + pub version: NvU32, + #[doc = "!< display identifier for displays.The GPU to which it is connected, can be retireved from NvAPI_SYS_GetPhysicalGpuFromDisplayId"] + pub displayId: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Is this display slave/master\n!< (Retrieved with topology or set by caller for enable/disable sync)"] + pub syncState: NVAPI_GSYNC_DISPLAY_SYNC_STATE, +} +impl _NV_GSYNC_DISPLAY { + #[inline] + pub fn isMasterable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMasterable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMasterable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMasterable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isMasterable: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isMasterable: u32 = unsafe { ::std::mem::transmute(isMasterable) }; + isMasterable as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_GSYNC_DISPLAY = _NV_GSYNC_DISPLAY; +pub const _NVAPI_GSYNC_POLARITY_NVAPI_GSYNC_POLARITY_RISING_EDGE: _NVAPI_GSYNC_POLARITY = 0; +pub const _NVAPI_GSYNC_POLARITY_NVAPI_GSYNC_POLARITY_FALLING_EDGE: _NVAPI_GSYNC_POLARITY = 1; +pub const _NVAPI_GSYNC_POLARITY_NVAPI_GSYNC_POLARITY_BOTH_EDGES: _NVAPI_GSYNC_POLARITY = 2; +#[doc = "! Source signal edge to be used for output pulse. See NV_GSYNC_CONTROL_PARAMS."] +pub type _NVAPI_GSYNC_POLARITY = ::std::os::raw::c_int; +#[doc = "! Source signal edge to be used for output pulse. See NV_GSYNC_CONTROL_PARAMS."] +pub use self::_NVAPI_GSYNC_POLARITY as NVAPI_GSYNC_POLARITY; +pub const _NVAPI_GSYNC_VIDEO_MODE_NVAPI_GSYNC_VIDEO_MODE_NONE: _NVAPI_GSYNC_VIDEO_MODE = 0; +pub const _NVAPI_GSYNC_VIDEO_MODE_NVAPI_GSYNC_VIDEO_MODE_TTL: _NVAPI_GSYNC_VIDEO_MODE = 1; +pub const _NVAPI_GSYNC_VIDEO_MODE_NVAPI_GSYNC_VIDEO_MODE_NTSCPALSECAM: _NVAPI_GSYNC_VIDEO_MODE = 2; +pub const _NVAPI_GSYNC_VIDEO_MODE_NVAPI_GSYNC_VIDEO_MODE_HDTV: _NVAPI_GSYNC_VIDEO_MODE = 3; +pub const _NVAPI_GSYNC_VIDEO_MODE_NVAPI_GSYNC_VIDEO_MODE_COMPOSITE: _NVAPI_GSYNC_VIDEO_MODE = 4; +#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] +pub type _NVAPI_GSYNC_VIDEO_MODE = ::std::os::raw::c_int; +#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] +pub use self::_NVAPI_GSYNC_VIDEO_MODE as NVAPI_GSYNC_VIDEO_MODE; +pub const _NVAPI_GSYNC_SYNC_SOURCE_NVAPI_GSYNC_SYNC_SOURCE_VSYNC: _NVAPI_GSYNC_SYNC_SOURCE = 0; +pub const _NVAPI_GSYNC_SYNC_SOURCE_NVAPI_GSYNC_SYNC_SOURCE_HOUSESYNC: _NVAPI_GSYNC_SYNC_SOURCE = 1; +#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] +pub type _NVAPI_GSYNC_SYNC_SOURCE = ::std::os::raw::c_int; +#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] +pub use self::_NVAPI_GSYNC_SYNC_SOURCE as NVAPI_GSYNC_SYNC_SOURCE; +#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GSYNC_DELAY { + #[doc = "!< Version of the structure"] + pub version: NvU32, + #[doc = "!< delay to be induced in number of horizontal lines."] + pub numLines: NvU32, + #[doc = "!< delay to be induced in number of pixels."] + pub numPixels: NvU32, + #[doc = "!< maximum number of lines supported at current display mode to induce delay. Updated by NvAPI_GSync_GetControlParameters(). Read only."] + pub maxLines: NvU32, + #[doc = "!< minimum number of pixels required at current display mode to induce delay. Updated by NvAPI_GSync_GetControlParameters(). Read only."] + pub minPixels: NvU32, +} +#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] +pub type NV_GSYNC_DELAY = _NV_GSYNC_DELAY; +#[doc = "! Used in NvAPI_GSync_GetControlParameters() and NvAPI_GSync_SetControlParameters()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GSYNC_CONTROL_PARAMS_V1 { + #[doc = "!< Version of the structure"] + pub version: NvU32, + #[doc = "!< Leading edge / Falling edge / both"] + pub polarity: NVAPI_GSYNC_POLARITY, + #[doc = "!< None, TTL, NTSCPALSECAM, HDTV"] + pub vmode: NVAPI_GSYNC_VIDEO_MODE, + #[doc = "!< Number of pulses to wait between framelock signal generation"] + pub interval: NvU32, + #[doc = "!< VSync/House sync"] + pub source: NVAPI_GSYNC_SYNC_SOURCE, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< The time delay between the frame sync signal and the GPUs signal."] + pub syncSkew: NV_GSYNC_DELAY, + #[doc = "!< Sync start delay for master."] + pub startupDelay: NV_GSYNC_DELAY, +} +impl _NV_GSYNC_CONTROL_PARAMS_V1 { + #[inline] + pub fn interlaceMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_interlaceMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn interlaceMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_interlaceMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn syncSourceIsOutput(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_syncSourceIsOutput(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn syncSourceIsOutput_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_syncSourceIsOutput_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 30u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 30u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 30u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + interlaceMode: NvU32, + syncSourceIsOutput: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let interlaceMode: u32 = unsafe { ::std::mem::transmute(interlaceMode) }; + interlaceMode as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let syncSourceIsOutput: u32 = unsafe { ::std::mem::transmute(syncSourceIsOutput) }; + syncSourceIsOutput as u64 + }); + __bindgen_bitfield_unit.set(2usize, 30u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! Used in NvAPI_GSync_GetControlParameters() and NvAPI_GSync_SetControlParameters()."] +pub type NV_GSYNC_CONTROL_PARAMS_V1 = _NV_GSYNC_CONTROL_PARAMS_V1; +pub const _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE_NVAPI_GSYNC_UNDEFINED_MODE: + _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE = 0; +pub const _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE_NVAPI_GSYNC_MULTIPLY_MODE: + _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE = 1; +pub const _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE_NVAPI_GSYNC_DIVIDE_MODE: + _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE = 2; +#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] +pub type _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE = ::std::os::raw::c_int; +#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] +pub use self::_NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE as NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GSYNC_CONTROL_PARAMS_V2 { + #[doc = "!< Version of the structure"] + pub version: NvU32, + #[doc = "!< Leading edge / Falling edge / both"] + pub polarity: NVAPI_GSYNC_POLARITY, + #[doc = "!< None, TTL, NTSCPALSECAM, HDTV"] + pub vmode: NVAPI_GSYNC_VIDEO_MODE, + #[doc = "!< Number of pulses to wait between framelock signal generation"] + pub interval: NvU32, + #[doc = "!< VSync/House sync"] + pub source: NVAPI_GSYNC_SYNC_SOURCE, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< The time delay between the frame sync signal and the GPUs signal."] + pub syncSkew: NV_GSYNC_DELAY, + #[doc = "!< Sync start delay for master."] + pub startupDelay: NV_GSYNC_DELAY, + #[doc = "!< Indicates multiplier/divider mode for the housesync signal.\n!< While setting multiplyDivideMode, source needs to be set as NVAPI_GSYNC_SYNC_SOURCE_HOUSESYNC."] + pub multiplyDivideMode: NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE, + #[doc = "!< Indicates the multiplier/divider value for the housesync signal. Only supported if bIsMulDivSupported field of the structure NV_GSYNC_CAPABILITIES is set to 1.\n!< The maximum supported value for this field can be obtained from maxMulDivValue field of the structure NV_GSYNC_CAPABILITIES."] + pub multiplyDivideValue: NvU8, +} +impl _NV_GSYNC_CONTROL_PARAMS_V2 { + #[inline] + pub fn interlaceMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_interlaceMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn interlaceMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_interlaceMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn syncSourceIsOutput(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_syncSourceIsOutput(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn syncSourceIsOutput_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_syncSourceIsOutput_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 30u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 30u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 30u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + interlaceMode: NvU32, + syncSourceIsOutput: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let interlaceMode: u32 = unsafe { ::std::mem::transmute(interlaceMode) }; + interlaceMode as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let syncSourceIsOutput: u32 = unsafe { ::std::mem::transmute(syncSourceIsOutput) }; + syncSourceIsOutput as u64 + }); + __bindgen_bitfield_unit.set(2usize, 30u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_GSYNC_CONTROL_PARAMS_V2 = _NV_GSYNC_CONTROL_PARAMS_V2; +pub type NV_GSYNC_CONTROL_PARAMS = NV_GSYNC_CONTROL_PARAMS_V2; +#[doc = "! Used in NvAPI_GSync_GetSyncStatus()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GSYNC_STATUS { + #[doc = "!< Version of the structure"] + pub version: NvU32, + #[doc = "!< Is timing in sync?"] + pub bIsSynced: NvU32, + #[doc = "!< Does the phase of the timing signal from the GPU = the phase of the master sync signal?"] + pub bIsStereoSynced: NvU32, + #[doc = "!< Is the sync signal available?"] + pub bIsSyncSignalAvailable: NvU32, +} +#[doc = "! Used in NvAPI_GSync_GetSyncStatus()."] +pub type NV_GSYNC_STATUS = _NV_GSYNC_STATUS; +pub const _NVAPI_GSYNC_RJ45_IO_NVAPI_GSYNC_RJ45_OUTPUT: _NVAPI_GSYNC_RJ45_IO = 0; +pub const _NVAPI_GSYNC_RJ45_IO_NVAPI_GSYNC_RJ45_INPUT: _NVAPI_GSYNC_RJ45_IO = 1; +#[doc = "!< This field is used to notify that the framelock is not actually present."] +pub const _NVAPI_GSYNC_RJ45_IO_NVAPI_GSYNC_RJ45_UNUSED: _NVAPI_GSYNC_RJ45_IO = 2; +#[doc = "! Used in NV_GSYNC_STATUS_PARAMS."] +pub type _NVAPI_GSYNC_RJ45_IO = ::std::os::raw::c_int; +#[doc = "! Used in NV_GSYNC_STATUS_PARAMS."] +pub use self::_NVAPI_GSYNC_RJ45_IO as NVAPI_GSYNC_RJ45_IO; +#[doc = "! \\ingroup gsyncapi\n! Used in NvAPI_GSync_GetStatusParameters()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GSYNC_STATUS_PARAMS_V1 { + pub version: NvU32, + #[doc = "!< The refresh rate"] + pub refreshRate: NvU32, + #[doc = "!< Configured as input / output"] + pub RJ45_IO: [NVAPI_GSYNC_RJ45_IO; 2usize], + #[doc = "!< Connected to ethernet hub? [ERRONEOUSLY CONNECTED!]"] + pub RJ45_Ethernet: [NvU32; 2usize], + #[doc = "!< Incoming house sync frequency in Hz"] + pub houseSyncIncoming: NvU32, + #[doc = "!< Is house sync connected?"] + pub bHouseSync: NvU32, +} +#[doc = "! \\ingroup gsyncapi\n! Used in NvAPI_GSync_GetStatusParameters()."] +pub type NV_GSYNC_STATUS_PARAMS_V1 = _NV_GSYNC_STATUS_PARAMS_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GSYNC_STATUS_PARAMS_V2 { + pub version: NvU32, + #[doc = "!< The refresh rate"] + pub refreshRate: NvU32, + #[doc = "!< Configured as input / output"] + pub RJ45_IO: [NVAPI_GSYNC_RJ45_IO; 2usize], + #[doc = "!< Connected to ethernet hub? [ERRONEOUSLY CONNECTED!]"] + pub RJ45_Ethernet: [NvU32; 2usize], + #[doc = "!< Incoming house sync frequency in Hz"] + pub houseSyncIncoming: NvU32, + #[doc = "!< Is house sync connected?"] + pub bHouseSync: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl _NV_GSYNC_STATUS_PARAMS_V2 { + #[inline] + pub fn bInternalSlave(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bInternalSlave(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bInternalSlave_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bInternalSlave_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bInternalSlave: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bInternalSlave: u32 = unsafe { ::std::mem::transmute(bInternalSlave) }; + bInternalSlave as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_GSYNC_STATUS_PARAMS_V2 = _NV_GSYNC_STATUS_PARAMS_V2; +pub type NV_GSYNC_STATUS_PARAMS = NV_GSYNC_STATUS_PARAMS_V2; +pub const _NV_RESOLVE_MODE_NV_RESOLVE_MODE_SAMPLE_0: _NV_RESOLVE_MODE = 0; +#[doc = "! \\ingroup dx\n! Valid modes for NvAPI_D3D11_ResolveSubresourceRegion() and NvAPI_D3D12_ResolveSubresourceRegion"] +pub type _NV_RESOLVE_MODE = ::std::os::raw::c_int; +#[doc = "! \\ingroup dx\n! Valid modes for NvAPI_D3D11_ResolveSubresourceRegion() and NvAPI_D3D12_ResolveSubresourceRegion"] +pub use self::_NV_RESOLVE_MODE as NV_RESOLVE_MODE; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of Single Pass Stereo HW feature\n! \\ingroup dx"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V1 { + pub version: NvU32, + pub bSinglePassStereoSupported: NvU32, +} +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of Single Pass Stereo HW feature\n! \\ingroup dx"] +pub type NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V1 = + _NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V2 { + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl _NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V2 { + #[inline] + pub fn bSinglePassStereoSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bSinglePassStereoSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bSinglePassStereoSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bSinglePassStereoSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bSinglePassStereoXYZWSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bSinglePassStereoXYZWSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bSinglePassStereoXYZWSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bSinglePassStereoXYZWSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 30u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 30u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 30u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bSinglePassStereoSupported: NvU32, + bSinglePassStereoXYZWSupported: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bSinglePassStereoSupported: u32 = + unsafe { ::std::mem::transmute(bSinglePassStereoSupported) }; + bSinglePassStereoSupported as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bSinglePassStereoXYZWSupported: u32 = + unsafe { ::std::mem::transmute(bSinglePassStereoXYZWSupported) }; + bSinglePassStereoXYZWSupported as u64 + }); + __bindgen_bitfield_unit.set(2usize, 30u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V2 = + _NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V2; +pub type NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS = NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V2; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of MultiView HW feature\n! \\ingroup dx"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_QUERY_MULTIVIEW_SUPPORT_PARAMS_V1 { + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl _NV_QUERY_MULTIVIEW_SUPPORT_PARAMS_V1 { + #[inline] + pub fn bMultiViewSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bMultiViewSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bMultiViewSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bMultiViewSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bSinglePassStereoSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bSinglePassStereoSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bSinglePassStereoSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bSinglePassStereoSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bSinglePassStereoXYZWSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_bSinglePassStereoXYZWSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bSinglePassStereoXYZWSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bSinglePassStereoXYZWSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 29u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 29u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 29u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 29u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bMultiViewSupported: NvU32, + bSinglePassStereoSupported: NvU32, + bSinglePassStereoXYZWSupported: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bMultiViewSupported: u32 = unsafe { ::std::mem::transmute(bMultiViewSupported) }; + bMultiViewSupported as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bSinglePassStereoSupported: u32 = + unsafe { ::std::mem::transmute(bSinglePassStereoSupported) }; + bSinglePassStereoSupported as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let bSinglePassStereoXYZWSupported: u32 = + unsafe { ::std::mem::transmute(bSinglePassStereoXYZWSupported) }; + bSinglePassStereoXYZWSupported as u64 + }); + __bindgen_bitfield_unit.set(3usize, 29u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of MultiView HW feature\n! \\ingroup dx"] +pub type NV_QUERY_MULTIVIEW_SUPPORT_PARAMS_V1 = _NV_QUERY_MULTIVIEW_SUPPORT_PARAMS_V1; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of MultiView HW feature\n! \\ingroup dx"] +pub type NV_QUERY_MULTIVIEW_SUPPORT_PARAMS = NV_QUERY_MULTIVIEW_SUPPORT_PARAMS_V1; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used for setting the Mode for MultiView HW Feature.\n! \\ingroup dx"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MULTIVIEW_PARAMS_V1 { + pub version: NvU32, + pub numViews: NvU32, + pub renderTargetIndexOffset: [NvU32; 4usize], + pub independentViewportMaskEnable: NvU8, +} +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used for setting the Mode for MultiView HW Feature.\n! \\ingroup dx"] +pub type NV_MULTIVIEW_PARAMS_V1 = _NV_MULTIVIEW_PARAMS_V1; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used for setting the Mode for MultiView HW Feature.\n! \\ingroup dx"] +pub type NV_MULTIVIEW_PARAMS = NV_MULTIVIEW_PARAMS_V1; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of Lens Matched Shading HW feature\n! \\ingroup dx"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_QUERY_MODIFIED_W_SUPPORT_PARAMS { + pub version: NvU32, + pub bModifiedWSupported: NvU32, +} +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of Lens Matched Shading HW feature\n! \\ingroup dx"] +pub type NV_QUERY_MODIFIED_W_SUPPORT_PARAMS_V1 = _NV_QUERY_MODIFIED_W_SUPPORT_PARAMS; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of Lens Matched Shading HW feature\n! \\ingroup dx"] +pub type NV_QUERY_MODIFIED_W_SUPPORT_PARAMS = NV_QUERY_MODIFIED_W_SUPPORT_PARAMS_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MODIFIED_W_COEFFICIENTS { + pub fA: f32, + pub fB: f32, + pub fAReserved: f32, + pub fBReserved: f32, + pub fReserved: [f32; 2usize], +} +pub type NV_MODIFIED_W_COEFFICIENTS = _NV_MODIFIED_W_COEFFICIENTS; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MODIFIED_W_PARAMS { + pub version: NvU32, + pub numEntries: NvU32, + pub modifiedWCoefficients: [NV_MODIFIED_W_COEFFICIENTS; 16usize], + pub id: NvU32, + pub reserved: [NvU32; 16usize], +} +pub type NV_MODIFIED_W_PARAMS_V1 = _NV_MODIFIED_W_PARAMS; +pub type NV_MODIFIED_W_PARAMS = NV_MODIFIED_W_PARAMS_V1; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to get sleep status\n! \\ingroup dx"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GET_SLEEP_STATUS_PARAMS { + #[doc = "!< (IN) Structure version"] + pub version: NvU32, + #[doc = "!< (OUT) Is low latency mode enabled?"] + pub bLowLatencyMode: NvBool, + #[doc = "!< (OUT) Is fullscreen VRR enabled?"] + pub bFsVrr: NvBool, + #[doc = "!< (OUT) Is Control Panel overriding VSYNC ON?"] + pub bCplVsyncOn: NvBool, + #[doc = "!< (OUT) Latest sleep interval in microseconds."] + pub sleepIntervalUs: NvU32, + #[doc = "!< (OUT) Is NvAPI_D3D_Sleep() being called?"] + pub bUseGameSleep: NvBool, + #[doc = "!< (OUT) Is in fullscreen/iFlip mode?"] + pub bFullscreenIFlip: NvBool, + #[doc = "!< (OUT) Latest Frame Generation multiplier used."] + pub fgMultiplier: NvU8, + #[doc = "!< (IN) Reserved. Must be set to 0s."] + pub rsvd: [NvU8; 119usize], +} +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to get sleep status\n! \\ingroup dx"] +pub type NV_GET_SLEEP_STATUS_PARAMS_V1 = _NV_GET_SLEEP_STATUS_PARAMS; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to get sleep status\n! \\ingroup dx"] +pub type NV_GET_SLEEP_STATUS_PARAMS = NV_GET_SLEEP_STATUS_PARAMS_V1; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to set sleep mode\n! \\ingroup dx"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_SET_SLEEP_MODE_PARAMS { + #[doc = "!< (IN) Structure version"] + pub version: NvU32, + #[doc = "!< (IN) Low latency mode enable/disable."] + pub bLowLatencyMode: NvBool, + #[doc = "!< (IN) Request maximum GPU clock frequency regardless of workload."] + pub bLowLatencyBoost: NvBool, + #[doc = "!< (IN) Minimum frame interval in microseconds. 0 = no frame rate limit."] + pub minimumIntervalUs: NvU32, + #[doc = "!< (IN) Allow latency markers to be used for runtime optimizations."] + pub bUseMarkersToOptimize: NvBool, + #[doc = "!< (IN) Consider all submission overlaps (both in between frames and within each frame)."] + pub bUseMinQueueTime: NvBool, + #[doc = "!< (IN) Reserved. Must be set to 0s."] + pub rsvd: [NvU8; 30usize], +} +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to set sleep mode\n! \\ingroup dx"] +pub type NV_SET_SLEEP_MODE_PARAMS_V1 = _NV_SET_SLEEP_MODE_PARAMS; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to set sleep mode\n! \\ingroup dx"] +pub type NV_SET_SLEEP_MODE_PARAMS = NV_SET_SLEEP_MODE_PARAMS_V1; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to send Reflex Sync data to UMD\n! \\ingroup dx"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_SET_REFLEX_SYNC_PARAMS { + #[doc = "!< (IN) Structure version"] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< (IN) Interval between VBLANKs in microseconds. (0 means N/A)"] + pub vblankIntervalUs: NvU32, + #[doc = "!< (IN) Amount of time in the completed frame queue. Can be negative. (0 means N/A)"] + pub timeInQueueUs: NvS32, + #[doc = "!< (IN) Target amount of time in the completed frame queue. (0 means N/A)"] + pub timeInQueueUsTarget: NvU32, + #[doc = "!< (IN) Specify the frame generation multipler to use. (0 means driver should auto-detect)"] + pub fgMultiplier: NvU8, + #[doc = "!< (IN) Reserved. Must be set to 0s."] + pub rsvd: [NvU8; 27usize], +} +impl _NV_SET_REFLEX_SYNC_PARAMS { + #[inline] + pub fn bEnable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bEnable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bEnable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bEnable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bDisable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bDisable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bDisable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bDisable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn flagsRsvd(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } + } + #[inline] + pub fn set_flagsRsvd(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 30u8, val as u64) + } + } + #[inline] + pub unsafe fn flagsRsvd_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 30u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_flagsRsvd_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 30u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bEnable: NvU32, + bDisable: NvU32, + flagsRsvd: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bEnable: u32 = unsafe { ::std::mem::transmute(bEnable) }; + bEnable as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bDisable: u32 = unsafe { ::std::mem::transmute(bDisable) }; + bDisable as u64 + }); + __bindgen_bitfield_unit.set(2usize, 30u8, { + let flagsRsvd: u32 = unsafe { ::std::mem::transmute(flagsRsvd) }; + flagsRsvd as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to send Reflex Sync data to UMD\n! \\ingroup dx"] +pub type NV_SET_REFLEX_SYNC_PARAMS_V1 = _NV_SET_REFLEX_SYNC_PARAMS; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to send Reflex Sync data to UMD\n! \\ingroup dx"] +pub type NV_SET_REFLEX_SYNC_PARAMS = NV_SET_REFLEX_SYNC_PARAMS_V1; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to get latency report.\n! \\ingroup dx"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LATENCY_RESULT_PARAMS { + #[doc = "!< (IN) Structure version"] + pub version: NvU32, + pub frameReport: [_NV_LATENCY_RESULT_PARAMS_FrameReport; 64usize], + pub rsvd: [NvU8; 32usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LATENCY_RESULT_PARAMS_FrameReport { + #[doc = "!< (OUT)"] + pub frameID: NvU64, + #[doc = "!< (OUT)"] + pub inputSampleTime: NvU64, + #[doc = "!< (OUT)"] + pub simStartTime: NvU64, + #[doc = "!< (OUT)"] + pub simEndTime: NvU64, + #[doc = "!< (OUT)"] + pub renderSubmitStartTime: NvU64, + #[doc = "!< (OUT)"] + pub renderSubmitEndTime: NvU64, + #[doc = "!< (OUT)"] + pub presentStartTime: NvU64, + #[doc = "!< (OUT)"] + pub presentEndTime: NvU64, + #[doc = "!< (OUT)"] + pub driverStartTime: NvU64, + #[doc = "!< (OUT)"] + pub driverEndTime: NvU64, + #[doc = "!< (OUT)"] + pub osRenderQueueStartTime: NvU64, + #[doc = "!< (OUT)"] + pub osRenderQueueEndTime: NvU64, + #[doc = "!< (OUT)"] + pub gpuRenderStartTime: NvU64, + #[doc = "!< (OUT)"] + pub gpuRenderEndTime: NvU64, + #[doc = "!< (OUT) Difference between gpuRenderStartTime and gpuRenderEndTime, excluding the idles in between, in microseconds."] + pub gpuActiveRenderTimeUs: NvU32, + #[doc = "!< (OUT) Difference between previous and current frame's gpuRenderEndTime, in microseconds."] + pub gpuFrameTimeUs: NvU32, + #[doc = "!< (OUT)"] + pub cameraConstructedTime: NvU64, + #[doc = "!< (OUT) Cross adapter copy time in microseconds."] + pub crossAdapterCopyTimeUs: NvU32, + #[doc = "!< (OUT) Frame generation time in microseconds."] + pub aiFrameTimeUs: NvU32, + pub rsvd: [NvU8; 104usize], +} +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to get latency report.\n! \\ingroup dx"] +pub type NV_LATENCY_RESULT_PARAMS_V1 = _NV_LATENCY_RESULT_PARAMS; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to get latency report.\n! \\ingroup dx"] +pub type NV_LATENCY_RESULT_PARAMS = NV_LATENCY_RESULT_PARAMS_V1; +pub const NV_LATENCY_MARKER_TYPE_SIMULATION_START: NV_LATENCY_MARKER_TYPE = 0; +pub const NV_LATENCY_MARKER_TYPE_SIMULATION_END: NV_LATENCY_MARKER_TYPE = 1; +pub const NV_LATENCY_MARKER_TYPE_RENDERSUBMIT_START: NV_LATENCY_MARKER_TYPE = 2; +pub const NV_LATENCY_MARKER_TYPE_RENDERSUBMIT_END: NV_LATENCY_MARKER_TYPE = 3; +pub const NV_LATENCY_MARKER_TYPE_PRESENT_START: NV_LATENCY_MARKER_TYPE = 4; +pub const NV_LATENCY_MARKER_TYPE_PRESENT_END: NV_LATENCY_MARKER_TYPE = 5; +pub const NV_LATENCY_MARKER_TYPE_INPUT_SAMPLE: NV_LATENCY_MARKER_TYPE = 6; +pub const NV_LATENCY_MARKER_TYPE_TRIGGER_FLASH: NV_LATENCY_MARKER_TYPE = 7; +pub const NV_LATENCY_MARKER_TYPE_PC_LATENCY_PING: NV_LATENCY_MARKER_TYPE = 8; +pub const NV_LATENCY_MARKER_TYPE_OUT_OF_BAND_RENDERSUBMIT_START: NV_LATENCY_MARKER_TYPE = 9; +pub const NV_LATENCY_MARKER_TYPE_OUT_OF_BAND_RENDERSUBMIT_END: NV_LATENCY_MARKER_TYPE = 10; +pub const NV_LATENCY_MARKER_TYPE_OUT_OF_BAND_PRESENT_START: NV_LATENCY_MARKER_TYPE = 11; +pub const NV_LATENCY_MARKER_TYPE_OUT_OF_BAND_PRESENT_END: NV_LATENCY_MARKER_TYPE = 12; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used define latency marker type\n! \\ingroup dx"] +pub type NV_LATENCY_MARKER_TYPE = ::std::os::raw::c_int; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used set latency markers\n! \\ingroup dx"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LATENCY_MARKER_PARAMS { + #[doc = "!< (IN) Structure version"] + pub version: NvU32, + pub frameID: NvU64, + pub markerType: NV_LATENCY_MARKER_TYPE, + pub rsvd0: NvU64, + pub rsvd: [NvU8; 56usize], +} +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used set latency markers\n! \\ingroup dx"] +pub type NV_LATENCY_MARKER_PARAMS_V1 = _NV_LATENCY_MARKER_PARAMS; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used set latency markers\n! \\ingroup dx"] +pub type NV_LATENCY_MARKER_PARAMS = NV_LATENCY_MARKER_PARAMS_V1; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used in NvAPI_D3D12_SetAsyncFrameMarker and NvAPI_D3D11_SetAsyncFrameMarker\n! \\ingroup dx"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_ASYNC_FRAME_MARKER_PARAMS_V1 { + #[doc = "!< (IN) Structure version"] + pub version: NvU32, + pub frameID: NvU64, + pub markerType: NV_LATENCY_MARKER_TYPE, + pub presentFrameID: NvU64, + pub vendorInternal: NvBool, + pub rsvd: [NvU8; 55usize], +} +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used in NvAPI_D3D12_SetAsyncFrameMarker and NvAPI_D3D11_SetAsyncFrameMarker\n! \\ingroup dx"] +pub type NV_ASYNC_FRAME_MARKER_PARAMS_V1 = _NV_ASYNC_FRAME_MARKER_PARAMS_V1; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used in NvAPI_D3D12_SetAsyncFrameMarker and NvAPI_D3D11_SetAsyncFrameMarker\n! \\ingroup dx"] +pub type NV_ASYNC_FRAME_MARKER_PARAMS = NV_ASYNC_FRAME_MARKER_PARAMS_V1; +pub const NV_OUT_OF_BAND_CQ_TYPE_OUT_OF_BAND_RENDER: NV_OUT_OF_BAND_CQ_TYPE = 0; +pub const NV_OUT_OF_BAND_CQ_TYPE_OUT_OF_BAND_PRESENT: NV_OUT_OF_BAND_CQ_TYPE = 1; +pub const NV_OUT_OF_BAND_CQ_TYPE_OUT_OF_BAND_IGNORE: NV_OUT_OF_BAND_CQ_TYPE = 2; +pub const NV_OUT_OF_BAND_CQ_TYPE_OUT_OF_BAND_RENDER_PRESENT: NV_OUT_OF_BAND_CQ_TYPE = 3; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used in NvAPI_D3D12_NotifyOutOfBandCommandQueue\n! \\ingroup dx"] +pub type NV_OUT_OF_BAND_CQ_TYPE = ::std::os::raw::c_int; +pub const _NV_D3D12_WORKSTATION_FEATURE_TYPE_NV_D3D12_WORKSTATION_FEATURE_TYPE_PRESENT_BARRIER: + _NV_D3D12_WORKSTATION_FEATURE_TYPE = 1; +pub const _NV_D3D12_WORKSTATION_FEATURE_TYPE_NV_D3D12_WORKSTATION_FEATURE_TYPE_RDMA_BAR1_SUPPORT: + _NV_D3D12_WORKSTATION_FEATURE_TYPE = 2; +#[doc = "! \\ingroup DX"] +pub type _NV_D3D12_WORKSTATION_FEATURE_TYPE = ::std::os::raw::c_int; +#[doc = "! \\ingroup DX"] +pub use self::_NV_D3D12_WORKSTATION_FEATURE_TYPE as NV_D3D12_WORKSTATION_FEATURE_TYPE; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_D3D12_WORKSTATION_FEATURE_RDMA_PROPERTIES { + pub rdmaHeapSize: NvU64, +} +pub type NV_D3D12_WORKSTATION_FEATURE_RDMA_PROPERTIES = + _NV_D3D12_WORKSTATION_FEATURE_RDMA_PROPERTIES; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_INITIALIZED: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 1; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_ENABLED: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 2; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_DLL_EXISTS: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 4; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_DLL_LOADED: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 8; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_DLL_SELECTED: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 16; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_PRESET: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 32; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_PERF_MODE: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 64; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_SCALING_RATIO: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 128; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_OPTIMAL_SETTINGS: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 256; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_CREATED: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 512; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_EVALUATE: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 1024; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_FG_MODE: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 8192; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_SR_DLAA_MODE: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 16384; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_FG_MULTI_FRAME: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 32768; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_ERR_FAILED: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 65536; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_ERR_DENIED: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 131072; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_ERR_DRS: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 262144; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_ERR_NOT_FOUND: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 524288; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_ERR_DLL_LOAD: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 1048576; +pub type NV_NGX_DLSS_OVERRIDE_BITFIELD = ::std::os::raw::c_int; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_NGX_DLSS_OVERRIDE_GET_STATE_PARAMS_V1 { + #[doc = "!< [in] Structure version"] + pub version: NvU32, + #[doc = "!< [in] Process Identifier"] + pub processIdentifier: NvU32, + #[doc = "!< [out] Feedback bits for Super Resolution"] + pub feedbackMaskSR: NvU64, + #[doc = "!< [out] Feedback bits for Ray Reconstruction"] + pub feedbackMaskRR: NvU64, + #[doc = "!< [out] Feedback bits for Frame Generation"] + pub feedbackMaskFG: NvU64, + #[doc = "!< [out] Scaling Ratio"] + pub scalingRatio: NvF32, + #[doc = "!< [out] Performance Mode"] + pub performanceMode: NvU32, + #[doc = "!< [out] Render Preset for SR/RR"] + pub renderPreset: NvU32, + #[doc = "!< [out] FG Override Frame Count Target"] + pub frameGenerationCount: NvU32, + #[doc = "!< [out] Render Preset for FG"] + pub frameGenerationPreset: NvU32, + #[doc = "!< [out] Frame Generation Mode"] + pub frameGenerationMode: NvU32, + #[doc = "!< Reserved for future use. Must be zero."] + pub reserved: [NvU32; 2usize], +} +pub type NV_NGX_DLSS_OVERRIDE_GET_STATE_PARAMS_V1 = _NV_NGX_DLSS_OVERRIDE_GET_STATE_PARAMS_V1; +pub type NV_NGX_DLSS_OVERRIDE_GET_STATE_PARAMS = NV_NGX_DLSS_OVERRIDE_GET_STATE_PARAMS_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_NGX_DLSS_OVERRIDE_SET_STATE_PARAMS_V1 { + #[doc = "!< [in] Structure version"] + pub version: NvU32, + #[doc = "!< [in] Process identifier of caller"] + pub processIdentifier: NvU32, + #[doc = "!< [in] DLSS feature ID"] + pub feature: NvU32, + #[doc = "!< [in] Feedback bits for DLSS feature"] + pub feedbackMask: NvU64, + #[doc = "!< Reserved for future use. Must be zero."] + pub reserved: [NvU64; 4usize], +} +pub type NV_NGX_DLSS_OVERRIDE_SET_STATE_PARAMS_V1 = _NV_NGX_DLSS_OVERRIDE_SET_STATE_PARAMS_V1; +pub type NV_NGX_DLSS_OVERRIDE_SET_STATE_PARAMS = NV_NGX_DLSS_OVERRIDE_SET_STATE_PARAMS_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NVVIOTOPOLOGYTARGET { + #[doc = "!< Handle to Physical GPU (This could be NULL for GVI device if its not binded)"] + pub hPhysicalGpu: NvPhysicalGpuHandle, + #[doc = "!, +} +impl _NV_DISPLAY_DRIVER_INFO { + #[inline] + pub fn bIsDCHDriver(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsDCHDriver(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsDCHDriver_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsDCHDriver_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsNVIDIAStudioPackage(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsNVIDIAStudioPackage(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsNVIDIAStudioPackage_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsNVIDIAStudioPackage_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsNVIDIAGameReadyPackage(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsNVIDIAGameReadyPackage(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsNVIDIAGameReadyPackage_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsNVIDIAGameReadyPackage_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsNVIDIARTXProductionBranchPackage(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsNVIDIARTXProductionBranchPackage(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsNVIDIARTXProductionBranchPackage_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsNVIDIARTXProductionBranchPackage_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsNVIDIARTXNewFeatureBranchPackage(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsNVIDIARTXNewFeatureBranchPackage(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsNVIDIARTXNewFeatureBranchPackage_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsNVIDIARTXNewFeatureBranchPackage_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 27u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 27u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 27u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsDCHDriver: NvU32, + bIsNVIDIAStudioPackage: NvU32, + bIsNVIDIAGameReadyPackage: NvU32, + bIsNVIDIARTXProductionBranchPackage: NvU32, + bIsNVIDIARTXNewFeatureBranchPackage: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsDCHDriver: u32 = unsafe { ::std::mem::transmute(bIsDCHDriver) }; + bIsDCHDriver as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bIsNVIDIAStudioPackage: u32 = + unsafe { ::std::mem::transmute(bIsNVIDIAStudioPackage) }; + bIsNVIDIAStudioPackage as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let bIsNVIDIAGameReadyPackage: u32 = + unsafe { ::std::mem::transmute(bIsNVIDIAGameReadyPackage) }; + bIsNVIDIAGameReadyPackage as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let bIsNVIDIARTXProductionBranchPackage: u32 = + unsafe { ::std::mem::transmute(bIsNVIDIARTXProductionBranchPackage) }; + bIsNVIDIARTXProductionBranchPackage as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let bIsNVIDIARTXNewFeatureBranchPackage: u32 = + unsafe { ::std::mem::transmute(bIsNVIDIARTXNewFeatureBranchPackage) }; + bIsNVIDIARTXNewFeatureBranchPackage as u64 + }); + __bindgen_bitfield_unit.set(5usize, 27u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_DISPLAY_DRIVER_INFO_V1 = _NV_DISPLAY_DRIVER_INFO; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_DISPLAY_DRIVER_INFO_V2 { + #[doc = "!< Structure Version."] + pub version: NvU32, + #[doc = "!< Contains the driver version after successful return."] + pub driverVersion: NvU32, + #[doc = "!< Contains the driver-branch string after successful return."] + pub szBuildBranch: NvAPI_ShortString, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< (OUT) Contains the driver base branch string after successful return."] + pub szBuildBaseBranch: NvAPI_ShortString, + #[doc = "!< Reserved for future use"] + pub reservedEx: NvU32, +} +impl _NV_DISPLAY_DRIVER_INFO_V2 { + #[inline] + pub fn bIsDCHDriver(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsDCHDriver(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsDCHDriver_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsDCHDriver_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsNVIDIAStudioPackage(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsNVIDIAStudioPackage(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsNVIDIAStudioPackage_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsNVIDIAStudioPackage_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsNVIDIAGameReadyPackage(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsNVIDIAGameReadyPackage(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsNVIDIAGameReadyPackage_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsNVIDIAGameReadyPackage_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsNVIDIARTXProductionBranchPackage(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsNVIDIARTXProductionBranchPackage(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsNVIDIARTXProductionBranchPackage_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsNVIDIARTXProductionBranchPackage_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsNVIDIARTXNewFeatureBranchPackage(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsNVIDIARTXNewFeatureBranchPackage(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsNVIDIARTXNewFeatureBranchPackage_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsNVIDIARTXNewFeatureBranchPackage_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 27u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 27u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 27u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsDCHDriver: NvU32, + bIsNVIDIAStudioPackage: NvU32, + bIsNVIDIAGameReadyPackage: NvU32, + bIsNVIDIARTXProductionBranchPackage: NvU32, + bIsNVIDIARTXNewFeatureBranchPackage: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsDCHDriver: u32 = unsafe { ::std::mem::transmute(bIsDCHDriver) }; + bIsDCHDriver as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bIsNVIDIAStudioPackage: u32 = + unsafe { ::std::mem::transmute(bIsNVIDIAStudioPackage) }; + bIsNVIDIAStudioPackage as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let bIsNVIDIAGameReadyPackage: u32 = + unsafe { ::std::mem::transmute(bIsNVIDIAGameReadyPackage) }; + bIsNVIDIAGameReadyPackage as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let bIsNVIDIARTXProductionBranchPackage: u32 = + unsafe { ::std::mem::transmute(bIsNVIDIARTXProductionBranchPackage) }; + bIsNVIDIARTXProductionBranchPackage as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let bIsNVIDIARTXNewFeatureBranchPackage: u32 = + unsafe { ::std::mem::transmute(bIsNVIDIARTXNewFeatureBranchPackage) }; + bIsNVIDIARTXNewFeatureBranchPackage as u64 + }); + __bindgen_bitfield_unit.set(5usize, 27u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_DISPLAY_DRIVER_INFO_V2 = _NV_DISPLAY_DRIVER_INFO_V2; +pub type NV_DISPLAY_DRIVER_INFO = NV_DISPLAY_DRIVER_INFO_V2; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_PHYSICAL_GPU_HANDLE_DATA { + pub hPhysicalGpu: NvPhysicalGpuHandle, + pub adapterType: NV_ADAPTER_TYPE, + pub reserved2: [NvU32; 4usize], +} +pub type NV_PHYSICAL_GPU_HANDLE_DATA = _NV_PHYSICAL_GPU_HANDLE_DATA; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_PHYSICAL_GPUS { + pub version: NvU32, + pub gpuHandleData: [NV_PHYSICAL_GPU_HANDLE_DATA; 64usize], + pub gpuHandleCount: NvU32, + pub reserved: [NvU32; 4usize], +} +pub type NV_PHYSICAL_GPUS_V1 = _NV_PHYSICAL_GPUS; +pub type NV_PHYSICAL_GPUS = NV_PHYSICAL_GPUS_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LOGICAL_GPU_HANDLE_DATA { + pub hLogicalGpu: NvLogicalGpuHandle, + pub adapterType: NV_ADAPTER_TYPE, + pub reserved: [NvU32; 4usize], +} +pub type NV_LOGICAL_GPU_HANDLE_DATA = _NV_LOGICAL_GPU_HANDLE_DATA; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LOGICAL_GPUS { + pub version: NvU32, + pub gpuHandleData: [NV_LOGICAL_GPU_HANDLE_DATA; 64usize], + pub gpuHandleCount: NvU32, + pub reserved: [NvU32; 4usize], +} +pub type NV_LOGICAL_GPUS_V1 = _NV_LOGICAL_GPUS; +pub type NV_LOGICAL_GPUS = NV_LOGICAL_GPUS_V1; +pub const _NV_NGX_DRIVER_FEATURE_ID_NV_NGX_DRIVER_FEATURE_ID_SET_FLIP_CONFIG_V2: + _NV_NGX_DRIVER_FEATURE_ID = 3423695; +pub type _NV_NGX_DRIVER_FEATURE_ID = ::std::os::raw::c_int; +pub use self::_NV_NGX_DRIVER_FEATURE_ID as NV_NGX_DRIVER_FEATURE_ID; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_NGX_DRIVER_FEATURE_SUPPORT_INFO { + #[doc = "!< [IN] Feature ID to query"] + pub featureId: NV_NGX_DRIVER_FEATURE_ID, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Reserved for future use"] + pub reserved2: [NvU32; 2usize], +} +impl _NV_NGX_DRIVER_FEATURE_SUPPORT_INFO { + #[inline] + pub fn bSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved1(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved1(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved1_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved1_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bSupported: NvU32, + reserved1: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bSupported: u32 = unsafe { ::std::mem::transmute(bSupported) }; + bSupported as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved1: u32 = unsafe { ::std::mem::transmute(reserved1) }; + reserved1 as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_NGX_DRIVER_FEATURE_SUPPORT_INFO = _NV_NGX_DRIVER_FEATURE_SUPPORT_INFO; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_NGX_GET_DRIVER_FEATURE_SUPPORT_PARAMS_V1 { + #[doc = "!< [IN] Structure version"] + pub version: NvU32, + #[doc = "!< [IN] Number of features to query (must be <= NVAPI_MAX_NGX_FEATURES_PER_QUERY)"] + pub featureCount: NvU32, + #[doc = "!< [INOUT] Feature query array"] + pub featureSupportInfo: [NV_NGX_DRIVER_FEATURE_SUPPORT_INFO; 16usize], + #[doc = "!< Reserved for future use"] + pub reserved: [NvU32; 6usize], +} +pub type NV_NGX_GET_DRIVER_FEATURE_SUPPORT_PARAMS_V1 = _NV_NGX_GET_DRIVER_FEATURE_SUPPORT_PARAMS_V1; +pub type NV_NGX_GET_DRIVER_FEATURE_SUPPORT_PARAMS = NV_NGX_GET_DRIVER_FEATURE_SUPPORT_PARAMS_V1; +#[doc = " Callback settings common to all client callbacks."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1 { + #[doc = " [in] Generic callback parameter which will be passed to the callback."] + pub pCallbackParam: *mut ::std::os::raw::c_void, + #[doc = " Reserved bytes for future expansion."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Callback settings common to all client callbacks."] +pub type NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1 = _NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1; +#[doc = " Callback settings common to all client callbacks."] +pub type NV_GPU_CLIENT_CALLBACK_SETTINGS_SUPER_V1 = NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1; +#[doc = " Callback settings common to all periodic client callbacks."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_PERIODIC_CALLBACK_SETTINGS_SUPER_V1 { + #[doc = " [in] Super class data."] + pub super_: NV_GPU_CLIENT_CALLBACK_SETTINGS_SUPER_V1, + #[doc = " [in] Minimum interval at which callback will be called.\n\n The callback may be invoked slower than this interval if underlying\n sampling rate does not align precisely to the provided period."] + pub callbackPeriodms: NvU32, + #[doc = " Reserved bytes for future expansion."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Callback settings common to all periodic client callbacks."] +pub type NV_GPU_CLIENT_PERIODIC_CALLBACK_SETTINGS_SUPER_V1 = + _NV_GPU_CLIENT_PERIODIC_CALLBACK_SETTINGS_SUPER_V1; +#[doc = " Callback data common to all client callbacks."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_CALLBACK_DATA_SUPER_V1 { + #[doc = " [out] Generic callback parameter which was passed in at registration time."] + pub pCallbackParam: *mut ::std::os::raw::c_void, + #[doc = " Reserved bytes for future expansion."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Callback data common to all client callbacks."] +pub type NV_GPU_CLIENT_CALLBACK_DATA_SUPER_V1 = _NV_GPU_CLIENT_CALLBACK_DATA_SUPER_V1; +pub const _NV_GPU_CLIENT_UTIL_DOMAIN_ID_NV_GPU_CLIENT_UTIL_DOMAIN_GRAPHICS: + _NV_GPU_CLIENT_UTIL_DOMAIN_ID = 0; +pub const _NV_GPU_CLIENT_UTIL_DOMAIN_ID_NV_GPU_CLIENT_UTIL_DOMAIN_FRAME_BUFFER: + _NV_GPU_CLIENT_UTIL_DOMAIN_ID = 1; +pub const _NV_GPU_CLIENT_UTIL_DOMAIN_ID_NV_GPU_CLIENT_UTIL_DOMAIN_VIDEO: + _NV_GPU_CLIENT_UTIL_DOMAIN_ID = 2; +#[doc = " Reserved for future use."] +pub const _NV_GPU_CLIENT_UTIL_DOMAIN_ID_NV_GPU_CLIENT_UTIL_DOMAIN_RSVD: + _NV_GPU_CLIENT_UTIL_DOMAIN_ID = 3; +#[doc = " Enumeration of different utilization domains"] +pub type _NV_GPU_CLIENT_UTIL_DOMAIN_ID = ::std::os::raw::c_int; +#[doc = " Enumeration of different utilization domains"] +pub use self::_NV_GPU_CLIENT_UTIL_DOMAIN_ID as NV_GPU_CLIENT_UTIL_DOMAIN_ID; +#[doc = " Data specific to a single utilization domain."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_UTILIZATION_DATA_V1 { + #[doc = " [out] Utilization domain identifier."] + pub utilId: NV_GPU_CLIENT_UTIL_DOMAIN_ID, + #[doc = " [out] Percentage of time where the domain is considered busy since the\n last sample. Units of percent*100; i.e. 5000 = 50%."] + pub utilizationPercent: NvU32, + #[doc = " Reserved bytes for future expansion."] + pub rsvd: [NvU8; 61usize], +} +#[doc = " Data specific to a single utilization domain."] +pub type NV_GPU_CLIENT_UTILIZATION_DATA_V1 = _NV_GPU_CLIENT_UTILIZATION_DATA_V1; +#[doc = " Data passed back to callback registered with\n @ref NvAPI_GPU_ClientRegisterForUtilizationSampleUpdates."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_CALLBACK_UTILIZATION_DATA_V1 { + #[doc = " [out] Super struct."] + pub super_: NV_GPU_CLIENT_CALLBACK_DATA_SUPER_V1, + #[doc = " [out] Number of valid entries in `utils` array."] + pub numUtils: NvU32, + #[doc = " [out] Time at which data was collected. Represented as elapsed\n microseconds since 00:00:00 UTC on January 1, 1970."] + pub timestamp: NvU64, + #[doc = " Reserved bytes for future expansion."] + pub rsvd: [NvU8; 64usize], + #[doc = " [out] Status data for each utilization domain."] + pub utils: [NV_GPU_CLIENT_UTILIZATION_DATA_V1; 4usize], +} +#[doc = " Data passed back to callback registered with\n @ref NvAPI_GPU_ClientRegisterForUtilizationSampleUpdates."] +pub type NV_GPU_CLIENT_CALLBACK_UTILIZATION_DATA_V1 = _NV_GPU_CLIENT_CALLBACK_UTILIZATION_DATA_V1; +#[doc = " Function prototype for a periodic utilization data callback that will be registered with NvAPI."] +pub type NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_V1 = ::std::option::Option< + unsafe extern "C" fn( + hPhysicalGpu: NvPhysicalGpuHandle, + pData: *mut NV_GPU_CLIENT_CALLBACK_UTILIZATION_DATA_V1, + ), +>; +#[doc = " Data required to register a periodic callback for utilization data."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_SETTINGS_V1 { + #[doc = " [in] Structure Version, must always be first."] + pub version: NvU32, + #[doc = " [in] Generic callback settings. Some data within will be passed to the\n callback when invoked."] + pub super_: NV_GPU_CLIENT_PERIODIC_CALLBACK_SETTINGS_SUPER_V1, + #[doc = " [in] Callback. Pass in NULL or nullptr to indicate request to unregister."] + pub callback: NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_V1, + #[doc = " Reserved bytes for future expansion."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Data required to register a periodic callback for utilization data."] +pub type NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_SETTINGS_V1 = + _NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_SETTINGS_V1; +#[doc = " Data required to register a periodic callback for utilization data."] +pub type NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_SETTINGS = + NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_SETTINGS_V1; +pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_INVALID: _NV_RISE_CONTENT_TYPE = 0; +pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_TEXT: _NV_RISE_CONTENT_TYPE = 1; +pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_GRAPH: _NV_RISE_CONTENT_TYPE = 2; +pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_CUSTOM_BEHAVIOR: _NV_RISE_CONTENT_TYPE = 3; +pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_CUSTOM_BEHAVIOR_RESULT: _NV_RISE_CONTENT_TYPE = + 4; +pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_INSTALLING: _NV_RISE_CONTENT_TYPE = 5; +pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_PROGRESS_UPDATE: _NV_RISE_CONTENT_TYPE = 6; +pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_READY: _NV_RISE_CONTENT_TYPE = 7; +pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_DOWNLOAD_REQUEST: _NV_RISE_CONTENT_TYPE = 8; +pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_UPDATE_INFO: _NV_RISE_CONTENT_TYPE = 9; +#[doc = " Enumeration of different RISE content types."] +pub type _NV_RISE_CONTENT_TYPE = ::std::os::raw::c_int; +#[doc = " Enumeration of different RISE content types."] +pub use self::_NV_RISE_CONTENT_TYPE as NV_RISE_CONTENT_TYPE; +#[doc = " Data passed back to callback."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_RISE_CALLBACK_DATA_V1 { + #[doc = " Super struct."] + pub super_: NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1, + #[doc = " RISE type of content"] + pub contentType: NV_RISE_CONTENT_TYPE, + #[doc = " RISE content."] + pub content: NvAPI_String, + #[doc = " Is this the last in the batch?"] + pub completed: NvBool, +} +#[doc = " Data passed back to callback."] +pub type NV_RISE_CALLBACK_DATA_V1 = _NV_RISE_CALLBACK_DATA_V1; +#[doc = " Callback for RISE update callbacks."] +pub type NV_RISE_CALLBACK_V1 = + ::std::option::Option; +#[doc = " Data required to register an update callback from the RISE."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_RISE_CALLBACK_SETTINGS_V1 { + #[doc = " [in] Structure Version, must always be first."] + pub version: NvU32, + #[doc = " [in] Generic callback parameter which will be passed to the callback."] + pub super_: NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1, + #[doc = " [in] Callback. Pass in NULL or nullptr to indicate request to unregister."] + pub callback: NV_RISE_CALLBACK_V1, + #[doc = " Reserved, must be set to zero by client."] + pub reserved: [NvU8; 32usize], +} +#[doc = " Data required to register an update callback from the RISE."] +pub type NV_RISE_CALLBACK_SETTINGS_V1 = _NV_RISE_CALLBACK_SETTINGS_V1; +#[doc = " Data required to register an update callback from the RISE."] +pub type NV_RISE_CALLBACK_SETTINGS = NV_RISE_CALLBACK_SETTINGS_V1; +#[doc = " Request contents sent to RISE."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_REQUEST_RISE_SETTINGS_V1 { + #[doc = " [in] Structure Version, must always be first."] + pub version: NvU32, + #[doc = " RISE type of content"] + pub contentType: NV_RISE_CONTENT_TYPE, + #[doc = " RISE request content."] + pub content: NvAPI_String, + #[doc = " Is the request fully sent?"] + pub completed: NvBool, + #[doc = " Reserved, must be set to zero by client."] + pub reserved: [NvU8; 32usize], +} +#[doc = " Request contents sent to RISE."] +pub type NV_REQUEST_RISE_SETTINGS_V1 = _NV_REQUEST_RISE_SETTINGS_V1; +#[doc = " Request contents sent to RISE."] +pub type NV_REQUEST_RISE_SETTINGS = NV_REQUEST_RISE_SETTINGS_V1; +#[doc = " Request contents sent to RISE."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_UNINSTALL_RISE_SETTINGS_V1 { + #[doc = " [in] Structure Version, must always be first."] + pub version: NvU32, + #[doc = " Reserved, must be set to zero by client."] + pub reserved: [NvU8; 32usize], +} +#[doc = " Request contents sent to RISE."] +pub type NV_UNINSTALL_RISE_SETTINGS_V1 = _NV_UNINSTALL_RISE_SETTINGS_V1; +#[doc = " Request contents sent to RISE."] +pub type NV_UNINSTALL_RISE_SETTINGS = NV_UNINSTALL_RISE_SETTINGS_V1; diff --git a/nvapi_trace/Cargo.toml b/nvapi_trace/Cargo.toml new file mode 100644 index 000000000..ed86c5453 --- /dev/null +++ b/nvapi_trace/Cargo.toml @@ -0,0 +1,29 @@ +[package] +name = "nvapi_trace" +version = "0.0.0" +authors = ["Andrzej Janik "] +edition = "2021" + +[lib] +name = "nvapi_trace" +crate-type = ["cdylib"] + +[dependencies] +format = { path = "../format" } +dark_api = { path = "../dark_api" } +cuda_macros = { path = "../cuda_macros" } +cuda_types = { path = "../cuda_types" } +zluda_trace_common = { path = "../zluda_trace_common" } +libloading = "0.8" +paste = "1.0" +unwrap_or = "1.0.1" +cglue = "0.3.5" +dynasm = "5.0" +dynasmrt = "5.0" +rustc-hash = "2.0.0" + +[package.metadata.zluda] +windows_only = true +windows_paths = ["trace/nvapi64.dll"] +windows32_paths = ["trace/nvapi.dll"] +32bit = true diff --git a/nvapi_trace/src/lib.rs b/nvapi_trace/src/lib.rs new file mode 100644 index 000000000..9fcc8dd06 --- /dev/null +++ b/nvapi_trace/src/lib.rs @@ -0,0 +1,704 @@ +use libloading::Library; +use rustc_hash::FxHashMap; +use std::{ + collections::hash_map, + ffi::c_void, + mem, ptr, + sync::{LazyLock, Mutex}, +}; +use zluda_trace_common::ReprUsize; + +static GLOBAL_STATE: LazyLock)>> = + LazyLock::new(get_global_state); + +fn get_global_state() -> Option<(Library, Mutex)> { + let cuda_lib = std::env::var("ZLUDA_NVAPI_LIB").ok().unwrap_or_else(|| { + if cfg!(target_pointer_width = "64") { + r"C:\Windows\System32\nvapi64.dll".to_string() + } else { + r"C:\Windows\System32\nvapi.dll".to_string() + } + }); + let lib = zluda_trace_common::dlopen_local_noredirect(cuda_lib).ok()?; + Some((Library::from(lib), Mutex::new(GlobalState::new()))) +} + +struct GlobalState { + thunks: FxHashMap, +} + +impl GlobalState { + fn new() -> Self { + GlobalState { + thunks: FxHashMap::default(), + } + } + + fn get_thunk( + &mut self, + original: *mut c_void, + report_fn: unsafe extern "C" fn(i32, u32), + interface: u32, + ) -> *mut c_void { + match self.thunks.entry(interface) { + hash_map::Entry::Occupied(entry) => *entry.get() as *mut c_void, + hash_map::Entry::Vacant(entry) => { + let thunk = get_thunk(original, report_fn, interface); + entry.insert(thunk as usize); + thunk + } + } + } +} + +macro_rules! interface_to_name { + ($({ $name:literal, $id:literal }),* $(,)?) => { + fn interface_to_name(interface: u32) -> Option<&'static str> { + match interface { + $( + $id => Some($name), + )* + _ => None, + } + } + }; +} + +interface_to_name!( + { "NvAPI_Initialize", 0x0150e828 }, + { "NvAPI_Unload", 0xd22bdd7e }, + { "NvAPI_GetErrorMessage", 0x6c2d048c }, + { "NvAPI_GetInterfaceVersionString", 0x01053fa5 }, + { "NvAPI_GPU_GetEDID", 0x37d32e69 }, + { "NvAPI_SetView", 0x0957d7b6 }, + { "NvAPI_SetViewEx", 0x06b89e68 }, + { "NvAPI_GetDisplayDriverVersion", 0xf951a4d1 }, + { "NvAPI_SYS_GetDriverAndBranchVersion", 0x2926aaad }, + { "NvAPI_GPU_GetMemoryInfo", 0x07f9b368 }, + { "NvAPI_GPU_GetMemoryInfoEx", 0xc0599498 }, + { "NvAPI_OGL_ExpertModeSet", 0x3805ef7a }, + { "NvAPI_OGL_ExpertModeGet", 0x22ed9516 }, + { "NvAPI_OGL_ExpertModeDefaultsSet", 0xb47a657e }, + { "NvAPI_OGL_ExpertModeDefaultsGet", 0xae921f12 }, + { "NvAPI_EnumPhysicalGPUs", 0xe5ac921f }, + { "NvAPI_EnumTCCPhysicalGPUs", 0xd9930b07 }, + { "NvAPI_EnumLogicalGPUs", 0x48b3ea59 }, + { "NvAPI_GetPhysicalGPUsFromDisplay", 0x34ef9506 }, + { "NvAPI_GetPhysicalGPUFromUnAttachedDisplay", 0x5018ed61 }, + { "NvAPI_GetLogicalGPUFromDisplay", 0xee1370cf }, + { "NvAPI_GetLogicalGPUFromPhysicalGPU", 0xadd604d1 }, + { "NvAPI_GetPhysicalGPUsFromLogicalGPU", 0xaea3fa32 }, + { "NvAPI_GetPhysicalGPUFromGPUID", 0x5380ad1a }, + { "NvAPI_GetGPUIDfromPhysicalGPU", 0x6533ea3e }, + { "NvAPI_GPU_GetShaderSubPipeCount", 0x0be17923 }, + { "NvAPI_GPU_GetGpuCoreCount", 0xc7026a87 }, + { "NvAPI_GPU_GetAllOutputs", 0x7d554f8e }, + { "NvAPI_GPU_GetConnectedOutputs", 0x1730bfc9 }, + { "NvAPI_GPU_GetConnectedSLIOutputs", 0x0680de09 }, + { "NvAPI_GPU_GetConnectedDisplayIds", 0x0078dba2 }, + { "NvAPI_GPU_GetAllDisplayIds", 0x785210a2 }, + { "NvAPI_GPU_GetConnectedOutputsWithLidState", 0xcf8caf39 }, + { "NvAPI_GPU_GetConnectedSLIOutputsWithLidState", 0x96043cc7 }, + { "NvAPI_GPU_GetSystemType", 0xbaaabfcc }, + { "NvAPI_GPU_GetActiveOutputs", 0xe3e89b6f }, + { "NvAPI_GPU_SetEDID", 0xe83d6456 }, + { "NvAPI_GPU_GetOutputType", 0x40a505e4 }, + { "NvAPI_GPU_ValidateOutputCombination", 0x34c9c2d4 }, + { "NvAPI_GPU_GetFullName", 0xceee8e9f }, + { "NvAPI_GPU_GetPCIIdentifiers", 0x2ddfb66e }, + { "NvAPI_GPU_GetGPUType", 0xc33baeb1 }, + { "NvAPI_GPU_GetBusType", 0x1bb18724 }, + { "NvAPI_GPU_GetBusId", 0x1be0b8e5 }, + { "NvAPI_GPU_GetBusSlotId", 0x2a0a350f }, + { "NvAPI_GPU_GetIRQ", 0xe4715417 }, + { "NvAPI_GPU_GetVbiosRevision", 0xacc3da0a }, + { "NvAPI_GPU_GetVbiosOEMRevision", 0x2d43fb31 }, + { "NvAPI_GPU_GetVbiosVersionString", 0xa561fd7d }, + { "NvAPI_GPU_GetAGPAperture", 0x6e042794 }, + { "NvAPI_GPU_GetCurrentAGPRate", 0xc74925a0 }, + { "NvAPI_GPU_GetCurrentPCIEDownstreamWidth", 0xd048c3b1 }, + { "NvAPI_GPU_GetPhysicalFrameBufferSize", 0x46fbeb03 }, + { "NvAPI_GPU_GetVirtualFrameBufferSize", 0x5a04b644 }, + { "NvAPI_GPU_GetQuadroStatus", 0xe332fa47 }, + { "NvAPI_GPU_GetBoardInfo", 0x22d54523 }, + { "NvAPI_GPU_GetRamBusWidth", 0x7975c581 }, + { "NvAPI_GPU_GetArchInfo", 0xd8265d24 }, + { "NvAPI_I2CRead", 0x2fde12c5 }, + { "NvAPI_I2CWrite", 0xe812eb07 }, + { "NvAPI_GPU_WorkstationFeatureSetup", 0x6c1f3fe4 }, + { "NvAPI_GPU_WorkstationFeatureQuery", 0x004537df }, + { "NvAPI_GPU_GetHDCPSupportStatus", 0xf089eef5 }, + { "NvAPI_GPU_CudaEnumComputeCapableGpus", 0x5786cc6e }, + { "NvAPI_GPU_GetTachReading", 0x5f608315 }, + { "NvAPI_GPU_GetECCStatusInfo", 0xca1ddaf3 }, + { "NvAPI_GPU_GetECCErrorInfo", 0xc71f85a6 }, + { "NvAPI_GPU_ResetECCErrorInfo", 0xc02eec20 }, + { "NvAPI_GPU_GetECCConfigurationInfo", 0x77a796f3 }, + { "NvAPI_GPU_SetECCConfiguration", 0x1cf639d9 }, + { "NvAPI_GPU_QueryWorkstationFeatureSupport", 0x80b1abb9 }, + { "NvAPI_GPU_SetScanoutIntensity", 0xa57457a4 }, + { "NvAPI_GPU_GetScanoutIntensityState", 0xe81ce836 }, + { "NvAPI_GPU_SetScanoutWarping", 0xb34bab4f }, + { "NvAPI_GPU_GetScanoutWarpingState", 0x6f5435af }, + { "NvAPI_GPU_SetScanoutCompositionParameter", 0xf898247d }, + { "NvAPI_GPU_GetScanoutCompositionParameter", 0x58fe51e6 }, + { "NvAPI_GPU_GetScanoutConfiguration", 0x6a9f5b63 }, + { "NvAPI_GPU_GetScanoutConfigurationEx", 0xe2e1e6f0 }, + { "NvAPI_GPU_GetAdapterIdFromPhysicalGpu", 0x0ff07fde }, + { "NvAPI_GPU_GetVirtualizationInfo", 0x44e022a9 }, + { "NvAPI_GPU_GetLogicalGpuInfo", 0x842b066e }, + { "NvAPI_GPU_GetLicensableFeatures", 0x3fc596aa }, + { "NvAPI_GPU_GetEncoderStatistics", 0xf0a9aeeb }, + { "NvAPI_GPU_GetEncoderSessionsInfo", 0xd8a72ce5 }, + { "NvAPI_GPU_GetGPUInfo", 0xafd1b02c }, + { "NvAPI_GPU_GetVRReadyData", 0x81d629c5 }, + { "NvAPI_GPU_GetGspFeatures", 0x581c4391 }, + { "NvAPI_GPU_GetUUID", 0xdc95673d }, + { "NvAPI_GPU_NVLINK_GetCaps", 0xbef1119d }, + { "NvAPI_GPU_NVLINK_GetStatus", 0xc72a38e3 }, + { "NvAPI_GPU_GetPerfDecreaseInfo", 0x7f7f4600 }, + { "NvAPI_GPU_GetPstatesInfoEx", 0x843c0256 }, + { "NvAPI_GPU_GetPstates20", 0x6ff81213 }, + { "NvAPI_GPU_GetCurrentPstate", 0x927da4f6 }, + { "NvAPI_GPU_GetDynamicPstatesInfoEx", 0x60ded2ed }, + { "NvAPI_GPU_GetThermalSettings", 0xe3640a56 }, + { "NvAPI_GPU_GetAllClockFrequencies", 0xdcb616c3 }, + { "NvAPI_GPU_QueryIlluminationSupport", 0xa629da31 }, + { "NvAPI_GPU_GetIllumination", 0x9a1b9365 }, + { "NvAPI_GPU_SetIllumination", 0x0254a187 }, + { "NvAPI_GPU_ClientIllumDevicesGetInfo", 0xd4100e58 }, + { "NvAPI_GPU_ClientIllumDevicesGetControl", 0x73c01d58 }, + { "NvAPI_GPU_ClientIllumDevicesSetControl", 0x57024c62 }, + { "NvAPI_GPU_ClientIllumZonesGetInfo", 0x4b81241b }, + { "NvAPI_GPU_ClientIllumZonesGetControl", 0x3dbf5764 }, + { "NvAPI_GPU_ClientIllumZonesSetControl", 0x197d065e }, + { "NvAPI_Event_RegisterCallback", 0xe6dbea69 }, + { "NvAPI_Event_UnregisterCallback", 0xde1f9b45 }, + { "NvAPI_EnumNvidiaDisplayHandle", 0x9abdd40d }, + { "NvAPI_EnumNvidiaUnAttachedDisplayHandle", 0x20de9260 }, + { "NvAPI_CreateDisplayFromUnAttachedDisplay", 0x63f9799e }, + { "NvAPI_GetAssociatedNvidiaDisplayHandle", 0x35c29134 }, + { "NvAPI_DISP_GetAssociatedUnAttachedNvidiaDisplayHandle", 0xa70503b2 }, + { "NvAPI_GetAssociatedNvidiaDisplayName", 0x22a78b05 }, + { "NvAPI_GetUnAttachedAssociatedDisplayName", 0x4888d790 }, + { "NvAPI_EnableHWCursor", 0x2863148d }, + { "NvAPI_DisableHWCursor", 0xab163097 }, + { "NvAPI_GetVBlankCounter", 0x67b5db55 }, + { "NvAPI_SetRefreshRateOverride", 0x3092ac32 }, + { "NvAPI_GetAssociatedDisplayOutputId", 0xd995937e }, + { "NvAPI_GetDisplayPortInfo", 0xc64ff367 }, + { "NvAPI_SetDisplayPort", 0xfa13e65a }, + { "NvAPI_GetHDMISupportInfo", 0x6ae16ec3 }, + { "NvAPI_Disp_InfoFrameControl", 0x6067af3f }, + { "NvAPI_Disp_ColorControl", 0x92f9d80d }, + { "NvAPI_Disp_GetHdrCapabilities", 0x84f2a8df }, + { "NvAPI_Disp_HdrColorControl", 0x351da224 }, + { "NvAPI_Disp_SetSourceColorSpace", 0x473b6caf }, + { "NvAPI_Disp_GetSourceColorSpace", 0xceedc85b }, + { "NvAPI_Disp_SetSourceHdrMetadata", 0x905eb63b }, + { "NvAPI_Disp_GetSourceHdrMetadata", 0x0d3f52da }, + { "NvAPI_Disp_SetOutputMode", 0x98e7661a }, + { "NvAPI_Disp_GetOutputMode", 0x81fed88d }, + { "NvAPI_Disp_SetHdrToneMapping", 0xdd6da362 }, + { "NvAPI_Disp_GetHdrToneMapping", 0xfbd36e71 }, + { "NvAPI_Disp_GetColorimetry", 0x00b421ad }, + { "NvAPI_DISP_GetTiming", 0x175167e9 }, + { "NvAPI_DISP_GetMonitorCapabilities", 0x3b05c7e1 }, + { "NvAPI_DISP_GetMonitorColorCapabilities", 0x6ae4cfb5 }, + { "NvAPI_DISP_EnumCustomDisplay", 0xa2072d59 }, + { "NvAPI_DISP_TryCustomDisplay", 0x1f7db630 }, + { "NvAPI_DISP_DeleteCustomDisplay", 0x552e5b9b }, + { "NvAPI_DISP_SaveCustomDisplay", 0x49882876 }, + { "NvAPI_DISP_RevertCustomDisplayTrial", 0xcbbd40f0 }, + { "NvAPI_GetView", 0xd6b99d89 }, + { "NvAPI_GetViewEx", 0xdbbc0af4 }, + { "NvAPI_GetSupportedViews", 0x66fb7fc0 }, + { "NvAPI_DISP_GetDisplayIdByDisplayName", 0xae457190 }, + { "NvAPI_DISP_GetGDIPrimaryDisplayId", 0x1e9d8a31 }, + { "NvAPI_DISP_GetDisplayConfig", 0x11abccf8 }, + { "NvAPI_DISP_SetDisplayConfig", 0x5d8cf8de }, + { "NvAPI_DISP_GetEdidData", 0x436ced76 }, + { "NvAPI_DISP_GetAdaptiveSyncData", 0xb73d1ee9 }, + { "NvAPI_DISP_SetAdaptiveSyncData", 0x3eebba1d }, + { "NvAPI_DISP_GetVirtualRefreshRateData", 0x8c00429a }, + { "NvAPI_DISP_SetVirtualRefreshRateData", 0x5abbe6a3 }, + { "NvAPI_DISP_SetPreferredStereoDisplay", 0xc9d0e25f }, + { "NvAPI_DISP_GetPreferredStereoDisplay", 0x1f6b4666 }, + { "NvAPI_DISP_GetNvManagedDedicatedDisplays", 0xdbdf0cb2 }, + { "NvAPI_DISP_AcquireDedicatedDisplay", 0x47c917ba }, + { "NvAPI_DISP_ReleaseDedicatedDisplay", 0x1247825f }, + { "NvAPI_DISP_GetNvManagedDedicatedDisplayMetadata", 0xd645d80c }, + { "NvAPI_DISP_SetNvManagedDedicatedDisplayMetadata", 0x3d8b129a }, + { "NvAPI_Disp_GetDisplayIdInfo", 0xbae8aa5e }, + { "NvAPI_Disp_GetDisplayIdsFromTarget", 0xe7e5f89e }, + { "NvAPI_Disp_GetVRRInfo", 0xdf8fda57 }, + { "NvAPI_Mosaic_GetSupportedTopoInfo", 0xfdb63c81 }, + { "NvAPI_Mosaic_GetTopoGroup", 0xcb89381d }, + { "NvAPI_Mosaic_GetOverlapLimits", 0x989685f0 }, + { "NvAPI_Mosaic_SetCurrentTopo", 0x9b542831 }, + { "NvAPI_Mosaic_GetCurrentTopo", 0xec32944e }, + { "NvAPI_Mosaic_EnableCurrentTopo", 0x5f1aa66c }, + { "NvAPI_Mosaic_GetDisplayViewportsByResolution", 0xdc6dc8d3 }, + { "NvAPI_Mosaic_SetDisplayGrids", 0x4d959a89 }, + { "NvAPI_Mosaic_ValidateDisplayGrids", 0xcf43903d }, + { "NvAPI_Mosaic_EnumDisplayModes", 0x78db97d7 }, + { "NvAPI_Mosaic_EnumDisplayGrids", 0xdf2887af }, + { "NvAPI_GetSupportedMosaicTopologies", 0x410b5c25 }, + { "NvAPI_GetCurrentMosaicTopology", 0xf60852bd }, + { "NvAPI_SetCurrentMosaicTopology", 0xd54b8989 }, + { "NvAPI_EnableCurrentMosaicTopology", 0x74073cc9 }, + { "NvAPI_GSync_EnumSyncDevices", 0xd9639601 }, + { "NvAPI_GSync_QueryCapabilities", 0x44a3f1d1 }, + { "NvAPI_GSync_GetTopology", 0x4562bc38 }, + { "NvAPI_GSync_SetSyncStateSettings", 0x60acdfdd }, + { "NvAPI_GSync_GetControlParameters", 0x16de1c6a }, + { "NvAPI_GSync_SetControlParameters", 0x8bbff88b }, + { "NvAPI_GSync_AdjustSyncDelay", 0x2d11ff51 }, + { "NvAPI_GSync_GetSyncStatus", 0xf1f5b434 }, + { "NvAPI_GSync_GetStatusParameters", 0x70d404ec }, + { "NvAPI_D3D_GetCurrentSLIState", 0x4b708b54 }, + { "NvAPI_D3D9_RegisterResource", 0xa064bdfc }, + { "NvAPI_D3D9_UnregisterResource", 0xbb2b17aa }, + { "NvAPI_D3D9_AliasSurfaceAsTexture", 0xe5ceae41 }, + { "NvAPI_D3D9_StretchRectEx", 0x22de03aa }, + { "NvAPI_D3D9_ClearRT", 0x332d3942 }, + { "NvAPI_D3D_GetObjectHandleForResource", 0xfceac864 }, + { "NvAPI_D3D_SetResourceHint", 0x6c0ed98c }, + { "NvAPI_D3D_BeginResourceRendering", 0x91123d6a }, + { "NvAPI_D3D_EndResourceRendering", 0x37e7191c }, + { "NvAPI_D3D9_GetSurfaceHandle", 0x0f2dd3f2 }, + { "NvAPI_D3D9_VideoSetStereoInfo", 0xb852f4db }, + { "NvAPI_D3D10_SetDepthBoundsTest", 0x4eadf5d2 }, + { "NvAPI_D3D11_CreateDevice", 0x6a16d3a0 }, + { "NvAPI_D3D11_CreateDeviceAndSwapChain", 0xbb939ee5 }, + { "NvAPI_D3D11_SetDepthBoundsTest", 0x7aaf7a04 }, + { "NvAPI_D3D11_IsNvShaderExtnOpCodeSupported", 0x5f68da40 }, + { "NvAPI_D3D11_SetNvShaderExtnSlot", 0x8e90bb9f }, + { "NvAPI_D3D12_SetNvShaderExtnSlotSpace", 0xac2dfeb5 }, + { "NvAPI_D3D12_SetNvShaderExtnSlotSpaceLocalThread", 0x43d867c0 }, + { "NvAPI_D3D11_SetNvShaderExtnSlotLocalThread", 0x0e6482a0 }, + { "NvAPI_D3D11_BeginUAVOverlapEx", 0xba08208a }, + { "NvAPI_D3D11_BeginUAVOverlap", 0x65b93ca8 }, + { "NvAPI_D3D11_EndUAVOverlap", 0x2216a357 }, + { "NvAPI_D3D11_GetResourceHandle", 0x09d52986 }, + { "NvAPI_D3D_SetFPSIndicatorState", 0xa776e8db }, + { "NvAPI_D3D9_Present", 0x05650beb }, + { "NvAPI_D3D9_QueryFrameCount", 0x9083e53a }, + { "NvAPI_D3D9_ResetFrameCount", 0xfa6a0675 }, + { "NvAPI_D3D9_QueryMaxSwapGroup", 0x5995410d }, + { "NvAPI_D3D9_QuerySwapGroup", 0xeba4d232 }, + { "NvAPI_D3D9_JoinSwapGroup", 0x7d44bb54 }, + { "NvAPI_D3D9_BindSwapBarrier", 0x9c39c246 }, + { "NvAPI_D3D_SetVerticalSyncMode", 0x5526cfd1 }, + { "NvAPI_D3D1x_Present", 0x03b845a1 }, + { "NvAPI_D3D1x_QueryFrameCount", 0x9152e055 }, + { "NvAPI_D3D1x_ResetFrameCount", 0xfbbb031a }, + { "NvAPI_D3D1x_QueryMaxSwapGroup", 0x9bb9d68f }, + { "NvAPI_D3D1x_QuerySwapGroup", 0x407f67aa }, + { "NvAPI_D3D1x_JoinSwapGroup", 0x14610cd7 }, + { "NvAPI_D3D1x_BindSwapBarrier", 0x9de8c729 }, + { "NvAPI_D3D12_QueryPresentBarrierSupport", 0xa15faef7 }, + { "NvAPI_D3D12_CreatePresentBarrierClient", 0x4d815de9 }, + { "NvAPI_D3D12_RegisterPresentBarrierResources", 0xd53c9ef0 }, + { "NvAPI_DestroyPresentBarrierClient", 0x3c5c351b }, + { "NvAPI_JoinPresentBarrier", 0x17f6bf82 }, + { "NvAPI_LeavePresentBarrier", 0xc3ec5a7f }, + { "NvAPI_QueryPresentBarrierFrameStatistics", 0x61b844a1 }, + { "NvAPI_D3D12_CreateDDisplayPresentBarrierClient", 0xb5a21987 }, + { "NvAPI_D3D11_CreateRasterizerState", 0xdb8d28af }, + { "NvAPI_D3D_ConfigureAnsel", 0x341c6c7f }, + { "NvAPI_D3D11_CreateTiledTexture2DArray", 0x7886981a }, + { "NvAPI_D3D11_CheckFeatureSupport", 0x106a487e }, + { "NvAPI_D3D11_CreateImplicitMSAATexture2D", 0xb8f79632 }, + { "NvAPI_D3D12_CreateCommittedImplicitMSAATexture2D", 0x24c6a07b }, + { "NvAPI_D3D11_ResolveSubresourceRegion", 0xe6bfedd6 }, + { "NvAPI_D3D12_ResolveSubresourceRegion", 0xc24a15bf }, + { "NvAPI_D3D11_TiledTexture2DArrayGetDesc", 0xf1a2b9d5 }, + { "NvAPI_D3D11_UpdateTileMappings", 0x9a06ea07 }, + { "NvAPI_D3D11_CopyTileMappings", 0xc09ee6bc }, + { "NvAPI_D3D11_TiledResourceBarrier", 0xd6839099 }, + { "NvAPI_D3D11_AliasMSAATexture2DAsNonMSAA", 0xf1c54fc9 }, + { "NvAPI_D3D11_CreateGeometryShaderEx_2", 0x99ed5c1c }, + { "NvAPI_D3D11_CreateVertexShaderEx", 0x0beaa0b2 }, + { "NvAPI_D3D11_CreateHullShaderEx", 0xb53cab00 }, + { "NvAPI_D3D11_CreateDomainShaderEx", 0xa0d7180d }, + { "NvAPI_D3D11_CreatePixelShaderEx_2", 0x4162822b }, + { "NvAPI_D3D11_CreateFastGeometryShaderExplicit", 0x71ab7c9c }, + { "NvAPI_D3D11_CreateFastGeometryShader", 0x525d43be }, + { "NvAPI_D3D11_DecompressView", 0x3a94e822 }, + { "NvAPI_D3D12_CreateGraphicsPipelineState", 0x2fc28856 }, + { "NvAPI_D3D12_CreateComputePipelineState", 0x2762deac }, + { "NvAPI_D3D12_SetDepthBoundsTestValues", 0xb9333fe9 }, + { "NvAPI_D3D12_CreateReservedResource", 0x2c85f101 }, + { "NvAPI_D3D12_CreateHeap", 0x5cb397cf }, + { "NvAPI_D3D12_CreateHeap2", 0x924be9d6 }, + { "NvAPI_D3D12_QueryCpuVisibleVidmem", 0x26322bc3 }, + { "NvAPI_D3D12_ReservedResourceGetDesc", 0x9aa2aabb }, + { "NvAPI_D3D12_UpdateTileMappings", 0xc6017a7d }, + { "NvAPI_D3D12_CopyTileMappings", 0x47f78194 }, + { "NvAPI_D3D12_ResourceAliasingBarrier", 0xb942bab7 }, + { "NvAPI_D3D12_CaptureUAVInfo", 0x6e5ea9db }, + { "NvAPI_D3D11_GetResourceGPUVirtualAddressEx", 0xaf6d14da }, + { "NvAPI_D3D11_EnumerateMetaCommands", 0xc7453ba8 }, + { "NvAPI_D3D11_CreateMetaCommand", 0xf505fba0 }, + { "NvAPI_D3D11_InitializeMetaCommand", 0xaec629e9 }, + { "NvAPI_D3D11_ExecuteMetaCommand", 0x82236c47 }, + { "NvAPI_D3D12_EnumerateMetaCommands", 0xcd9141d8 }, + { "NvAPI_D3D12_CreateMetaCommand", 0xeb29634b }, + { "NvAPI_D3D12_InitializeMetaCommand", 0xa4125399 }, + { "NvAPI_D3D12_ExecuteMetaCommand", 0xde24fc3d }, + { "NvAPI_D3D12_CreateCommittedResource", 0x027e98ae }, + { "NvAPI_D3D12_GetCopyableFootprints", 0xf6305eb5 }, + { "NvAPI_D3D12_CopyTextureRegion", 0x82b91b25 }, + { "NvAPI_D3D12_IsNvShaderExtnOpCodeSupported", 0x3dfacec8 }, + { "NvAPI_D3D12_GetOptimalThreadCountForMesh", 0xb43995cb }, + { "NvAPI_D3D_IsGSyncCapable", 0x9c1eed78 }, + { "NvAPI_D3D_IsGSyncActive", 0xe942b0ff }, + { "NvAPI_D3D12_SetFlipConfig", 0xf3148c42 }, + { "NvAPI_D3D1x_DisableShaderDiskCache", 0xd0cbca7d }, + { "NvAPI_D3D11_MultiGPU_GetCaps", 0xd2d25687 }, + { "NvAPI_D3D11_MultiGPU_Init", 0x017be49e }, + { "NvAPI_D3D11_CreateMultiGPUDevice", 0xbdb20007 }, + { "NvAPI_D3D_QuerySinglePassStereoSupport", 0x6f5f0a6d }, + { "NvAPI_D3D_SetSinglePassStereoMode", 0xa39e6e6e }, + { "NvAPI_D3D12_QuerySinglePassStereoSupport", 0x3b03791b }, + { "NvAPI_D3D12_SetSinglePassStereoMode", 0x83556d87 }, + { "NvAPI_D3D_QueryMultiViewSupport", 0xb6e0a41c }, + { "NvAPI_D3D_SetMultiViewMode", 0x8285c8da }, + { "NvAPI_D3D_QueryModifiedWSupport", 0xcbf9f4f5 }, + { "NvAPI_D3D_SetModifiedWMode", 0x06ea4bf4 }, + { "NvAPI_D3D12_QueryModifiedWSupport", 0x51235248 }, + { "NvAPI_D3D12_SetModifiedWMode", 0xe1fdaba7 }, + { "NvAPI_D3D_CreateLateLatchObject", 0x2db27d09 }, + { "NvAPI_D3D_QueryLateLatchSupport", 0x8ceca0ec }, + { "NvAPI_D3D_RegisterDevice", 0x8c02c4d0 }, + { "NvAPI_D3D11_MultiDrawInstancedIndirect", 0xd4e26bbf }, + { "NvAPI_D3D11_MultiDrawIndexedInstancedIndirect", 0x59e890f9 }, + { "NvAPI_D3D_ImplicitSLIControl", 0x2aede111 }, + { "NvAPI_D3D12_GetNeedsAppFPBlendClamping", 0x6ef4d2d1 }, + { "NvAPI_D3D12_UseDriverHeapPriorities", 0xf0d978a8 }, + { "NvAPI_D3D12_Mosaic_GetCompanionAllocations", 0xa46022c7 }, + { "NvAPI_D3D12_Mosaic_GetViewportAndGpuPartitions", 0xb092b818 }, + { "NvAPI_D3D1x_GetGraphicsCapabilities", 0x52b1499a }, + { "NvAPI_D3D12_GetGraphicsCapabilities", 0x01e87354 }, + { "NvAPI_D3D11_RSSetExclusiveScissorRects", 0xae4d73ef }, + { "NvAPI_D3D11_RSSetViewportsPixelShadingRates", 0x34f7938f }, + { "NvAPI_D3D11_CreateShadingRateResourceView", 0x99ca2dff }, + { "NvAPI_D3D11_RSSetShadingRateResourceView", 0x1b0c2f83 }, + { "NvAPI_D3D11_RSGetPixelShadingRateSampleOrder", 0x092442a1 }, + { "NvAPI_D3D11_RSSetPixelShadingRateSampleOrder", 0xa942373a }, + { "NvAPI_D3D_InitializeVRSHelper", 0x4780d70b }, + { "NvAPI_D3D_InitializeNvGazeHandler", 0x5b3b7479 }, + { "NvAPI_D3D_InitializeSMPAssist", 0x42763d0c }, + { "NvAPI_D3D_QuerySMPAssistSupport", 0xc57921de }, + { "NvAPI_D3D_GetSleepStatus", 0xaef96ca1 }, + { "NvAPI_D3D_SetSleepMode", 0xac1ca9e0 }, + { "NvAPI_D3D_Sleep", 0x852cd1d2 }, + { "NvAPI_D3D_SetReflexSync", 0xb9f6faff }, + { "NvAPI_D3D_GetLatency", 0x1a587f9c }, + { "NvAPI_D3D_SetLatencyMarker", 0xd9984c05 }, + { "NvAPI_D3D12_SetAsyncFrameMarker", 0x13c98f73 }, + { "NvAPI_D3D11_SetAsyncFrameMarker", 0x59c2c510 }, + { "NvAPI_D3D12_NotifyOutOfBandCommandQueue", 0x03d6e8cb }, + { "NvAPI_D3D12_SetCreateCommandQueueLowLatencyHint", 0x548c224f }, + { "NvAPI_D3D12_CreateCubinComputeShaderExV2", 0x299f5fdc }, + { "NvAPI_D3D12_CreateCubinComputeShader", 0x2a2c79e8 }, + { "NvAPI_D3D12_CreateCubinComputeShaderEx", 0x3151211b }, + { "NvAPI_D3D12_CreateCubinComputeShaderWithName", 0x1dc7261f }, + { "NvAPI_D3D12_LaunchCubinShader", 0x5c52bb86 }, + { "NvAPI_D3D12_DestroyCubinComputeShader", 0x7fb785ba }, + { "NvAPI_D3D12_GetCudaMergedTextureSamplerObject", 0x329fe6e0 }, + { "NvAPI_D3D12_GetCudaIndependentDescriptorObject", 0x0ddac234 }, + { "NvAPI_D3D12_GetCudaTextureObject", 0x80403fc9 }, + { "NvAPI_D3D12_GetCudaSurfaceObject", 0x48f5b2ee }, + { "NvAPI_D3D12_IsFatbinPTXSupported", 0x70c07832 }, + { "NvAPI_D3D12_CreateCuModule", 0xad1a677d }, + { "NvAPI_D3D12_EnumFunctionsInModule", 0x7ab88d88 }, + { "NvAPI_D3D12_CreateCuFunction", 0xe2436e22 }, + { "NvAPI_D3D12_LaunchCuKernelChain", 0x24973538 }, + { "NvAPI_D3D12_LaunchCuKernelChainEx", 0x846a9bf0 }, + { "NvAPI_D3D12_DestroyCuModule", 0x41c65285 }, + { "NvAPI_D3D12_DestroyCuFunction", 0xdf295ea6 }, + { "NvAPI_D3D11_CreateCubinComputeShaderExV2", 0xf2c71d48 }, + { "NvAPI_D3D11_CreateCubinComputeShader", 0x0ed98181 }, + { "NvAPI_D3D11_CreateCubinComputeShaderEx", 0x32c2a0f6 }, + { "NvAPI_D3D11_CreateCubinComputeShaderWithName", 0xb672be19 }, + { "NvAPI_D3D11_LaunchCubinShader", 0x427e236d }, + { "NvAPI_D3D11_DestroyCubinComputeShader", 0x01682c86 }, + { "NvAPI_D3D11_IsFatbinPTXSupported", 0x6086bd93 }, + { "NvAPI_D3D11_GetCudaIndependentViewObject", 0x34d2afa8 }, + { "NvAPI_D3D11_GetCudaMergedTextureSamplerObject", 0x5d637d8f }, + { "NvAPI_D3D11_CreateUnorderedAccessView", 0x74a497a1 }, + { "NvAPI_D3D11_CreateShaderResourceView", 0x65cb431e }, + { "NvAPI_D3D11_CreateSamplerState", 0x89eca416 }, + { "NvAPI_D3D11_GetCudaTextureObject", 0x9006fa68 }, + { "NvAPI_D3D11_GetResourceGPUVirtualAddress", 0x1819b423 }, + { "NvAPI_D3D12_GetRaytracingCaps", 0x85a6c2a0 }, + { "NvAPI_D3D12_EnableRaytracingValidation", 0x1de5991b }, + { "NvAPI_D3D12_RegisterRaytracingValidationMessageCallback", 0x8554eb38 }, + { "NvAPI_D3D12_UnregisterRaytracingValidationMessageCallback", 0x26975da6 }, + { "NvAPI_D3D12_FlushRaytracingValidationMessages", 0xb8fb1fcb }, + { "NvAPI_D3D12_GetRaytracingDisplacementMicromapArrayPrebuildInfo", 0xfa99b6de }, + { "NvAPI_D3D12_GetRaytracingOpacityMicromapArrayPrebuildInfo", 0x4726d180 }, + { "NvAPI_D3D12_SetCreatePipelineStateOptions", 0x5c607a27 }, + { "NvAPI_D3D12_CheckDriverMatchingIdentifierEx", 0xafb237d4 }, + { "NvAPI_D3D12_GetRaytracingAccelerationStructurePrebuildInfoEx", 0x8d025b77 }, + { "NvAPI_D3D12_BuildRaytracingOpacityMicromapArray", 0x814f8d11 }, + { "NvAPI_D3D12_RelocateRaytracingOpacityMicromapArray", 0x0425c538 }, + { "NvAPI_D3D12_BuildRaytracingDisplacementMicromapArray", 0x066f569d }, + { "NvAPI_D3D12_RelocateRaytracingDisplacementMicromapArray", 0x1c142308 }, + { "NvAPI_D3D12_EmitRaytracingDisplacementMicromapArrayPostbuildInfo", 0x68b9a790 }, + { "NvAPI_D3D12_EmitRaytracingOpacityMicromapArrayPostbuildInfo", 0x1d9a39b6 }, + { "NvAPI_D3D12_BuildRaytracingAccelerationStructureEx", 0xe24ead45 }, + { "NvAPI_D3D12_QueryWorkstationFeatureProperties", 0xa92ea23a }, + { "NvAPI_D3D12_CreateCommittedRDMABuffer", 0xe78dcb44 }, + { "NvAPI_D3D12_ConvertCooperativeVectorMatrix", 0x0f252cb3 }, + { "NvAPI_D3D12_ConvertCooperativeVectorMatrixMultiple", 0x96ba5235 }, + { "NvAPI_D3D12_GetPhysicalDeviceCooperativeVectorProperties", 0x8f182aec }, + { "NvAPI_D3D12_GetRaytracingMultiIndirectClusterOperationRequirementsInfo", 0x5c9163f4 }, + { "NvAPI_D3D12_RaytracingExecuteMultiIndirectClusterOperation", 0x67c798af }, + { "NvAPI_D3D12_GetRaytracingPartitionedTlasIndirectPrebuildInfo", 0xcdfdc5f2 }, + { "NvAPI_D3D12_BuildRaytracingPartitionedTlasIndirect", 0x7cfc6fc3 }, + { "NvAPI_NGX_GetNGXOverrideState", 0x3fd96fba }, + { "NvAPI_NGX_SetNGXOverrideState", 0xb60fcb4e }, + { "NvAPI_DirectD3D12GraphicsCommandList_Create", 0x74a4e712 }, + { "NvAPI_DirectD3D12GraphicsCommandList_Release", 0x99da3dde }, + { "NvAPI_DirectD3D12GraphicsCommandList_Reset", 0x999c26d8 }, + { "NvAPI_VIO_GetCapabilities", 0x1dc91303 }, + { "NvAPI_VIO_Open", 0x44ee4841 }, + { "NvAPI_VIO_Close", 0xd01bd237 }, + { "NvAPI_VIO_Status", 0x0e6ce4f1 }, + { "NvAPI_VIO_SyncFormatDetect", 0x118d48a3 }, + { "NvAPI_VIO_GetConfig", 0xd34a789b }, + { "NvAPI_VIO_SetConfig", 0x0e4eec07 }, + { "NvAPI_VIO_SetCSC", 0xa1ec8d74 }, + { "NvAPI_VIO_GetCSC", 0x7b0d72a3 }, + { "NvAPI_VIO_SetGamma", 0x964bf452 }, + { "NvAPI_VIO_GetGamma", 0x51d53d06 }, + { "NvAPI_VIO_SetSyncDelay", 0x2697a8d1 }, + { "NvAPI_VIO_GetSyncDelay", 0x462214a9 }, + { "NvAPI_VIO_GetPCIInfo", 0xb981d935 }, + { "NvAPI_VIO_IsRunning", 0x96bd040e }, + { "NvAPI_VIO_Start", 0xcde8e1a3 }, + { "NvAPI_VIO_Stop", 0x6ba2a5d6 }, + { "NvAPI_VIO_IsFrameLockModeCompatible", 0x7bf0a94d }, + { "NvAPI_VIO_EnumDevices", 0xfd7c5557 }, + { "NvAPI_VIO_QueryTopology", 0x869534e2 }, + { "NvAPI_VIO_EnumSignalFormats", 0xead72fe4 }, + { "NvAPI_VIO_EnumDataFormats", 0x221fa8e8 }, + { "NvAPI_Stereo_CreateConfigurationProfileRegistryKey", 0xbe7692ec }, + { "NvAPI_Stereo_DeleteConfigurationProfileRegistryKey", 0xf117b834 }, + { "NvAPI_Stereo_SetConfigurationProfileValue", 0x24409f48 }, + { "NvAPI_Stereo_DeleteConfigurationProfileValue", 0x49bceecf }, + { "NvAPI_Stereo_Enable", 0x239c4545 }, + { "NvAPI_Stereo_Disable", 0x2ec50c2b }, + { "NvAPI_Stereo_IsEnabled", 0x348ff8e1 }, + { "NvAPI_Stereo_GetStereoSupport", 0x296c434d }, + { "NvAPI_Stereo_CreateHandleFromIUnknown", 0xac7e37f4 }, + { "NvAPI_Stereo_DestroyHandle", 0x3a153134 }, + { "NvAPI_Stereo_Activate", 0xf6a1ad68 }, + { "NvAPI_Stereo_Deactivate", 0x2d68de96 }, + { "NvAPI_Stereo_IsActivated", 0x1fb0bc30 }, + { "NvAPI_Stereo_GetSeparation", 0x451f2134 }, + { "NvAPI_Stereo_SetSeparation", 0x5c069fa3 }, + { "NvAPI_Stereo_DecreaseSeparation", 0xda044458 }, + { "NvAPI_Stereo_IncreaseSeparation", 0xc9a8ecec }, + { "NvAPI_Stereo_GetConvergence", 0x4ab00934 }, + { "NvAPI_Stereo_SetConvergence", 0x3dd6b54b }, + { "NvAPI_Stereo_DecreaseConvergence", 0x4c87e317 }, + { "NvAPI_Stereo_IncreaseConvergence", 0xa17daabe }, + { "NvAPI_Stereo_GetFrustumAdjustMode", 0xe6839b43 }, + { "NvAPI_Stereo_SetFrustumAdjustMode", 0x7be27fa2 }, + { "NvAPI_Stereo_CaptureJpegImage", 0x932cb140 }, + { "NvAPI_Stereo_InitActivation", 0xc7177702 }, + { "NvAPI_Stereo_Trigger_Activation", 0x0d6c6cd2 }, + { "NvAPI_Stereo_CapturePngImage", 0x8b7e99b5 }, + { "NvAPI_Stereo_ReverseStereoBlitControl", 0x3cd58f89 }, + { "NvAPI_Stereo_SetNotificationMessage", 0x6b9b409e }, + { "NvAPI_Stereo_SetActiveEye", 0x96eea9f8 }, + { "NvAPI_Stereo_SetDriverMode", 0x5e8f0bec }, + { "NvAPI_Stereo_GetEyeSeparation", 0xce653127 }, + { "NvAPI_Stereo_IsWindowedModeSupported", 0x40c8ed5e }, + { "NvAPI_Stereo_SetSurfaceCreationMode", 0xf5dcfcba }, + { "NvAPI_Stereo_GetSurfaceCreationMode", 0x36f1c736 }, + { "NvAPI_Stereo_Debug_WasLastDrawStereoized", 0xed4416c5 }, + { "NvAPI_Stereo_SetDefaultProfile", 0x44f0ecd1 }, + { "NvAPI_Stereo_GetDefaultProfile", 0x624e21c2 }, + { "NvAPI_D3D1x_CreateSwapChain", 0x1bc21b66 }, + { "NvAPI_D3D9_CreateSwapChain", 0x1a131e09 }, + { "NvAPI_Vulkan_InitLowLatencyDevice", 0x5c1696b6 }, + { "NvAPI_Vulkan_DestroyLowLatencyDevice", 0x11a5932b }, + { "NvAPI_Vulkan_GetSleepStatus", 0xadf966af }, + { "NvAPI_Vulkan_SetSleepMode", 0x2acfd162 }, + { "NvAPI_Vulkan_Sleep", 0x36732b1e }, + { "NvAPI_Vulkan_GetLatency", 0x3233d44a }, + { "NvAPI_Vulkan_SetLatencyMarker", 0xa17d13d6 }, + { "NvAPI_Vulkan_NotifyOutOfBandVkQueue", 0x5d6d3840 }, + { "NvAPI_DRS_CreateSession", 0x0694d52e }, + { "NvAPI_DRS_DestroySession", 0xdad9cff8 }, + { "NvAPI_DRS_LoadSettings", 0x375dbd6b }, + { "NvAPI_DRS_SaveSettings", 0xfcbc7e14 }, + { "NvAPI_DRS_LoadSettingsFromFile", 0xd3ede889 }, + { "NvAPI_DRS_SaveSettingsToFile", 0x2be25df8 }, + { "NvAPI_DRS_CreateProfile", 0xcc176068 }, + { "NvAPI_DRS_DeleteProfile", 0x17093206 }, + { "NvAPI_DRS_SetCurrentGlobalProfile", 0x1c89c5df }, + { "NvAPI_DRS_GetCurrentGlobalProfile", 0x617bff9f }, + { "NvAPI_DRS_GetProfileInfo", 0x61cd6fd6 }, + { "NvAPI_DRS_SetProfileInfo", 0x16abd3a9 }, + { "NvAPI_DRS_FindProfileByName", 0x7e4a9a0b }, + { "NvAPI_DRS_EnumProfiles", 0xbc371ee0 }, + { "NvAPI_DRS_GetNumProfiles", 0x1dae4fbc }, + { "NvAPI_DRS_CreateApplication", 0x4347a9de }, + { "NvAPI_DRS_DeleteApplicationEx", 0xc5ea85a1 }, + { "NvAPI_DRS_DeleteApplication", 0x2c694bc6 }, + { "NvAPI_DRS_GetApplicationInfo", 0xed1f8c69 }, + { "NvAPI_DRS_EnumApplications", 0x7fa2173a }, + { "NvAPI_DRS_FindApplicationByName", 0xeee566b2 }, + { "NvAPI_DRS_SetSetting", 0x577dd202 }, + { "NvAPI_DRS_GetSetting", 0x73bf8338 }, + { "NvAPI_DRS_EnumSettings", 0xae3039da }, + { "NvAPI_DRS_EnumAvailableSettingIds", 0xf020614a }, + { "NvAPI_DRS_EnumAvailableSettingValues", 0x2ec39f90 }, + { "NvAPI_DRS_GetSettingIdFromName", 0xcb7309cd }, + { "NvAPI_DRS_GetSettingNameFromId", 0xd61cbe6e }, + { "NvAPI_DRS_DeleteProfileSetting", 0xe4a26362 }, + { "NvAPI_DRS_RestoreAllDefaults", 0x5927b094 }, + { "NvAPI_DRS_RestoreProfileDefault", 0xfa5f6134 }, + { "NvAPI_DRS_RestoreProfileDefaultSetting", 0x53f0381e }, + { "NvAPI_DRS_GetBaseProfile", 0xda8466a0 }, + { "NvAPI_SYS_GetChipSetInfo", 0x53dabbca }, + { "NvAPI_SYS_GetLidAndDockInfo", 0xcda14d8a }, + { "NvAPI_SYS_GetDisplayIdFromGpuAndOutputId", 0x08f2bab4 }, + { "NvAPI_SYS_GetGpuAndOutputIdFromDisplayId", 0x112ba1a5 }, + { "NvAPI_SYS_GetPhysicalGpuFromDisplayId", 0x9ea74659 }, + { "NvAPI_SYS_GetDisplayDriverInfo", 0x721faceb }, + { "NvAPI_SYS_GetPhysicalGPUs", 0xd3b24d2d }, + { "NvAPI_SYS_GetLogicalGPUs", 0xccfffc10 }, + { "NvAPI_NGX_GetDriverFeatureSupport", 0x6194b19d }, + { "NvAPI_GPU_ClientRegisterForUtilizationSampleUpdates", 0xadeeaf67 }, + { "NvAPI_RegisterRiseCallback", 0x9cfe8f94 }, + { "NvAPI_RequestRise", 0x5047de98 }, + { "NvAPI_UninstallRise", 0xab8d09f6 }, +); + +#[no_mangle] +pub unsafe extern "C" fn nvapi_QueryInterface(interface: u32) -> *mut c_void { + let maybe_fn_ptr_global = (&*GLOBAL_STATE).as_ref().and_then(|(lib, state)| { + let fn_ptr = lib + .get:: *mut c_void>(b"nvapi_QueryInterface\0") + .ok()?; + Some((fn_ptr, state)) + }); + let (fn_ptr, global_state) = + unwrap_or::unwrap_some_or!(maybe_fn_ptr_global, return ptr::null_mut()); + let export_table = unwrap_or::unwrap_some_or!( + ::zluda_trace_common::get_export_table(), + return ptr::null_mut() + ); + let format_args = dark_api::FnFfiWrapper(|| { + use std::io::Write; + let mut writer = Vec::new(); + let name = interface_to_name(interface); + match name { + Some(name) => write!(&mut writer, "(interface: {})", name).ok(), + None => write!(&mut writer, "(interface: {:#010x})", interface).ok(), + }; + dark_api::ByteVecFfi::new(writer) + }); + let underlying_fn = dark_api::FnFfiWrapper(|| { + let result = fn_ptr(interface); + result as usize + }); + let original: *mut c_void = ReprUsize::from_usize(export_table.logged_call( + cglue::slice::CSliceRef::from_str("nvapi_QueryInterface"), + 0, + cglue::trait_obj!(&format_args as dark_api::FnFfi), + cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), + ptr::null_mut::() as usize, + <*mut c_void as ReprUsize>::format_status, + )); + if cfg!(target_pointer_width = "32") && !original.is_null() { + global_state + .lock() + .ok() + .map(|mut state| state.get_thunk(original, report_fn, interface)) + .unwrap_or_else(|| get_thunk(original, report_fn, interface)) + } else { + original + } +} + +unsafe extern "C" fn report_fn(result: i32, interface: u32) { + let export_table = unwrap_or::unwrap_some_or!(::zluda_trace_common::get_export_table(), return); + let format_args = + dark_api::FnFfiWrapper(|| dark_api::ByteVecFfi::new("(...)".as_bytes().to_vec())); + let underlying_fn = dark_api::FnFfiWrapper(|| ReprUsize::to_usize(result)); + let (fn_name, interface) = match interface_to_name(interface) { + Some(name) => (name, 0), + None => ("", interface), + }; + export_table.logged_call( + cglue::slice::CSliceRef::from_str(fn_name), + interface, + cglue::trait_obj!(&format_args as dark_api::FnFfi), + cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), + ::INTERNAL_ERROR, + ::format_status, + ); +} + +#[cfg(target_arch = "x86")] +pub fn get_thunk( + original_fn: *mut c_void, + report_fn: unsafe extern "C" fn(i32, u32), + interface: u32, +) -> *mut c_void { + use dynasmrt::{dynasm, DynasmApi}; + let mut ops = dynasmrt::x86::Assembler::new().unwrap(); + let start = ops.offset(); + dynasm!(ops + ; .arch x86 + ; push ebp + ; mov ebp, esp + ; push DWORD [ebp+68] + ; push DWORD [ebp+64] + ; push DWORD [ebp+60] + ; push DWORD [ebp+56] + ; push DWORD [ebp+52] + ; push DWORD [ebp+48] + ; push DWORD [ebp+44] + ; push DWORD [ebp+40] + ; push DWORD [ebp+36] + ; push DWORD [ebp+32] + ; push DWORD [ebp+28] + ; push DWORD [ebp+24] + ; push DWORD [ebp+20] + ; push DWORD [ebp+16] + ; push DWORD [ebp+12] + ; push DWORD [ebp+8] + ; mov eax, original_fn as i32 + ; call eax + ; push interface as i32 + ; push eax + ; mov eax, report_fn as i32 + ; call eax + ; pop eax + ; leave + ; ret + ; int 3 + ); + let exe_buf = ops.finalize().unwrap(); + let result_fn = exe_buf.ptr(start); + std::mem::forget(exe_buf); + result_fn as *mut _ +} + +#[cfg(target_arch = "x86_64")] +pub fn get_thunk( + _original_fn: *mut c_void, + _report_fn: unsafe extern "C" fn(i32, u32), + _interface: u32, +) -> *mut c_void { + todo!() +} diff --git a/ptx/lib/zluda_ptx_impl.cpp b/ptx/lib/zluda_ptx_impl.cpp index 65d5545bd..2676ed294 100644 --- a/ptx/lib/zluda_ptx_impl.cpp +++ b/ptx/lib/zluda_ptx_impl.cpp @@ -1132,7 +1132,7 @@ extern "C" v4##RETURN_TYPE FUNC(texobj_3d_v4_##RETURN_TYPE##_##COORD_TYPE)(uint64_t texobj, v4##COORD_TYPE coord) \ { \ auto [i, s] = get_image_and_sampler(texobj); \ - auto result = sample_3D(i, s, v4f32{float(coord.x), float(coord.y), float(coord.z), float(coord.w)}); \ + auto result = sample_3D(i, s, v4f32{float(coord.x), float(coord.y), float(coord.z), float(coord.w)}); \ return v4##RETURN_TYPE{std::bit_cast(result.x), std::bit_cast(result.y), std::bit_cast(result.z), std::bit_cast(result.w)}; \ } \ v4##RETURN_TYPE FUNC(texref_3d_v4_##RETURN_TYPE##_##COORD_TYPE)(struct textureReference GLOBAL_SPACE * texref, v4##COORD_TYPE coord) \ diff --git a/ptx/src/pass/convert_32bit_to_64bit.rs b/ptx/src/pass/convert_32bit_to_64bit.rs index 9760b0da8..6ebc7f582 100644 --- a/ptx/src/pass/convert_32bit_to_64bit.rs +++ b/ptx/src/pass/convert_32bit_to_64bit.rs @@ -31,18 +31,24 @@ pub(super) fn run<'input>( TranslateError, > { let (global_ids, globals) = collect_globals(resolver, &directives)?; - let mut explicit_arg_count = Vec::new(); + let mut explicit_args_size_align = Vec::new(); let directives = directives .into_iter() .filter_map(|directive| { - run_directive(resolver, directive, &global_ids, &mut explicit_arg_count).transpose() + run_directive( + resolver, + directive, + &global_ids, + &mut explicit_args_size_align, + ) + .transpose() }) .collect::, _>>()?; Ok(( directives, ModuleMetadata32Bit { globals, - explicit_arg_count, + explicit_args_size_align, }, )) } @@ -136,7 +142,7 @@ fn run_directive<'input>( resolver: &mut GlobalStringIdentResolver2<'input>, directive: Directive2, SpirvWord>, globals_ids: &[SpirvWord], - explicit_arg_count: &mut Vec<(String, u32)>, + explicit_args_size_align: &mut Vec<(String, Vec<(u32, u32)>)>, ) -> Result, SpirvWord>>, TranslateError> { Ok(match directive { Directive2::Variable(linking, varinfo) if pass_through_variable(&varinfo) => { @@ -146,7 +152,7 @@ fn run_directive<'input>( resolver, method, globals_ids, - explicit_arg_count, + explicit_args_size_align, )?)), _ => None, }) @@ -156,7 +162,7 @@ fn run_method<'input>( resolver: &mut GlobalStringIdentResolver2<'input>, mut method: Function, SpirvWord>, globals_ids: &[SpirvWord], - explicit_arg_count: &mut Vec<(String, u32)>, + explicit_args_size_align: &mut Vec<(String, Vec<(u32, u32)>)>, ) -> Result, SpirvWord>, TranslateError> { let is_kernel = method.is_kernel(); if let Some(ref mut body) = method.body { @@ -181,7 +187,17 @@ fn run_method<'input>( }) .ok_or_else(error_unreachable)? .to_string(); - explicit_arg_count.push((text_name, method.input_arguments.len() as u32)); + let argument_sizes = method + .input_arguments + .iter() + .map(|arg| { + let layout = arg.info.v_type.layout().unwrap(); + let size = layout.size() as u32; + let align = layout.align() as u32; + (size, align) + }) + .collect(); + explicit_args_size_align.push((text_name, argument_sizes)); let implicit_memory_ptr = add_hidden_argument( resolver, ast::ScalarType::B64, diff --git a/ptx/src/pass/llvm/attributes.rs b/ptx/src/pass/llvm/attributes.rs index ffde4c6c9..1b60584ed 100644 --- a/ptx/src/pass/llvm/attributes.rs +++ b/ptx/src/pass/llvm/attributes.rs @@ -38,7 +38,7 @@ fn emit_attribute( module.get(), attribute_type, name.as_ptr(), - get_state_space(ast::StateSpace::Const)?, + get_state_space(ast::StateSpace::Const, false)?, ) }; unsafe { LLVMSetLinkage(global, llvm_zluda::LLVMLinkage::LLVMExternalLinkage) }; diff --git a/ptx/src/pass/llvm/emit.rs b/ptx/src/pass/llvm/emit.rs index 9bfbcd92e..942e13764 100644 --- a/ptx/src/pass/llvm/emit.rs +++ b/ptx/src/pass/llvm/emit.rs @@ -66,9 +66,10 @@ pub(crate) fn run<'input>( context: &Context, id_defs: GlobalStringIdentResolver2<'input>, directives: Vec, SpirvWord>>, + is_32bit: bool, ) -> Result { let module = llvm::Module::new(context, LLVM_UNNAMED); - let mut emit_ctx = ModuleEmitContext::new(context, &module, &id_defs); + let mut emit_ctx = ModuleEmitContext::new(context, &module, &id_defs, is_32bit); for directive in directives { match directive { Directive2::Variable(linking, variable) => emit_ctx.emit_global(linking, variable)?, @@ -83,12 +84,223 @@ pub(crate) fn run<'input>( Ok(module) } +#[derive(Debug, Clone, Copy)] +struct ZludaTypeToLLVM { + context: LLVMContextRef, + is_32bit: bool, +} + +impl ZludaTypeToLLVM { + fn get_state_space(&self, space: ast::StateSpace) -> Result { + get_state_space(space, self.is_32bit) + } + + fn get_input_argument_type( + &self, + v_type: &ast::Type, + state_space: ast::StateSpace, + ) -> Result { + match state_space { + ast::StateSpace::ParamEntry | ast::StateSpace::Shared => Ok(unsafe { + LLVMPointerTypeInContext(self.context, self.get_state_space(state_space)?) + }), + ast::StateSpace::Reg => self.get_type(v_type), + ast::StateSpace::Global | ast::StateSpace::Const + if matches!(v_type, ast::Type::Texref) => + { + Ok(unsafe { + LLVMPointerTypeInContext(self.context, self.get_state_space(state_space)?) + }) + } + _ => return Err(error_unreachable()), + } + } + + fn get_pointer_type<'ctx>( + &self, + to_space: ast::StateSpace, + ) -> Result { + Ok(unsafe { LLVMPointerTypeInContext(self.context, self.get_state_space(to_space)?) }) + } + + fn get_type(&self, type_: &ast::Type) -> Result { + Ok(match type_ { + ast::Type::Scalar(scalar) => get_scalar_type(self.context, *scalar), + ast::Type::Vector(size, scalar) => { + let base_type = get_scalar_type(self.context, *scalar); + unsafe { LLVMVectorType(base_type, *size as u32) } + } + ast::Type::Array(vec, scalar, dimensions) => { + let mut underlying_type = get_scalar_type(self.context, *scalar); + if let Some(size) = vec { + underlying_type = unsafe { LLVMVectorType(underlying_type, size.get() as u32) }; + } + if dimensions.is_empty() { + return Ok(unsafe { LLVMArrayType2(underlying_type, 0) }); + } + dimensions + .iter() + .rfold(underlying_type, |result, dimension| unsafe { + LLVMArrayType2(result, *dimension as u64) + }) + } + ast::Type::Texref => { + // Definitions taken from ROCm LLVM output + let format_desc = unsafe { + LLVMStructCreateNamed(self.context, c"struct.hipChannelFormatDesc".as_ptr()) + }; + let llvm_i32 = get_scalar_type(self.context, ast::ScalarType::B32); + let mut format_desc_fields = [llvm_i32, llvm_i32, llvm_i32, llvm_i32, llvm_i32]; + unsafe { + LLVMStructSetBody( + format_desc, + format_desc_fields.as_mut_ptr(), + format_desc_fields.len() as u32, + 0, + ) + }; + let texture_reference = unsafe { + LLVMStructCreateNamed(self.context, c"struct.textureReference".as_ptr()) + }; + let llvm_a3i32 = unsafe { LLVMArrayType2(llvm_i32, 3) }; + let llvm_float = get_scalar_type(self.context, ast::ScalarType::F32); + let llvm_ptr = self.get_pointer_type(ast::StateSpace::Generic)?; + let mut texture_reference_fields = [ + llvm_i32, + llvm_i32, + llvm_i32, + llvm_a3i32, + format_desc, + llvm_i32, + llvm_i32, + llvm_i32, + llvm_float, + llvm_float, + llvm_float, + llvm_ptr, + llvm_i32, + llvm_i32, + ]; + unsafe { + LLVMStructSetBody( + texture_reference, + texture_reference_fields.as_mut_ptr(), + texture_reference_fields.len() as u32, + 0, + ) + }; + let texture = + unsafe { LLVMStructCreateNamed(self.context, c"struct.texture".as_ptr()) }; + let mut texture_fields = [texture_reference]; + unsafe { + LLVMStructSetBody( + texture, + texture_fields.as_mut_ptr(), + texture_fields.len() as u32, + 0, + ) + }; + texture + } + }) + } + + fn get_anonymous_struct_type<'a>( + &self, + elem_types: impl Iterator, + ) -> Result { + let mut elem_types = elem_types + .map(|t| self.get_type(t)) + .collect::, _>>()?; + Ok(unsafe { + LLVMStructTypeInContext( + self.context, + elem_types.as_mut_ptr(), + elem_types.len() as u32, + 0, + ) + }) + } + + fn get_function_type_impl<'a>( + &self, + mut return_args: impl DoubleEndedIterator + + ExactSizeIterator, + input_args: impl Iterator>, + struct_kind: StructKind, + ) -> Result { + let mut input_args = input_args.collect::, _>>()?; + let return_type = match return_args.len() { + 0 => unsafe { LLVMVoidTypeInContext(self.context) }, + 1 => self.get_type(&return_args.next().unwrap())?, + _ => match struct_kind { + StructKind::Named => self.get_or_create_struct_type(return_args)?, + StructKind::Anonymous => self.get_anonymous_struct_type(return_args)?, + }, + }; + + Ok(unsafe { + LLVMFunctionType( + return_type, + input_args.as_mut_ptr(), + input_args.len() as u32, + 0, + ) + }) + } + + fn get_function_type<'a>( + &self, + return_args: impl DoubleEndedIterator + + ExactSizeIterator, + input_args: impl Iterator>, + ) -> Result { + self.get_function_type_impl(return_args, input_args, StructKind::Named) + } + + fn get_intrinsic_type<'a>( + &self, + return_args: impl DoubleEndedIterator + + ExactSizeIterator, + input_args: impl Iterator>, + ) -> Result { + self.get_function_type_impl(return_args, input_args, StructKind::Anonymous) + } + + fn get_or_create_struct_type<'a>( + &self, + mut elem_types: impl Iterator, + ) -> Result { + use std::fmt::Write; + let (mut name, types) = elem_types.try_fold( + ("struct".to_string(), Vec::new()), + |(mut name, mut types), t| { + name.push('.'); + if let ast::Type::Scalar(scalar) = t { + write!(name, "{}", LLVMTypeDisplay(*scalar)).ok(); + } else { + return Err(error_unreachable()); + } + types.push(self.get_type(t)?); + Ok((name, types)) + }, + )?; + name.push('\0'); + let mut struct_type = unsafe { LLVMGetTypeByName2(self.context, name.as_ptr().cast()) }; + if struct_type.is_null() { + struct_type = create_struct_type(self.context, name, types); + } + Ok(struct_type) + } +} + struct ModuleEmitContext<'a, 'input> { context: LLVMContextRef, module: LLVMModuleRef, builder: Builder, id_defs: &'a GlobalStringIdentResolver2<'input>, resolver: ResolveIdent, + llvm_types: ZludaTypeToLLVM, } impl<'a, 'input> ModuleEmitContext<'a, 'input> { @@ -96,6 +308,7 @@ impl<'a, 'input> ModuleEmitContext<'a, 'input> { context: &Context, module: &llvm::Module, id_defs: &'a GlobalStringIdentResolver2<'input>, + is_32bit: bool, ) -> Self { ModuleEmitContext { context: context.get(), @@ -103,6 +316,10 @@ impl<'a, 'input> ModuleEmitContext<'a, 'input> { builder: Builder::new(context), id_defs, resolver: ResolveIdent::new(&id_defs), + llvm_types: ZludaTypeToLLVM { + context: context.get(), + is_32bit, + }, } } @@ -126,11 +343,11 @@ impl<'a, 'input> ModuleEmitContext<'a, 'input> { let name = CString::new(name).map_err(|_| error_unreachable())?; let mut fn_ = unsafe { LLVMGetNamedFunction(self.module, name.as_ptr()) }; if fn_ == ptr::null_mut() { - let fn_type = get_function_type( - self.context, + let fn_type = self.llvm_types.get_function_type( method.return_arguments.iter().map(|v| &v.info.v_type), method.input_arguments.iter().map(|v| { - get_input_argument_type(self.context, &v.info.v_type, v.info.state_space) + self.llvm_types + .get_input_argument_type(&v.info.v_type, v.info.state_space) }), )?; fn_ = unsafe { LLVMAddFunction(self.module, name.as_ptr(), fn_type) }; @@ -176,7 +393,7 @@ impl<'a, 'input> ModuleEmitContext<'a, 'input> { LLVMCreateTypeAttribute( self.context, attr_kind, - get_type(self.context, ¶m.info.v_type)?, + self.llvm_types.get_type(¶m.info.v_type)?, ) }; unsafe { LLVMAddAttributeAtIndex(fn_, i as u32 + 1, attr) }; @@ -214,7 +431,7 @@ impl<'a, 'input> ModuleEmitContext<'a, 'input> { unsafe { LLVMPositionBuilderAtEnd(self.builder.get(), real_bb) }; let base_32bit_memory = method.kernel_meta32.as_ref().map(|m| m.implicit_memory_ptr); let mut method_emitter = - MethodEmitContext::new(self, fn_, variables_builder, base_32bit_memory, is_kernel); + MethodEmitContext::new(self, fn_, variables_builder, self.llvm_types, base_32bit_memory, is_kernel); for var in method.return_arguments { method_emitter.emit_variable(var)?; } @@ -257,13 +474,13 @@ impl<'a, 'input> ModuleEmitContext<'a, 'input> { .transpose() .map_err(|_| error_unreachable())? .unwrap_or(Cow::Borrowed(LLVM_UNNAMED)); - let llvm_type = get_type(self.context, &var.info.v_type)?; + let llvm_type = self.llvm_types.get_type(&var.info.v_type)?; let global = unsafe { LLVMAddGlobalInAddressSpace( self.module, llvm_type, name.as_ptr(), - get_state_space(var.info.state_space)?, + self.llvm_types.get_state_space(var.info.state_space)?, ) }; if matches!(var.info.v_type, ast::Type::Texref) { @@ -441,23 +658,6 @@ fn llvm_ftz(ftz: bool) -> &'static str { } } -fn get_input_argument_type( - context: LLVMContextRef, - v_type: &ast::Type, - state_space: ast::StateSpace, -) -> Result { - match state_space { - ast::StateSpace::ParamEntry | ast::StateSpace::Shared => { - Ok(unsafe { LLVMPointerTypeInContext(context, get_state_space(state_space)?) }) - } - ast::StateSpace::Reg => get_type(context, v_type), - ast::StateSpace::Global | ast::StateSpace::Const if matches!(v_type, ast::Type::Texref) => { - Ok(unsafe { LLVMPointerTypeInContext(context, get_state_space(state_space)?) }) - } - _ => return Err(error_unreachable()), - } -} - struct MethodEmitContext<'a> { context: LLVMContextRef, module: LLVMModuleRef, @@ -466,6 +666,7 @@ struct MethodEmitContext<'a> { variables_builder: Builder, resolver: &'a mut ResolveIdent, carry_flag: Option, + llvm_types: ZludaTypeToLLVM, base_32bit_memory: Option, is_kernel: bool, } @@ -475,6 +676,7 @@ impl<'a> MethodEmitContext<'a> { parent: &'a mut ModuleEmitContext, method: LLVMValueRef, variables_builder: Builder, + llvm_types: ZludaTypeToLLVM, base_32bit_memory: Option, is_kernel: bool, ) -> MethodEmitContext<'a> { @@ -486,6 +688,7 @@ impl<'a> MethodEmitContext<'a> { resolver: &mut parent.resolver, method, carry_flag: None, + llvm_types, base_32bit_memory, is_kernel, } @@ -543,8 +746,8 @@ impl<'a> MethodEmitContext<'a> { let alloca = unsafe { LLVMZludaBuildAlloca( self.variables_builder.get(), - get_type(self.context, &var.info.v_type)?, - get_state_space(var.info.state_space)?, + self.llvm_types.get_type(&var.info.v_type)?, + self.llvm_types.get_state_space(var.info.state_space)?, self.resolver.get_or_add_raw(var.name), ) }; @@ -685,7 +888,7 @@ impl<'a> MethodEmitContext<'a> { arguments: ast::LdArgs, ) -> Result<(), TranslateError> { let builder = self.builder; - let underlying_type = get_type(self.context, &data.typ)?; + let underlying_type = self.llvm_types.get_type(&data.typ)?; let needs_cast = not_supported_by_atomics(data.qualifier, underlying_type); let op_type = if needs_cast { unsafe { @@ -729,7 +932,7 @@ impl<'a> MethodEmitContext<'a> { ), ConversionKind::SignExtend => { let src = self.resolver.value(conversion.src)?; - let type_ = get_type(self.context, &conversion.to_type)?; + let type_ = self.llvm_types.get_type(&conversion.to_type)?; self.resolver.with_result(conversion.dst, |dst| unsafe { LLVMBuildSExt(builder, src, type_, dst) }); @@ -737,7 +940,7 @@ impl<'a> MethodEmitContext<'a> { } ConversionKind::BitToPtr => { let src = self.resolver.value(conversion.src)?; - let ptr_type = get_pointer_type(self.context, conversion.to_space)?; + let ptr_type = self.llvm_types.get_pointer_type(conversion.to_space)?; if let ( Some(base32), ast::StateSpace::Global | ast::StateSpace::Generic | ast::StateSpace::Const, @@ -776,8 +979,11 @@ impl<'a> MethodEmitContext<'a> { src: conversion.src, }); } + if self.base_32bit_memory.is_some() { + return Err(error_todo()); + } let src = self.resolver.value(conversion.src)?; - let dst_type = get_pointer_type(self.context, conversion.to_space)?; + let dst_type = self.llvm_types.get_pointer_type(conversion.to_space)?; self.resolver.with_result(conversion.dst, |dst| unsafe { LLVMBuildAddrSpaceCast(builder, src, dst_type, dst) }); @@ -785,7 +991,7 @@ impl<'a> MethodEmitContext<'a> { } ConversionKind::AddressOf => { let src = self.resolver.value(conversion.src)?; - let dst_type = get_type(self.context, &conversion.to_type)?; + let dst_type = self.llvm_types.get_type(&conversion.to_type)?; if let ( Some(_), ast::StateSpace::Global | ast::StateSpace::Generic | ast::StateSpace::Const, @@ -817,7 +1023,7 @@ impl<'a> MethodEmitContext<'a> { let from_layout = from_type.layout(); let to_layout = to_type.layout().ok_or_else(error_unreachable)?; if from_layout.size() == to_layout.size() { - let dst_type = get_type(self.context, &to_type)?; + let dst_type = self.llvm_types.get_type(&to_type)?; if from_type.kind() != ast::ScalarKind::Float && to_type_scalar.kind() != ast::ScalarKind::Float { @@ -903,7 +1109,7 @@ impl<'a> MethodEmitContext<'a> { | (ast::Type::Scalar(..), ast::Type::Vector(..)) | (ast::Type::Scalar(..), ast::Type::Array(..)) | (ast::Type::Array(..), ast::Type::Scalar(..)) => { - let dst_type = get_type(self.context, to_type)?; + let dst_type = self.llvm_types.get_type(to_type)?; self.resolver.with_result(dst, |dst| unsafe { LLVMBuildBitCast(self.builder, src, dst_type, dst) }); @@ -988,7 +1194,7 @@ impl<'a> MethodEmitContext<'a> { LLVMZludaBuildAlloca( self.variables_builder.get(), LLVMIntTypeInContext(self.context, 1), - get_state_space(ast::StateSpace::Reg)?, + self.llvm_types.get_state_space(ast::StateSpace::Reg)?, c"__ZLUDA_REG_CC_CF".as_ptr(), ) }; @@ -1152,7 +1358,7 @@ impl<'a> MethodEmitContext<'a> { arguments: ast::StArgs, ) -> Result<(), TranslateError> { let ptr = self.resolver.value(arguments.src1)?; - let underlying_type = get_type(self.context, &data.typ)?; + let underlying_type = self.llvm_types.get_type(&data.typ)?; let needs_cast = not_supported_by_atomics(data.qualifier, underlying_type); let mut value = self.resolver.value(arguments.src2)?; if needs_cast { @@ -1199,12 +1405,11 @@ impl<'a> MethodEmitContext<'a> { [dst] => self.resolver.get_or_add_raw(*dst), _ => LLVM_UNNAMED.as_ptr(), }; - let type_ = get_function_type( - self.context, + let type_ = self.llvm_types.get_function_type( data.return_arguments.iter().map(|(type_, ..)| type_), data.input_arguments .iter() - .map(|(type_, space)| get_input_argument_type(self.context, &type_, *space)), + .map(|(type_, space)| self.llvm_types.get_input_argument_type(&type_, *space)), )?; let mut input_arguments = arguments .input_arguments @@ -1365,7 +1570,7 @@ impl<'a> MethodEmitContext<'a> { .iter() .map(|(value, type_)| { let value = self.resolver.value(*value)?; - let lowered_type = get_type(self.context, type_)?; + let lowered_type = self.llvm_types.get_type(type_)?; let load = unsafe { LLVMBuildLoad2(self.builder, lowered_type, value, LLVM_UNNAMED.as_ptr()) }; @@ -1382,8 +1587,9 @@ impl<'a> MethodEmitContext<'a> { [] => unsafe { LLVMBuildRetVoid(self.builder) }, [(value, _)] => unsafe { LLVMBuildRet(self.builder, *value) }, loads => { - let struct_type = - get_or_create_struct_type(self.context, loads.iter().map(|(_, type_)| *type_))?; + let struct_type = self + .llvm_types + .get_or_create_struct_type(loads.iter().map(|(_, type_)| *type_))?; let mut value = unsafe { LLVMGetUndef(struct_type) }; for (i, (load, _)) in loads.iter().enumerate() { value = unsafe { @@ -1607,10 +1813,9 @@ impl<'a> MethodEmitContext<'a> { }); } } else { - let vector_type = get_type( - self.context, - &ast::Type::Vector(repack.unpacked.len() as u8, repack.typ), - )?; + let vector_type = self + .llvm_types + .get_type(&ast::Type::Vector(repack.unpacked.len() as u8, repack.typ))?; let mut temp_vec = unsafe { LLVMGetUndef(vector_type) }; for (index, src_id) in repack.unpacked.iter().enumerate() { let dst = if index == repack.unpacked.len() - 1 { @@ -1716,8 +1921,19 @@ impl<'a> MethodEmitContext<'a> { (data.state_space, ast::StateSpace::Generic) } }; - let from_type = get_pointer_type(self.context, from_space)?; - let dest_type = get_pointer_type(self.context, to_space)?; + if self.base_32bit_memory.is_some() + && matches!( + data.state_space, + ast::StateSpace::Global | ast::StateSpace::Generic | ast::StateSpace::Const + ) + { + return self.emit_mov(ast::MovArgs { + dst: arguments.dst, + src: arguments.src, + }); + } + let from_type = self.llvm_types.get_pointer_type(from_space)?; + let dest_type = self.llvm_types.get_pointer_type(to_space)?; let src = self.resolver.value(arguments.src)?; let temp_ptr = unsafe { LLVMBuildIntToPtr(self.builder, src, from_type, LLVM_UNNAMED.as_ptr()) }; @@ -1809,8 +2025,7 @@ impl<'a> MethodEmitContext<'a> { return_types: Vec<&ast::Type>, arguments: Vec<(LLVMValueRef, LLVMTypeRef)>, ) -> Result { - let fn_type = get_intrinsic_type( - self.context, + let fn_type = self.llvm_types.get_intrinsic_type( return_types.iter().copied(), arguments.iter().map(|(_, type_)| Ok(*type_)), )?; @@ -3263,10 +3478,10 @@ impl<'a> MethodEmitContext<'a> { let vector_result = unsafe { LLVMBuildInsertElement( self.builder, - LLVMGetPoison(get_type( - self.context, - &ast::Type::Vector(2, ast::ScalarType::U16), - )?), + LLVMGetPoison( + self.llvm_types + .get_type(&ast::Type::Vector(2, ast::ScalarType::U16))?, + ), setp_result_0, zero, LLVM_UNNAMED.as_ptr(), @@ -3296,10 +3511,10 @@ impl<'a> MethodEmitContext<'a> { let vector_result = unsafe { LLVMBuildInsertElement( self.builder, - LLVMGetPoison(get_type( - self.context, - &ast::Type::Vector(2, ast::ScalarType::F16), - )?), + LLVMGetPoison( + self.llvm_types + .get_type(&ast::Type::Vector(2, ast::ScalarType::F16))?, + ), setp_result_0, zero, LLVM_UNNAMED.as_ptr(), @@ -3717,13 +3932,6 @@ fn apply_qualifier( Ok(()) } -fn get_pointer_type<'ctx>( - context: LLVMContextRef, - to_space: ast::StateSpace, -) -> Result { - Ok(unsafe { LLVMPointerTypeInContext(context, get_state_space(to_space)?) }) -} - // https://llvm.org/docs/AMDGPUUsage.html#memory-scopes fn get_scope(scope: ast::MemScope) -> Result<*const i8, TranslateError> { Ok(match scope { @@ -3764,111 +3972,6 @@ fn get_ordering_failure(semantics: ast::AtomSemantics) -> LLVMAtomicOrdering { } } -fn get_type(context: LLVMContextRef, type_: &ast::Type) -> Result { - Ok(match type_ { - ast::Type::Scalar(scalar) => get_scalar_type(context, *scalar), - ast::Type::Vector(size, scalar) => { - let base_type = get_scalar_type(context, *scalar); - unsafe { LLVMVectorType(base_type, *size as u32) } - } - ast::Type::Array(vec, scalar, dimensions) => { - let mut underlying_type = get_scalar_type(context, *scalar); - if let Some(size) = vec { - underlying_type = unsafe { LLVMVectorType(underlying_type, size.get() as u32) }; - } - if dimensions.is_empty() { - return Ok(unsafe { LLVMArrayType2(underlying_type, 0) }); - } - dimensions - .iter() - .rfold(underlying_type, |result, dimension| unsafe { - LLVMArrayType2(result, *dimension as u64) - }) - } - ast::Type::Texref => { - // Definitions taken from ROCm LLVM output - let format_desc = - unsafe { LLVMStructCreateNamed(context, c"struct.hipChannelFormatDesc".as_ptr()) }; - let llvm_i32 = get_scalar_type(context, ast::ScalarType::B32); - let mut format_desc_fields = [llvm_i32, llvm_i32, llvm_i32, llvm_i32, llvm_i32]; - unsafe { - LLVMStructSetBody( - format_desc, - format_desc_fields.as_mut_ptr(), - format_desc_fields.len() as u32, - 0, - ) - }; - let texture_reference = - unsafe { LLVMStructCreateNamed(context, c"struct.textureReference".as_ptr()) }; - let llvm_a3i32 = unsafe { LLVMArrayType2(llvm_i32, 3) }; - let llvm_float = get_scalar_type(context, ast::ScalarType::F32); - let llvm_ptr = get_pointer_type(context, ast::StateSpace::Generic)?; - let mut texture_reference_fields = [ - llvm_i32, - llvm_i32, - llvm_i32, - llvm_a3i32, - format_desc, - llvm_i32, - llvm_i32, - llvm_i32, - llvm_float, - llvm_float, - llvm_float, - llvm_ptr, - llvm_i32, - llvm_i32, - ]; - unsafe { - LLVMStructSetBody( - texture_reference, - texture_reference_fields.as_mut_ptr(), - texture_reference_fields.len() as u32, - 0, - ) - }; - let texture = unsafe { LLVMStructCreateNamed(context, c"struct.texture".as_ptr()) }; - let mut texture_fields = [texture_reference]; - unsafe { - LLVMStructSetBody( - texture, - texture_fields.as_mut_ptr(), - texture_fields.len() as u32, - 0, - ) - }; - texture - } - }) -} - -fn get_or_create_struct_type<'a>( - context: LLVMContextRef, - mut elem_types: impl Iterator, -) -> Result { - use std::fmt::Write; - let (mut name, types) = elem_types.try_fold( - ("struct".to_string(), Vec::new()), - |(mut name, mut types), t| { - name.push('.'); - if let ast::Type::Scalar(scalar) = t { - write!(name, "{}", LLVMTypeDisplay(*scalar)).ok(); - } else { - return Err(error_unreachable()); - } - types.push(get_type(context, t)?); - Ok((name, types)) - }, - )?; - name.push('\0'); - let mut struct_type = unsafe { LLVMGetTypeByName2(context, name.as_ptr().cast()) }; - if struct_type.is_null() { - struct_type = create_struct_type(context, name, types); - } - Ok(struct_type) -} - fn create_struct_type( context: LLVMContextRef, name: String, @@ -3886,68 +3989,11 @@ fn create_struct_type( llvm_type } -fn get_anonymous_struct_type<'a>( - context: LLVMContextRef, - elem_types: impl Iterator, -) -> Result { - let mut elem_types = elem_types - .map(|t| get_type(context, t)) - .collect::, _>>()?; - Ok(unsafe { - LLVMStructTypeInContext(context, elem_types.as_mut_ptr(), elem_types.len() as u32, 0) - }) -} - enum StructKind { Named, Anonymous, } -fn get_function_type_impl<'a>( - context: LLVMContextRef, - mut return_args: impl DoubleEndedIterator - + ExactSizeIterator, - input_args: impl Iterator>, - struct_kind: StructKind, -) -> Result { - let mut input_args = input_args.collect::, _>>()?; - let return_type = match return_args.len() { - 0 => unsafe { LLVMVoidTypeInContext(context) }, - 1 => get_type(context, &return_args.next().unwrap())?, - _ => match struct_kind { - StructKind::Named => get_or_create_struct_type(context, return_args)?, - StructKind::Anonymous => get_anonymous_struct_type(context, return_args)?, - }, - }; - - Ok(unsafe { - LLVMFunctionType( - return_type, - input_args.as_mut_ptr(), - input_args.len() as u32, - 0, - ) - }) -} - -fn get_function_type<'a>( - context: LLVMContextRef, - return_args: impl DoubleEndedIterator - + ExactSizeIterator, - input_args: impl Iterator>, -) -> Result { - get_function_type_impl(context, return_args, input_args, StructKind::Named) -} - -fn get_intrinsic_type<'a>( - context: LLVMContextRef, - return_args: impl DoubleEndedIterator - + ExactSizeIterator, - input_args: impl Iterator>, -) -> Result { - get_function_type_impl(context, return_args, input_args, StructKind::Anonymous) -} - struct ResolveIdent { words: HashMap, values: HashMap, diff --git a/ptx/src/pass/llvm/mod.rs b/ptx/src/pass/llvm/mod.rs index ebfe86dcb..6fc3556a7 100644 --- a/ptx/src/pass/llvm/mod.rs +++ b/ptx/src/pass/llvm/mod.rs @@ -46,7 +46,7 @@ fn get_scalar_type(context: LLVMContextRef, type_: ast::ScalarType) -> LLVMTypeR } } -fn get_state_space(space: ast::StateSpace) -> Result { +fn get_state_space(space: ast::StateSpace, is_32bit: bool) -> Result { match space { ast::StateSpace::Reg => Ok(PRIVATE_ADDRESS_SPACE), ast::StateSpace::Generic => Ok(GENERIC_ADDRESS_SPACE), @@ -58,7 +58,14 @@ fn get_state_space(space: ast::StateSpace) -> Result { ast::StateSpace::ParamFunc => Err(error_todo()), ast::StateSpace::Local => Ok(PRIVATE_ADDRESS_SPACE), ast::StateSpace::Global => Ok(GLOBAL_ADDRESS_SPACE), - ast::StateSpace::Const => Ok(CONSTANT_ADDRESS_SPACE), + ast::StateSpace::Const => Ok(if is_32bit { + // FIXME: This is probably incorrect, but when using constant or + // global address space, we get incorrect codegen. Might be a bug + // in LLVM, might be a bug in ZLUDA + GENERIC_ADDRESS_SPACE + } else { + CONSTANT_ADDRESS_SPACE + }), ast::StateSpace::Shared => Ok(SHARED_ADDRESS_SPACE), ast::StateSpace::SharedCta => Err(error_todo()), ast::StateSpace::SharedCluster => Err(error_todo()), diff --git a/ptx/src/pass/mod.rs b/ptx/src/pass/mod.rs index 77f00bf6e..530490e31 100644 --- a/ptx/src/pass/mod.rs +++ b/ptx/src/pass/mod.rs @@ -112,7 +112,7 @@ pub fn to_llvm_module<'input>( let directives = hoist_globals::run(directives)?; on_pass_end("hoist_globals"); let context = llvm_zluda::utils::Context::new(); - let llvm_ir = llvm::emit::run(&context, flat_resolver, directives)?; + let llvm_ir = llvm::emit::run(&context, flat_resolver, directives, ast.address_size == 32)?; let attributes_ir = llvm::attributes::run(&context, attributes)?; on_pass_end("emit_llvm"); Ok(Module { diff --git a/ptx/src/pass/replace_instructions_with_functions.rs b/ptx/src/pass/replace_instructions_with_functions.rs index 413fcec66..d5005c8d4 100644 --- a/ptx/src/pass/replace_instructions_with_functions.rs +++ b/ptx/src/pass/replace_instructions_with_functions.rs @@ -301,6 +301,11 @@ fn run_instruction<'input>( }, .. } => { + let dtype = match dtype { + // For 32 bit + ast::ScalarType::U32 => ast::ScalarType::S32, + t => t, + }; let prefix = match type_ { ast::TexType::Texref => "texref", ast::TexType::Texobj => "texobj", diff --git a/ptx/src/test/spirv_run/mod.rs b/ptx/src/test/spirv_run/mod.rs index 36f3da393..a6d23d92b 100644 --- a/ptx/src/test/spirv_run/mod.rs +++ b/ptx/src/test/spirv_run/mod.rs @@ -1617,9 +1617,12 @@ fn run_zluda32 + Copy + Debug, Output: From + Copy + Debug + ) .unwrap(); let zluda32 = kernel_metadata::ModuleMetadata32Bit::read_object(&elf_module).unwrap(); - assert_eq!(zluda32.explicit_arg_count.len(), 1); - assert_eq!(zluda32.explicit_arg_count[0].0, name.to_str().unwrap()); - assert_eq!(zluda32.explicit_arg_count[0].1, 2); + assert_eq!(zluda32.explicit_args_size_align.len(), 1); + assert_eq!( + zluda32.explicit_args_size_align[0].0, + name.to_str().unwrap() + ); + assert_eq!(zluda32.explicit_args_size_align[0].1.len(), 2); let mut module = unsafe { mem::zeroed() }; unsafe { hipModuleLoadData(&mut module, elf_module.as_ptr() as _) }.unwrap(); let mut kernel = unsafe { mem::zeroed() }; diff --git a/ptx_parser/src/lib.rs b/ptx_parser/src/lib.rs index f2a0c5d26..df3e7397d 100644 --- a/ptx_parser/src/lib.rs +++ b/ptx_parser/src/lib.rs @@ -4416,7 +4416,7 @@ derive_parser!( } } - .dtype: ScalarType = { .s32, .f32 }; + .dtype: ScalarType = { .u32, .s32, .f32 }; .ctype: ScalarType = { .s32, .f32 }; // https://docs.nvidia.com/cuda/parallel-thread-execution/ diff --git a/xtask/src/main.rs b/xtask/src/main.rs index 5e4763bdc..c362655d2 100644 --- a/xtask/src/main.rs +++ b/xtask/src/main.rs @@ -37,11 +37,14 @@ struct Cargo { release: Option, #[bpaf(long)] profile: Option, + #[bpaf(long)] + target: Option, #[bpaf(any("", Some), many)] _unused: Vec, } struct Project { + is_32bit: bool, #[cfg_attr(unix, allow(unused))] manifest_path: PathBuf, name: String, @@ -51,7 +54,7 @@ struct Project { } impl Project { - fn try_new(p: Package) -> Option { + fn try_new(p: Package, is_32bit: bool) -> Option { let name = p.name; let manifest_path = p.manifest_path.into(); serde_json::from_value::>(p.metadata) @@ -76,13 +79,14 @@ impl Project { target_name, target_kind, meta: m.zluda, + is_32bit, } }) } #[cfg(windows)] fn zip_compiler_output(&self) -> bool { - self.meta.windows_paths.is_empty() + self.meta.windows_paths(self.is_32bit).is_empty() } #[cfg(unix)] @@ -146,7 +150,7 @@ impl Project { target_dir, profile, libname, - self.meta.windows_paths.as_slice(), + self.meta.windows_paths(self.is_32bit).as_slice(), ) .map(move |(.., full_path, target)| { let copy_output = full_path.clone(); @@ -239,6 +243,10 @@ struct ZludaMetadata { linux_only: bool, #[serde(default)] windows_only: bool, + #[serde(default = "always_true", rename = "64bit")] + is_64bit: bool, + #[serde(default, rename = "32bit")] + is_32bit: bool, #[serde(default)] debug_only: bool, #[cfg_attr(not(unix), allow(unused))] @@ -249,9 +257,26 @@ struct ZludaMetadata { windows_paths: Vec, #[serde(default)] #[cfg_attr(unix, allow(unused))] + windows32_paths: Vec, + #[serde(default)] + #[cfg_attr(unix, allow(unused))] windows_extra_files: HashMap, } +impl ZludaMetadata { + fn windows_paths(&self, is_32bit: bool) -> &Vec { + if is_32bit && !self.windows32_paths.is_empty() { + &self.windows32_paths + } else { + &self.windows_paths + } + } +} + +fn always_true() -> bool { + true +} + fn main() { let options = match options().run_inner(Args::current_args()) { Ok(b) => b, @@ -272,21 +297,33 @@ fn main() { } fn compile(b: Build) -> (PathBuf, String, Vec) { - let profile = sniff_out_profile_name(&b.cargo_arguments); + let cargo_flags = sniff_out_cargo_flags(&b.cargo_arguments); let meta = MetadataCommand::new().no_deps().exec().unwrap(); - let target_directory = meta.target_directory.into_std_path_buf(); + let mut target_directory = meta.target_directory.into_std_path_buf(); + if let Some(target) = &cargo_flags.target { + target_directory.push(target); + } let projects = meta .packages .into_iter() - .filter_map(Project::try_new) + .filter_map(|pkg| Project::try_new(pkg, cargo_flags.is_32bit)) .filter(|project| { + if cargo_flags.is_32bit { + if !project.meta.is_32bit { + return false; + } + } else { + if !project.meta.is_64bit { + return false; + } + } if project.meta.linux_only && cfg!(windows) { return false; } if project.meta.windows_only && cfg!(not(windows)) { return false; } - if project.meta.debug_only && profile != "debug" { + if project.meta.debug_only && cargo_flags.profile != "debug" { return false; } true @@ -302,13 +339,21 @@ fn compile(b: Build) -> (PathBuf, String, Vec) { } command.args(b.cargo_arguments); assert!(command.status().unwrap().success()); - os::make_symlinks(&target_directory, &*projects, &*profile); - (target_directory, profile, projects) + os::make_symlinks(&target_directory, &*projects, &*cargo_flags.profile); + (target_directory, cargo_flags.profile, projects) } -fn sniff_out_profile_name(b: &[OsString]) -> String { +fn sniff_out_cargo_flags(b: &[OsString]) -> CargoFlags { let parsed_cargo_arguments = cargo().to_options().run_inner(b); - match parsed_cargo_arguments { + let (target, is_32bit) = match parsed_cargo_arguments.as_ref() { + Ok(Cargo { + target: Some(target), + .. + }) => (Some(target.clone()), target.starts_with("i686")), + Ok(Cargo { target: None, .. }) => (None, cfg!(target_pointer_width = "32")), + _ => (None, false), + }; + let profile = match parsed_cargo_arguments { Ok(Cargo { release: Some(true), .. @@ -318,9 +363,20 @@ fn sniff_out_profile_name(b: &[OsString]) -> String { .. }) => profile, _ => "debug".to_string(), + }; + CargoFlags { + profile, + target, + is_32bit, } } +struct CargoFlags { + profile: String, + target: Option, + is_32bit: bool, +} + fn zip(zip: Build) { let (target_dir, profile, projects) = compile(zip); os::zip(target_dir, profile, projects) diff --git a/zluda/src/impl/driver.rs b/zluda/src/impl/driver.rs index 1a8987cb5..11e593c7e 100644 --- a/zluda/src/impl/driver.rs +++ b/zluda/src/impl/driver.rs @@ -1,5 +1,6 @@ use crate::r#impl::{self, context, device, function, module}; use cuda_types::cuda::*; +use dark_api::FunctionArgInfo; use hip_runtime_sys::*; use libloading::Library; use std::{ @@ -469,6 +470,91 @@ fn get_device_hash_info() -> Result, CUerror> { static EXPORT_TABLE: ::dark_api::cuda::CudaDarkApiGlobalTable = ::dark_api::cuda::CudaDarkApiGlobalTable::new::(); +struct Zluda32DarkApi {} + +impl ::dark_api::zluda32::CudaDarkApi for Zluda32DarkApi { + unsafe extern "system" fn get_module_globals( + names: *mut *mut u8, + initializers: *mut *const u8, + sizes: *mut u32, + alignments: *mut u32, + count: *mut u32, + module: cuda_types::cuda::CUmodule, + ) -> cuda_types::cuda::CUresult { + let module: &module::Module = FromCuda::<_, CUerror>::from_cuda(&module)?; + let zluda32 = module.bit32.as_ref().ok_or(CUerror::NOT_FOUND)?; + if let Some(c) = count.as_mut() { + *c = zluda32.globals.len() as u32; + } + let mut names = if names.is_null() { + None + } else { + Some(slice::from_raw_parts_mut(names, zluda32.globals.len())) + }; + let mut initializers = if initializers.is_null() { + None + } else { + Some(slice::from_raw_parts_mut( + initializers, + zluda32.globals.len(), + )) + }; + let mut sizes = if sizes.is_null() { + None + } else { + Some(slice::from_raw_parts_mut(sizes, zluda32.globals.len())) + }; + let mut alignments = if alignments.is_null() { + None + } else { + Some(slice::from_raw_parts_mut(alignments, zluda32.globals.len())) + }; + if names.is_some() || initializers.is_some() || sizes.is_some() || alignments.is_some() { + for (i, global) in zluda32.globals.iter().enumerate() { + if let Some(names) = &mut names { + names[i] = global.name.as_ptr() as *mut u8; + } + if let Some(initializers) = &mut initializers { + initializers[i] = global.initializer.as_ptr(); + } + if let Some(sizes) = &mut sizes { + sizes[i] = global.initializer.len() as u32; + } + if let Some(alignments) = &mut alignments { + alignments[i] = global.align as u32; + } + } + } + Ok(()) + } + + unsafe extern "system" fn get_function_info( + explicit_sizes_out: *mut FunctionArgInfo, + explicit_count_out: *mut u32, + func: cuda_types::cuda::CUfunction, + ) -> cuda_types::cuda::CUresult { + let func: &function::Function = FromCuda::<_, CUerror>::from_cuda(&func)?; + let explicit_args_size_align = match &func.explicit_args_size_align { + Some(sizes) => sizes, + None => return CUresult::ERROR_NOT_FOUND, + }; + if !explicit_sizes_out.is_null() { + std::ptr::copy_nonoverlapping( + explicit_args_size_align.as_ptr(), + explicit_sizes_out, + explicit_args_size_align.len(), + ); + } + if let Some(explicit_count_out) = explicit_count_out.as_mut() { + *explicit_count_out = explicit_args_size_align.len() as u32; + } + Ok(()) + } +} + +static ZLUDA32_EXPORT_TABLE: ::dark_api::zluda32::CudaDarkApiGlobalTable = + ::dark_api::zluda32::CudaDarkApiGlobalTable::new::(); + pub(crate) fn get_export_table( pp_export_table: &mut *const ::core::ffi::c_void, p_export_table_id: &CUuuid, @@ -476,6 +562,9 @@ pub(crate) fn get_export_table( if let Some(table) = EXPORT_TABLE.get(p_export_table_id) { *pp_export_table = table.start(); cuda_types::cuda::CUresult::SUCCESS + } else if let Some(table) = ZLUDA32_EXPORT_TABLE.get(p_export_table_id) { + *pp_export_table = table.start(); + cuda_types::cuda::CUresult::SUCCESS } else { cuda_types::cuda::CUresult::ERROR_INVALID_VALUE } diff --git a/zluda/src/impl/function.rs b/zluda/src/impl/function.rs index 6dd6f3144..aea11d554 100644 --- a/zluda/src/impl/function.rs +++ b/zluda/src/impl/function.rs @@ -1,10 +1,12 @@ use cuda_types::cuda::{CUfunction, CUfunction_attribute, CUkernel}; +use dark_api::FunctionArgInfo; use hip_runtime_sys::*; use std::mem; pub(crate) struct Function { pub(crate) base: hipFunction_t, pub(crate) sm_version: u32, + pub(crate) explicit_args_size_align: Option>, } impl<'a, E: zluda_common::CudaErrorType> zluda_common::FromCuda<'a, CUfunction, E> diff --git a/zluda/src/impl/hipfix.rs b/zluda/src/impl/hipfix.rs index f8de70767..3326da8cd 100644 --- a/zluda/src/impl/hipfix.rs +++ b/zluda/src/impl/hipfix.rs @@ -18,6 +18,9 @@ const HIP_TRSA_OVERRIDE_FORMAT: u32 = 1; pub(crate) unsafe fn refresh_texref(raw_texref: *mut textureReference) -> hipError_t { let texref = raw_texref.as_ref().ok_or(hipErrorCode_t::InvalidValue)?; let mut res_desc = std::mem::zeroed(); + if texref.textureObject.is_null() { + return Ok(()); + } hipTexObjectGetResourceDesc(&mut res_desc, texref.textureObject)?; match res_desc.resType { HIPresourcetype::HIP_RESOURCE_TYPE_ARRAY => hipTexRefSetArray( diff --git a/zluda/src/impl/library.rs b/zluda/src/impl/library.rs index 9869d8eca..98be33e67 100644 --- a/zluda/src/impl/library.rs +++ b/zluda/src/impl/library.rs @@ -21,8 +21,8 @@ impl Library { let module_lock = self.modules.get(device).ok_or(CUerror::INVALID_DEVICE)?; *module_lock.get_or_init(|| match self.data { LibraryData::Lazy(lib) => { - let (module, sm_version) = module::load_hip_module(lib)?; - Ok(Module::new(module, sm_version).wrap()) + let (module, sm_version, meta32) = module::load_hip_module(lib)?; + Ok(Module::new(module, sm_version, meta32).wrap()) } LibraryData::Eager(()) => Err(CUerror::NOT_SUPPORTED), }) diff --git a/zluda/src/impl/module.rs b/zluda/src/impl/module.rs index c49051ddd..f49c72478 100644 --- a/zluda/src/impl/module.rs +++ b/zluda/src/impl/module.rs @@ -2,6 +2,7 @@ use super::driver; use crate::r#impl::function; use crate::r#impl::{driver::GlobalState, function::Function}; use cuda_types::{cuda::*, dark_api::FatbinFileHeader}; +use dark_api::FunctionArgInfo; use hip_runtime_sys::*; use rustc_hash::FxHashMap; use std::collections::hash_map; @@ -17,6 +18,7 @@ use zluda_common::{CodeLibraryRef, CodeModuleRef, ZludaObject}; pub(crate) struct Module { pub(crate) base: hipModule_t, pub(crate) sm_version: u32, + pub(crate) bit32: Option, mutable: Mutex, } @@ -30,6 +32,7 @@ impl ModuleMutable { module: hipModule_t, sm_version: u32, name: CString, + explicit_args_size_align: Option>, ) -> Result<&Function, CUerror> { Ok(match self.functions.entry(name) { hash_map::Entry::Occupied(entry) => &*entry.into_mut(), @@ -39,6 +42,7 @@ impl ModuleMutable { let func = Box::new(Function { base: func_handle, sm_version, + explicit_args_size_align, }); &*entry.insert(func) } @@ -58,21 +62,102 @@ impl ZludaObject for Module { } } +pub(crate) struct Metadata32Bit { + pub globals: Vec, + pub explicit_args_size_align: FxHashMap>, +} + +impl Metadata32Bit { + fn new(meta: &kernel_metadata::ModuleMetadata32Bit) -> Self { + let globals = meta + .globals + .iter() + .map(|g| Global32Bit { + name: CString::new(&*g.name).unwrap(), + initializer: g.initializer.to_vec(), + align: g.align, + }) + .collect(); + let explicit_args_size_align = meta + .explicit_args_size_align + .iter() + .map(|(key, value)| { + let key = key.to_string(); + let value = value + .iter() + .map(|(size, align)| FunctionArgInfo { + size: *size, + align: *align, + }) + .collect(); + (key, value) + }) + .collect(); + Self { + globals, + explicit_args_size_align, + } + } + + fn from_archived(archived: &kernel_metadata::ArchivedModuleMetadata32Bit) -> Self { + let globals = archived + .globals + .iter() + .map(|g| Global32Bit { + name: CString::new(g.name.as_str()).unwrap(), + initializer: g.initializer.to_vec(), + align: g.align.to_native(), + }) + .collect(); + let explicit_args_size_align = archived + .explicit_args_size_align + .iter() + .map(|kv| { + ( + kv.0.to_string(), + kv.1.iter() + .map(|x| FunctionArgInfo { + size: x.0.to_native(), + align: x.1.to_native(), + }) + .collect(), + ) + }) + .collect(); + Self { + globals, + explicit_args_size_align, + } + } +} + +pub(crate) struct Global32Bit { + pub name: CString, + pub initializer: Vec, + pub align: u32, +} + impl Module { - pub(crate) fn new(base: hipModule_t, sm_version: u32) -> Self { + pub(crate) fn new(base: hipModule_t, sm_version: u32, bit32: Option) -> Self { Self { base, sm_version, mutable: Mutex::new(ModuleMutable { functions: FxHashMap::default(), }), + bit32, } } pub(crate) fn get_function<'a>(&'a self, name: &CStr) -> Result<&'static Function, CUerror> { let mut mutable = self.mutable.lock().map_err(|_| CUerror::UNKNOWN)?; + let explicit_args = self.bit32.as_ref().and_then(|meta| { + meta.explicit_args_size_align + .get(name.to_str().ok()?) + .map(Vec::clone) + }); mutable - .get_function(self.base, self.sm_version, name.to_owned()) + .get_function(self.base, self.sm_version, name.to_owned(), explicit_args) .map(|f| unsafe { (f as *const Function).as_ref().unwrap() }) } } @@ -80,7 +165,7 @@ impl Module { fn get_best_ptx_and_compile( global_state: &GlobalState, image: CodeLibraryRef<'_>, -) -> Result<(hipModule_t, u32), CUerror> { +) -> Result<(hipModule_t, u32, Option), CUerror> { let mut ptx_modules = Vec::new(); unsafe { CodeLibraryRef::iterate_modules(image, |_, module| match module { @@ -91,7 +176,7 @@ fn get_best_ptx_and_compile( if file.header.kind != FatbinFileHeader::HEADER_KIND_PTX { return; } - if let Ok(text) = file.get_or_decompress_content() { + if let Ok(text) = file.get_or_decompress_content(true) { if let Some(text) = cow_bytes_to_str(text) { ptx_modules.push(text); } @@ -168,12 +253,12 @@ fn get_best_ptx_and_compile( _ => None, }; let cached_binary = load_cached_binary(&mut cache_with_key); - let (elf_module, sm_version) = cached_binary + let (elf_module, sm_version, zluda32) = cached_binary .ok_or(CUerror::UNKNOWN) .or_else(|_| compile_and_cache(gcn_arch, attributes, module, &mut cache_with_key))?; let mut hip_module = unsafe { mem::zeroed() }; unsafe { hipModuleLoadData(&mut hip_module, elf_module.as_ptr().cast()) }?; - Ok((hip_module, sm_version)) + Ok((hip_module, sm_version, zluda32)) } fn cow_bytes_to_str<'a>(data: Cow<'a, [u8]>) -> Option> { @@ -183,7 +268,9 @@ fn cow_bytes_to_str<'a>(data: Cow<'a, [u8]>) -> Option> { } } -pub(crate) fn load_hip_module(library: CodeLibraryRef) -> Result<(hipModule_t, u32), CUerror> { +pub(crate) fn load_hip_module( + library: CodeLibraryRef, +) -> Result<(hipModule_t, u32, Option), CUerror> { let global_state = driver::global_state()?; get_best_ptx_and_compile(global_state, library) } @@ -229,14 +316,16 @@ fn get_cache_key<'a, 'b>( fn load_cached_binary( cache_with_key: &mut Option<(zluda_cache::ModuleCache, zluda_cache::ModuleKey)>, -) -> Option<(Vec, u32)> { +) -> Option<(Vec, u32, Option)> { let binary = cache_with_key .as_mut() .and_then(|(c, key)| c.get_module_binary(key))?; let sm_version = kernel_metadata::ModuleMetadataV1::read_object(&binary)? .sm_version .to_native(); - Some((binary, sm_version)) + let zluda32 = kernel_metadata::ModuleMetadata32Bit::read_object(&binary) + .map(Metadata32Bit::from_archived); + Some((binary, sm_version, zluda32)) } fn compile_and_cache( @@ -244,7 +333,7 @@ fn compile_and_cache( attributes: ExtraCacheAttributes, ast: ptx_parser::Module, cache_with_key: &mut Option<(zluda_cache::ModuleCache, zluda_cache::ModuleKey)>, -) -> Result<(Vec, u32), CUerror> { +) -> Result<(Vec, u32, Option), CUerror> { let llvm_module = ptx::to_llvm_module( ast, ptx::Attributes { @@ -255,6 +344,7 @@ fn compile_and_cache( .map_err(|_| CUerror::UNKNOWN)?; let ptx_impl = llvm_module.linked_bitcode(); let sm_version = llvm_module.metadata.sm_version; + let metadata32 = llvm_module.metadata32.as_ref().map(Metadata32Bit::new); let elf_module = llvm_zluda::compile( &llvm_module.context, gcn_arch, @@ -270,7 +360,7 @@ fn compile_and_cache( key.last_access = zluda_cache::ModuleCache::time_now(); cache.insert_module(key, &elf_module); } - Ok((elf_module, sm_version)) + Ok((elf_module, sm_version, metadata32)) } pub(crate) fn load(module: &mut CUmodule, fname: &CStr) -> CUresult { @@ -280,16 +370,16 @@ pub(crate) fn load(module: &mut CUmodule, fname: &CStr) -> CUresult { image.push(0); let library = unsafe { CodeLibraryRef::try_load(image.as_ptr() as *const std::ffi::c_void) } .map_err(|_| CUerror::NO_BINARY_FOR_GPU)?; - let (hip_module, sm_version) = load_hip_module(library)?; - *module = Module::new(hip_module, sm_version).wrap(); + let (hip_module, sm_version, meta32) = load_hip_module(library)?; + *module = Module::new(hip_module, sm_version, meta32).wrap(); Ok(()) } pub(crate) fn load_data(module: &mut CUmodule, image: &std::ffi::c_void) -> CUresult { let library = unsafe { CodeLibraryRef::try_load(image) }.map_err(|_| CUerror::NO_BINARY_FOR_GPU)?; - let (hip_module, sm_version) = load_hip_module(library)?; - *module = Module::new(hip_module, sm_version).wrap(); + let (hip_module, sm_version, meta32) = load_hip_module(library)?; + *module = Module::new(hip_module, sm_version, meta32).wrap(); Ok(()) } diff --git a/zluda/src/impl/tex.rs b/zluda/src/impl/tex.rs index 225e10a2a..347469a65 100644 --- a/zluda/src/impl/tex.rs +++ b/zluda/src/impl/tex.rs @@ -101,6 +101,9 @@ pub(crate) unsafe fn ref_set_address_v2( dev_ptr: hipDeviceptr_t, bytes: usize, ) -> hipError_t { + if dev_ptr.0.is_null() { + return hipUnbindTexture(texref); + } hipTexRefSetAddress(byte_offset, texref, dev_ptr, bytes) } diff --git a/zluda32/Cargo.toml b/zluda32/Cargo.toml new file mode 100644 index 000000000..b64dd8ec7 --- /dev/null +++ b/zluda32/Cargo.toml @@ -0,0 +1,45 @@ +[package] +name = "zluda32" +version = "0.0.0" +authors = ["Andrzej Janik "] +edition = "2021" + +[lib] +name = "nvcuda" +crate-type = ["cdylib"] + +[dependencies] +cuda_types = { path = "../cuda_types" } +zluda_common = { path = "../zluda_common" } +cuda_macros = { path = "../cuda_macros" } +zluda_windows = { path = "../zluda_windows" } +zluda_server_common = { path = "../zluda_server_common" } +dark_api = { path = "../dark_api" } +paste = "1.0" +ipc-channel = "^0.21.0" +windows = { version = "0.62.2", features = [ + "Win32_Foundation", + "Win32_Storage_FileSystem", + "Win32_System_IO", + "Win32_System_Pipes", + "Win32_Security", +] } +# windows-sys = { version = "0.61.2", features = [ +# "Win32_Foundation", +# "Win32_System_Pipes", +# "Win32_Storage_FileSystem", +# ] } +rand = "0.10.1" +widestring = "1.2.1" +bitcode = "0.6.9" +postcard = "1.1.3" +bincode = "2.0.1" +rkyv = "0.8.15" +unwrap_or = "1.0.1" +rustc-hash = "2.0.0" +libc = "0.2" + +[package.metadata.zluda] +windows_only = true +64bit = false +32bit = true diff --git a/zluda32/src/ipc.rs b/zluda32/src/ipc.rs new file mode 100644 index 000000000..fc527aec6 --- /dev/null +++ b/zluda32/src/ipc.rs @@ -0,0 +1,175 @@ +use cuda_types::cuda::CUerror; +use rand::distr::{Alphanumeric, SampleString}; +use rkyv::api::high::HighSerializer; +use rkyv::de::Pool; +use rkyv::rancor::{Failure, Strategy}; +use rkyv::rend::u32_le; +use rkyv::ser::allocator::ArenaHandle; +use rkyv::util::AlignedVec; +use rkyv::{rancor, Archive, Deserialize, Portable, Serialize}; +use std::io::{Read, Write}; +use std::os::windows::io::{AsHandle, AsRawHandle, FromRawHandle}; +// use rkyv::util::AlignedVec; +use std::num::NonZeroU32; +use std::process::{Child, Command, Stdio}; +use std::sync::{Mutex, OnceLock}; +use std::{mem, ptr}; +use widestring::{u16str, U16CString}; +use windows::core::{Error, Owned, PCSTR}; +use windows::Win32::Foundation::*; +use windows::Win32::System::Pipes::*; +use zluda_server_common::Opcode; + +fn server_path() -> &'static str { + if cfg!(debug_assertions) { + r"C:\dev\ZLUDA\target\debug\zluda64_server.exe" + } else { + //"zluda64_server.exe" + r"C:\dev\ZLUDA\target\release\zluda64_server.exe" + } +} + +pub(crate) struct Server { + pipe: std::fs::File, + _child: Child, + buffer: AlignedVec, +} + +unsafe impl Sync for Server {} +unsafe impl Send for Server {} + +impl Server { + fn new(pipe: std::fs::File, child: Child) -> Self { + Self { + pipe, + _child: child, + buffer: AlignedVec::new(), + } + } + + pub unsafe fn start() -> Result { + let name = Alphanumeric.sample_string(&mut rand::rng(), 32); + let pipe_path = format!("\\\\.\\pipe\\zluda-{name}\0"); + let pipe = std::fs::File::from_raw_handle( + CreateNamedPipeA( + PCSTR(pipe_path.as_ptr()), + windows::Win32::Storage::FileSystem::PIPE_ACCESS_DUPLEX, + PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT | PIPE_REJECT_REMOTE_CLIENTS, + 1, + 4 * 1024, + 4 * 1024, + 0, + None, + )? + .0, + ); + let child = Command::new(server_path()) + .arg(&pipe_path[..pipe_path.len() - 1]) + .stdin(Stdio::null()) + .stdout(Stdio::null()) + .stderr(Stdio::null()) + .spawn()?; + zluda_windows::kill_child_on_process_exit(child.as_handle().as_raw_handle())?; + match ConnectNamedPipe(HANDLE(pipe.as_raw_handle()), None) { + Ok(_) => Ok(Server::new(pipe, child)), + Err(e) if e.code() == ERROR_PIPE_CONNECTED.into() => Ok(Server::new(pipe, child)), + Err(e) => Err(e), + } + } + + pub(crate) fn remote_call_zero_copy( + &mut self, + opcode: Opcode, + data: impl for<'a, 'b> Serialize< + HighSerializer<&'a mut AlignedVec, ArenaHandle<'b>, rkyv::rancor::Failure>, + >, + ) -> Result { + self.buffer.clear(); + self.pipe + .write_all(&(opcode as u32).to_le_bytes()[..]) + .map_err(|_| CUerror::UNKNOWN)?; + let slice = + rkyv::api::high::to_bytes_in::<_, rkyv::rancor::Failure>(&data, &mut self.buffer) + .map_err(|_| CUerror::UNKNOWN)?; + self.pipe.write_all(&slice).map_err(|_| CUerror::UNKNOWN)?; + read_return_code(self)?; + self.buffer.resize(mem::size_of::(), 0); + self.pipe + .read_exact(&mut self.buffer) + .map_err(|_| CUerror::UNKNOWN)?; + let output = unsafe { rkyv::access_unchecked::(&self.buffer) }; + Ok(output.clone()) + } + + pub(crate) fn remote_call_framed_in( + &mut self, + opcode: Opcode, + data: impl for<'a, 'b> Serialize< + HighSerializer<&'a mut AlignedVec, ArenaHandle<'b>, rkyv::rancor::Failure>, + >, + ) -> Result { + self.buffer.clear(); + self.pipe + .write_all(&(opcode as u32).to_le_bytes()[..]) + .map_err(|_| CUerror::UNKNOWN)?; + let slice = + rkyv::api::high::to_bytes_in::<_, rkyv::rancor::Failure>(&data, &mut self.buffer) + .map_err(|_| CUerror::UNKNOWN)?; + self.pipe + .write_all(&(slice.len() as u32).to_le_bytes()[..]) + .map_err(|_| CUerror::UNKNOWN)?; + self.pipe.write_all(&slice).map_err(|_| CUerror::UNKNOWN)?; + read_return_code(self)?; + self.buffer.resize(mem::size_of::(), 0); + self.pipe + .read_exact(&mut self.buffer) + .map_err(|_| CUerror::UNKNOWN)?; + let output = unsafe { rkyv::access_unchecked::(&self.buffer) }; + Ok(output.clone()) + } + + pub(crate) fn remote_call_framed_out( + &mut self, + opcode: Opcode, + data: impl for<'a, 'b> Serialize< + HighSerializer<&'a mut AlignedVec, ArenaHandle<'b>, rkyv::rancor::Failure>, + >, + ) -> Result + where + ::Archived: Deserialize>, + { + self.buffer.clear(); + self.pipe + .write_all(&(opcode as u32).to_le_bytes()[..]) + .map_err(|_| CUerror::UNKNOWN)?; + let slice = + rkyv::api::high::to_bytes_in::<_, rkyv::rancor::Failure>(&data, &mut self.buffer) + .map_err(|_| CUerror::UNKNOWN)?; + self.pipe.write_all(&slice).map_err(|_| CUerror::UNKNOWN)?; + read_return_code(self)?; + let out_size = read_u32(self)?; + self.buffer.resize(out_size as usize, 0); + self.pipe + .read_exact(&mut self.buffer) + .map_err(|_| CUerror::UNKNOWN)?; + unsafe { rkyv::from_bytes_unchecked::(&self.buffer) } + .map_err(|_| CUerror::UNKNOWN) + } +} + +fn read_return_code(this: &mut Server) -> Result<(), CUerror> { + let code = read_u32(this)?; + match NonZeroU32::new(code) { + None => Ok(()), + Some(code) => Err(CUerror(code)), + } +} + +fn read_u32(this: &mut Server) -> Result { + let mut code_buffer = [0u8; 4]; + this.pipe + .read_exact(&mut code_buffer) + .map_err(|_| CUerror::UNKNOWN)?; + let code = u32::from_le_bytes(code_buffer); + Ok(code) +} diff --git a/zluda32/src/lib.rs b/zluda32/src/lib.rs new file mode 100644 index 000000000..a497e9c00 --- /dev/null +++ b/zluda32/src/lib.rs @@ -0,0 +1,1064 @@ +use cuda_macros::cuda_function_declarations; +use cuda_types::cuda::*; +use dark_api::cuda::CudaDarkApi; +use dark_api::FunctionArgInfo; +use paste::paste; +use rkyv::api::high::HighSerializer; +use rkyv::de::Pool; +use rkyv::rancor::{Failure, Strategy}; +use rkyv::rend::u32_le; +use rkyv::ser::allocator::ArenaHandle; +use rkyv::util::AlignedVec; +use rkyv::{Archive, Deserialize, Portable, Serialize}; +use rustc_hash::FxHashMap; +use std::alloc::Layout; +use std::slice; +use std::sync::atomic::AtomicBool; +use std::sync::{Mutex, OnceLock}; +use std::{cell::RefCell, ffi::c_void, ptr}; +use zluda_common::{CodeLibraryRef, CodeModuleRef, CudaErrorType}; +use zluda_server_common::*; + +mod ipc; + +macro_rules! not_implemented { + ($($abi:literal fn $fn_name:ident( $($arg_id:ident : $arg_type:ty),* ) -> $ret_type:ty;)*) => { + $( + #[cfg_attr(not(test), no_mangle)] + #[allow(improper_ctypes)] + #[allow(improper_ctypes_definitions)] + #[allow(unused_variables)] + pub unsafe extern $abi fn $fn_name ( $( $arg_id : $arg_type),* ) -> $ret_type { + if !crate::initialized() { + return Err(CUerror::DEINITIALIZED); + } + Err(cuda_types::cuda::CUerror::NOT_SUPPORTED) + } + )* + }; +} + +macro_rules! implemented { + ($($abi:literal fn $fn_name:ident( $($arg_id:ident : $arg_type:ty),* ) -> $ret_type:ty;)*) => { + $( + #[cfg_attr(not(test), no_mangle)] + #[allow(improper_ctypes)] + #[allow(improper_ctypes_definitions)] + pub unsafe extern $abi fn $fn_name ( $( $arg_id : $arg_type),* ) -> $ret_type { + if !crate::initialized() { + return Err(CUerror::DEINITIALIZED); + } + paste!{ [< $fn_name:snake >] ( $( $arg_id ),* ) } + } + )* + + }; +} + +cuda_function_declarations! { + not_implemented, + implemented <= [ + cuCtxCreate_v2, + cuCtxDetach, + cuCtxGetApiVersion, + cuCtxGetCurrent, + cuCtxGetDevice, + cuCtxSynchronize, + cuDeviceComputeCapability, + cuDeviceGet, + cuDeviceGetAttribute, + cuDeviceGetCount, + cuDeviceGetName, + cuDeviceGetProperties, + cuDeviceTotalMem_v2, + cuDriverGetVersion, + cuEventCreate, + cuEventDestroy_v2, + cuGetExportTable, + cuInit, + cuLaunchKernel, + cuMemAlloc_v2, + cuMemcpyDtoDAsync_v2, + cuMemcpyDtoHAsync_v2, + cuMemcpyHtoDAsync_v2, + cuMemFree_v2, + cuMemFreeHost, + cuMemGetAddressRange_v2, + cuMemHostAlloc, + cuMemsetD8_v2, + cuModuleGetFunction, + cuModuleGetGlobal_v2, + cuModuleGetTexRef, + cuStreamCreate, + cuStreamDestroy_v2, + cuTexRefSetAddress_v2, + cuTexRefSetAddressMode, + cuTexRefSetFilterMode, + cuTexRefSetFlags, + cuTexRefSetFormat, + cuTexRefSetMaxAnisotropy, + cuTexRefSetMipmapFilterMode, + cuTexRefSetMipmapLevelBias, + cuTexRefSetMipmapLevelClamp, + ] +} + +thread_local! { + pub(crate) static CONTEXT_STACK: ContextStack = ContextStack::new(); +} + +struct ContextStack(RefCell>); + +impl ContextStack { + fn new() -> Self { + ContextStack(RefCell::new(Vec::new())) + } + + fn push(&self, ctx: CUcontext, dev: CUdevice) { + self.0.borrow_mut().push((ctx, dev)); + } + + fn unwrap(&self, ctx: CUcontext) -> Result { + if ctx.0.is_null() { + let stack = self.0.borrow(); + stack + .last() + .map(|(ctx, _)| *ctx) + .ok_or(CUerror::INVALID_VALUE) + } else { + Ok(ctx) + } + } + + fn current(&self) -> (CUcontext, CUdevice) { + self.0 + .borrow() + .last() + .copied() + .unwrap_or((CUcontext(ptr::null_mut()), 0)) + } +} + +struct GlobalState { + function_args: FxHashMap>, + server: ipc::Server, +} + +impl GlobalState { + fn get() -> Result<&'static Mutex, CUerror> { + static LOCK: OnceLock, windows::core::Error>> = OnceLock::new(); + LOCK.get_or_init(|| { + Ok(Mutex::new(GlobalState { + function_args: FxHashMap::default(), + server: unsafe { ipc::Server::start() }?, + })) + }) + .as_ref() + .map_err(|_| CUerror::UNKNOWN) + } + + pub(crate) fn remote_call_zero_copy( + opcode: Opcode, + data: impl for<'a, 'b> Serialize< + HighSerializer<&'a mut AlignedVec, ArenaHandle<'b>, rkyv::rancor::Failure>, + >, + ) -> Result { + Self::get()? + .lock() + .map_err(|_| CUerror::UNKNOWN)? + .server + .remote_call_zero_copy(opcode, data) + } + + pub(crate) fn remote_call_framed_in( + opcode: Opcode, + data: impl for<'a, 'b> Serialize< + HighSerializer<&'a mut AlignedVec, ArenaHandle<'b>, rkyv::rancor::Failure>, + >, + ) -> Result { + Self::get()? + .lock() + .map_err(|_| CUerror::UNKNOWN)? + .server + .remote_call_framed_in(opcode, data) + } + + pub(crate) fn remote_call_framed_out( + opcode: Opcode, + data: impl for<'a, 'b> Serialize< + HighSerializer<&'a mut AlignedVec, ArenaHandle<'b>, rkyv::rancor::Failure>, + >, + ) -> Result + where + ::Archived: Deserialize>, + { + Self::get()? + .lock() + .map_err(|_| CUerror::UNKNOWN)? + .server + .remote_call_framed_out(opcode, data) + } +} + +pub(crate) fn cu_init(flags: u32) -> Result<(), CUerror> { + GlobalState::remote_call_zero_copy::(Opcode::cuInit, cuInitIn { Flags: flags })?; + Ok(()) +} + +pub(crate) fn cu_ctx_create_v2( + pctx: *mut CUcontext, + flags: ::core::ffi::c_uint, + dev: CUdevice, +) -> Result<(), CUerror> { + let ctx_ref = unsafe { pctx.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + let cu_ctx = CudaEncode::decode( + GlobalState::remote_call_zero_copy::( + Opcode::cuCtxCreate_v2, + cuCtxCreate_v2In { flags, dev }, + )? + .pctx, + ); + CONTEXT_STACK.with(|stack| { + stack.push(cu_ctx, dev); + }); + *ctx_ref = cu_ctx; + Ok(()) +} + +pub(crate) fn cu_ctx_detach(_ctx: CUcontext) -> Result<(), CUerror> { + // TODO + Ok(()) +} + +pub(crate) fn cu_ctx_get_api_version( + ctx: CUcontext, + version: *mut ::core::ffi::c_uint, +) -> Result<(), CUerror> { + let version = unsafe { version.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + let ctx = CONTEXT_STACK.with(|s| s.unwrap(ctx))?; + *version = CudaEncode::decode( + GlobalState::remote_call_zero_copy::( + Opcode::cuCtxGetApiVersion, + cuCtxGetApiVersionIn { + ctx: CudaEncode::encode(ctx), + }, + )? + .version, + ); + Ok(()) +} + +pub(crate) fn cu_ctx_get_current(pctx: *mut CUcontext) -> Result<(), CUerror> { + let pctx = unsafe { pctx.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + *pctx = CONTEXT_STACK.with(|s| s.current()).0; + Ok(()) +} + +pub(crate) fn cu_ctx_get_device(device: *mut CUdevice) -> Result<(), CUerror> { + let device = unsafe { device.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + let (_, dev) = CONTEXT_STACK.with(|s| s.current()); + *device = dev; + Ok(()) +} + +pub(crate) fn cu_ctx_synchronize() -> Result<(), CUerror> { + GlobalState::remote_call_zero_copy::( + Opcode::cuCtxSynchronize, + cuCtxSynchronizeIn {}, + )?; + Ok(()) +} + +pub(crate) fn cu_device_compute_capability( + major: *mut ::core::ffi::c_int, + minor: *mut ::core::ffi::c_int, + dev: CUdevice, +) -> Result<(), CUerror> { + unimplemented!() +} + +pub(crate) fn cu_device_get( + device: *mut CUdevice, + ordinal: ::core::ffi::c_int, +) -> Result<(), CUerror> { + let device = unsafe { device.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + *device = GlobalState::remote_call_zero_copy::( + Opcode::cuDeviceGet, + cuDeviceGetIn { ordinal }, + )? + .device; + Ok(()) +} + +pub(crate) fn cu_device_get_attribute( + pi: *mut ::core::ffi::c_int, + attrib: CUdevice_attribute, + dev: CUdevice, +) -> Result<(), CUerror> { + let pi = unsafe { pi.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + *pi = GlobalState::remote_call_zero_copy::( + Opcode::cuDeviceGetAttribute, + cuDeviceGetAttributeIn { + attrib: CudaEncode::encode(attrib), + dev, + }, + )? + .pi; + Ok(()) +} + +pub(crate) fn cu_device_get_count(count: *mut ::core::ffi::c_int) -> Result<(), CUerror> { + let count = unsafe { count.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + *count = GlobalState::remote_call_zero_copy::( + Opcode::cuDeviceGetCount, + cuDeviceGetCountIn {}, + )? + .count; + Ok(()) +} + +pub(crate) fn cu_device_get_name( + name: *mut ::core::ffi::c_char, + len: ::core::ffi::c_int, + dev: CUdevice, +) -> Result<(), CUerror> { + if name.is_null() { + return Err(CUerror::INVALID_VALUE); + } + let name_out = GlobalState::remote_call_framed_out::( + Opcode::cuDeviceGetName, + cuDeviceGetNameIn { len, dev }, + )?; + unsafe { + std::ptr::copy_nonoverlapping( + name_out.name.as_ptr() as *const i8, + name, + (len as usize).min(name_out.name.len()), + ) + }; + Ok(()) +} + +pub(crate) fn cu_device_get_properties(prop: *mut CUdevprop, dev: CUdevice) -> Result<(), CUerror> { + unimplemented!() +} + +pub(crate) fn cu_device_total_mem_v2(bytes: *mut usize, dev: CUdevice) -> Result<(), CUerror> { + let bytes = unsafe { bytes.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + *bytes = GlobalState::remote_call_zero_copy::( + Opcode::cuDeviceTotalMem_v2, + cuDeviceTotalMem_v2In { dev }, + )? + .bytes + .to_native() + .min(u32::MAX as u64) as usize; + Ok(()) +} + +pub(crate) fn cu_driver_get_version( + driver_version: *mut ::core::ffi::c_int, +) -> Result<(), CUerror> { + let driver_version = unsafe { driver_version.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + *driver_version = GlobalState::remote_call_zero_copy::( + Opcode::cuDriverGetVersion, + cuDriverGetVersionIn {}, + )? + .driverVersion; + Ok(()) +} + +pub(crate) fn cu_event_create( + phEvent: *mut CUevent, + Flags: ::core::ffi::c_uint, +) -> Result<(), CUerror> { + unimplemented!() +} + +pub(crate) fn cu_event_destroy_v2(hEvent: CUevent) -> Result<(), CUerror> { + unimplemented!() +} + +static EXPORT_TABLE: ::dark_api::cuda::CudaDarkApiGlobalTable = + ::dark_api::cuda::CudaDarkApiGlobalTable::new::(); + +pub(crate) fn cu_get_export_table( + pp_export_table: *mut *const ::core::ffi::c_void, + p_export_table_id: *const CUuuid, +) -> Result<(), CUerror> { + if let (Some(result), Some(guid)) = + unsafe { (pp_export_table.as_mut(), p_export_table_id.as_ref()) } + { + if let Some(table) = EXPORT_TABLE.get(guid) { + *result = table.start(); + cuda_types::cuda::CUresult::SUCCESS + } else { + cuda_types::cuda::CUresult::ERROR_NOT_SUPPORTED + } + } else { + cuda_types::cuda::CUresult::ERROR_INVALID_VALUE + } +} + +pub(crate) fn cu_launch_kernel( + f: CUfunction, + grid_dim_x: ::core::ffi::c_uint, + grid_dim_y: ::core::ffi::c_uint, + grid_dim_z: ::core::ffi::c_uint, + block_dim_x: ::core::ffi::c_uint, + block_dim_y: ::core::ffi::c_uint, + block_dim_z: ::core::ffi::c_uint, + shared_mem_bytes: ::core::ffi::c_uint, + stream: CUstream, + kernel_params: *mut *mut ::core::ffi::c_void, + extra: *mut *mut ::core::ffi::c_void, +) -> Result<(), CUerror> { + if !kernel_params.is_null() || extra.is_null() { + return Err(CUerror::NOT_SUPPORTED); + } + let mut state = GlobalState::get()?.lock().map_err(|_| CUerror::UNKNOWN)?; + let args = state.function_args.get(&f).ok_or(CUerror::INVALID_VALUE)?; + let extra_slice = unsafe { std::slice::from_raw_parts(extra, 5) }; + if extra_slice[0] != CU_LAUNCH_PARAM_BUFFER_POINTER_AS_INT as _ { + return Err(CUerror::INVALID_VALUE); + } + if extra_slice[2] != CU_LAUNCH_PARAM_BUFFER_SIZE_AS_INT as _ { + return Err(CUerror::INVALID_VALUE); + } + if extra_slice[4] != CU_LAUNCH_PARAM_END_AS_INT as _ { + return Err(CUerror::INVALID_VALUE); + } + let arg_ptr = extra_slice[1]; + let arg_size = unsafe { *extra_slice[3].cast::() }; + let mut total_size = 0; + let kernel_params = args + .iter() + .scan( + unsafe { Layout::from_size_align_unchecked(0, 1) }, + |layout, arg_info| { + let (new_layout, offset) = layout.extend(arg_info.to_layout().unwrap()).unwrap(); + total_size = offset + arg_info.size as usize; + *layout = new_layout; + let start = arg_ptr.wrapping_byte_add(offset as usize).cast::(); + Some(Ok(unsafe { + std::slice::from_raw_parts(start, arg_info.size as usize) + } + .to_vec())) + }, + ) + .collect::, CUerror>>()?; + if total_size as usize != arg_size { + return Err(CUerror::INVALID_VALUE); + } + state.server.remote_call_framed_in::( + Opcode::cuLaunchKernel, + cuLaunchKernelIn { + f: CudaEncode::encode(f), + grid_dim_x: u32_le::from_native(grid_dim_x), + grid_dim_y: u32_le::from_native(grid_dim_y), + grid_dim_z: u32_le::from_native(grid_dim_z), + block_dim_x: u32_le::from_native(block_dim_x), + block_dim_y: u32_le::from_native(block_dim_y), + block_dim_z: u32_le::from_native(block_dim_z), + shared_mem_bytes: u32_le::from_native(shared_mem_bytes), + stream: CudaEncode::encode(stream), + kernel_params, + }, + )?; + Ok(()) +} + +pub(crate) fn cu_mem_alloc_v2(dptr: *mut CUdeviceptr, bytesize: usize) -> Result<(), CUerror> { + let dptr = unsafe { dptr.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + *dptr = CudaEncode::decode( + GlobalState::remote_call_zero_copy::( + Opcode::cuMemAlloc_v2, + cuMemAlloc_v2In { + bytesize: u32_le::from_native(bytesize as u32), + }, + )? + .dptr, + ); + Ok(()) +} + +pub(crate) fn cu_mem_free_v2(dptr: CUdeviceptr) -> Result<(), CUerror> { + GlobalState::remote_call_zero_copy::( + Opcode::cuMemFree_v2, + cuMemFree_v2In { + dptr: CudaEncode::encode(dptr), + }, + )?; + Ok(()) +} + +pub(crate) fn cu_mem_get_address_range_v2( + pbase: *mut CUdeviceptr, + psize: *mut usize, + dptr: CUdeviceptr, +) -> Result<(), CUerror> { + let pbase = unsafe { pbase.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + let psize = unsafe { psize.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + let result = GlobalState::remote_call_zero_copy::( + Opcode::cuMemGetAddressRange_v2, + cuMemGetAddressRange_v2In { + dptr: CudaEncode::encode(dptr), + }, + )?; + *pbase = CudaEncode::decode(result.pbase); + *psize = result.psize.to_native() as usize; + Ok(()) +} + +pub(crate) fn cu_mem_host_alloc( + result: *mut *mut ::core::ffi::c_void, + bytesize: usize, + _flags: ::core::ffi::c_uint, +) -> Result<(), CUerror> { + let result = unsafe { result.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + *result = unsafe { libc::calloc(1, bytesize) }; + Ok(()) +} + +pub(crate) fn cu_mem_free_host(p: *mut ::core::ffi::c_void) -> Result<(), CUerror> { + if p.is_null() { + return Err(CUerror::INVALID_VALUE); + } + unsafe { libc::free(p) }; + Ok(()) +} + +pub(crate) fn cu_memcpy_dto_d_async_v2( + dstDevice: CUdeviceptr, + srcDevice: CUdeviceptr, + ByteCount: usize, + hStream: CUstream, +) -> Result<(), CUerror> { + unimplemented!() +} + +pub(crate) fn cu_memcpy_dto_h_async_v2( + dst_host: *mut ::core::ffi::c_void, + src_device: CUdeviceptr, + byte_count: usize, + stream: CUstream, +) -> Result<(), CUerror> { + if dst_host.is_null() || src_device.0.is_null() { + return Err(CUerror::INVALID_VALUE); + } + let dst_slice = unsafe { std::slice::from_raw_parts_mut(dst_host.cast::(), byte_count) }; + let result = GlobalState::remote_call_framed_out::( + Opcode::cuMemcpyDtoHAsync_v2, + cuMemcpyDtoHAsync_v2In { + src_device: CudaEncode::encode(src_device), + stream: CudaEncode::encode(stream), + byte_count: u32_le::from_native(byte_count as u32), + }, + )?; + dst_slice.copy_from_slice(&result.dst_host); + Ok(()) +} + +pub(crate) fn cu_memcpy_hto_d_async_v2( + dst_device: CUdeviceptr, + src_host: *const ::core::ffi::c_void, + byte_count: usize, + h_stream: CUstream, +) -> Result<(), CUerror> { + if src_host.is_null() || dst_device.0.is_null() { + return Err(CUerror::INVALID_VALUE); + } + let slice = unsafe { std::slice::from_raw_parts(src_host.cast::(), byte_count) }; + GlobalState::remote_call_framed_in::( + Opcode::cuMemcpyHtoDAsync_v2, + cuMemcpyHtoDAsync_v2In { + dst_device: CudaEncode::encode(dst_device), + src_host: slice.to_vec(), + stream: CudaEncode::encode(h_stream), + }, + )?; + Ok(()) +} + +pub(crate) fn cu_memset_d8_v2( + dstDevice: CUdeviceptr, + uc: ::core::ffi::c_uchar, + N: usize, +) -> Result<(), CUerror> { + unimplemented!() +} + +pub(crate) fn cu_module_get_function( + hfunc: *mut CUfunction, + hmod: CUmodule, + name: *const ::core::ffi::c_char, +) -> Result<(), CUerror> { + let hfunc = unsafe { hfunc.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + let mut state = GlobalState::get()?.lock().map_err(|_| CUerror::UNKNOWN)?; + *hfunc = CUfunction( + state + .server + .remote_call_framed_in::( + Opcode::cuModuleGetFunction, + cuModuleGetFunctionIn { + hmod: CudaEncode::encode(hmod), + name: unsafe { std::ffi::CStr::from_ptr(name) } + .to_bytes_with_nul() + .to_vec(), + }, + )? + .hfunc + .to_native() as _, + ); + let arg_sizes_out = state + .server + .remote_call_framed_out::( + Opcode::zludaGetFunctionArgs, + zludaGetFunctionArgsIn { + f: CudaEncode::encode(*hfunc), + }, + )?; + state.function_args.insert(*hfunc, arg_sizes_out.args); + Ok(()) +} + +pub(crate) fn cu_module_get_global_v2( + dptr: *mut CUdeviceptr, + bytes: *mut usize, + hmod: CUmodule, + name: *const ::core::ffi::c_char, +) -> Result<(), CUerror> { + let mut bytes_fallback = 0usize; + let dptr = unsafe { dptr.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + let bytes = unsafe { bytes.as_mut() }.unwrap_or(&mut bytes_fallback); + let result = GlobalState::remote_call_framed_in::( + Opcode::cuModuleGetGlobal_v2, + cuModuleGetGlobal_v2In { + hmod: CudaEncode::encode(hmod), + name: unsafe { std::ffi::CStr::from_ptr(name) } + .to_bytes() + .to_vec(), + }, + )?; + *dptr = CudaEncode::decode(result.dptr); + *bytes = result.bytes.to_native() as usize; + Ok(()) +} + +pub(crate) fn cu_module_get_tex_ref( + texref: *mut CUtexref, + hmod: CUmodule, + name: *const ::core::ffi::c_char, +) -> Result<(), CUerror> { + let texref = unsafe { texref.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + let result = GlobalState::remote_call_framed_in::( + Opcode::cuModuleGetTexRef, + cuModuleGetTexRefIn { + hmod: CudaEncode::encode(hmod), + name: unsafe { std::ffi::CStr::from_ptr(name) } + .to_bytes_with_nul() + .to_vec(), + }, + )?; + *texref = CudaEncode::decode(result.texref); + Ok(()) +} + +pub(crate) fn cu_stream_create( + phStream: *mut CUstream, + Flags: ::core::ffi::c_uint, +) -> Result<(), CUerror> { + unimplemented!() +} + +pub(crate) fn cu_stream_destroy_v2(hStream: CUstream) -> Result<(), CUerror> { + unimplemented!() +} + +pub(crate) fn cu_tex_ref_set_address_mode( + _tex_ref: CUtexref, + _dim: ::core::ffi::c_int, + _am: CUaddress_mode, +) -> Result<(), CUerror> { + // TODO + Ok(()) +} + +pub(crate) fn cu_tex_ref_set_address_v2( + byte_offset: *mut usize, + tex_ref: CUtexref, + dptr: CUdeviceptr, + bytes: usize, +) -> Result<(), CUerror> { + let mut bytes_fallback = 0usize; + let byte_offset = unsafe { byte_offset.as_mut() }.unwrap_or(&mut bytes_fallback); + let result = GlobalState::remote_call_zero_copy::( + Opcode::cuTexRefSetAddress_v2, + cuTexRefSetAddress_v2In { + hTexRef: CudaEncode::encode(tex_ref), + dptr: CudaEncode::encode(dptr), + bytes: u32_le::from_native(bytes as u32), + }, + )?; + *byte_offset = CudaEncode::decode(result.ByteOffset); + Ok(()) +} + +pub(crate) fn cu_tex_ref_set_filter_mode( + _tex_ref: CUtexref, + _fm: CUfilter_mode, +) -> Result<(), CUerror> { + // TODO + Ok(()) +} + +pub(crate) fn cu_tex_ref_set_flags( + tex_ref: CUtexref, + flags: ::core::ffi::c_uint, +) -> Result<(), CUerror> { + GlobalState::remote_call_zero_copy::( + Opcode::cuTexRefSetFlags, + cuTexRefSetFlagsIn { + hTexRef: CudaEncode::encode(tex_ref), + Flags: flags, + }, + )?; + Ok(()) +} + +pub(crate) fn cu_tex_ref_set_format( + tex_ref: CUtexref, + fmt: CUarray_format, + num_packed_components: ::core::ffi::c_int, +) -> Result<(), CUerror> { + GlobalState::remote_call_zero_copy::( + Opcode::cuTexRefSetFormat, + cuTexRefSetFormatIn { + hTexRef: CudaEncode::encode(tex_ref), + fmt: fmt.0.into(), + NumPackedComponents: num_packed_components, + }, + )?; + Ok(()) +} + +pub(crate) fn cu_tex_ref_set_max_anisotropy( + _tex_ref: CUtexref, + _max_aniso: ::core::ffi::c_uint, +) -> Result<(), CUerror> { + // TODO + Ok(()) +} + +pub(crate) fn cu_tex_ref_set_mipmap_filter_mode( + _tex_ref: CUtexref, + _fm: CUfilter_mode, +) -> Result<(), CUerror> { + // TODO + Ok(()) +} + +pub(crate) fn cu_tex_ref_set_mipmap_level_bias( + _tex_ref: CUtexref, + _bias: f32, +) -> Result<(), CUerror> { + // TODO + Ok(()) +} + +pub(crate) fn cu_tex_ref_set_mipmap_level_clamp( + _tex_ref: CUtexref, + _min_mipmap_level_clamp: f32, + _max_mipmap_level_clamp: f32, +) -> Result<(), CUerror> { + // TODO + Ok(()) +} + +struct UnknownBuffer { + buffer: std::cell::UnsafeCell<[u32; S]>, +} + +impl UnknownBuffer { + const fn new() -> Self { + UnknownBuffer { + buffer: std::cell::UnsafeCell::new([0; S]), + } + } + const fn len(&self) -> usize { + S + } +} + +unsafe impl Sync for UnknownBuffer {} + +static UNKNOWN_BUFFER1: UnknownBuffer<1024> = UnknownBuffer::new(); +static UNKNOWN_BUFFER2: UnknownBuffer<14> = UnknownBuffer::new(); + +struct DarkApi32; + +#[repr(C)] +struct AllocRecord { + x: usize, + y: usize, +} + +impl CudaDarkApi for DarkApi32 { + unsafe extern "system" fn get_module_from_cubin( + result: *mut cuda_types::cuda::CUmodule, + fatbinc_wrapper: *const cuda_types::dark_api::FatbincWrapper, + ) -> cuda_types::cuda::CUresult { + let result = match result.as_mut() { + Some(p) => p, + None => return CUresult::ERROR_INVALID_VALUE, + }; + let code_lib = CodeLibraryRef::try_load(fatbinc_wrapper.cast()) + .map_err(|_| CUerror::NO_BINARY_FOR_GPU)?; + let mut modules = Vec::with_capacity(1); + code_lib.iterate_modules(|_, module| match module { + Ok(CodeModuleRef::Text(ptx)) => { + modules.push(std::borrow::Cow::Borrowed(ptx.as_bytes())); + } + Ok(CodeModuleRef::File(file)) => { + if file.kind() == "ptx" { + if let Ok(text) = file.get_or_decompress_content(false) { + modules.push(text); + } + } + } + _ => {} + }); + let mut last_module = + unwrap_or::unwrap_some_or!(modules.pop(), return Err(CUerror::NO_BINARY_FOR_GPU)); + if last_module.last() != Some(&0) { + last_module.to_mut().push(0); + } + *result = CUmodule( + GlobalState::remote_call_framed_in::( + Opcode::cuModuleLoadData, + cuModuleLoadDataIn { + image: last_module.into_owned(), + }, + )? + .module + .to_native() as _, + ); + Ok(()) + } + + unsafe extern "system" fn cudart_interface_fn2( + pctx: *mut cuda_types::cuda::CUcontext, + _dev: cuda_types::cuda::CUdevice, + ) -> cuda_types::cuda::CUresult { + let ctx = unsafe { pctx.as_mut() }.ok_or(cuda_types::cuda::CUerror::INVALID_VALUE)?; + *ctx = CUcontext(0xDEADBEEFu32 as _); + cuda_types::cuda::CUresult::SUCCESS + } + + unsafe extern "system" fn get_module_from_cubin_ext1( + result: *mut cuda_types::cuda::CUmodule, + fatbinc_wrapper: *const cuda_types::dark_api::FatbincWrapper, + arg3: *mut std::ffi::c_void, + arg4: *mut std::ffi::c_void, + arg5: u32, + ) -> cuda_types::cuda::CUresult { + unimplemented!() + } + + unsafe extern "system" fn cudart_interface_fn7(arg1: usize) -> () { + unimplemented!() + } + + unsafe extern "system" fn get_module_from_cubin_ext2( + fatbin_header: *const cuda_types::dark_api::FatbinHeader, + result: *mut cuda_types::cuda::CUmodule, + arg3: *mut std::ffi::c_void, + arg4: *mut std::ffi::c_void, + arg5: u32, + ) -> cuda_types::cuda::CUresult { + unimplemented!() + } + + unsafe extern "system" fn load_compilers() -> cuda_types::cuda::CUresult { + unimplemented!() + } + + unsafe extern "system" fn get_unknown_buffer1( + ptr: *mut *mut std::ffi::c_void, + size: *mut usize, + ) -> () { + *ptr = UNKNOWN_BUFFER1.buffer.get() as *mut std::ffi::c_void; + *size = UNKNOWN_BUFFER1.len(); + } + + unsafe extern "system" fn get_unknown_buffer2( + ptr: *mut *mut std::ffi::c_void, + size: *mut usize, + ) -> () { + *ptr = UNKNOWN_BUFFER2.buffer.get() as *mut std::ffi::c_void; + *size = UNKNOWN_BUFFER2.len(); + } + + unsafe extern "system" fn context_local_storage_put( + cu_ctx: cuda_types::cuda::CUcontext, + key: *mut std::ffi::c_void, + value: *mut std::ffi::c_void, + _dtor_cb: Option< + extern "system" fn( + cuda_types::cuda::CUcontext, + *mut std::ffi::c_void, + *mut std::ffi::c_void, + ), + >, + ) -> cuda_types::cuda::CUresult { + let cu_ctx = CONTEXT_STACK.with(|s| s.unwrap(cu_ctx))?; + GlobalState::remote_call_zero_copy::( + Opcode::ContextLocalStoragePut, + ContextLocalStoragePutIn { + cu_ctx: cu_ctx.encode().into(), + key: (key as u32).into(), + value: (value as u32).into(), + }, + )?; + Ok(()) + } + + unsafe extern "system" fn context_local_storage_delete( + cu_ctx: cuda_types::cuda::CUcontext, + key: *mut std::ffi::c_void, + ) -> cuda_types::cuda::CUresult { + if !initialized() { + return Err(CUerror::DEINITIALIZED); + } + let cu_ctx = CONTEXT_STACK.with(|s| s.unwrap(cu_ctx))?; + GlobalState::remote_call_zero_copy::( + Opcode::ContextLocalStorageDelete, + ContextLocalStorageDeleteIn { + cu_ctx: cu_ctx.encode().into(), + key: (key as u32).into(), + }, + )?; + Ok(()) + } + + unsafe extern "system" fn context_local_storage_get( + value: *mut *mut std::ffi::c_void, + cu_ctx: cuda_types::cuda::CUcontext, + key: *mut std::ffi::c_void, + ) -> cuda_types::cuda::CUresult { + let value = unsafe { value.as_mut() }.ok_or(cuda_types::cuda::CUerror::INVALID_VALUE)?; + let cu_ctx = CONTEXT_STACK.with(|s| s.unwrap(cu_ctx))?; + *value = GlobalState::remote_call_zero_copy::( + Opcode::ContextLocalStorageGet, + ContextLocalStorageGetIn { + cu_ctx: cu_ctx.encode().into(), + key: (key as u32).into(), + }, + )? + .value + .to_native() as _; + Ok(()) + } + + unsafe extern "system" fn ctx_create_v2_bypass( + pctx: *mut cuda_types::cuda::CUcontext, + flags: ::std::os::raw::c_uint, + dev: cuda_types::cuda::CUdevice, + ) -> cuda_types::cuda::CUresult { + cu_ctx_create_v2(pctx, flags, dev) + } + + unsafe extern "system" fn heap_alloc( + heap_alloc_record_ptr: *mut *const std::ffi::c_void, + arg2: usize, + arg3: usize, + ) -> cuda_types::cuda::CUresult { + let heap_alloc_record_ptr = heap_alloc_record_ptr as *mut *mut AllocRecord; + let alloc_record = Box::into_raw(Box::new(AllocRecord { x: arg2, y: arg3 })); + *heap_alloc_record_ptr = alloc_record; + Ok(()) + } + + unsafe extern "system" fn heap_free( + heap_alloc_record_ptr: *const std::ffi::c_void, + arg2: *mut usize, + ) -> cuda_types::cuda::CUresult { + if !initialized() { + return Err(CUerror::DEINITIALIZED); + } + let heap_alloc_record_ptr = heap_alloc_record_ptr as *mut AllocRecord; + let record = Box::from_raw(heap_alloc_record_ptr); + if !arg2.is_null() { + *arg2 = record.y; + } + Ok(()) + } + + unsafe extern "system" fn device_get_attribute_ext( + dev: cuda_types::cuda::CUdevice, + attribute: std::ffi::c_uint, + unknown: std::ffi::c_int, + result: *mut [usize; 2], + ) -> cuda_types::cuda::CUresult { + unimplemented!() + } + + unsafe extern "system" fn device_get_something( + result: *mut std::ffi::c_uchar, + dev: cuda_types::cuda::CUdevice, + ) -> cuda_types::cuda::CUresult { + unimplemented!() + } + + unsafe extern "system" fn integrity_check( + version: u32, + unix_seconds: u64, + result: *mut [u64; 2], + ) -> cuda_types::cuda::CUresult { + unimplemented!() + } + + unsafe extern "system" fn context_check( + ctx_in: cuda_types::cuda::CUcontext, + result1: *mut u32, + result2: *mut *const std::ffi::c_void, + ) -> cuda_types::cuda::CUresult { + unimplemented!() + } + + unsafe extern "system" fn check_fn3() -> u32 { + unimplemented!() + } + + unsafe extern "system" fn hybrid_runtime_load_get_proc_address( + name: *const std::ffi::c_char, + fn_ptr: *mut *const std::ffi::c_void, + token: *mut usize, + ) -> cuda_types::cuda::CUresult { + unimplemented!() + } + + unsafe extern "system" fn hybrid_runtime_free(token: usize) -> cuda_types::cuda::CUresult { + unimplemented!() + } +} + +const DLL_PROCESS_DETACH: u32 = 0; + +#[allow(non_snake_case, unused_variables)] +#[no_mangle] +extern "system" fn DllMain(_dll_module: *const c_void, call_reason: u32, _: *const c_void) -> bool { + if call_reason == DLL_PROCESS_DETACH { + deinitialize(); + } + true +} + +static INITIALIZED: AtomicBool = AtomicBool::new(true); + +fn initialized() -> bool { + INITIALIZED.load(std::sync::atomic::Ordering::SeqCst) +} + +fn deinitialize() { + INITIALIZED.store(false, std::sync::atomic::Ordering::SeqCst); +} diff --git a/zluda64_server/Cargo.toml b/zluda64_server/Cargo.toml new file mode 100644 index 000000000..69be4b5e9 --- /dev/null +++ b/zluda64_server/Cargo.toml @@ -0,0 +1,26 @@ +[package] +name = "zluda64_server" +version = "0.0.0" +authors = ["Andrzej Janik "] +edition = "2021" + +[[bin]] +name = "zluda64_server" +path = "src/main.rs" + +[dependencies] +cuda_types = { path = "../cuda_types" } +cuda_macros = { path = "../cuda_macros" } +zluda_server_common = { path = "../zluda_server_common" } +dark_api = { path = "../dark_api" } +windows-sys = { version = "0.61.2", features = ["Win32_Foundation"] } +compio = { version = "0.18.0", features = ["macros", "fs"] } +slab = "0.4.12" +bincode = "2.0.1" +rkyv = "0.8.15" +orderly-allocator = "0.2.2" +range-alloc = "0.1.5" +rustc-hash = "2.0.0" + +[package.metadata.zluda] +windows_only = true diff --git a/zluda64_server/src/main.rs b/zluda64_server/src/main.rs new file mode 100644 index 000000000..6fd2dddb1 --- /dev/null +++ b/zluda64_server/src/main.rs @@ -0,0 +1,1192 @@ +// Prevent the console window from appearing when running the server on Windows +#![windows_subsystem = "windows"] + +use compio::{ + buf::{buf_try, IoBuf, IoBufMut, ReserveError, ReserveExactError, SetLen}, + fs::named_pipe::{ClientOptions, NamedPipeClient}, + io::{AsyncRead, AsyncReadExt, AsyncReadManaged, AsyncWrite, AsyncWriteExt}, + BufResult, +}; +use cuda_macros::cuda_function_declarations; +use cuda_types::cuda::*; +use dark_api::FunctionArgInfo; +use rkyv::{ + api::high::HighSerializer, + rend::{u32_le, u64_le}, + ser::allocator::ArenaHandle, + util::AlignedVec, + Archive, Portable, Serialize, +}; +use rustc_hash::FxHashMap; +use slab::Slab; +use std::{ + collections::BTreeMap, + ffi::{c_void, CStr, CString}, + io::{self, Write}, + mem, + ops::Range, + ptr::{self, NonNull}, + rc::Rc, +}; +use zluda_server_common::*; + +struct State { + handles: HandlePool, + dark_api: dark_api::cuda::ContextLocalStorageInterfaceV0301, + devmemory: Vec, + modules: ModuleLaunchData, +} + +struct HandlePool { + handles: Slab, +} + +impl HandlePool { + fn new() -> Self { + Self { + handles: Slab::new(), + } + } + + fn insert(&mut self, handle: *mut T) -> u32 { + (self.handles.insert(handle as usize) as u32) + 1 + } + + fn get(&self, id: u32) -> Result<*mut T, CUerror> { + if id == 0 { + return Err(CUerror::INVALID_VALUE); + } + self.handles + .get((id - 1) as usize) + .map(|&handle| handle as *mut T) + .ok_or(CUerror::INVALID_VALUE) + } +} + +struct ModuleLaunchData { + dark_api: dark_api::zluda32::Zluda32Internal, + modules: FxHashMap, + functions: FxHashMap, +} + +impl ModuleLaunchData { + fn new() -> Result { + let mut zluda32_ptr = unsafe { mem::zeroed() }; + unsafe { cuGetExportTable(&mut zluda32_ptr, &dark_api::zluda32::Zluda32Internal::GUID) }?; + let zluda32 = unsafe { dark_api::zluda32::Zluda32Internal::new(zluda32_ptr) }; + Ok(Self { + dark_api: zluda32, + modules: FxHashMap::default(), + functions: FxHashMap::default(), + }) + } + + unsafe fn new_module( + &mut self, + devmemory: &mut Vec, + module: CUmodule, + ) -> Result<(), CUerror> { + let mut count = 0; + self.dark_api.get_module_globals( + ptr::null_mut(), + ptr::null_mut(), + ptr::null_mut(), + ptr::null_mut(), + &mut count, + module, + )?; + let mut names = vec![mem::zeroed(); count as usize]; + let mut initializers = vec![mem::zeroed(); count as usize]; + let mut sizes = vec![mem::zeroed(); count as usize]; + let mut alignments = vec![mem::zeroed(); count as usize]; + self.dark_api.get_module_globals( + names.as_mut_ptr(), + initializers.as_mut_ptr(), + sizes.as_mut_ptr(), + alignments.as_mut_ptr(), + &mut count, + module, + )?; + let mut device = 0; + unsafe { cuCtxGetDevice(&mut device) }?; + let globals = (0..count as usize) + .map(|i| { + if alignments[i] > Allocator::ALLOCATION_UNIT { + return Err(CUerror::OUT_OF_MEMORY); + } + let initializer = std::slice::from_raw_parts(initializers[i], sizes[i] as usize); + let allocation = devmemory[device as usize].alloc_range(sizes[i])?; + let devptr = devmemory[device as usize].translate_range(allocation.clone())?; + unsafe { + cuMemcpyHtoD_v2( + CUdeviceptr_v2(devptr), + initializer.as_ptr().cast(), + initializer.len(), + ) + }?; + Ok::<_, CUerror>(Global { + name: unsafe { CStr::from_ptr(names[i].cast()) } + .to_string_lossy() + .into_owned(), + allocation, + size: sizes[i], + }) + }) + .collect::, _>>()?; + let module_data = Module { + globals: Rc::new(globals), + texrefs: FxHashMap::default(), + }; + self.modules.insert(module, module_data); + Ok(()) + } +} + +struct Module { + globals: Rc>, + texrefs: FxHashMap, u32>, +} + +struct Global { + name: String, + allocation: Range, + size: u32, +} + +impl Global { + fn address(&self) -> u32 { + self.allocation.start * Allocator::ALLOCATION_UNIT + } +} + +struct Function { + globals: Rc>, +} + +struct Allocator { + start: Option<*mut c_void>, + allocator: range_alloc::RangeAllocator, + allocation_ends: BTreeMap, +} + +impl Allocator { + const ALLOCATION_UNIT: u32 = 128; + const ALLOCATOR_SIZE: u32 = 512 * 1024 * 1024; // 512 MiB + + fn new() -> Self { + Self { + start: None, + allocator: range_alloc::RangeAllocator::new( + // starting from 1 to avoid handing out null pointers + 1..Self::ALLOCATOR_SIZE / Self::ALLOCATION_UNIT, + ), + allocation_ends: BTreeMap::new(), + } + } + + fn get_or_allocate_device_ptr(&mut self) -> Result<*mut c_void, CUerror> { + match self.start { + Some(ptr) => Ok(ptr), + None => { + let mut dev_ptr = CUdeviceptr_v2(ptr::null_mut()); + unsafe { cuMemAlloc_v2(&mut dev_ptr, Self::ALLOCATOR_SIZE as usize) }?; + self.start = Some(dev_ptr.0); + Ok(dev_ptr.0) + } + } + } + + fn get_device_ptr(&self) -> Result<*mut c_void, CUerror> { + self.start.ok_or(CUerror::INVALID_VALUE) + } + + fn alloc_range(&mut self, size: u32) -> Result, CUerror> { + self.get_or_allocate_device_ptr()?; + let units = size.next_multiple_of(Self::ALLOCATION_UNIT) / Self::ALLOCATION_UNIT; + self.allocator + .allocate_range(units) + .map_err(|_| CUerror::OUT_OF_MEMORY) + } + + fn alloc(&mut self, size: u32) -> Result { + let offset = self.alloc_range(size)?; + self.allocation_ends.insert(offset.start, offset.end); + Ok(offset.start * Self::ALLOCATION_UNIT) + } + + fn free(&mut self, start: u32) -> Result<(), CUerror> { + let end = self + .allocation_ends + .remove(&(start / Allocator::ALLOCATION_UNIT)) + .ok_or(CUerror::INVALID_VALUE)?; + self.allocator.free_range(start..end); + Ok(()) + } + + fn translate(&self, offset: u32) -> Result<*mut c_void, CUerror> { + let base_ptr = self.get_device_ptr()?; + Ok(base_ptr.wrapping_byte_add(offset as usize)) + } + + fn translate_range(&self, range: Range) -> Result<*mut c_void, CUerror> { + let base_ptr = self.get_device_ptr()?; + Ok(base_ptr.wrapping_byte_add(range.start as usize * Self::ALLOCATION_UNIT as usize)) + } + + fn get_range(&self, mut offset: u32) -> Option> { + offset /= Self::ALLOCATION_UNIT; + // Find last pair where `start <= ptr` + let (start, alloc) = self.allocation_ends.range(..=offset).rev().next()?; + let range = *start..*alloc; + // Check if allocation contains the pointer + if range.contains(&offset) { + Some(range) + } else { + None + } + } +} + +impl State { + fn new() -> Result { + unsafe { cuInit(0) }?; + let mut table_ptr = std::ptr::null(); + unsafe { + cuGetExportTable( + &mut table_ptr, + &dark_api::cuda::ContextLocalStorageInterfaceV0301::GUID, + ) + }?; + let dark_api = unsafe { dark_api::cuda::ContextLocalStorageInterfaceV0301::new(table_ptr) }; + let mut devices = 0; + unsafe { cuDeviceGetCount(&mut devices) }?; + Ok(Self { + handles: HandlePool::new(), + dark_api, + devmemory: (0..devices).map(|_| Allocator::new()).collect(), + modules: ModuleLaunchData::new()?, + }) + } +} + +#[compio::main] +async fn main() -> std::io::Result<()> { + let pipe_name = std::env::args_os().nth(1).ok_or(std::io::Error::new( + std::io::ErrorKind::InvalidInput, + "Pipe name not provided", + ))?; + let mut client = ClientOptions::new() + .pipe_mode(compio::fs::named_pipe::PipeMode::Byte) + .read(true) + .write(true) + .open(pipe_name) + .await?; + let mut buffer = AlignedVecBuffer(AlignedVec::new()); + let mut state = State::new().map_err(|_| { + std::io::Error::new( + std::io::ErrorKind::Other, + "Failed to initialize CUDA context", + ) + })?; + loop { + let opcode = client.read_u32_le().await?; // Read the length prefix + buffer.clear(); + match Opcode::from_repr(opcode) { + Some(Opcode::cuInit) => { + buffer = handle_cuda_function::(&mut client, buffer, cu_init) + .await?; + } + Some(Opcode::cuDeviceGetCount) => { + buffer = handle_cuda_function::( + &mut client, + buffer, + cu_device_get_count, + ) + .await?; + } + Some(Opcode::cuDeviceGetAttribute) => { + buffer = handle_cuda_function::( + &mut client, + buffer, + cu_device_get_attribute, + ) + .await?; + } + Some(Opcode::cuDeviceGet) => { + buffer = handle_cuda_function::( + &mut client, + buffer, + cu_device_get, + ) + .await?; + } + Some(Opcode::cuCtxCreate_v2) => { + buffer = handle_cuda_function::( + &mut client, + buffer, + |input| cu_ctx_create_v2(input, &mut state), + ) + .await?; + } + Some(Opcode::cuDriverGetVersion) => { + buffer = handle_cuda_function::( + &mut client, + buffer, + cu_driver_get_version, + ) + .await?; + } + Some(Opcode::cuDeviceGetName) => { + buffer = handle_cuda_function_framed_out::( + &mut client, + buffer, + cu_device_get_name, + ) + .await?; + } + Some(Opcode::cuDeviceTotalMem_v2) => { + buffer = handle_cuda_function::( + &mut client, + buffer, + cu_device_total_mem_v2, + ) + .await?; + } + Some(Opcode::ContextLocalStoragePut) => { + buffer = + handle_cuda_function::( + &mut client, + buffer, + |input| context_local_storage_put(&mut state, input), + ) + .await?; + } + Some(Opcode::ContextLocalStorageGet) => { + buffer = + handle_cuda_function::( + &mut client, + buffer, + |input| context_local_storage_get(&mut state, input), + ) + .await?; + } + Some(Opcode::ContextLocalStorageDelete) => { + buffer = handle_cuda_function::< + ContextLocalStorageDeleteIn, + ContextLocalStorageDeleteOut, + >(&mut client, buffer, |input| { + context_local_storage_delete(&mut state, input) + }) + .await?; + } + Some(Opcode::cuCtxGetApiVersion) => { + buffer = handle_cuda_function::( + &mut client, + buffer, + |input| cu_ctx_get_api_version(&mut state, input), + ) + .await?; + } + Some(Opcode::cuModuleLoadData) => { + buffer = handle_cuda_function_framed_in::( + &mut client, + buffer, + |input| cu_module_load_data(&mut state, input), + ) + .await?; + } + Some(Opcode::cuModuleGetFunction) => { + buffer = handle_cuda_function_framed_in::< + cuModuleGetFunctionIn, + cuModuleGetFunctionOut, + >(&mut client, buffer, |input| { + cu_module_get_function(&mut state, input) + }) + .await?; + } + Some(Opcode::cuModuleGetGlobal_v2) => { + buffer = handle_cuda_function_framed_in::< + cuModuleGetGlobal_v2In, + cuModuleGetGlobal_v2Out, + >(&mut client, buffer, |input| { + cu_module_get_global_v2(&mut state, input) + }) + .await?; + } + Some(Opcode::cuMemAlloc_v2) => { + buffer = handle_cuda_function::( + &mut client, + buffer, + |input| cu_mem_alloc_v2(&mut state, input), + ) + .await?; + } + Some(Opcode::cuMemcpyHtoDAsync_v2) => { + buffer = handle_cuda_function_framed_in::< + cuMemcpyHtoDAsync_v2In, + cuMemcpyHtoDAsync_v2Out, + >(&mut client, buffer, |input| { + cu_memcpy_hto_d_async_v2(&mut state, input) + }) + .await?; + } + Some(Opcode::cuModuleGetTexRef) => { + buffer = + handle_cuda_function_framed_in::( + &mut client, + buffer, + |input| cu_module_get_tex_ref(&mut state, input), + ) + .await?; + } + Some(Opcode::zludaGetFunctionArgs) => { + buffer = handle_cuda_function_framed_out::< + zludaGetFunctionArgsIn, + zludaGetFunctionArgsOut, + >(&mut client, buffer, |input| { + zluda_get_function_args(&mut state, input) + }) + .await?; + } + Some(Opcode::cuLaunchKernel) => { + buffer = handle_cuda_function_framed_in::( + &mut client, + buffer, + |input| cu_launch_kernel(&mut state, input), + ) + .await?; + } + Some(Opcode::cuCtxSynchronize) => { + buffer = handle_cuda_function::( + &mut client, + buffer, + cu_ctx_synchronize, + ) + .await?; + } + Some(Opcode::cuMemcpyDtoHAsync_v2) => { + buffer = handle_cuda_function_framed_out::< + cuMemcpyDtoHAsync_v2In, + cuMemcpyDtoHAsync_v2Out, + >(&mut client, buffer, |input| { + cu_memcpy_dtoh_async_v2(&mut state, input) + }) + .await?; + } + Some(Opcode::cuMemGetAddressRange_v2) => { + buffer = handle_cuda_function::< + cuMemGetAddressRange_v2In, + cuMemGetAddressRange_v2Out, + >(&mut client, buffer, |input| { + cu_mem_get_address_range_v2(&mut state, input) + }) + .await?; + } + Some(Opcode::cuTexRefSetAddress_v2) => { + buffer = handle_cuda_function::( + &mut client, + buffer, + |input| cu_tex_ref_set_address_v2(&mut state, input), + ) + .await?; + } + Some(Opcode::cuTexRefSetFlags) => { + buffer = handle_cuda_function::( + &mut client, + buffer, + |input| cu_tex_ref_set_flags(&mut state, input), + ) + .await?; + } + Some(Opcode::cuTexRefSetFormat) => { + buffer = handle_cuda_function::( + &mut client, + buffer, + |input| cu_tex_ref_set_format(&mut state, input), + ) + .await?; + } + Some(Opcode::cuMemFree_v2) => { + buffer = handle_cuda_function::( + &mut client, + buffer, + |input| cu_mem_free_v2(&mut state, input), + ) + .await?; + } + _ => { + client.write_u32_le(CUerror::NOT_SUPPORTED.0.get()).await?; + return Err(std::io::Error::new( + std::io::ErrorKind::Other, + "Unsupported operation", + )); + } + } + } +} + +fn cu_mem_free_v2( + state: &mut State, + input: &ArchivedcuMemFree_v2In, +) -> Result { + let mut device = 0; + unsafe { cuCtxGetDevice(&mut device) }?; + let dptr = input.dptr.to_native(); + state.devmemory[device as usize].free(dptr)?; + Ok(cuMemFree_v2Out {}) +} + +fn cu_tex_ref_set_format( + state: &mut State, + input: &ArchivedcuTexRefSetFormatIn, +) -> Result { + let tex_ref = state.handles.get(input.hTexRef.to_native())?; + unsafe { + cuTexRefSetFormat( + tex_ref, + CUarray_format(input.fmt.to_native()), + input.NumPackedComponents.to_native(), + ) + }?; + Ok(cuTexRefSetFormatOut {}) +} + +fn cu_tex_ref_set_flags( + state: &mut State, + input: &ArchivedcuTexRefSetFlagsIn, +) -> Result { + let tex_ref = state.handles.get(input.hTexRef.to_native())?; + unsafe { cuTexRefSetFlags(tex_ref, input.Flags.to_native()) }?; + Ok(cuTexRefSetFlagsOut {}) +} + +fn cu_tex_ref_set_address_v2( + state: &mut State, + input: &ArchivedcuTexRefSetAddress_v2In, +) -> Result { + let mut device = 0; + unsafe { cuCtxGetDevice(&mut device) }?; + let mut byte_offset = 0; + let dptr = input.dptr.to_native(); + let dptr = if dptr != 0 { + CUdeviceptr_v2(state.devmemory[device as usize].translate(dptr)?) + } else { + CUdeviceptr_v2(ptr::null_mut()) + }; + unsafe { + cuTexRefSetAddress_v2( + &mut byte_offset, + state.handles.get(input.hTexRef.to_native())?, + dptr, + input.bytes.to_native() as usize, + ) + }?; + Ok(cuTexRefSetAddress_v2Out { + ByteOffset: (byte_offset as u32).into(), + }) +} + +fn cu_mem_get_address_range_v2( + state: &mut State, + input: &ArchivedcuMemGetAddressRange_v2In, +) -> Result { + let mut device = 0; + unsafe { cuCtxGetDevice(&mut device) }?; + let allocator = &state.devmemory[device as usize]; + let range = allocator + .get_range(input.dptr.to_native()) + .ok_or(CUerror::INVALID_VALUE)?; + Ok(cuMemGetAddressRange_v2Out { + pbase: (range.start * Allocator::ALLOCATION_UNIT).into(), + psize: ((range.end - range.start) * Allocator::ALLOCATION_UNIT).into(), + }) +} + +fn cu_memcpy_dtoh_async_v2( + state: &mut State, + input: &ArchivedcuMemcpyDtoHAsync_v2In, +) -> Result { + let mut device = 0; + unsafe { cuCtxGetDevice(&mut device) }?; + let devptr = state.devmemory[device as usize].translate(input.src_device.to_native())?; + let stream = input.stream.to_native(); + let stream = if stream == 0 { + CUstream(ptr::null_mut()) + } else { + CUstream(state.handles.get(stream)?) + }; + let mut dst_host = vec![0u8; input.byte_count.to_native() as usize]; + unsafe { + cuMemcpyDtoHAsync_v2( + dst_host.as_mut_ptr().cast(), + CUdeviceptr_v2(devptr), + input.byte_count.to_native() as usize, + stream, + ) + }?; + unsafe { cuStreamSynchronize(stream) }?; + Ok(cuMemcpyDtoHAsync_v2Out { dst_host }) +} + +fn cu_ctx_synchronize(input: &ArchivedcuCtxSynchronizeIn) -> Result { + unsafe { cuCtxSynchronize() }?; + Ok(cuCtxSynchronizeOut {}) +} + +fn cu_launch_kernel( + state: &mut State, + input: &ArchivedcuLaunchKernelIn, +) -> Result { + let mut device = 0; + unsafe { cuCtxGetDevice(&mut device) }?; + let mut params = input + .kernel_params + .iter() + .map(|p| p.as_ptr().cast_mut().cast::()) + .collect::>(); + let mut base64_ptr = state.devmemory[device as usize].get_device_ptr()?; + params.push(ptr::from_mut(&mut base64_ptr).cast()); + let function = CUfunction(state.handles.get(input.f.to_native())?); + let function_info = state + .modules + .functions + .get(&function) + .ok_or(CUerror::INVALID_VALUE)?; + let globals = function_info + .globals + .iter() + .map(|global| global.allocation.start * Allocator::ALLOCATION_UNIT) + .collect::>(); + for g in globals.iter() { + params.push(ptr::from_ref(g).cast_mut().cast()); + } + unsafe { + cuLaunchKernel( + function, + input.grid_dim_x.to_native(), + input.grid_dim_y.to_native(), + input.grid_dim_z.to_native(), + input.block_dim_x.to_native(), + input.block_dim_y.to_native(), + input.block_dim_z.to_native(), + input.shared_mem_bytes.to_native(), + if input.stream == 0 { + CUstream(ptr::null_mut()) + } else { + CUstream(state.handles.get(input.stream.to_native())?) + }, + params.as_mut_ptr(), + std::ptr::null_mut(), + ) + }?; + Ok(cuLaunchKernelOut {}) +} + +fn zluda_get_function_args( + state: &mut State, + input: &ArchivedzludaGetFunctionArgsIn, +) -> Result { + let hfunc = state.handles.get(input.f.to_native())?; + let mut count = 0; + unsafe { + state.modules.dark_api.get_function_info( + std::ptr::null_mut(), + &mut count, + CUfunction(hfunc), + ) + }?; + let mut arg_sizes = vec![FunctionArgInfo { size: 0, align: 0 }; count as usize]; + unsafe { + state.modules.dark_api.get_function_info( + arg_sizes.as_mut_ptr(), + &mut count, + CUfunction(hfunc), + ) + }?; + Ok(zludaGetFunctionArgsOut { args: arg_sizes }) +} + +fn cu_module_get_tex_ref( + state: &mut State, + input: &ArchivedcuModuleGetTexRefIn, +) -> Result { + let hmod = state.handles.get::(input.hmod.to_native())?; + let module = state + .modules + .modules + .get_mut(&CUmodule(hmod)) + .ok_or(CUerror::INVALID_VALUE)?; + let texref = match module.texrefs.entry(input.name.to_vec()) { + std::collections::hash_map::Entry::Occupied(entry) => *entry.get(), + std::collections::hash_map::Entry::Vacant(entry) => { + let mut texref = unsafe { mem::zeroed() }; + unsafe { cuModuleGetTexRef(&mut texref, CUmodule(hmod), input.name.as_ptr().cast()) }?; + let handle = state.handles.insert(texref); + *entry.insert(handle) + } + }; + Ok(cuModuleGetTexRefOut { + texref: u32_le::from_native(texref), + }) +} + +fn cu_memcpy_hto_d_async_v2( + state: &mut State, + input: &ArchivedcuMemcpyHtoDAsync_v2In, +) -> Result { + let mut device = 0; + unsafe { cuCtxGetDevice(&mut device) }?; + let devptr = state.devmemory[device as usize].translate(input.dst_device.to_native())?; + let stream = input.stream.to_native(); + let stream = if stream == 0 { + CUstream(ptr::null_mut()) + } else { + CUstream(state.handles.get(stream)?) + }; + unsafe { + cuMemcpyHtoDAsync_v2( + CUdeviceptr_v2(devptr), + input.src_host.as_ptr().cast(), + input.src_host.len(), + stream, + ) + }?; + Ok(cuMemcpyHtoDAsync_v2Out {}) +} + +fn cu_mem_alloc_v2( + state: &mut State, + input: &ArchivedcuMemAlloc_v2In, +) -> Result { + let mut device = 0; + unsafe { cuCtxGetDevice(&mut device) }?; + let fake_ptr = state.devmemory[device as usize].alloc(input.bytesize.to_native())?; + Ok(cuMemAlloc_v2Out { + dptr: u32_le::from_native(fake_ptr), + }) +} + +fn cu_module_get_global_v2( + state: &mut State, + input: &ArchivedcuModuleGetGlobal_v2In, +) -> Result { + let hmod = state.handles.get::(input.hmod.to_native())?; + let module = state + .modules + .modules + .get(&CUmodule(hmod)) + .ok_or(CUerror::INVALID_VALUE)?; + let global = module + .globals + .iter() + .find(|global| global.name.as_bytes() == input.name.as_slice()) + .ok_or(CUerror::NOT_FOUND)?; + Ok(cuModuleGetGlobal_v2Out { + dptr: u32_le::from_native(global.address()), + bytes: u64_le::from_native(global.size as u64), + }) +} + +fn cu_module_get_function( + state: &mut State, + input: &ArchivedcuModuleGetFunctionIn, +) -> Result { + let mut hfunc = unsafe { mem::zeroed() }; + let hmod = state.handles.get(input.hmod.to_native())?; + unsafe { cuModuleGetFunction(&mut hfunc, CUmodule(hmod), input.name.as_ptr().cast()) }?; + state + .modules + .functions + .entry(hfunc) + .or_insert_with(|| Function { + globals: Rc::clone(&state.modules.modules[&CUmodule(hmod)].globals), + }); + Ok(cuModuleGetFunctionOut { + hfunc: u32_le::from_native(state.handles.insert(hfunc.0)), + }) +} + +fn cu_module_load_data( + state: &mut State, + input: &ArchivedcuModuleLoadDataIn, +) -> Result { + let mut module = unsafe { mem::zeroed() }; + unsafe { cuModuleLoadData(&mut module, input.image.as_ptr().cast()) }?; + unsafe { state.modules.new_module(&mut state.devmemory, module) }?; + Ok(cuModuleLoadDataOut { + module: u32_le::from_native(state.handles.insert(module.0)), + }) +} + +fn cu_init(input: &ArchivedcuInitIn) -> Result { + unsafe { cuInit(input.Flags.to_native()) }?; + Ok(cuInitOut {}) +} + +fn cu_device_get_count( + _input: &ArchivedcuDeviceGetCountIn, +) -> Result { + let mut count = 0; + unsafe { cuDeviceGetCount(&mut count) }?; + Ok(cuDeviceGetCountOut { count }) +} + +fn cu_device_get_attribute( + input: &ArchivedcuDeviceGetAttributeIn, +) -> Result { + let mut pi = 0; + unsafe { + cuDeviceGetAttribute( + &mut pi, + CUdevice_attribute_enum(input.attrib.to_native()), + input.dev.to_native(), + ) + }?; + Ok(cuDeviceGetAttributeOut { pi }) +} + +fn cu_device_get(input: &ArchivedcuDeviceGetIn) -> Result { + let mut device = 0; + unsafe { cuDeviceGet(&mut device, input.ordinal.to_native()) }?; + Ok(cuDeviceGetOut { device }) +} + +fn cu_device_get_name(input: &ArchivedcuDeviceGetNameIn) -> Result { + let mut name = vec![0u8; input.len.to_native() as usize]; + unsafe { + cuDeviceGetName( + name.as_mut_ptr().cast(), + input.len.to_native(), + input.dev.to_native(), + ) + }?; + if let Some(pos) = name.iter().copied().position(|c| c == 0) { + name.truncate(pos); + } + Ok(cuDeviceGetNameOut { name }) +} + +fn cu_ctx_create_v2( + input: &ArchivedcuCtxCreate_v2In, + state: &mut State, +) -> Result { + let mut pctx = unsafe { mem::zeroed() }; + unsafe { cuCtxCreate_v2(&mut pctx, input.flags.to_native(), input.dev.to_native()) }?; + let pctx = state.handles.insert(pctx.0); + Ok(cuCtxCreate_v2Out { + pctx: u32_le::from_native(pctx), + }) +} + +fn cu_device_total_mem_v2( + input: &ArchivedcuDeviceTotalMem_v2In, +) -> Result { + let mut bytes = 0usize; + unsafe { cuDeviceTotalMem_v2(&mut bytes, input.dev.to_native()) }?; + Ok(cuDeviceTotalMem_v2Out { + bytes: u64_le::from_native(bytes as u64), + }) +} + +fn cu_driver_get_version( + _input: &ArchivedcuDriverGetVersionIn, +) -> Result { + let mut driver_version = 0; + unsafe { cuDriverGetVersion(&mut driver_version) }?; + Ok(cuDriverGetVersionOut { + driverVersion: driver_version, + }) +} + +fn cu_ctx_get_api_version( + state: &mut State, + input: &ArchivedcuCtxGetApiVersionIn, +) -> Result { + let ctx = CUcontext(state.handles.get(input.ctx.to_native())?); + let mut version = 0; + unsafe { cuCtxGetApiVersion(ctx, &mut version) }?; + Ok(cuCtxGetApiVersionOut { version }) +} + +fn context_local_storage_put( + state: &mut State, + input: &ArchivedContextLocalStoragePutIn, +) -> Result { + unsafe { + state.dark_api.context_local_storage_put( + CUcontext(state.handles.get(input.cu_ctx.to_native())?), + input.key.to_native() as _, + input.value.to_native() as _, + None, + ) + }?; + Ok(ContextLocalStoragePutOut {}) +} + +fn context_local_storage_get( + state: &mut State, + input: &ArchivedContextLocalStorageGetIn, +) -> Result { + let mut value = ptr::null_mut(); + unsafe { + state.dark_api.context_local_storage_get( + &mut value, + CUcontext(state.handles.get(input.cu_ctx.to_native())?), + input.key.to_native() as _, + ) + }?; + Ok(ContextLocalStorageGetOut { + value: u32_le::from_native(value as u32), + }) +} + +fn context_local_storage_delete( + state: &mut State, + input: &ArchivedContextLocalStorageDeleteIn, +) -> Result { + unsafe { + state.dark_api.context_local_storage_delete( + CUcontext(state.handles.get(input.cu_ctx.to_native())?), + input.key.to_native() as _, + ) + }?; + Ok(ContextLocalStorageDeleteOut {}) +} + +async fn handle_cuda_function( + client: &mut NamedPipeClient, + mut buffer: AlignedVecBuffer, + handler: impl FnOnce(&In::Archived) -> Result, +) -> std::io::Result +where + Out: for<'a, 'b> Serialize< + HighSerializer<&'a mut AlignedVec, ArenaHandle<'b>, rkyv::rancor::Failure>, + >, +{ + buffer = read_all::(buffer, client).await?; + let input = unsafe { rkyv::access_unchecked::(buffer.as_init()) }; + match handler(input) { + Ok(output) => { + buffer.clear(); + client.write_u32_le(0).await?; + rkyv::api::high::to_bytes_in::<_, rkyv::rancor::Failure>(&output, &mut buffer.0) + .map_err(|_| { + std::io::Error::new(std::io::ErrorKind::Other, "Failed to serialize response") + })?; + let ((), new_buffer) = buf_try!(@try client.write_all(buffer).await); + Ok(new_buffer) + } + Err(e) => { + client.write_u32_le(e.0.get()).await?; + Ok(buffer) + } + } +} + +async fn handle_cuda_function_framed_in( + client: &mut NamedPipeClient, + mut buffer: AlignedVecBuffer, + handler: impl FnOnce(&In::Archived) -> Result, +) -> std::io::Result +where + Out: for<'a, 'b> Serialize< + HighSerializer<&'a mut AlignedVec, ArenaHandle<'b>, rkyv::rancor::Failure>, + >, +{ + let length_prefix = client.read_u32_le().await? as usize; + buffer = read_sized(buffer, client, length_prefix).await?; + let input = unsafe { rkyv::access_unchecked::(buffer.as_init()) }; + match handler(input) { + Ok(output) => { + buffer.clear(); + client.write_u32_le(0).await?; + rkyv::api::high::to_bytes_in::<_, rkyv::rancor::Failure>(&output, &mut buffer.0) + .map_err(|_| { + std::io::Error::new(std::io::ErrorKind::Other, "Failed to serialize response") + })?; + let ((), new_buffer) = buf_try!(@try client.write_all(buffer).await); + Ok(new_buffer) + } + Err(e) => { + client.write_u32_le(e.0.get()).await?; + Ok(buffer) + } + } +} + +async fn handle_cuda_function_framed_out( + client: &mut NamedPipeClient, + mut buffer: AlignedVecBuffer, + handler: impl FnOnce(&In::Archived) -> Result, +) -> std::io::Result +where + Out: for<'a, 'b> Serialize< + HighSerializer<&'a mut AlignedVec, ArenaHandle<'b>, rkyv::rancor::Failure>, + >, +{ + buffer = read_all::(buffer, client).await?; + let input = unsafe { rkyv::access_unchecked::(buffer.as_init()) }; + match handler(input) { + Ok(output) => { + buffer.clear(); + rkyv::api::high::to_bytes_in::<_, rkyv::rancor::Failure>(&output, &mut buffer.0) + .map_err(|_| { + std::io::Error::new(std::io::ErrorKind::Other, "Failed to serialize response") + })?; + let code_and_len = unsafe { + std::mem::transmute::<(u32, u32), [u8; 8]>((0u32, buffer.0.len() as u32)) + }; + client.write_all(code_and_len).await.0?; + let ((), new_buffer) = buf_try!(@try client.write_all(buffer).await); + Ok(new_buffer) + } + Err(e) => { + client.write_u32_le(e.0.get()).await?; + Ok(buffer) + } + } +} + +async fn read_all( + buffer: AlignedVecBuffer, + client: &mut NamedPipeClient, +) -> std::io::Result { + read_sized(buffer, client, mem::size_of::()).await +} + +async fn read_sized( + mut buffer: AlignedVecBuffer, + client: &mut NamedPipeClient, + mut remaining_read: usize, +) -> std::io::Result { + buffer.clear(); + buffer.reserve(remaining_read)?; + while remaining_read > 0 { + let BufResult(read_result, new_buffer) = client.append(buffer).await; + let n = read_result?; + remaining_read = remaining_read.checked_sub(n).ok_or_else(|| { + std::io::Error::new( + std::io::ErrorKind::InvalidData, + "Read more bytes than expected", + ) + })?; + buffer = new_buffer; + } + Ok(buffer) +} + +struct AlignedVecBuffer(AlignedVec); + +impl AlignedVecBuffer { + fn clear(&mut self) { + self.0.clear(); + } +} + +impl IoBuf for AlignedVecBuffer { + fn as_init(&self) -> &[u8] { + self.0.as_slice() + } +} + +impl SetLen for AlignedVecBuffer { + unsafe fn set_len(&mut self, len: usize) { + unsafe { self.0.set_len(len) } + } +} + +impl IoBufMut for AlignedVecBuffer { + fn as_uninit(&mut self) -> &mut [std::mem::MaybeUninit] { + let ptr = self.0.as_mut_ptr() as *mut std::mem::MaybeUninit; + let cap = self.0.capacity(); + unsafe { std::slice::from_raw_parts_mut(ptr, cap) } + } + + fn reserve(&mut self, len: usize) -> Result<(), ReserveError> { + self.0.reserve(len); + Ok(()) + } + + fn reserve_exact(&mut self, len: usize) -> Result<(), ReserveExactError> { + if self.0.capacity() - self.0.len() >= len { + return Ok(()); + } + + self.0.reserve_exact(len); + + if self.0.capacity() - self.0.len() != len { + return Err(ReserveExactError::ExactSizeMismatch { + reserved: self.0.capacity() - self.0.len(), + expected: len, + }); + } + Ok(()) + } +} + +macro_rules! nop { + ($($abi:literal fn $fn_name:ident( $($arg_id:ident : $arg_type:ty),* ) -> $ret_type:ty;)*) => {}; +} + +macro_rules! implemented { + ($($abi:literal fn $fn_name:ident( $($arg_id:ident : $arg_type:ty),* ) -> $ret_type:ty;)*) => { + $( + #[link(name = "nvcuda", kind = "raw-dylib")] + unsafe extern $abi { + fn $fn_name ( $( $arg_id : $arg_type),* ) -> $ret_type; + } + )* + + }; +} + +cuda_function_declarations! { + nop, + implemented <= [ + cuCtxCreate_v2, + // cuCtxDetach, + cuCtxGetApiVersion, + // cuCtxGetCurrent, + cuCtxGetDevice, + cuCtxSynchronize, + // cuDeviceComputeCapability, + cuDeviceGet, + cuDeviceGetAttribute, + cuDeviceGetCount, + cuDeviceGetName, + // cuDeviceGetProperties, + cuDeviceTotalMem_v2, + cuDriverGetVersion, + // cuEventCreate, + // cuEventDestroy_v2, + cuGetExportTable, + cuInit, + cuLaunchKernel, + cuMemAlloc_v2, + // cuMemFreeHost, + cuMemFree_v2, + // cuMemGetAddressRange_v2, + // cuMemHostAlloc, + // cuMemcpyDtoDAsync_v2, + cuMemcpyDtoHAsync_v2, + cuMemcpyHtoD_v2, + cuMemcpyHtoDAsync_v2, + // cuMemsetD8_v2, + cuModuleGetFunction, + cuModuleGetGlobal_v2, + cuModuleGetTexRef, + cuModuleLoadData, + // cuStreamCreate, + // cuStreamDestroy_v2, + // cuTexRefSetAddressMode, + cuTexRefSetAddress_v2, + // cuTexRefSetFilterMode, + cuTexRefSetFlags, + cuTexRefSetFormat, + // cuTexRefSetMaxAnisotropy, + // cuTexRefSetMipmapFilterMode, + // cuTexRefSetMipmapLevelBias, + // cuTexRefSetMipmapLevelClamp, + cuStreamSynchronize, + ] +} diff --git a/zluda_common/src/constants.rs b/zluda_common/src/constants.rs index 8d316211b..fb468e9bf 100644 --- a/zluda_common/src/constants.rs +++ b/zluda_common/src/constants.rs @@ -2,6 +2,7 @@ pub const PROJECT_SUFFIX: &[u8] = b" [ZLUDA]\0"; const COMPUTE_CAPABILITY_MAJOR: i32 = 8; const COMPUTE_CAPABILITY_MINOR: i32 = 8; +#[cfg(target_pointer_width = "64")] pub const BLAS_HANDLE_COOKIE: usize = 0x57c3fdb0fd72b08e; pub fn compute_capability() -> (i32, i32) { diff --git a/zluda_common/src/lib.rs b/zluda_common/src/lib.rs index 4568f2ac2..5a701ac4b 100644 --- a/zluda_common/src/lib.rs +++ b/zluda_common/src/lib.rs @@ -135,6 +135,7 @@ macro_rules! from_cuda_nop { macro_rules! from_cuda_transmute { ($($from:ty => $to:ty),*) => { $( + #[cfg(target_pointer_width = "64")] impl<'a, E: CudaErrorType> FromCuda<'a, $from, E> for $to { fn from_cuda(x: &'a $from) -> Result { Ok(unsafe { std::mem::transmute(*x) }) diff --git a/zluda_inject/Cargo.toml b/zluda_inject/Cargo.toml index a334ded57..a8bd44775 100644 --- a/zluda_inject/Cargo.toml +++ b/zluda_inject/Cargo.toml @@ -13,7 +13,6 @@ windows = { version = "0.62.2", features = [ "Win32_Foundation", "Win32_System_Threading", "Win32_Security", - "Win32_System_JobObjects", "Win32_System_Diagnostics_Debug", "Win32_System_LibraryLoader", ] } @@ -34,3 +33,4 @@ zluda_ml = { path = "../zluda_ml" } [package.metadata.zluda] windows_only = true +32bit = true diff --git a/zluda_inject/src/bin.rs b/zluda_inject/src/bin.rs index a75ee40f6..dd571fbe1 100644 --- a/zluda_inject/src/bin.rs +++ b/zluda_inject/src/bin.rs @@ -7,10 +7,6 @@ use std::ffi::{CString, OsStr}; use std::path::PathBuf; use std::{env, mem, process, ptr}; use windows::Win32::Foundation::{HANDLE, WAIT_FAILED}; -use windows::Win32::System::JobObjects::{ - AssignProcessToJobObject, JobObjectExtendedLimitInformation, SetInformationJobObject, - JOBOBJECT_EXTENDED_LIMIT_INFORMATION, JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE, -}; use windows::Win32::System::Threading::{ self, GetExitCodeProcess, ResumeThread, WaitForSingleObject, CREATE_SUSPENDED, CREATE_UNICODE_ENVIRONMENT, @@ -69,7 +65,7 @@ pub fn main_impl() -> Result<(), Box> { Option::None ) }; - kill_child_on_process_exit(proc_info.hProcess)?; + zluda_windows::kill_child_on_process_exit(proc_info.hProcess)?; injection_env.copy_payloads_to_process(proc_info.hProcess)?; os_call! { ResumeThread(HANDLE(proc_info.hThread)), |x| x == -1i32 as u32 }; os_call! { WaitForSingleObject(HANDLE(proc_info.hProcess), Threading::INFINITE), |x| x == WAIT_FAILED }; @@ -338,19 +334,3 @@ impl InjectionConfig { Ok(result.into_vec()) } } - -fn kill_child_on_process_exit(child: detours_sys::HANDLE) -> Result<(), Box> { - let job_handle = unsafe { windows::Win32::System::JobObjects::CreateJobObjectA(None, None) }?; - let mut info = JOBOBJECT_EXTENDED_LIMIT_INFORMATION::default(); - info.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE; - unsafe { - SetInformationJobObject( - job_handle, - JobObjectExtendedLimitInformation, - &mut info as *mut _ as *mut _, - size_of_val(&info) as u32, - ) - }?; - unsafe { AssignProcessToJobObject(job_handle, HANDLE(child)) }?; - Ok(()) -} diff --git a/zluda_redirect/Cargo.toml b/zluda_redirect/Cargo.toml index e216fd7b2..9133e6567 100644 --- a/zluda_redirect/Cargo.toml +++ b/zluda_redirect/Cargo.toml @@ -36,3 +36,4 @@ rustc-hash = "2.0.0" [package.metadata.zluda] windows_only = true +32bit = true diff --git a/zluda_server_common/Cargo.toml b/zluda_server_common/Cargo.toml new file mode 100644 index 000000000..c1b9de263 --- /dev/null +++ b/zluda_server_common/Cargo.toml @@ -0,0 +1,17 @@ +[package] +name = "zluda_server_common" +version = "0.0.0" +authors = ["Andrzej Janik "] +edition = "2021" + +[dependencies] +dark_api = { path = "../dark_api" } +cuda_types = { path = "../cuda_types" } +cuda_macros = { path = "../cuda_macros" } +bitcode = "0.6.9" +paste = "1" +postcard = "1.1.3" +bincode = "2.0.1" +rkyv = "0.8.15" +strum = "0.28" +strum_macros = "0.28" diff --git a/zluda_server_common/src/lib.rs b/zluda_server_common/src/lib.rs new file mode 100644 index 000000000..7148c53f9 --- /dev/null +++ b/zluda_server_common/src/lib.rs @@ -0,0 +1,368 @@ +use bincode::{Decode, Encode}; +use cuda_macros::{cuda_function_declarations, generate_input_struct, generate_output_struct}; +use cuda_types::cuda::*; +use paste::paste; +use rkyv::rend::{u32_le, u64_le}; +use rkyv::{rend, Archive, Deserialize, Portable, Serialize}; +use std::ffi::CString; +use std::num::NonZeroU32; +use std::{ffi::CStr, num::NonZero}; +use strum_macros::FromRepr; + +macro_rules! noop { + ($($abi:literal fn $fn_name:ident( $($arg_id:ident : $arg_type:ty),* ) -> $ret_type:ty;)*) => {}; +} + +macro_rules! generate_messages_inout { + ($($abi:literal fn $fn_name:ident( $($arg_id:ident : $arg_type:ty),* ) -> $ret_type:ty;)*) => { + $( + generate_input_struct!($fn_name, $($arg_id : $arg_type),*); + generate_output_struct!($fn_name, $($arg_id : $arg_type),*); + )* + + #[repr(u32)] + #[derive(FromRepr)] + pub enum Opcode { + System = 0, + $( + $fn_name, + )* + cuDeviceGetName, + cuDeviceTotalMem_v2, + cuModuleLoadData, + ContextLocalStoragePut, + ContextLocalStorageGet, + ContextLocalStorageDelete, + cuModuleGetFunction, + cuModuleGetGlobal_v2, + cuMemAlloc_v2, + cuMemcpyHtoDAsync_v2, + cuModuleGetTexRef, + cuLaunchKernel, + zludaGetFunctionArgs, + cuMemcpyDtoHAsync_v2 + } + }; +} + +macro_rules! generate_messages_in { + ($($abi:literal fn $fn_name:ident( $($arg_id:ident : $arg_type:ty),* ) -> $ret_type:ty;)*) => { + $( + generate_input_struct!($fn_name, $($arg_id : $arg_type),*); + )* + }; +} + +cuda_function_declarations! { + noop, + generate_messages_inout <= [ + cuCtxCreate_v2, + cuCtxDetach, + cuCtxGetApiVersion, + cuCtxGetCurrent, + cuCtxGetDevice, + cuCtxSynchronize, + cuDeviceComputeCapability, + cuDeviceGet, + cuDeviceGetAttribute, + cuDeviceGetCount, + cuDeviceGetProperties, + cuDriverGetVersion, + cuEventCreate, + cuEventDestroy_v2, + //cuGetExportTable, + cuInit, + // cuLaunchKernel, + //cuMemAlloc_v2, + //cuMemFreeHost, + cuMemFree_v2, + cuMemGetAddressRange_v2, + //cuMemHostAlloc, + //cuMemcpyDtoDAsync_v2, + //cuMemcpyDtoHAsync_v2, + //cuMemcpyHtoDAsync_v2, + // cuMemsetD8_v2, + // cuModuleGetFunction, + // cuModuleGetGlobal_v2, + // cuModuleGetTexRef, + cuStreamCreate, + cuStreamDestroy_v2, + cuTexRefSetAddressMode, + cuTexRefSetAddress_v2, + cuTexRefSetFilterMode, + cuTexRefSetFlags, + cuTexRefSetFormat, + cuTexRefSetMaxAnisotropy, + cuTexRefSetMipmapFilterMode, + cuTexRefSetMipmapLevelBias, + cuTexRefSetMipmapLevelClamp, + ], + generate_messages_in <= [ + cuDeviceGetName, + cuDeviceTotalMem_v2 + ] +} + +pub trait CudaEncode: Copy { + type WireObject; + fn encode(self) -> Self::WireObject; + fn decode(o: Self::WireObject) -> Self; +} + +macro_rules! encode_as_self { + ($type_:ty) => { + impl CudaEncode for $type_ { + type WireObject = Self; + fn encode(self) -> Self { + self + } + fn decode(o: Self::WireObject) -> Self { + o + } + } + }; +} + +macro_rules! encode_as_proxy { + ($type_:ty, $proxy_type:ty) => { + impl CudaEncode for $type_ { + type WireObject = $proxy_type; + fn encode(self) -> $proxy_type { + unsafe { std::mem::transmute::(self) } + } + fn decode(o: Self::WireObject) -> Self { + unsafe { std::mem::transmute::<$proxy_type, Self>(o) } + } + } + }; +} + +macro_rules! encode_as_u32 { + ($type_:ty) => { + impl CudaEncode for $type_ { + type WireObject = u32_le; + fn encode(self) -> u32_le { + unsafe { std::mem::transmute_copy::(&self) } + } + fn decode(o: Self::WireObject) -> Self { + unsafe { std::mem::transmute_copy::(&o) } + } + } + }; +} + +encode_as_self!(u8); +encode_as_self!(i8); +encode_as_self!(u32); +encode_as_self!(i32); +encode_as_self!(f32); + +encode_as_proxy!(CUdevprop_v1, CUdevprop_v1_Wire); +encode_as_proxy!(CUdevice_attribute, u32_le); +encode_as_proxy!(CUfilter_mode, u32_le); +encode_as_proxy!(CUaddress_mode, u32_le); +encode_as_proxy!(CUarray_format, u32_le); + +encode_as_u32!(CUcontext); +encode_as_u32!(CUdeviceptr_v2); +encode_as_u32!(CUevent); +encode_as_u32!(CUfunction); +encode_as_u32!(CUmodule); +encode_as_u32!(CUstream); +encode_as_u32!(CUtexref); + +impl CudaEncode for usize { + type WireObject = u32_le; + fn encode(self) -> u32_le { + (self as u32).into() + } + fn decode(o: Self::WireObject) -> Self { + o.to_native() as usize + } +} + +#[repr(C)] +#[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct CUdevprop_v1_Wire { + pub maxThreadsPerBlock: ::core::ffi::c_int, + pub maxThreadsDim: [::core::ffi::c_int; 3usize], + pub maxGridSize: [::core::ffi::c_int; 3usize], + pub sharedMemPerBlock: ::core::ffi::c_int, + pub totalConstantMemory: ::core::ffi::c_int, + pub SIMDWidth: ::core::ffi::c_int, + pub memPitch: ::core::ffi::c_int, + pub regsPerBlock: ::core::ffi::c_int, + pub clockRate: ::core::ffi::c_int, + pub textureAlign: ::core::ffi::c_int, +} + +unsafe impl Portable for CUdevprop_v1_Wire {} + +#[repr(C)] +#[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct cuDeviceGetNameOut { + pub name: Vec, +} + +#[repr(C)] +#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct cuDeviceTotalMem_v2Out { + pub bytes: u64_le, +} + +#[repr(C)] +#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct ContextLocalStoragePutIn { + pub cu_ctx: u32_le, + pub key: u32_le, + pub value: u32_le, +} + +#[repr(C)] +#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct ContextLocalStoragePutOut {} + +#[repr(C)] +#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct ContextLocalStorageGetIn { + pub cu_ctx: u32_le, + pub key: u32_le, +} + +#[repr(C)] +#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct ContextLocalStorageGetOut { + pub value: u32_le, +} + +#[repr(C)] +#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct ContextLocalStorageDeleteIn { + pub cu_ctx: u32_le, + pub key: u32_le, +} + +#[repr(C)] +#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct ContextLocalStorageDeleteOut {} + +#[repr(C)] +#[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct cuModuleLoadDataIn { + pub image: Vec, +} + +#[repr(C)] +#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct cuModuleLoadDataOut { + pub module: ::WireObject, +} + +#[repr(C)] +#[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct cuModuleGetFunctionIn { + pub hmod: ::WireObject, + pub name: Vec, +} + +#[repr(C)] +#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct cuModuleGetFunctionOut { + pub hfunc: ::WireObject, +} + +#[repr(C)] +#[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct cuModuleGetGlobal_v2In { + pub hmod: ::WireObject, + pub name: Vec, +} + +#[repr(C)] +#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct cuModuleGetGlobal_v2Out { + pub dptr: ::WireObject, + pub bytes: u64_le, +} + +#[repr(C)] +#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct cuMemAlloc_v2In { + pub bytesize: u32_le, +} + +#[repr(C)] +#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct cuMemAlloc_v2Out { + pub dptr: ::WireObject, +} + +#[repr(C)] +#[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct cuMemcpyHtoDAsync_v2In { + pub dst_device: ::WireObject, + pub src_host: Vec, + pub stream: ::WireObject, +} + +#[repr(C)] +#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct cuMemcpyHtoDAsync_v2Out {} + +#[repr(C)] +#[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct cuModuleGetTexRefIn { + pub hmod: ::WireObject, + pub name: Vec, +} + +#[repr(C)] +#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct cuModuleGetTexRefOut { + pub texref: ::WireObject, +} + +#[repr(C)] +#[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct cuLaunchKernelIn { + pub f: ::WireObject, + pub grid_dim_x: u32_le, + pub grid_dim_y: u32_le, + pub grid_dim_z: u32_le, + pub block_dim_x: u32_le, + pub block_dim_y: u32_le, + pub block_dim_z: u32_le, + pub shared_mem_bytes: u32_le, + pub stream: ::WireObject, + pub kernel_params: Vec>, +} + +#[repr(C)] +#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct cuLaunchKernelOut {} + +#[repr(C)] +#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct zludaGetFunctionArgsIn { + pub f: ::WireObject, +} + +#[repr(C)] +#[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct zludaGetFunctionArgsOut { + pub args: Vec, +} + +#[repr(C)] +#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct cuMemcpyDtoHAsync_v2In { + pub src_device: ::WireObject, + pub stream: ::WireObject, + pub byte_count: u32_le, +} + +#[repr(C)] +#[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] +pub struct cuMemcpyDtoHAsync_v2Out { + pub dst_host: Vec, +} diff --git a/zluda_trace/Cargo.toml b/zluda_trace/Cargo.toml index d36cb1cb1..decfa48f7 100644 --- a/zluda_trace/Cargo.toml +++ b/zluda_trace/Cargo.toml @@ -9,15 +9,14 @@ name = "zluda_trace" crate-type = ["cdylib"] [dependencies] -ptx = { path = "../ptx" } ptx_parser = { path = "../ptx_parser" } zluda_trace_common = { path = "../zluda_trace_common" } zluda_common = { path = "../zluda_common" } format = { path = "../format" } dark_api = { path = "../dark_api" } regex = "1.4" -dynasm = "1.2" -dynasmrt = "1.2" +dynasm = "5.0" +dynasmrt = "5.0" # we don't need elf32, but goblin has a bug where elf64 does not build without elf32 goblin = { version = "0.9", default-features = false, features = [ "elf64", @@ -52,3 +51,4 @@ linux_symlinks = [ "trace_nvidia/libcuda.so.1", ] windows_paths = ["trace/nvcuda.dll"] +32bit = true diff --git a/zluda_trace/src/lib.rs b/zluda_trace/src/lib.rs index b813f631e..20bb3e687 100644 --- a/zluda_trace/src/lib.rs +++ b/zluda_trace/src/lib.rs @@ -63,6 +63,24 @@ impl CudaDynamicFns { } } +#[cfg(unix)] +impl Drop for CudaDynamicFns { + fn drop(&mut self) { + unsafe { + libloading::os::unix::Library::from_raw(self.lib_handle.as_ptr() as _); + } + } +} + +#[cfg(windows)] +impl Drop for CudaDynamicFns { + fn drop(&mut self) { + unsafe { + libloading::os::windows::Library::from_raw(self.lib_handle.as_ptr() as _); + } + } +} + unsafe impl Send for CudaDynamicFns {} unsafe impl Sync for CudaDynamicFns {} @@ -147,13 +165,19 @@ struct InternalTableImpl; impl ::dark_api::zluda_trace::CudaDarkApi for InternalTableImpl { unsafe extern "system" fn logged_call( fn_name: cglue::slice::CSliceRef<'static, u8>, + nvapi_interface: u32, args: ::dark_api::FnFfiRef<::dark_api::ByteVecFfi>, fn_: ::dark_api::FnFfiRef, internal_error: usize, format_status: extern "C" fn(usize) -> ::dark_api::ByteVecFfi, ) -> usize { + let fn_name = if nvapi_interface == 0 { + CudaFunctionName::Normal(unsafe { fn_name.into_str() }) + } else { + CudaFunctionName::Nvapi(nvapi_interface) + }; GlobalState2::under_lock( - CudaFunctionName::Normal(unsafe { fn_name.into_str() }), + fn_name, Some(|| args.call().to_vec()), internal_error, |status| format_status(status).to_vec(), diff --git a/zluda_trace/src/log.rs b/zluda_trace/src/log.rs index 5915f1938..023d7979d 100644 --- a/zluda_trace/src/log.rs +++ b/zluda_trace/src/log.rs @@ -236,6 +236,7 @@ impl Write for WriteBuffer { pub(crate) enum CudaFunctionName { Normal(&'static str), Dark { guid: CUuuid, index: usize }, + Nvapi(u32) } impl Display for CudaFunctionName { @@ -257,6 +258,9 @@ impl Display for CudaFunctionName { } } } + CudaFunctionName::Nvapi(interface) => { + write!(f, "{{nvapi:{:#010x}}}", interface) + } } } } diff --git a/zluda_trace/src/trace.rs b/zluda_trace/src/trace.rs index fa3315076..1db1c62c1 100644 --- a/zluda_trace/src/trace.rs +++ b/zluda_trace/src/trace.rs @@ -102,9 +102,10 @@ impl StateTracker { }) } Ok(zluda_common::CodeModuleRef::File(file)) => { - if let Some(buffer) = fn_logger - .try_(|_| file.get_or_decompress_content().map_err(ErrorEntry::from)) - { + if let Some(buffer) = fn_logger.try_(|_| { + file.get_or_decompress_content(true) + .map_err(ErrorEntry::from) + }) { self.record_new_submodule(index, &*buffer, fn_logger, file.kind()); } } diff --git a/zluda_trace_blas/src/lib.rs b/zluda_trace_blas/src/lib.rs index b1bc28fdc..0ef7600eb 100644 --- a/zluda_trace_blas/src/lib.rs +++ b/zluda_trace_blas/src/lib.rs @@ -35,6 +35,7 @@ macro_rules! unimplemented { }); ReprUsize::from_usize(export_table.logged_call( cglue::slice::CSliceRef::from_str(stringify!($fn_name)), + 0, cglue::trait_obj!(&format_args as dark_api::FnFfi), cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), internal_error_untyped, diff --git a/zluda_trace_blaslt/src/lib.rs b/zluda_trace_blaslt/src/lib.rs index 5202a79dc..e1c4b1f1a 100644 --- a/zluda_trace_blaslt/src/lib.rs +++ b/zluda_trace_blaslt/src/lib.rs @@ -35,6 +35,7 @@ macro_rules! unimplemented { }); ReprUsize::from_usize(export_table.logged_call( cglue::slice::CSliceRef::from_str(stringify!($fn_name)), + 0, cglue::trait_obj!(&format_args as dark_api::FnFfi), cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), internal_error_untyped, diff --git a/zluda_trace_dnn8/src/lib.rs b/zluda_trace_dnn8/src/lib.rs index 6e98a384b..f0ebd0402 100644 --- a/zluda_trace_dnn8/src/lib.rs +++ b/zluda_trace_dnn8/src/lib.rs @@ -35,6 +35,7 @@ macro_rules! unimplemented { }); ReprUsize::from_usize(export_table.logged_call( cglue::slice::CSliceRef::from_str(stringify!($fn_name)), + 0, cglue::trait_obj!(&format_args as dark_api::FnFfi), cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), internal_error_untyped, diff --git a/zluda_trace_dnn9/src/lib.rs b/zluda_trace_dnn9/src/lib.rs index 5989ccb3a..96e1a7536 100644 --- a/zluda_trace_dnn9/src/lib.rs +++ b/zluda_trace_dnn9/src/lib.rs @@ -35,6 +35,7 @@ macro_rules! unimplemented { }); ReprUsize::from_usize(export_table.logged_call( cglue::slice::CSliceRef::from_str(stringify!($fn_name)), + 0, cglue::trait_obj!(&format_args as dark_api::FnFfi), cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), internal_error_untyped, diff --git a/zluda_trace_fft/src/lib.rs b/zluda_trace_fft/src/lib.rs index dbedc29fd..ca1f83881 100644 --- a/zluda_trace_fft/src/lib.rs +++ b/zluda_trace_fft/src/lib.rs @@ -35,6 +35,7 @@ macro_rules! unimplemented { }); ReprUsize::from_usize(export_table.logged_call( cglue::slice::CSliceRef::from_str(stringify!($fn_name)), + 0, cglue::trait_obj!(&format_args as dark_api::FnFfi), cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), internal_error_untyped, diff --git a/zluda_trace_nvml/src/lib.rs b/zluda_trace_nvml/src/lib.rs index 4eed6940f..8fe8b5b51 100644 --- a/zluda_trace_nvml/src/lib.rs +++ b/zluda_trace_nvml/src/lib.rs @@ -35,6 +35,7 @@ macro_rules! unimplemented { }); ReprUsize::from_usize(export_table.logged_call( cglue::slice::CSliceRef::from_str(stringify!($fn_name)), + 0, cglue::trait_obj!(&format_args as dark_api::FnFfi), cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), internal_error_untyped, diff --git a/zluda_trace_sparse/src/lib.rs b/zluda_trace_sparse/src/lib.rs index 44a286d0c..2e2d7683a 100644 --- a/zluda_trace_sparse/src/lib.rs +++ b/zluda_trace_sparse/src/lib.rs @@ -35,6 +35,7 @@ macro_rules! unimplemented { }); ReprUsize::from_usize(export_table.logged_call( cglue::slice::CSliceRef::from_str(stringify!($fn_name)), + 0, cglue::trait_obj!(&format_args as dark_api::FnFfi), cglue::trait_obj!(&underlying_fn as dark_api::FnFfi), internal_error_untyped, diff --git a/zluda_windows/src/lib.rs b/zluda_windows/src/lib.rs index c9d482e70..26ba82846 100644 --- a/zluda_windows/src/lib.rs +++ b/zluda_windows/src/lib.rs @@ -13,11 +13,19 @@ use widestring::{u16str, U16Str, U16String}; use windows::{ core::{w, HRESULT, PCWSTR}, Win32::{ - Foundation::{HINSTANCE, HMODULE, HWND, LPARAM, S_OK, WPARAM}, - System::LibraryLoader::{ - GetModuleFileNameA, GetModuleFileNameW, GetModuleHandleExW, LoadLibraryExW, - GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, - LOAD_LIBRARY_SEARCH_DEFAULT_DIRS, LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR, + Foundation::{HANDLE, HINSTANCE, HMODULE, HWND, LPARAM, S_OK, WPARAM}, + System::{ + JobObjects::{ + AssignProcessToJobObject, JobObjectExtendedLimitInformation, + SetInformationJobObject, JOBOBJECT_EXTENDED_LIMIT_INFORMATION, + JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE, + }, + LibraryLoader::{ + GetModuleFileNameA, GetModuleFileNameW, GetModuleHandleExW, LoadLibraryExW, + GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, + GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, LOAD_LIBRARY_SEARCH_DEFAULT_DIRS, + LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR, + }, }, UI::{ Controls::{ @@ -30,9 +38,13 @@ use windows::{ }, }; -pub static LIBRARIES: [LibraryInfo; 16] = [ +#[cfg(target_pointer_width = "32")] +pub static LIBRARIES: [LibraryInfo; 2] = [NVCUDA, NVAPI]; + +#[cfg(target_pointer_width = "64")] +pub static LIBRARIES: [LibraryInfo; 17] = [ NVCUDA, NVML, DNN8, DNN9, BLAS13, BLAS12, BLAS11, BLAS_LT13, BLAS_LT12, BLAS_LT11, SPARSE12, - SPARSE11, SPARSE10, FFT12, FFT11, FFT10, + SPARSE11, SPARSE10, FFT12, FFT11, FFT10, NVAPI, ]; pub const NVCUDA: LibraryInfo = LibraryInfo { @@ -195,6 +207,22 @@ pub const FFT10: LibraryInfo = LibraryInfo { in_system32: false, }; +pub const NVAPI: LibraryInfo = LibraryInfo { + short_name: "nvapi", + is_alias: false, + #[cfg(target_pointer_width = "32")] + ascii_name: "nvapi.dll", + #[cfg(target_pointer_width = "64")] + ascii_name: "nvapi64.dll", + #[cfg(target_pointer_width = "32")] + utf16_name: u16str!("nvapi.dll"), + #[cfg(target_pointer_width = "64")] + utf16_name: u16str!("nvapi64.dll"), + guid: uuid!("f7449ed6-d01c-4376-9fc4-446eb2e4cf70"), + trace_env_var: "ZLUDA_NVAPI_LIB", + in_system32: true, +}; + #[derive(Debug)] pub struct LibraryInfo { pub short_name: &'static str, @@ -583,6 +611,22 @@ pub fn get_module_path_utf16(hm: HMODULE) -> OsString { OsString::from_wide(&buffer) } +pub fn kill_child_on_process_exit(child: *mut c_void) -> windows::core::Result<()> { + let job_handle = unsafe { windows::Win32::System::JobObjects::CreateJobObjectA(None, None) }?; + let mut info = JOBOBJECT_EXTENDED_LIMIT_INFORMATION::default(); + info.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE; + unsafe { + SetInformationJobObject( + job_handle, + JobObjectExtendedLimitInformation, + &mut info as *mut _ as *mut _, + size_of_val(&info) as u32, + ) + }?; + unsafe { AssignProcessToJobObject(job_handle, HANDLE(child)) }?; + Ok(()) +} + #[cfg(test)] mod tests { use super::*; From 052b163c79373d128e52e9861dd3c63dcdf0fd91 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Mon, 22 Jun 2026 16:39:06 -0700 Subject: [PATCH 66/85] Revert "Use generic address space for consts" This reverts commit 18f776f9225984fdb4b8659b74fac59da72f8bd7. # Conflicts: # ptx/src/pass/llvm/emit.rs --- ptx/src/pass/llvm/attributes.rs | 2 +- ptx/src/pass/llvm/emit.rs | 496 +++++++++++++++----------------- ptx/src/pass/llvm/mod.rs | 11 +- ptx/src/pass/mod.rs | 2 +- 4 files changed, 231 insertions(+), 280 deletions(-) diff --git a/ptx/src/pass/llvm/attributes.rs b/ptx/src/pass/llvm/attributes.rs index 1b60584ed..ffde4c6c9 100644 --- a/ptx/src/pass/llvm/attributes.rs +++ b/ptx/src/pass/llvm/attributes.rs @@ -38,7 +38,7 @@ fn emit_attribute( module.get(), attribute_type, name.as_ptr(), - get_state_space(ast::StateSpace::Const, false)?, + get_state_space(ast::StateSpace::Const)?, ) }; unsafe { LLVMSetLinkage(global, llvm_zluda::LLVMLinkage::LLVMExternalLinkage) }; diff --git a/ptx/src/pass/llvm/emit.rs b/ptx/src/pass/llvm/emit.rs index 942e13764..f31cab05e 100644 --- a/ptx/src/pass/llvm/emit.rs +++ b/ptx/src/pass/llvm/emit.rs @@ -66,10 +66,9 @@ pub(crate) fn run<'input>( context: &Context, id_defs: GlobalStringIdentResolver2<'input>, directives: Vec, SpirvWord>>, - is_32bit: bool, ) -> Result { let module = llvm::Module::new(context, LLVM_UNNAMED); - let mut emit_ctx = ModuleEmitContext::new(context, &module, &id_defs, is_32bit); + let mut emit_ctx = ModuleEmitContext::new(context, &module, &id_defs); for directive in directives { match directive { Directive2::Variable(linking, variable) => emit_ctx.emit_global(linking, variable)?, @@ -84,223 +83,12 @@ pub(crate) fn run<'input>( Ok(module) } -#[derive(Debug, Clone, Copy)] -struct ZludaTypeToLLVM { - context: LLVMContextRef, - is_32bit: bool, -} - -impl ZludaTypeToLLVM { - fn get_state_space(&self, space: ast::StateSpace) -> Result { - get_state_space(space, self.is_32bit) - } - - fn get_input_argument_type( - &self, - v_type: &ast::Type, - state_space: ast::StateSpace, - ) -> Result { - match state_space { - ast::StateSpace::ParamEntry | ast::StateSpace::Shared => Ok(unsafe { - LLVMPointerTypeInContext(self.context, self.get_state_space(state_space)?) - }), - ast::StateSpace::Reg => self.get_type(v_type), - ast::StateSpace::Global | ast::StateSpace::Const - if matches!(v_type, ast::Type::Texref) => - { - Ok(unsafe { - LLVMPointerTypeInContext(self.context, self.get_state_space(state_space)?) - }) - } - _ => return Err(error_unreachable()), - } - } - - fn get_pointer_type<'ctx>( - &self, - to_space: ast::StateSpace, - ) -> Result { - Ok(unsafe { LLVMPointerTypeInContext(self.context, self.get_state_space(to_space)?) }) - } - - fn get_type(&self, type_: &ast::Type) -> Result { - Ok(match type_ { - ast::Type::Scalar(scalar) => get_scalar_type(self.context, *scalar), - ast::Type::Vector(size, scalar) => { - let base_type = get_scalar_type(self.context, *scalar); - unsafe { LLVMVectorType(base_type, *size as u32) } - } - ast::Type::Array(vec, scalar, dimensions) => { - let mut underlying_type = get_scalar_type(self.context, *scalar); - if let Some(size) = vec { - underlying_type = unsafe { LLVMVectorType(underlying_type, size.get() as u32) }; - } - if dimensions.is_empty() { - return Ok(unsafe { LLVMArrayType2(underlying_type, 0) }); - } - dimensions - .iter() - .rfold(underlying_type, |result, dimension| unsafe { - LLVMArrayType2(result, *dimension as u64) - }) - } - ast::Type::Texref => { - // Definitions taken from ROCm LLVM output - let format_desc = unsafe { - LLVMStructCreateNamed(self.context, c"struct.hipChannelFormatDesc".as_ptr()) - }; - let llvm_i32 = get_scalar_type(self.context, ast::ScalarType::B32); - let mut format_desc_fields = [llvm_i32, llvm_i32, llvm_i32, llvm_i32, llvm_i32]; - unsafe { - LLVMStructSetBody( - format_desc, - format_desc_fields.as_mut_ptr(), - format_desc_fields.len() as u32, - 0, - ) - }; - let texture_reference = unsafe { - LLVMStructCreateNamed(self.context, c"struct.textureReference".as_ptr()) - }; - let llvm_a3i32 = unsafe { LLVMArrayType2(llvm_i32, 3) }; - let llvm_float = get_scalar_type(self.context, ast::ScalarType::F32); - let llvm_ptr = self.get_pointer_type(ast::StateSpace::Generic)?; - let mut texture_reference_fields = [ - llvm_i32, - llvm_i32, - llvm_i32, - llvm_a3i32, - format_desc, - llvm_i32, - llvm_i32, - llvm_i32, - llvm_float, - llvm_float, - llvm_float, - llvm_ptr, - llvm_i32, - llvm_i32, - ]; - unsafe { - LLVMStructSetBody( - texture_reference, - texture_reference_fields.as_mut_ptr(), - texture_reference_fields.len() as u32, - 0, - ) - }; - let texture = - unsafe { LLVMStructCreateNamed(self.context, c"struct.texture".as_ptr()) }; - let mut texture_fields = [texture_reference]; - unsafe { - LLVMStructSetBody( - texture, - texture_fields.as_mut_ptr(), - texture_fields.len() as u32, - 0, - ) - }; - texture - } - }) - } - - fn get_anonymous_struct_type<'a>( - &self, - elem_types: impl Iterator, - ) -> Result { - let mut elem_types = elem_types - .map(|t| self.get_type(t)) - .collect::, _>>()?; - Ok(unsafe { - LLVMStructTypeInContext( - self.context, - elem_types.as_mut_ptr(), - elem_types.len() as u32, - 0, - ) - }) - } - - fn get_function_type_impl<'a>( - &self, - mut return_args: impl DoubleEndedIterator - + ExactSizeIterator, - input_args: impl Iterator>, - struct_kind: StructKind, - ) -> Result { - let mut input_args = input_args.collect::, _>>()?; - let return_type = match return_args.len() { - 0 => unsafe { LLVMVoidTypeInContext(self.context) }, - 1 => self.get_type(&return_args.next().unwrap())?, - _ => match struct_kind { - StructKind::Named => self.get_or_create_struct_type(return_args)?, - StructKind::Anonymous => self.get_anonymous_struct_type(return_args)?, - }, - }; - - Ok(unsafe { - LLVMFunctionType( - return_type, - input_args.as_mut_ptr(), - input_args.len() as u32, - 0, - ) - }) - } - - fn get_function_type<'a>( - &self, - return_args: impl DoubleEndedIterator - + ExactSizeIterator, - input_args: impl Iterator>, - ) -> Result { - self.get_function_type_impl(return_args, input_args, StructKind::Named) - } - - fn get_intrinsic_type<'a>( - &self, - return_args: impl DoubleEndedIterator - + ExactSizeIterator, - input_args: impl Iterator>, - ) -> Result { - self.get_function_type_impl(return_args, input_args, StructKind::Anonymous) - } - - fn get_or_create_struct_type<'a>( - &self, - mut elem_types: impl Iterator, - ) -> Result { - use std::fmt::Write; - let (mut name, types) = elem_types.try_fold( - ("struct".to_string(), Vec::new()), - |(mut name, mut types), t| { - name.push('.'); - if let ast::Type::Scalar(scalar) = t { - write!(name, "{}", LLVMTypeDisplay(*scalar)).ok(); - } else { - return Err(error_unreachable()); - } - types.push(self.get_type(t)?); - Ok((name, types)) - }, - )?; - name.push('\0'); - let mut struct_type = unsafe { LLVMGetTypeByName2(self.context, name.as_ptr().cast()) }; - if struct_type.is_null() { - struct_type = create_struct_type(self.context, name, types); - } - Ok(struct_type) - } -} - struct ModuleEmitContext<'a, 'input> { context: LLVMContextRef, module: LLVMModuleRef, builder: Builder, id_defs: &'a GlobalStringIdentResolver2<'input>, resolver: ResolveIdent, - llvm_types: ZludaTypeToLLVM, } impl<'a, 'input> ModuleEmitContext<'a, 'input> { @@ -308,7 +96,6 @@ impl<'a, 'input> ModuleEmitContext<'a, 'input> { context: &Context, module: &llvm::Module, id_defs: &'a GlobalStringIdentResolver2<'input>, - is_32bit: bool, ) -> Self { ModuleEmitContext { context: context.get(), @@ -316,10 +103,6 @@ impl<'a, 'input> ModuleEmitContext<'a, 'input> { builder: Builder::new(context), id_defs, resolver: ResolveIdent::new(&id_defs), - llvm_types: ZludaTypeToLLVM { - context: context.get(), - is_32bit, - }, } } @@ -343,11 +126,11 @@ impl<'a, 'input> ModuleEmitContext<'a, 'input> { let name = CString::new(name).map_err(|_| error_unreachable())?; let mut fn_ = unsafe { LLVMGetNamedFunction(self.module, name.as_ptr()) }; if fn_ == ptr::null_mut() { - let fn_type = self.llvm_types.get_function_type( + let fn_type = get_function_type( + self.context, method.return_arguments.iter().map(|v| &v.info.v_type), method.input_arguments.iter().map(|v| { - self.llvm_types - .get_input_argument_type(&v.info.v_type, v.info.state_space) + get_input_argument_type(self.context, &v.info.v_type, v.info.state_space) }), )?; fn_ = unsafe { LLVMAddFunction(self.module, name.as_ptr(), fn_type) }; @@ -393,7 +176,7 @@ impl<'a, 'input> ModuleEmitContext<'a, 'input> { LLVMCreateTypeAttribute( self.context, attr_kind, - self.llvm_types.get_type(¶m.info.v_type)?, + get_type(self.context, ¶m.info.v_type)?, ) }; unsafe { LLVMAddAttributeAtIndex(fn_, i as u32 + 1, attr) }; @@ -431,7 +214,7 @@ impl<'a, 'input> ModuleEmitContext<'a, 'input> { unsafe { LLVMPositionBuilderAtEnd(self.builder.get(), real_bb) }; let base_32bit_memory = method.kernel_meta32.as_ref().map(|m| m.implicit_memory_ptr); let mut method_emitter = - MethodEmitContext::new(self, fn_, variables_builder, self.llvm_types, base_32bit_memory, is_kernel); + MethodEmitContext::new(self, fn_, variables_builder, base_32bit_memory, is_kernel); for var in method.return_arguments { method_emitter.emit_variable(var)?; } @@ -474,13 +257,13 @@ impl<'a, 'input> ModuleEmitContext<'a, 'input> { .transpose() .map_err(|_| error_unreachable())? .unwrap_or(Cow::Borrowed(LLVM_UNNAMED)); - let llvm_type = self.llvm_types.get_type(&var.info.v_type)?; + let llvm_type = get_type(self.context, &var.info.v_type)?; let global = unsafe { LLVMAddGlobalInAddressSpace( self.module, llvm_type, name.as_ptr(), - self.llvm_types.get_state_space(var.info.state_space)?, + get_state_space(var.info.state_space)?, ) }; if matches!(var.info.v_type, ast::Type::Texref) { @@ -658,6 +441,23 @@ fn llvm_ftz(ftz: bool) -> &'static str { } } +fn get_input_argument_type( + context: LLVMContextRef, + v_type: &ast::Type, + state_space: ast::StateSpace, +) -> Result { + match state_space { + ast::StateSpace::ParamEntry | ast::StateSpace::Shared => { + Ok(unsafe { LLVMPointerTypeInContext(context, get_state_space(state_space)?) }) + } + ast::StateSpace::Reg => get_type(context, v_type), + ast::StateSpace::Global | ast::StateSpace::Const if matches!(v_type, ast::Type::Texref) => { + Ok(unsafe { LLVMPointerTypeInContext(context, get_state_space(state_space)?) }) + } + _ => return Err(error_unreachable()), + } +} + struct MethodEmitContext<'a> { context: LLVMContextRef, module: LLVMModuleRef, @@ -666,7 +466,6 @@ struct MethodEmitContext<'a> { variables_builder: Builder, resolver: &'a mut ResolveIdent, carry_flag: Option, - llvm_types: ZludaTypeToLLVM, base_32bit_memory: Option, is_kernel: bool, } @@ -676,7 +475,6 @@ impl<'a> MethodEmitContext<'a> { parent: &'a mut ModuleEmitContext, method: LLVMValueRef, variables_builder: Builder, - llvm_types: ZludaTypeToLLVM, base_32bit_memory: Option, is_kernel: bool, ) -> MethodEmitContext<'a> { @@ -688,7 +486,6 @@ impl<'a> MethodEmitContext<'a> { resolver: &mut parent.resolver, method, carry_flag: None, - llvm_types, base_32bit_memory, is_kernel, } @@ -746,8 +543,8 @@ impl<'a> MethodEmitContext<'a> { let alloca = unsafe { LLVMZludaBuildAlloca( self.variables_builder.get(), - self.llvm_types.get_type(&var.info.v_type)?, - self.llvm_types.get_state_space(var.info.state_space)?, + get_type(self.context, &var.info.v_type)?, + get_state_space(var.info.state_space)?, self.resolver.get_or_add_raw(var.name), ) }; @@ -888,7 +685,7 @@ impl<'a> MethodEmitContext<'a> { arguments: ast::LdArgs, ) -> Result<(), TranslateError> { let builder = self.builder; - let underlying_type = self.llvm_types.get_type(&data.typ)?; + let underlying_type = get_type(self.context, &data.typ)?; let needs_cast = not_supported_by_atomics(data.qualifier, underlying_type); let op_type = if needs_cast { unsafe { @@ -932,7 +729,7 @@ impl<'a> MethodEmitContext<'a> { ), ConversionKind::SignExtend => { let src = self.resolver.value(conversion.src)?; - let type_ = self.llvm_types.get_type(&conversion.to_type)?; + let type_ = get_type(self.context, &conversion.to_type)?; self.resolver.with_result(conversion.dst, |dst| unsafe { LLVMBuildSExt(builder, src, type_, dst) }); @@ -940,7 +737,7 @@ impl<'a> MethodEmitContext<'a> { } ConversionKind::BitToPtr => { let src = self.resolver.value(conversion.src)?; - let ptr_type = self.llvm_types.get_pointer_type(conversion.to_space)?; + let ptr_type = get_pointer_type(self.context, conversion.to_space)?; if let ( Some(base32), ast::StateSpace::Global | ast::StateSpace::Generic | ast::StateSpace::Const, @@ -972,18 +769,8 @@ impl<'a> MethodEmitContext<'a> { Ok(()) } ConversionKind::PtrToPtr => { - if conversion.from_space == conversion.to_space { - // With opaque pointers it's meaningless - return self.emit_mov(ast::MovArgs { - dst: conversion.dst, - src: conversion.src, - }); - } - if self.base_32bit_memory.is_some() { - return Err(error_todo()); - } let src = self.resolver.value(conversion.src)?; - let dst_type = self.llvm_types.get_pointer_type(conversion.to_space)?; + let dst_type = get_pointer_type(self.context, conversion.to_space)?; self.resolver.with_result(conversion.dst, |dst| unsafe { LLVMBuildAddrSpaceCast(builder, src, dst_type, dst) }); @@ -991,7 +778,7 @@ impl<'a> MethodEmitContext<'a> { } ConversionKind::AddressOf => { let src = self.resolver.value(conversion.src)?; - let dst_type = self.llvm_types.get_type(&conversion.to_type)?; + let dst_type = get_type(self.context, &conversion.to_type)?; if let ( Some(_), ast::StateSpace::Global | ast::StateSpace::Generic | ast::StateSpace::Const, @@ -1023,7 +810,7 @@ impl<'a> MethodEmitContext<'a> { let from_layout = from_type.layout(); let to_layout = to_type.layout().ok_or_else(error_unreachable)?; if from_layout.size() == to_layout.size() { - let dst_type = self.llvm_types.get_type(&to_type)?; + let dst_type = get_type(self.context, &to_type)?; if from_type.kind() != ast::ScalarKind::Float && to_type_scalar.kind() != ast::ScalarKind::Float { @@ -1109,7 +896,7 @@ impl<'a> MethodEmitContext<'a> { | (ast::Type::Scalar(..), ast::Type::Vector(..)) | (ast::Type::Scalar(..), ast::Type::Array(..)) | (ast::Type::Array(..), ast::Type::Scalar(..)) => { - let dst_type = self.llvm_types.get_type(to_type)?; + let dst_type = get_type(self.context, to_type)?; self.resolver.with_result(dst, |dst| unsafe { LLVMBuildBitCast(self.builder, src, dst_type, dst) }); @@ -1194,7 +981,7 @@ impl<'a> MethodEmitContext<'a> { LLVMZludaBuildAlloca( self.variables_builder.get(), LLVMIntTypeInContext(self.context, 1), - self.llvm_types.get_state_space(ast::StateSpace::Reg)?, + get_state_space(ast::StateSpace::Reg)?, c"__ZLUDA_REG_CC_CF".as_ptr(), ) }; @@ -1358,7 +1145,7 @@ impl<'a> MethodEmitContext<'a> { arguments: ast::StArgs, ) -> Result<(), TranslateError> { let ptr = self.resolver.value(arguments.src1)?; - let underlying_type = self.llvm_types.get_type(&data.typ)?; + let underlying_type = get_type(self.context, &data.typ)?; let needs_cast = not_supported_by_atomics(data.qualifier, underlying_type); let mut value = self.resolver.value(arguments.src2)?; if needs_cast { @@ -1405,11 +1192,12 @@ impl<'a> MethodEmitContext<'a> { [dst] => self.resolver.get_or_add_raw(*dst), _ => LLVM_UNNAMED.as_ptr(), }; - let type_ = self.llvm_types.get_function_type( + let type_ = get_function_type( + self.context, data.return_arguments.iter().map(|(type_, ..)| type_), data.input_arguments .iter() - .map(|(type_, space)| self.llvm_types.get_input_argument_type(&type_, *space)), + .map(|(type_, space)| get_input_argument_type(self.context, &type_, *space)), )?; let mut input_arguments = arguments .input_arguments @@ -1570,7 +1358,7 @@ impl<'a> MethodEmitContext<'a> { .iter() .map(|(value, type_)| { let value = self.resolver.value(*value)?; - let lowered_type = self.llvm_types.get_type(type_)?; + let lowered_type = get_type(self.context, type_)?; let load = unsafe { LLVMBuildLoad2(self.builder, lowered_type, value, LLVM_UNNAMED.as_ptr()) }; @@ -1587,9 +1375,8 @@ impl<'a> MethodEmitContext<'a> { [] => unsafe { LLVMBuildRetVoid(self.builder) }, [(value, _)] => unsafe { LLVMBuildRet(self.builder, *value) }, loads => { - let struct_type = self - .llvm_types - .get_or_create_struct_type(loads.iter().map(|(_, type_)| *type_))?; + let struct_type = + get_or_create_struct_type(self.context, loads.iter().map(|(_, type_)| *type_))?; let mut value = unsafe { LLVMGetUndef(struct_type) }; for (i, (load, _)) in loads.iter().enumerate() { value = unsafe { @@ -1813,9 +1600,10 @@ impl<'a> MethodEmitContext<'a> { }); } } else { - let vector_type = self - .llvm_types - .get_type(&ast::Type::Vector(repack.unpacked.len() as u8, repack.typ))?; + let vector_type = get_type( + self.context, + &ast::Type::Vector(repack.unpacked.len() as u8, repack.typ), + )?; let mut temp_vec = unsafe { LLVMGetUndef(vector_type) }; for (index, src_id) in repack.unpacked.iter().enumerate() { let dst = if index == repack.unpacked.len() - 1 { @@ -1932,8 +1720,8 @@ impl<'a> MethodEmitContext<'a> { src: arguments.src, }); } - let from_type = self.llvm_types.get_pointer_type(from_space)?; - let dest_type = self.llvm_types.get_pointer_type(to_space)?; + let from_type = get_pointer_type(self.context, from_space)?; + let dest_type = get_pointer_type(self.context, to_space)?; let src = self.resolver.value(arguments.src)?; let temp_ptr = unsafe { LLVMBuildIntToPtr(self.builder, src, from_type, LLVM_UNNAMED.as_ptr()) }; @@ -2025,7 +1813,8 @@ impl<'a> MethodEmitContext<'a> { return_types: Vec<&ast::Type>, arguments: Vec<(LLVMValueRef, LLVMTypeRef)>, ) -> Result { - let fn_type = self.llvm_types.get_intrinsic_type( + let fn_type = get_intrinsic_type( + self.context, return_types.iter().copied(), arguments.iter().map(|(_, type_)| Ok(*type_)), )?; @@ -3478,10 +3267,10 @@ impl<'a> MethodEmitContext<'a> { let vector_result = unsafe { LLVMBuildInsertElement( self.builder, - LLVMGetPoison( - self.llvm_types - .get_type(&ast::Type::Vector(2, ast::ScalarType::U16))?, - ), + LLVMGetPoison(get_type( + self.context, + &ast::Type::Vector(2, ast::ScalarType::U16), + )?), setp_result_0, zero, LLVM_UNNAMED.as_ptr(), @@ -3511,10 +3300,10 @@ impl<'a> MethodEmitContext<'a> { let vector_result = unsafe { LLVMBuildInsertElement( self.builder, - LLVMGetPoison( - self.llvm_types - .get_type(&ast::Type::Vector(2, ast::ScalarType::F16))?, - ), + LLVMGetPoison(get_type( + self.context, + &ast::Type::Vector(2, ast::ScalarType::F16), + )?), setp_result_0, zero, LLVM_UNNAMED.as_ptr(), @@ -3932,6 +3721,13 @@ fn apply_qualifier( Ok(()) } +fn get_pointer_type<'ctx>( + context: LLVMContextRef, + to_space: ast::StateSpace, +) -> Result { + Ok(unsafe { LLVMPointerTypeInContext(context, get_state_space(to_space)?) }) +} + // https://llvm.org/docs/AMDGPUUsage.html#memory-scopes fn get_scope(scope: ast::MemScope) -> Result<*const i8, TranslateError> { Ok(match scope { @@ -3972,6 +3768,111 @@ fn get_ordering_failure(semantics: ast::AtomSemantics) -> LLVMAtomicOrdering { } } +fn get_type(context: LLVMContextRef, type_: &ast::Type) -> Result { + Ok(match type_ { + ast::Type::Scalar(scalar) => get_scalar_type(context, *scalar), + ast::Type::Vector(size, scalar) => { + let base_type = get_scalar_type(context, *scalar); + unsafe { LLVMVectorType(base_type, *size as u32) } + } + ast::Type::Array(vec, scalar, dimensions) => { + let mut underlying_type = get_scalar_type(context, *scalar); + if let Some(size) = vec { + underlying_type = unsafe { LLVMVectorType(underlying_type, size.get() as u32) }; + } + if dimensions.is_empty() { + return Ok(unsafe { LLVMArrayType2(underlying_type, 0) }); + } + dimensions + .iter() + .rfold(underlying_type, |result, dimension| unsafe { + LLVMArrayType2(result, *dimension as u64) + }) + } + ast::Type::Texref => { + // Definitions taken from ROCm LLVM output + let format_desc = + unsafe { LLVMStructCreateNamed(context, c"struct.hipChannelFormatDesc".as_ptr()) }; + let llvm_i32 = get_scalar_type(context, ast::ScalarType::B32); + let mut format_desc_fields = [llvm_i32, llvm_i32, llvm_i32, llvm_i32, llvm_i32]; + unsafe { + LLVMStructSetBody( + format_desc, + format_desc_fields.as_mut_ptr(), + format_desc_fields.len() as u32, + 0, + ) + }; + let texture_reference = + unsafe { LLVMStructCreateNamed(context, c"struct.textureReference".as_ptr()) }; + let llvm_a3i32 = unsafe { LLVMArrayType2(llvm_i32, 3) }; + let llvm_float = get_scalar_type(context, ast::ScalarType::F32); + let llvm_ptr = get_pointer_type(context, ast::StateSpace::Generic)?; + let mut texture_reference_fields = [ + llvm_i32, + llvm_i32, + llvm_i32, + llvm_a3i32, + format_desc, + llvm_i32, + llvm_i32, + llvm_i32, + llvm_float, + llvm_float, + llvm_float, + llvm_ptr, + llvm_i32, + llvm_i32, + ]; + unsafe { + LLVMStructSetBody( + texture_reference, + texture_reference_fields.as_mut_ptr(), + texture_reference_fields.len() as u32, + 0, + ) + }; + let texture = unsafe { LLVMStructCreateNamed(context, c"struct.texture".as_ptr()) }; + let mut texture_fields = [texture_reference]; + unsafe { + LLVMStructSetBody( + texture, + texture_fields.as_mut_ptr(), + texture_fields.len() as u32, + 0, + ) + }; + texture + } + }) +} + +fn get_or_create_struct_type<'a>( + context: LLVMContextRef, + mut elem_types: impl Iterator, +) -> Result { + use std::fmt::Write; + let (mut name, types) = elem_types.try_fold( + ("struct".to_string(), Vec::new()), + |(mut name, mut types), t| { + name.push('.'); + if let ast::Type::Scalar(scalar) = t { + write!(name, "{}", LLVMTypeDisplay(*scalar)).ok(); + } else { + return Err(error_unreachable()); + } + types.push(get_type(context, t)?); + Ok((name, types)) + }, + )?; + name.push('\0'); + let mut struct_type = unsafe { LLVMGetTypeByName2(context, name.as_ptr().cast()) }; + if struct_type.is_null() { + struct_type = create_struct_type(context, name, types); + } + Ok(struct_type) +} + fn create_struct_type( context: LLVMContextRef, name: String, @@ -3989,11 +3890,68 @@ fn create_struct_type( llvm_type } +fn get_anonymous_struct_type<'a>( + context: LLVMContextRef, + elem_types: impl Iterator, +) -> Result { + let mut elem_types = elem_types + .map(|t| get_type(context, t)) + .collect::, _>>()?; + Ok(unsafe { + LLVMStructTypeInContext(context, elem_types.as_mut_ptr(), elem_types.len() as u32, 0) + }) +} + enum StructKind { Named, Anonymous, } +fn get_function_type_impl<'a>( + context: LLVMContextRef, + mut return_args: impl DoubleEndedIterator + + ExactSizeIterator, + input_args: impl Iterator>, + struct_kind: StructKind, +) -> Result { + let mut input_args = input_args.collect::, _>>()?; + let return_type = match return_args.len() { + 0 => unsafe { LLVMVoidTypeInContext(context) }, + 1 => get_type(context, &return_args.next().unwrap())?, + _ => match struct_kind { + StructKind::Named => get_or_create_struct_type(context, return_args)?, + StructKind::Anonymous => get_anonymous_struct_type(context, return_args)?, + }, + }; + + Ok(unsafe { + LLVMFunctionType( + return_type, + input_args.as_mut_ptr(), + input_args.len() as u32, + 0, + ) + }) +} + +fn get_function_type<'a>( + context: LLVMContextRef, + return_args: impl DoubleEndedIterator + + ExactSizeIterator, + input_args: impl Iterator>, +) -> Result { + get_function_type_impl(context, return_args, input_args, StructKind::Named) +} + +fn get_intrinsic_type<'a>( + context: LLVMContextRef, + return_args: impl DoubleEndedIterator + + ExactSizeIterator, + input_args: impl Iterator>, +) -> Result { + get_function_type_impl(context, return_args, input_args, StructKind::Anonymous) +} + struct ResolveIdent { words: HashMap, values: HashMap, diff --git a/ptx/src/pass/llvm/mod.rs b/ptx/src/pass/llvm/mod.rs index 6fc3556a7..ebfe86dcb 100644 --- a/ptx/src/pass/llvm/mod.rs +++ b/ptx/src/pass/llvm/mod.rs @@ -46,7 +46,7 @@ fn get_scalar_type(context: LLVMContextRef, type_: ast::ScalarType) -> LLVMTypeR } } -fn get_state_space(space: ast::StateSpace, is_32bit: bool) -> Result { +fn get_state_space(space: ast::StateSpace) -> Result { match space { ast::StateSpace::Reg => Ok(PRIVATE_ADDRESS_SPACE), ast::StateSpace::Generic => Ok(GENERIC_ADDRESS_SPACE), @@ -58,14 +58,7 @@ fn get_state_space(space: ast::StateSpace, is_32bit: bool) -> Result Err(error_todo()), ast::StateSpace::Local => Ok(PRIVATE_ADDRESS_SPACE), ast::StateSpace::Global => Ok(GLOBAL_ADDRESS_SPACE), - ast::StateSpace::Const => Ok(if is_32bit { - // FIXME: This is probably incorrect, but when using constant or - // global address space, we get incorrect codegen. Might be a bug - // in LLVM, might be a bug in ZLUDA - GENERIC_ADDRESS_SPACE - } else { - CONSTANT_ADDRESS_SPACE - }), + ast::StateSpace::Const => Ok(CONSTANT_ADDRESS_SPACE), ast::StateSpace::Shared => Ok(SHARED_ADDRESS_SPACE), ast::StateSpace::SharedCta => Err(error_todo()), ast::StateSpace::SharedCluster => Err(error_todo()), diff --git a/ptx/src/pass/mod.rs b/ptx/src/pass/mod.rs index 530490e31..77f00bf6e 100644 --- a/ptx/src/pass/mod.rs +++ b/ptx/src/pass/mod.rs @@ -112,7 +112,7 @@ pub fn to_llvm_module<'input>( let directives = hoist_globals::run(directives)?; on_pass_end("hoist_globals"); let context = llvm_zluda::utils::Context::new(); - let llvm_ir = llvm::emit::run(&context, flat_resolver, directives, ast.address_size == 32)?; + let llvm_ir = llvm::emit::run(&context, flat_resolver, directives)?; let attributes_ir = llvm::attributes::run(&context, attributes)?; on_pass_end("emit_llvm"); Ok(Module { From 2e6311526983d76b7c8ba22b6e688a173a8bef22 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Mon, 22 Jun 2026 17:42:59 -0700 Subject: [PATCH 67/85] Work around issues with scalar cache --- Cargo.lock | 1 + ptx/src/pass/llvm/emit.rs | 11 +++++++++-- 2 files changed, 10 insertions(+), 2 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 72b33bb96..8062822cf 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -5669,6 +5669,7 @@ dependencies = [ "cuda_types", "dark_api", "ipc-channel", + "libc", "paste", "postcard", "rand 0.10.1", diff --git a/ptx/src/pass/llvm/emit.rs b/ptx/src/pass/llvm/emit.rs index f31cab05e..6d3e42158 100644 --- a/ptx/src/pass/llvm/emit.rs +++ b/ptx/src/pass/llvm/emit.rs @@ -229,7 +229,7 @@ impl<'a, 'input> ModuleEmitContext<'a, 'input> { } else { return Err(error_unreachable()); } - method_emitter.emit_kernel_rounding_prelude(method.kernel_attributes)?; + method_emitter.emit_kernel_prelude(method.kernel_attributes)?; for statement in statements { method_emitter.emit_statement(statement)?; } @@ -517,10 +517,17 @@ impl<'a> MethodEmitContext<'a> { // This should be a kernel attribute, but sadly AMDGPU LLVM target does // not support attribute for it. So we have to set it as the first // instruction in the body of a kernel - fn emit_kernel_rounding_prelude( + fn emit_kernel_prelude( &mut self, kernel_attrs: Option, ) -> Result<(), TranslateError> { + // TODO + // On Windows, with 32 bit ZLUDA on kernel _Z29KernelDeformableUberCollisionPi in + // SampleCloth.exe scalar memory accesses read stale memory. This might also affect + // Linux. Until I have a repro that's the best I can do + if cfg!(windows) { + self.emit_intrinsic(c"llvm.amdgcn.s.dcache.inv", None, Vec::new(), Vec::new())?; + } if let Some(KernelAttributes { rounding_mode_f32, rounding_mode_f16f64, From 85f5e0715e8de74c64a0d135b3d6cf17468e01f7 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Mon, 22 Jun 2026 19:11:53 -0700 Subject: [PATCH 68/85] More host-side functions --- zluda32/src/lib.rs | 90 +++++++++++++++---- zluda64_server/src/main.rs | 154 +++++++++++++++++++++++++++++++-- zluda_server_common/src/lib.rs | 36 +++++++- 3 files changed, 256 insertions(+), 24 deletions(-) diff --git a/zluda32/src/lib.rs b/zluda32/src/lib.rs index a497e9c00..eed9421f1 100644 --- a/zluda32/src/lib.rs +++ b/zluda32/src/lib.rs @@ -274,7 +274,19 @@ pub(crate) fn cu_device_compute_capability( minor: *mut ::core::ffi::c_int, dev: CUdevice, ) -> Result<(), CUerror> { - unimplemented!() + let major = unsafe { major.as_mut() }; + let minor = unsafe { minor.as_mut() }; + let capability = GlobalState::remote_call_zero_copy::( + Opcode::cuDeviceComputeCapability, + cuDeviceComputeCapabilityIn { dev }, + )?; + if let Some(major) = major { + *major = capability.major; + } + if let Some(minor) = minor { + *minor = capability.minor; + } + Ok(()) } pub(crate) fn cu_device_get( @@ -339,8 +351,18 @@ pub(crate) fn cu_device_get_name( Ok(()) } -pub(crate) fn cu_device_get_properties(prop: *mut CUdevprop, dev: CUdevice) -> Result<(), CUerror> { - unimplemented!() +pub(crate) fn cu_device_get_properties( + result: *mut CUdevprop, + dev: CUdevice, +) -> Result<(), CUerror> { + let result = unsafe { result.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + let prop = GlobalState::remote_call_zero_copy::( + Opcode::cuDeviceGetProperties, + cuDeviceGetPropertiesIn { dev }, + )? + .prop; + *result = prop.into(); + Ok(()) } pub(crate) fn cu_device_total_mem_v2(bytes: *mut usize, dev: CUdevice) -> Result<(), CUerror> { @@ -368,14 +390,28 @@ pub(crate) fn cu_driver_get_version( } pub(crate) fn cu_event_create( - phEvent: *mut CUevent, - Flags: ::core::ffi::c_uint, + result: *mut CUevent, + flags: ::core::ffi::c_uint, ) -> Result<(), CUerror> { - unimplemented!() + let result = unsafe { result.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + *result = CudaEncode::decode( + GlobalState::remote_call_zero_copy::( + Opcode::cuEventCreate, + cuEventCreateIn { Flags: flags }, + )? + .phEvent, + ); + Ok(()) } -pub(crate) fn cu_event_destroy_v2(hEvent: CUevent) -> Result<(), CUerror> { - unimplemented!() +pub(crate) fn cu_event_destroy_v2(event: CUevent) -> Result<(), CUerror> { + GlobalState::remote_call_zero_copy::( + Opcode::cuEventDestroy_v2, + cuEventDestroy_v2In { + hEvent: CudaEncode::encode(event), + }, + )?; + Ok(()) } static EXPORT_TABLE: ::dark_api::cuda::CudaDarkApiGlobalTable = @@ -580,11 +616,19 @@ pub(crate) fn cu_memcpy_hto_d_async_v2( } pub(crate) fn cu_memset_d8_v2( - dstDevice: CUdeviceptr, + dst_device: CUdeviceptr, uc: ::core::ffi::c_uchar, - N: usize, + n: usize, ) -> Result<(), CUerror> { - unimplemented!() + GlobalState::remote_call_zero_copy::( + Opcode::cuMemsetD8_v2, + cuMemsetD8_v2In { + dstDevice: CudaEncode::encode(dst_device), + uc, + N: u32_le::from_native(n as u32), + }, + )?; + Ok(()) } pub(crate) fn cu_module_get_function( @@ -664,14 +708,28 @@ pub(crate) fn cu_module_get_tex_ref( } pub(crate) fn cu_stream_create( - phStream: *mut CUstream, - Flags: ::core::ffi::c_uint, + result: *mut CUstream, + flags: ::core::ffi::c_uint, ) -> Result<(), CUerror> { - unimplemented!() + let result = unsafe { result.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + *result = CudaEncode::decode( + GlobalState::remote_call_zero_copy::( + Opcode::cuStreamCreate, + cuStreamCreateIn { Flags: flags }, + )? + .phStream, + ); + Ok(()) } -pub(crate) fn cu_stream_destroy_v2(hStream: CUstream) -> Result<(), CUerror> { - unimplemented!() +pub(crate) fn cu_stream_destroy_v2(stream: CUstream) -> Result<(), CUerror> { + GlobalState::remote_call_zero_copy::( + Opcode::cuStreamDestroy_v2, + cuStreamDestroy_v2In { + hStream: CudaEncode::encode(stream), + }, + )?; + Ok(()) } pub(crate) fn cu_tex_ref_set_address_mode( diff --git a/zluda64_server/src/main.rs b/zluda64_server/src/main.rs index 6fd2dddb1..291c9240a 100644 --- a/zluda64_server/src/main.rs +++ b/zluda64_server/src/main.rs @@ -514,6 +514,61 @@ async fn main() -> std::io::Result<()> { ) .await?; } + Some(Opcode::cuDeviceComputeCapability) => { + buffer = handle_cuda_function::< + cuDeviceComputeCapabilityIn, + cuDeviceComputeCapabilityOut, + >(&mut client, buffer, cu_device_compute_capability) + .await?; + } + Some(Opcode::cuDeviceGetProperties) => { + buffer = handle_cuda_function::( + &mut client, + buffer, + cu_device_get_properties, + ) + .await?; + } + Some(Opcode::cuStreamCreate) => { + buffer = handle_cuda_function::( + &mut client, + buffer, + |input| cu_stream_create(&mut state, input), + ) + .await?; + } + Some(Opcode::cuStreamDestroy_v2) => { + buffer = handle_cuda_function::( + &mut client, + buffer, + |input| cu_stream_destroy_v2(&mut state, input), + ) + .await?; + } + Some(Opcode::cuEventCreate) => { + buffer = handle_cuda_function::( + &mut client, + buffer, + |input| cu_event_create(&mut state, input), + ) + .await?; + } + Some(Opcode::cuEventDestroy_v2) => { + buffer = handle_cuda_function::( + &mut client, + buffer, + |input| cu_event_destroy_v2(&mut state, input), + ) + .await?; + } + Some(Opcode::cuMemsetD8_v2) => { + buffer = handle_cuda_function::( + &mut client, + buffer, + |input| cu_memset_d8_v2(&mut state, input), + ) + .await?; + } _ => { client.write_u32_le(CUerror::NOT_SUPPORTED.0.get()).await?; return Err(std::io::Error::new( @@ -525,6 +580,91 @@ async fn main() -> std::io::Result<()> { } } +fn cu_memset_d8_v2( + state: &mut State, + input: &ArchivedcuMemsetD8_v2In, +) -> Result { + let dst_device = input.dstDevice.to_native(); + let dptr = if dst_device != 0 { + CUdeviceptr_v2(state.devmemory[dst_device as usize].translate(dst_device)?) + } else { + CUdeviceptr_v2(ptr::null_mut()) + }; + let uc = input.uc; + let n = input.N.to_native(); + unsafe { cuMemsetD8_v2(dptr, uc, n as usize) }?; + Ok(cuMemsetD8_v2Out {}) +} + +fn cu_event_create( + state: &mut State, + input: &ArchivedcuEventCreateIn, +) -> Result { + let mut event = ptr::null_mut(); + unsafe { cuEventCreate(&mut event, input.Flags.to_native()) }?; + let handle = state.handles.insert(event); + Ok(cuEventCreateOut { + phEvent: u32_le::from_native(handle), + }) +} + +fn cu_event_destroy_v2( + state: &mut State, + input: &ArchivedcuEventDestroy_v2In, +) -> Result { + let event = input.hEvent.to_native(); + let cu_event = if event == 0 { + ptr::null_mut() + } else { + state.handles.get(event)? + }; + unsafe { cuEventDestroy_v2(cu_event) }?; + Ok(cuEventDestroy_v2Out {}) +} + +fn cu_stream_destroy_v2( + state: &mut State, + input: &ArchivedcuStreamDestroy_v2In, +) -> Result { + let stream = input.hStream.to_native(); + let cu_stream = if stream == 0 { + CUstream(ptr::null_mut()) + } else { + CUstream(state.handles.get(stream)?) + }; + unsafe { cuStreamDestroy_v2(cu_stream) }?; + Ok(cuStreamDestroy_v2Out {}) +} + +fn cu_stream_create( + state: &mut State, + input: &ArchivedcuStreamCreateIn, +) -> Result { + let mut stream = CUstream(ptr::null_mut()); + unsafe { cuStreamCreate(&mut stream, input.Flags.to_native()) }?; + let handle = state.handles.insert(stream.0); + Ok(cuStreamCreateOut { + phStream: u32_le::from_native(handle), + }) +} + +fn cu_device_get_properties( + input: &ArchivedcuDeviceGetPropertiesIn, +) -> Result { + let mut props = unsafe { mem::zeroed() }; + unsafe { cuDeviceGetProperties(&mut props, input.dev.to_native()) }?; + Ok(cuDeviceGetPropertiesOut { prop: props.into() }) +} + +fn cu_device_compute_capability( + input: &ArchivedcuDeviceComputeCapabilityIn, +) -> Result { + let mut major = 0; + let mut minor = 0; + unsafe { cuDeviceComputeCapability(&mut major, &mut minor, input.dev.to_native()) }?; + Ok(cuDeviceComputeCapabilityOut { major, minor }) +} + fn cu_mem_free_v2( state: &mut State, input: &ArchivedcuMemFree_v2In, @@ -1149,16 +1289,16 @@ cuda_function_declarations! { // cuCtxGetCurrent, cuCtxGetDevice, cuCtxSynchronize, - // cuDeviceComputeCapability, + cuDeviceComputeCapability, cuDeviceGet, cuDeviceGetAttribute, cuDeviceGetCount, cuDeviceGetName, - // cuDeviceGetProperties, + cuDeviceGetProperties, cuDeviceTotalMem_v2, cuDriverGetVersion, - // cuEventCreate, - // cuEventDestroy_v2, + cuEventCreate, + cuEventDestroy_v2, cuGetExportTable, cuInit, cuLaunchKernel, @@ -1171,13 +1311,13 @@ cuda_function_declarations! { cuMemcpyDtoHAsync_v2, cuMemcpyHtoD_v2, cuMemcpyHtoDAsync_v2, - // cuMemsetD8_v2, + cuMemsetD8_v2, cuModuleGetFunction, cuModuleGetGlobal_v2, cuModuleGetTexRef, cuModuleLoadData, - // cuStreamCreate, - // cuStreamDestroy_v2, + cuStreamCreate, + cuStreamDestroy_v2, // cuTexRefSetAddressMode, cuTexRefSetAddress_v2, // cuTexRefSetFilterMode, diff --git a/zluda_server_common/src/lib.rs b/zluda_server_common/src/lib.rs index 7148c53f9..a90dd36a0 100644 --- a/zluda_server_common/src/lib.rs +++ b/zluda_server_common/src/lib.rs @@ -81,7 +81,7 @@ cuda_function_declarations! { //cuMemcpyDtoDAsync_v2, //cuMemcpyDtoHAsync_v2, //cuMemcpyHtoDAsync_v2, - // cuMemsetD8_v2, + cuMemsetD8_v2, // cuModuleGetFunction, // cuModuleGetGlobal_v2, // cuModuleGetTexRef, @@ -196,6 +196,40 @@ pub struct CUdevprop_v1_Wire { pub textureAlign: ::core::ffi::c_int, } +impl From for CUdevprop_v1_Wire { + fn from(devprop: CUdevprop_v1) -> Self { + Self { + maxThreadsPerBlock: devprop.maxThreadsPerBlock, + maxThreadsDim: devprop.maxThreadsDim, + maxGridSize: devprop.maxGridSize, + sharedMemPerBlock: devprop.sharedMemPerBlock, + totalConstantMemory: devprop.totalConstantMemory, + SIMDWidth: devprop.SIMDWidth, + memPitch: devprop.memPitch, + regsPerBlock: devprop.regsPerBlock, + clockRate: devprop.clockRate, + textureAlign: devprop.textureAlign, + } + } +} + +impl Into for CUdevprop_v1_Wire { + fn into(self) -> CUdevprop_v1 { + CUdevprop_v1 { + maxThreadsPerBlock: self.maxThreadsPerBlock, + maxThreadsDim: self.maxThreadsDim, + maxGridSize: self.maxGridSize, + sharedMemPerBlock: self.sharedMemPerBlock, + totalConstantMemory: self.totalConstantMemory, + SIMDWidth: self.SIMDWidth, + memPitch: self.memPitch, + regsPerBlock: self.regsPerBlock, + clockRate: self.clockRate, + textureAlign: self.textureAlign, + } + } +} + unsafe impl Portable for CUdevprop_v1_Wire {} #[repr(C)] From ccc99bbb2a5d54f326fc3d315e0098aa72219302 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Mon, 22 Jun 2026 21:20:37 -0700 Subject: [PATCH 69/85] Throw away most of the context handling on the server --- zluda64_server/src/main.rs | 232 +++++++++++-------------------------- 1 file changed, 65 insertions(+), 167 deletions(-) diff --git a/zluda64_server/src/main.rs b/zluda64_server/src/main.rs index 291c9240a..63ebef1a1 100644 --- a/zluda64_server/src/main.rs +++ b/zluda64_server/src/main.rs @@ -4,7 +4,7 @@ use compio::{ buf::{buf_try, IoBuf, IoBufMut, ReserveError, ReserveExactError, SetLen}, fs::named_pipe::{ClientOptions, NamedPipeClient}, - io::{AsyncRead, AsyncReadExt, AsyncReadManaged, AsyncWrite, AsyncWriteExt}, + io::{AsyncReadExt, AsyncWriteExt}, BufResult, }; use cuda_macros::cuda_function_declarations; @@ -21,19 +21,19 @@ use rustc_hash::FxHashMap; use slab::Slab; use std::{ collections::BTreeMap, - ffi::{c_void, CStr, CString}, - io::{self, Write}, + ffi::{c_void, CStr}, mem, ops::Range, - ptr::{self, NonNull}, + ptr, rc::Rc, }; use zluda_server_common::*; struct State { + ctx: CUcontext, + device: i32, handles: HandlePool, - dark_api: dark_api::cuda::ContextLocalStorageInterfaceV0301, - devmemory: Vec, + devmemory: Allocator, modules: ModuleLaunchData, } @@ -54,7 +54,7 @@ impl HandlePool { fn get(&self, id: u32) -> Result<*mut T, CUerror> { if id == 0 { - return Err(CUerror::INVALID_VALUE); + return Ok(ptr::null_mut()); } self.handles .get((id - 1) as usize) @@ -83,7 +83,7 @@ impl ModuleLaunchData { unsafe fn new_module( &mut self, - devmemory: &mut Vec, + devmemory: &mut Allocator, module: CUmodule, ) -> Result<(), CUerror> { let mut count = 0; @@ -107,16 +107,14 @@ impl ModuleLaunchData { &mut count, module, )?; - let mut device = 0; - unsafe { cuCtxGetDevice(&mut device) }?; let globals = (0..count as usize) .map(|i| { if alignments[i] > Allocator::ALLOCATION_UNIT { return Err(CUerror::OUT_OF_MEMORY); } let initializer = std::slice::from_raw_parts(initializers[i], sizes[i] as usize); - let allocation = devmemory[device as usize].alloc_range(sizes[i])?; - let devptr = devmemory[device as usize].translate_range(allocation.clone())?; + let allocation = devmemory.alloc_range(sizes[i])?; + let devptr = devmemory.translate_range(allocation.clone())?; unsafe { cuMemcpyHtoD_v2( CUdeviceptr_v2(devptr), @@ -250,20 +248,14 @@ impl Allocator { impl State { fn new() -> Result { unsafe { cuInit(0) }?; - let mut table_ptr = std::ptr::null(); - unsafe { - cuGetExportTable( - &mut table_ptr, - &dark_api::cuda::ContextLocalStorageInterfaceV0301::GUID, - ) - }?; - let dark_api = unsafe { dark_api::cuda::ContextLocalStorageInterfaceV0301::new(table_ptr) }; - let mut devices = 0; - unsafe { cuDeviceGetCount(&mut devices) }?; + let mut ctx = unsafe { mem::zeroed() }; + let device = 0; + unsafe { cuDevicePrimaryCtxRetain(&mut ctx, device) }?; Ok(Self { + ctx, + device, handles: HandlePool::new(), - dark_api, - devmemory: (0..devices).map(|_| Allocator::new()).collect(), + devmemory: Allocator::new(), modules: ModuleLaunchData::new()?, }) } @@ -308,7 +300,7 @@ async fn main() -> std::io::Result<()> { buffer = handle_cuda_function::( &mut client, buffer, - cu_device_get_attribute, + |input| cu_device_get_attribute(&mut state, input), ) .await?; } @@ -316,15 +308,7 @@ async fn main() -> std::io::Result<()> { buffer = handle_cuda_function::( &mut client, buffer, - cu_device_get, - ) - .await?; - } - Some(Opcode::cuCtxCreate_v2) => { - buffer = handle_cuda_function::( - &mut client, - buffer, - |input| cu_ctx_create_v2(input, &mut state), + |input| cu_device_get(&mut state, input), ) .await?; } @@ -340,7 +324,7 @@ async fn main() -> std::io::Result<()> { buffer = handle_cuda_function_framed_out::( &mut client, buffer, - cu_device_get_name, + |input| cu_device_get_name(&mut state, input), ) .await?; } @@ -348,37 +332,10 @@ async fn main() -> std::io::Result<()> { buffer = handle_cuda_function::( &mut client, buffer, - cu_device_total_mem_v2, + |input| cu_device_total_mem_v2(&mut state, input), ) .await?; } - Some(Opcode::ContextLocalStoragePut) => { - buffer = - handle_cuda_function::( - &mut client, - buffer, - |input| context_local_storage_put(&mut state, input), - ) - .await?; - } - Some(Opcode::ContextLocalStorageGet) => { - buffer = - handle_cuda_function::( - &mut client, - buffer, - |input| context_local_storage_get(&mut state, input), - ) - .await?; - } - Some(Opcode::ContextLocalStorageDelete) => { - buffer = handle_cuda_function::< - ContextLocalStorageDeleteIn, - ContextLocalStorageDeleteOut, - >(&mut client, buffer, |input| { - context_local_storage_delete(&mut state, input) - }) - .await?; - } Some(Opcode::cuCtxGetApiVersion) => { buffer = handle_cuda_function::( &mut client, @@ -586,7 +543,7 @@ fn cu_memset_d8_v2( ) -> Result { let dst_device = input.dstDevice.to_native(); let dptr = if dst_device != 0 { - CUdeviceptr_v2(state.devmemory[dst_device as usize].translate(dst_device)?) + CUdeviceptr_v2(state.devmemory.translate(dst_device)?) } else { CUdeviceptr_v2(ptr::null_mut()) }; @@ -669,10 +626,8 @@ fn cu_mem_free_v2( state: &mut State, input: &ArchivedcuMemFree_v2In, ) -> Result { - let mut device = 0; - unsafe { cuCtxGetDevice(&mut device) }?; let dptr = input.dptr.to_native(); - state.devmemory[device as usize].free(dptr)?; + state.devmemory.free(dptr)?; Ok(cuMemFree_v2Out {}) } @@ -704,12 +659,10 @@ fn cu_tex_ref_set_address_v2( state: &mut State, input: &ArchivedcuTexRefSetAddress_v2In, ) -> Result { - let mut device = 0; - unsafe { cuCtxGetDevice(&mut device) }?; let mut byte_offset = 0; let dptr = input.dptr.to_native(); let dptr = if dptr != 0 { - CUdeviceptr_v2(state.devmemory[device as usize].translate(dptr)?) + CUdeviceptr_v2(state.devmemory.translate(dptr)?) } else { CUdeviceptr_v2(ptr::null_mut()) }; @@ -730,10 +683,8 @@ fn cu_mem_get_address_range_v2( state: &mut State, input: &ArchivedcuMemGetAddressRange_v2In, ) -> Result { - let mut device = 0; - unsafe { cuCtxGetDevice(&mut device) }?; - let allocator = &state.devmemory[device as usize]; - let range = allocator + let range = state + .devmemory .get_range(input.dptr.to_native()) .ok_or(CUerror::INVALID_VALUE)?; Ok(cuMemGetAddressRange_v2Out { @@ -746,9 +697,7 @@ fn cu_memcpy_dtoh_async_v2( state: &mut State, input: &ArchivedcuMemcpyDtoHAsync_v2In, ) -> Result { - let mut device = 0; - unsafe { cuCtxGetDevice(&mut device) }?; - let devptr = state.devmemory[device as usize].translate(input.src_device.to_native())?; + let devptr = state.devmemory.translate(input.src_device.to_native())?; let stream = input.stream.to_native(); let stream = if stream == 0 { CUstream(ptr::null_mut()) @@ -768,7 +717,7 @@ fn cu_memcpy_dtoh_async_v2( Ok(cuMemcpyDtoHAsync_v2Out { dst_host }) } -fn cu_ctx_synchronize(input: &ArchivedcuCtxSynchronizeIn) -> Result { +fn cu_ctx_synchronize(_input: &ArchivedcuCtxSynchronizeIn) -> Result { unsafe { cuCtxSynchronize() }?; Ok(cuCtxSynchronizeOut {}) } @@ -784,7 +733,7 @@ fn cu_launch_kernel( .iter() .map(|p| p.as_ptr().cast_mut().cast::()) .collect::>(); - let mut base64_ptr = state.devmemory[device as usize].get_device_ptr()?; + let mut base64_ptr = state.devmemory.get_device_ptr()?; params.push(ptr::from_mut(&mut base64_ptr).cast()); let function = CUfunction(state.handles.get(input.f.to_native())?); let function_info = state @@ -874,15 +823,8 @@ fn cu_memcpy_hto_d_async_v2( state: &mut State, input: &ArchivedcuMemcpyHtoDAsync_v2In, ) -> Result { - let mut device = 0; - unsafe { cuCtxGetDevice(&mut device) }?; - let devptr = state.devmemory[device as usize].translate(input.dst_device.to_native())?; - let stream = input.stream.to_native(); - let stream = if stream == 0 { - CUstream(ptr::null_mut()) - } else { - CUstream(state.handles.get(stream)?) - }; + let devptr = state.devmemory.translate(input.dst_device.to_native())?; + let stream = CUstream(state.handles.get(input.stream.to_native())?); unsafe { cuMemcpyHtoDAsync_v2( CUdeviceptr_v2(devptr), @@ -898,9 +840,7 @@ fn cu_mem_alloc_v2( state: &mut State, input: &ArchivedcuMemAlloc_v2In, ) -> Result { - let mut device = 0; - unsafe { cuCtxGetDevice(&mut device) }?; - let fake_ptr = state.devmemory[device as usize].alloc(input.bytesize.to_native())?; + let fake_ptr = state.devmemory.alloc(input.bytesize.to_native())?; Ok(cuMemAlloc_v2Out { dptr: u32_le::from_native(fake_ptr), }) @@ -966,38 +906,49 @@ fn cu_init(input: &ArchivedcuInitIn) -> Result { fn cu_device_get_count( _input: &ArchivedcuDeviceGetCountIn, ) -> Result { - let mut count = 0; - unsafe { cuDeviceGetCount(&mut count) }?; - Ok(cuDeviceGetCountOut { count }) + Ok(cuDeviceGetCountOut { count: 1 }) } fn cu_device_get_attribute( + state: &mut State, input: &ArchivedcuDeviceGetAttributeIn, ) -> Result { + if input.dev.to_native() != state.device { + return Err(CUerror::INVALID_DEVICE); + } let mut pi = 0; unsafe { cuDeviceGetAttribute( &mut pi, CUdevice_attribute_enum(input.attrib.to_native()), - input.dev.to_native(), + state.device, ) }?; Ok(cuDeviceGetAttributeOut { pi }) } -fn cu_device_get(input: &ArchivedcuDeviceGetIn) -> Result { - let mut device = 0; - unsafe { cuDeviceGet(&mut device, input.ordinal.to_native()) }?; - Ok(cuDeviceGetOut { device }) +fn cu_device_get( + state: &mut State, + _input: &ArchivedcuDeviceGetIn, +) -> Result { + Ok(cuDeviceGetOut { + device: state.device.into(), + }) } -fn cu_device_get_name(input: &ArchivedcuDeviceGetNameIn) -> Result { +fn cu_device_get_name( + state: &mut State, + input: &ArchivedcuDeviceGetNameIn, +) -> Result { + if input.dev.to_native() != state.device { + return Err(CUerror::INVALID_DEVICE); + } let mut name = vec![0u8; input.len.to_native() as usize]; unsafe { cuDeviceGetName( name.as_mut_ptr().cast(), input.len.to_native(), - input.dev.to_native(), + state.device, ) }?; if let Some(pos) = name.iter().copied().position(|c| c == 0) { @@ -1006,23 +957,15 @@ fn cu_device_get_name(input: &ArchivedcuDeviceGetNameIn) -> Result Result { - let mut pctx = unsafe { mem::zeroed() }; - unsafe { cuCtxCreate_v2(&mut pctx, input.flags.to_native(), input.dev.to_native()) }?; - let pctx = state.handles.insert(pctx.0); - Ok(cuCtxCreate_v2Out { - pctx: u32_le::from_native(pctx), - }) -} - fn cu_device_total_mem_v2( + state: &mut State, input: &ArchivedcuDeviceTotalMem_v2In, ) -> Result { + if input.dev.to_native() != state.device { + return Err(CUerror::INVALID_DEVICE); + } let mut bytes = 0usize; - unsafe { cuDeviceTotalMem_v2(&mut bytes, input.dev.to_native()) }?; + unsafe { cuDeviceTotalMem_v2(&mut bytes, state.device) }?; Ok(cuDeviceTotalMem_v2Out { bytes: u64_le::from_native(bytes as u64), }) @@ -1040,59 +983,13 @@ fn cu_driver_get_version( fn cu_ctx_get_api_version( state: &mut State, - input: &ArchivedcuCtxGetApiVersionIn, + _input: &ArchivedcuCtxGetApiVersionIn, ) -> Result { - let ctx = CUcontext(state.handles.get(input.ctx.to_native())?); let mut version = 0; - unsafe { cuCtxGetApiVersion(ctx, &mut version) }?; + unsafe { cuCtxGetApiVersion(state.ctx, &mut version) }?; Ok(cuCtxGetApiVersionOut { version }) } -fn context_local_storage_put( - state: &mut State, - input: &ArchivedContextLocalStoragePutIn, -) -> Result { - unsafe { - state.dark_api.context_local_storage_put( - CUcontext(state.handles.get(input.cu_ctx.to_native())?), - input.key.to_native() as _, - input.value.to_native() as _, - None, - ) - }?; - Ok(ContextLocalStoragePutOut {}) -} - -fn context_local_storage_get( - state: &mut State, - input: &ArchivedContextLocalStorageGetIn, -) -> Result { - let mut value = ptr::null_mut(); - unsafe { - state.dark_api.context_local_storage_get( - &mut value, - CUcontext(state.handles.get(input.cu_ctx.to_native())?), - input.key.to_native() as _, - ) - }?; - Ok(ContextLocalStorageGetOut { - value: u32_le::from_native(value as u32), - }) -} - -fn context_local_storage_delete( - state: &mut State, - input: &ArchivedContextLocalStorageDeleteIn, -) -> Result { - unsafe { - state.dark_api.context_local_storage_delete( - CUcontext(state.handles.get(input.cu_ctx.to_native())?), - input.key.to_native() as _, - ) - }?; - Ok(ContextLocalStorageDeleteOut {}) -} - async fn handle_cuda_function( client: &mut NamedPipeClient, mut buffer: AlignedVecBuffer, @@ -1283,16 +1180,16 @@ macro_rules! implemented { cuda_function_declarations! { nop, implemented <= [ - cuCtxCreate_v2, + // cuCtxCreate_v2, // cuCtxDetach, cuCtxGetApiVersion, // cuCtxGetCurrent, cuCtxGetDevice, cuCtxSynchronize, cuDeviceComputeCapability, - cuDeviceGet, + // cuDeviceGet, cuDeviceGetAttribute, - cuDeviceGetCount, + // cuDeviceGetCount, cuDeviceGetName, cuDeviceGetProperties, cuDeviceTotalMem_v2, @@ -1304,7 +1201,7 @@ cuda_function_declarations! { cuLaunchKernel, cuMemAlloc_v2, // cuMemFreeHost, - cuMemFree_v2, + // cuMemFree_v2, // cuMemGetAddressRange_v2, // cuMemHostAlloc, // cuMemcpyDtoDAsync_v2, @@ -1313,7 +1210,7 @@ cuda_function_declarations! { cuMemcpyHtoDAsync_v2, cuMemsetD8_v2, cuModuleGetFunction, - cuModuleGetGlobal_v2, + // cuModuleGetGlobal_v2, cuModuleGetTexRef, cuModuleLoadData, cuStreamCreate, @@ -1328,5 +1225,6 @@ cuda_function_declarations! { // cuTexRefSetMipmapLevelBias, // cuTexRefSetMipmapLevelClamp, cuStreamSynchronize, + cuDevicePrimaryCtxRetain, ] } From f0c371924b54dd72d5a78887401c6a34a94f1ff9 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Mon, 22 Jun 2026 23:55:30 -0700 Subject: [PATCH 70/85] Handle context purely on the 32bit side --- zluda/src/impl/driver.rs | 15 +++- zluda32/src/ipc.rs | 1 + zluda32/src/lib.rs | 145 +++++++++++++++++++++++---------- zluda64_server/src/main.rs | 72 +++++++++++----- zluda_server_common/src/lib.rs | 44 +--------- 5 files changed, 169 insertions(+), 108 deletions(-) diff --git a/zluda/src/impl/driver.rs b/zluda/src/impl/driver.rs index 11e593c7e..8c04186ea 100644 --- a/zluda/src/impl/driver.rs +++ b/zluda/src/impl/driver.rs @@ -243,21 +243,21 @@ impl ::dark_api::cuda::CudaDarkApi for DarkApi { value: *mut c_void, dtor_cb: Option, ) -> CUresult { - let _ctx = if cu_ctx.0 != ptr::null_mut() { + let ctx = if cu_ctx.0 != ptr::null_mut() { cu_ctx } else { let mut current_ctx: CUcontext = CUcontext(ptr::null_mut()); context::get_current(&mut current_ctx)?; current_ctx }; - let ctx_obj: &context::Context = FromCuda::<_, CUerror>::from_cuda(&_ctx)?; + let ctx_obj: &context::Context = FromCuda::<_, CUerror>::from_cuda(&ctx)?; ctx_obj.with_state_mut(|state: &mut context::ContextState| { state.storage.insert( key as usize, context::StorageData { value: value as usize, reset_cb: dtor_cb, - handle: _ctx, + handle: ctx, }, ); Ok(()) @@ -269,7 +269,14 @@ impl ::dark_api::cuda::CudaDarkApi for DarkApi { cu_ctx: CUcontext, key: *mut c_void, ) -> CUresult { - let ctx_obj: &context::Context = FromCuda::<_, CUerror>::from_cuda(&cu_ctx)?; + let ctx = if cu_ctx.0 != ptr::null_mut() { + cu_ctx + } else { + let mut current_ctx: CUcontext = CUcontext(ptr::null_mut()); + context::get_current(&mut current_ctx)?; + current_ctx + }; + let ctx_obj: &context::Context = FromCuda::<_, CUerror>::from_cuda(&ctx)?; ctx_obj.with_state_mut(|state: &mut context::ContextState| { state.storage.remove(&(key as usize)); Ok(()) diff --git a/zluda32/src/ipc.rs b/zluda32/src/ipc.rs index fc527aec6..ea6cd1479 100644 --- a/zluda32/src/ipc.rs +++ b/zluda32/src/ipc.rs @@ -7,6 +7,7 @@ use rkyv::rend::u32_le; use rkyv::ser::allocator::ArenaHandle; use rkyv::util::AlignedVec; use rkyv::{rancor, Archive, Deserialize, Portable, Serialize}; +use rustc_hash::FxHashMap; use std::io::{Read, Write}; use std::os::windows::io::{AsHandle, AsRawHandle, FromRawHandle}; // use rkyv::util::AlignedVec; diff --git a/zluda32/src/lib.rs b/zluda32/src/lib.rs index eed9421f1..6c0285b14 100644 --- a/zluda32/src/lib.rs +++ b/zluda32/src/lib.rs @@ -78,6 +78,7 @@ cuda_function_declarations! { cuInit, cuLaunchKernel, cuMemAlloc_v2, + cuMemcpyDtoD_v2, cuMemcpyDtoDAsync_v2, cuMemcpyDtoHAsync_v2, cuMemcpyHtoDAsync_v2, @@ -140,8 +141,25 @@ impl ContextStack { } struct GlobalState { - function_args: FxHashMap>, server: ipc::Server, + function_args: FxHashMap>, + next_context: u32, + context_state: FxHashMap< + cuda_types::cuda::CUcontext, + FxHashMap< + usize, + ( + usize, + Option< + extern "system" fn( + cuda_types::cuda::CUcontext, + *mut std::ffi::c_void, + *mut std::ffi::c_void, + ), + >, + ), + >, + >, } impl GlobalState { @@ -151,6 +169,8 @@ impl GlobalState { Ok(Mutex::new(GlobalState { function_args: FxHashMap::default(), server: unsafe { ipc::Server::start() }?, + next_context: 1024 * 1024, + context_state: FxHashMap::default(), })) }) .as_ref() @@ -207,17 +227,18 @@ pub(crate) fn cu_init(flags: u32) -> Result<(), CUerror> { pub(crate) fn cu_ctx_create_v2( pctx: *mut CUcontext, - flags: ::core::ffi::c_uint, + _flags: ::core::ffi::c_uint, dev: CUdevice, ) -> Result<(), CUerror> { let ctx_ref = unsafe { pctx.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; - let cu_ctx = CudaEncode::decode( - GlobalState::remote_call_zero_copy::( - Opcode::cuCtxCreate_v2, - cuCtxCreate_v2In { flags, dev }, - )? - .pctx, - ); + let cu_ctx: CUcontext; + { + let mut state = GlobalState::get()?.lock().map_err(|_| CUerror::UNKNOWN)?; + state.next_context = state.next_context.wrapping_add(1); + let new_ctx = CUcontext(state.next_context as *mut _); + state.context_state.insert(new_ctx, FxHashMap::default()); + cu_ctx = new_ctx; + } CONTEXT_STACK.with(|stack| { stack.push(cu_ctx, dev); }); @@ -225,8 +246,16 @@ pub(crate) fn cu_ctx_create_v2( Ok(()) } -pub(crate) fn cu_ctx_detach(_ctx: CUcontext) -> Result<(), CUerror> { - // TODO +pub(crate) fn cu_ctx_detach(ctx: CUcontext) -> Result<(), CUerror> { + let ctx_storage = { + let mut state = GlobalState::get()?.lock().map_err(|_| CUerror::UNKNOWN)?; + state.context_state.remove(&ctx).ok_or(CUerror::UNKNOWN)? + }; + for (key, (value, dtor_cb)) in ctx_storage { + if let Some(dtor_cb) = dtor_cb { + dtor_cb(ctx, key as _, value as _); + } + } Ok(()) } @@ -308,6 +337,10 @@ pub(crate) fn cu_device_get_attribute( dev: CUdevice, ) -> Result<(), CUerror> { let pi = unsafe { pi.as_mut() }.ok_or(CUerror::INVALID_VALUE)?; + if attrib.0 == 537396226 { + *pi = 256; + return Ok(()); + } *pi = GlobalState::remote_call_zero_copy::( Opcode::cuDeviceGetAttribute, cuDeviceGetAttributeIn { @@ -563,13 +596,38 @@ pub(crate) fn cu_mem_free_host(p: *mut ::core::ffi::c_void) -> Result<(), CUerro Ok(()) } +pub(crate) fn cu_memcpy_dto_d_v2( + dst_device: CUdeviceptr, + src_device: CUdeviceptr, + byte_count: usize, +) -> Result<(), CUerror> { + GlobalState::remote_call_zero_copy::( + Opcode::cuMemcpyDtoD_v2, + cuMemcpyDtoD_v2In { + dstDevice: CudaEncode::encode(dst_device), + srcDevice: CudaEncode::encode(src_device), + ByteCount: u32_le::from_native(byte_count as u32), + }, + )?; + Ok(()) +} + pub(crate) fn cu_memcpy_dto_d_async_v2( - dstDevice: CUdeviceptr, - srcDevice: CUdeviceptr, - ByteCount: usize, - hStream: CUstream, + dst_device: CUdeviceptr, + src_device: CUdeviceptr, + byte_count: usize, + stream: CUstream, ) -> Result<(), CUerror> { - unimplemented!() + GlobalState::remote_call_zero_copy::( + Opcode::cuMemcpyDtoDAsync_v2, + cuMemcpyDtoDAsync_v2In { + dstDevice: CudaEncode::encode(dst_device), + srcDevice: CudaEncode::encode(src_device), + ByteCount: u32_le::from_native(byte_count as u32), + hStream: CudaEncode::encode(stream), + }, + )?; + Ok(()) } pub(crate) fn cu_memcpy_dto_h_async_v2( @@ -968,15 +1026,16 @@ impl CudaDarkApi for DarkApi32 { ), >, ) -> cuda_types::cuda::CUresult { + if !initialized() { + return Err(CUerror::DEINITIALIZED); + } let cu_ctx = CONTEXT_STACK.with(|s| s.unwrap(cu_ctx))?; - GlobalState::remote_call_zero_copy::( - Opcode::ContextLocalStoragePut, - ContextLocalStoragePutIn { - cu_ctx: cu_ctx.encode().into(), - key: (key as u32).into(), - value: (value as u32).into(), - }, - )?; + let mut state = GlobalState::get()?.lock().map_err(|_| CUerror::UNKNOWN)?; + let ctx_storage = state + .context_state + .get_mut(&cu_ctx) + .ok_or(CUerror::INVALID_VALUE)?; + ctx_storage.insert(key as _, (value as _, _dtor_cb)); Ok(()) } @@ -988,13 +1047,13 @@ impl CudaDarkApi for DarkApi32 { return Err(CUerror::DEINITIALIZED); } let cu_ctx = CONTEXT_STACK.with(|s| s.unwrap(cu_ctx))?; - GlobalState::remote_call_zero_copy::( - Opcode::ContextLocalStorageDelete, - ContextLocalStorageDeleteIn { - cu_ctx: cu_ctx.encode().into(), - key: (key as u32).into(), - }, - )?; + let mut state = GlobalState::get()?.lock().map_err(|_| CUerror::UNKNOWN)?; + let ctx_storage = state + .context_state + .get_mut(&cu_ctx) + .ok_or(CUerror::INVALID_VALUE)?; + let key = key as usize; + ctx_storage.remove(&key); Ok(()) } @@ -1003,17 +1062,21 @@ impl CudaDarkApi for DarkApi32 { cu_ctx: cuda_types::cuda::CUcontext, key: *mut std::ffi::c_void, ) -> cuda_types::cuda::CUresult { + if !initialized() { + return Err(CUerror::DEINITIALIZED); + } let value = unsafe { value.as_mut() }.ok_or(cuda_types::cuda::CUerror::INVALID_VALUE)?; - let cu_ctx = CONTEXT_STACK.with(|s| s.unwrap(cu_ctx))?; - *value = GlobalState::remote_call_zero_copy::( - Opcode::ContextLocalStorageGet, - ContextLocalStorageGetIn { - cu_ctx: cu_ctx.encode().into(), - key: (key as u32).into(), - }, - )? - .value - .to_native() as _; + let stored_value = { + let cu_ctx = CONTEXT_STACK.with(|s| s.unwrap(cu_ctx))?; + let mut state = GlobalState::get()?.lock().map_err(|_| CUerror::UNKNOWN)?; + let ctx_storage = state + .context_state + .get_mut(&cu_ctx) + .ok_or(CUerror::INVALID_VALUE)?; + let key = key as usize; + ctx_storage.get(&key).ok_or(CUerror::INVALID_VALUE)?.0 + }; + *value = stored_value as _; Ok(()) } diff --git a/zluda64_server/src/main.rs b/zluda64_server/src/main.rs index 63ebef1a1..69500387b 100644 --- a/zluda64_server/src/main.rs +++ b/zluda64_server/src/main.rs @@ -222,6 +222,9 @@ impl Allocator { } fn translate(&self, offset: u32) -> Result<*mut c_void, CUerror> { + if offset == 0 { + return Ok(ptr::null_mut()); + } let base_ptr = self.get_device_ptr()?; Ok(base_ptr.wrapping_byte_add(offset as usize)) } @@ -251,6 +254,7 @@ impl State { let mut ctx = unsafe { mem::zeroed() }; let device = 0; unsafe { cuDevicePrimaryCtxRetain(&mut ctx, device) }?; + unsafe { cuCtxSetCurrent(ctx) }?; Ok(Self { ctx, device, @@ -526,6 +530,22 @@ async fn main() -> std::io::Result<()> { ) .await?; } + Some(Opcode::cuMemcpyDtoDAsync_v2) => { + buffer = handle_cuda_function::( + &mut client, + buffer, + |input| cu_memcpy_dto_d_async_v2(&mut state, input), + ) + .await?; + } + Some(Opcode::cuMemcpyDtoD_v2) => { + buffer = handle_cuda_function::( + &mut client, + buffer, + |input| cu_memcpy_dto_d_v2(&mut state, input), + ) + .await?; + } _ => { client.write_u32_le(CUerror::NOT_SUPPORTED.0.get()).await?; return Err(std::io::Error::new( @@ -537,16 +557,34 @@ async fn main() -> std::io::Result<()> { } } +fn cu_memcpy_dto_d_v2( + state: &mut State, + input: &ArchivedcuMemcpyDtoD_v2In, +) -> Result { + let dst_device = CUdeviceptr_v2(state.devmemory.translate(input.dstDevice.to_native())?); + let src_device = CUdeviceptr_v2(state.devmemory.translate(input.srcDevice.to_native())?); + let byte_count = input.ByteCount.to_native(); + unsafe { cuMemcpyDtoD_v2(dst_device, src_device, byte_count as usize) }?; + Ok(cuMemcpyDtoD_v2Out {}) +} + +fn cu_memcpy_dto_d_async_v2( + state: &mut State, + input: &ArchivedcuMemcpyDtoDAsync_v2In, +) -> Result { + let dst_device = CUdeviceptr_v2(state.devmemory.translate(input.dstDevice.to_native())?); + let src_device = CUdeviceptr_v2(state.devmemory.translate(input.srcDevice.to_native())?); + let byte_count = input.ByteCount.to_native(); + let cu_stream = CUstream(state.handles.get(input.hStream.to_native())?); + unsafe { cuMemcpyDtoDAsync_v2(dst_device, src_device, byte_count as usize, cu_stream) }?; + Ok(cuMemcpyDtoDAsync_v2Out {}) +} + fn cu_memset_d8_v2( state: &mut State, input: &ArchivedcuMemsetD8_v2In, ) -> Result { - let dst_device = input.dstDevice.to_native(); - let dptr = if dst_device != 0 { - CUdeviceptr_v2(state.devmemory.translate(dst_device)?) - } else { - CUdeviceptr_v2(ptr::null_mut()) - }; + let dptr = CUdeviceptr_v2(state.devmemory.translate(input.dstDevice.to_native())?); let uc = input.uc; let n = input.N.to_native(); unsafe { cuMemsetD8_v2(dptr, uc, n as usize) }?; @@ -584,11 +622,7 @@ fn cu_stream_destroy_v2( input: &ArchivedcuStreamDestroy_v2In, ) -> Result { let stream = input.hStream.to_native(); - let cu_stream = if stream == 0 { - CUstream(ptr::null_mut()) - } else { - CUstream(state.handles.get(stream)?) - }; + let cu_stream = CUstream(state.handles.get(stream)?); unsafe { cuStreamDestroy_v2(cu_stream) }?; Ok(cuStreamDestroy_v2Out {}) } @@ -661,11 +695,7 @@ fn cu_tex_ref_set_address_v2( ) -> Result { let mut byte_offset = 0; let dptr = input.dptr.to_native(); - let dptr = if dptr != 0 { - CUdeviceptr_v2(state.devmemory.translate(dptr)?) - } else { - CUdeviceptr_v2(ptr::null_mut()) - }; + let dptr = CUdeviceptr_v2(state.devmemory.translate(dptr)?); unsafe { cuTexRefSetAddress_v2( &mut byte_offset, @@ -699,11 +729,7 @@ fn cu_memcpy_dtoh_async_v2( ) -> Result { let devptr = state.devmemory.translate(input.src_device.to_native())?; let stream = input.stream.to_native(); - let stream = if stream == 0 { - CUstream(ptr::null_mut()) - } else { - CUstream(state.handles.get(stream)?) - }; + let stream = CUstream(state.handles.get(stream)?); let mut dst_host = vec![0u8; input.byte_count.to_native() as usize]; unsafe { cuMemcpyDtoHAsync_v2( @@ -1204,7 +1230,8 @@ cuda_function_declarations! { // cuMemFree_v2, // cuMemGetAddressRange_v2, // cuMemHostAlloc, - // cuMemcpyDtoDAsync_v2, + cuMemcpyDtoD_v2, + cuMemcpyDtoDAsync_v2, cuMemcpyDtoHAsync_v2, cuMemcpyHtoD_v2, cuMemcpyHtoDAsync_v2, @@ -1226,5 +1253,6 @@ cuda_function_declarations! { // cuTexRefSetMipmapLevelClamp, cuStreamSynchronize, cuDevicePrimaryCtxRetain, + cuCtxSetCurrent, ] } diff --git a/zluda_server_common/src/lib.rs b/zluda_server_common/src/lib.rs index a90dd36a0..a610cbb92 100644 --- a/zluda_server_common/src/lib.rs +++ b/zluda_server_common/src/lib.rs @@ -30,9 +30,6 @@ macro_rules! generate_messages_inout { cuDeviceGetName, cuDeviceTotalMem_v2, cuModuleLoadData, - ContextLocalStoragePut, - ContextLocalStorageGet, - ContextLocalStorageDelete, cuModuleGetFunction, cuModuleGetGlobal_v2, cuMemAlloc_v2, @@ -56,7 +53,7 @@ macro_rules! generate_messages_in { cuda_function_declarations! { noop, generate_messages_inout <= [ - cuCtxCreate_v2, + // cuCtxCreate_v2, cuCtxDetach, cuCtxGetApiVersion, cuCtxGetCurrent, @@ -78,7 +75,8 @@ cuda_function_declarations! { cuMemFree_v2, cuMemGetAddressRange_v2, //cuMemHostAlloc, - //cuMemcpyDtoDAsync_v2, + cuMemcpyDtoD_v2, + cuMemcpyDtoDAsync_v2, //cuMemcpyDtoHAsync_v2, //cuMemcpyHtoDAsync_v2, cuMemsetD8_v2, @@ -244,42 +242,6 @@ pub struct cuDeviceTotalMem_v2Out { pub bytes: u64_le, } -#[repr(C)] -#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] -pub struct ContextLocalStoragePutIn { - pub cu_ctx: u32_le, - pub key: u32_le, - pub value: u32_le, -} - -#[repr(C)] -#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] -pub struct ContextLocalStoragePutOut {} - -#[repr(C)] -#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] -pub struct ContextLocalStorageGetIn { - pub cu_ctx: u32_le, - pub key: u32_le, -} - -#[repr(C)] -#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] -pub struct ContextLocalStorageGetOut { - pub value: u32_le, -} - -#[repr(C)] -#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] -pub struct ContextLocalStorageDeleteIn { - pub cu_ctx: u32_le, - pub key: u32_le, -} - -#[repr(C)] -#[derive(Portable, Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] -pub struct ContextLocalStorageDeleteOut {} - #[repr(C)] #[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] pub struct cuModuleLoadDataIn { From 1db7546a5360d40f35d387a371a5b7405cf5faae Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Fri, 26 Jun 2026 12:39:50 -0700 Subject: [PATCH 71/85] Build fix --- Cargo.lock | 43 ++++++------------------------------------- ptx_parser/Cargo.toml | 2 +- 2 files changed, 7 insertions(+), 38 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 07f5a72d7..bc6775e3e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3668,8 +3668,8 @@ dependencies = [ "quick-error", "rustc-hash 2.1.2", "smallvec", - "strum 0.28.0", - "strum_macros 0.28.0", + "strum", + "strum_macros", "tempfile", "thiserror 1.0.64", "unwrap_or", @@ -3684,7 +3684,7 @@ dependencies = [ "logos", "ptx_parser_macros", "rustc-hash 2.1.2", - "strum 0.27.1", + "strum", "thiserror 1.0.64", "winnow 0.6.20", ] @@ -4298,32 +4298,13 @@ version = "0.11.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f" -[[package]] -name = "strum" -version = "0.27.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f64def088c51c9510a8579e3c5d67c65349dcf755e5479ad3d010aa6454e2c32" -dependencies = [ - "strum_macros 0.27.1", -] - [[package]] name = "strum" version = "0.28.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9628de9b8791db39ceda2b119bbe13134770b56c138ec1d3af810d045c04f9bd" - -[[package]] -name = "strum_macros" -version = "0.27.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c77a8c5abcaf0f9ce05d62342b7d298c346515365c36b673df4ebe3ced01fde8" dependencies = [ - "heck", - "proc-macro2", - "quote", - "rustversion", - "syn 2.0.117", + "strum_macros", ] [[package]] @@ -4338,18 +4319,6 @@ dependencies = [ "syn 2.0.117", ] -[[package]] -name = "strum_macros" -version = "0.28.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ab85eea0270ee17587ed4156089e10b9e6880ee688791d45a905f5b1ca36f664" -dependencies = [ - "heck", - "proc-macro2", - "quote", - "syn 2.0.89", -] - [[package]] name = "supports-color" version = "2.1.0" @@ -5910,8 +5879,8 @@ dependencies = [ "paste", "postcard", "rkyv", - "strum 0.28.0", - "strum_macros 0.28.0", + "strum", + "strum_macros", ] [[package]] diff --git a/ptx_parser/Cargo.toml b/ptx_parser/Cargo.toml index 6f67e933f..be7a106ab 100644 --- a/ptx_parser/Cargo.toml +++ b/ptx_parser/Cargo.toml @@ -12,7 +12,7 @@ derive_more = { version = "1", features = ["display"] } logos = "0.14" ptx_parser_macros = { path = "../ptx_parser_macros" } rustc-hash = "2.0.0" -strum = { version = "0.27.1", features = ["derive"] } +strum = { version = "0.28", features = ["derive"] } thiserror = "1.0" winnow = { version = "0.6.18" } # winnow = { version = "0.6.18", features = ["debug"] } From 5dcef318fbc861ad9cf31e5ca4710fe3cfe93eed Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Sat, 4 Jul 2026 16:04:35 -0700 Subject: [PATCH 72/85] Pick larger allocation unit (fix Fluidmark) --- zluda64_server/src/main.rs | 24 +++++++++++------------- 1 file changed, 11 insertions(+), 13 deletions(-) diff --git a/zluda64_server/src/main.rs b/zluda64_server/src/main.rs index 69500387b..7beeae353 100644 --- a/zluda64_server/src/main.rs +++ b/zluda64_server/src/main.rs @@ -42,6 +42,8 @@ struct HandlePool { } impl HandlePool { + const OFFSET: u32 = 512 * 1024 * 1024; + fn new() -> Self { Self { handles: Slab::new(), @@ -49,7 +51,7 @@ impl HandlePool { } fn insert(&mut self, handle: *mut T) -> u32 { - (self.handles.insert(handle as usize) as u32) + 1 + (self.handles.insert(handle as usize) as u32) + Self::OFFSET } fn get(&self, id: u32) -> Result<*mut T, CUerror> { @@ -57,7 +59,7 @@ impl HandlePool { return Ok(ptr::null_mut()); } self.handles - .get((id - 1) as usize) + .get((id - Self::OFFSET) as usize) .map(|&handle| handle as *mut T) .ok_or(CUerror::INVALID_VALUE) } @@ -168,7 +170,11 @@ struct Allocator { } impl Allocator { - const ALLOCATION_UNIT: u32 = 128; + // This should be at least a multiple of texture pitch + // otherwise fluidmark fails in myserious ways + // I could query at runtime, but it's hard to imagine a GPU + // with larger pitch + const ALLOCATION_UNIT: u32 = 256; const ALLOCATOR_SIZE: u32 = 512 * 1024 * 1024; // 512 MiB fn new() -> Self { @@ -608,11 +614,7 @@ fn cu_event_destroy_v2( input: &ArchivedcuEventDestroy_v2In, ) -> Result { let event = input.hEvent.to_native(); - let cu_event = if event == 0 { - ptr::null_mut() - } else { - state.handles.get(event)? - }; + let cu_event = state.handles.get(event)?; unsafe { cuEventDestroy_v2(cu_event) }?; Ok(cuEventDestroy_v2Out {}) } @@ -785,11 +787,7 @@ fn cu_launch_kernel( input.block_dim_y.to_native(), input.block_dim_z.to_native(), input.shared_mem_bytes.to_native(), - if input.stream == 0 { - CUstream(ptr::null_mut()) - } else { - CUstream(state.handles.get(input.stream.to_native())?) - }, + CUstream(state.handles.get(input.stream.to_native())?), params.as_mut_ptr(), std::ptr::null_mut(), ) From c44cc2b11f8878c58a595374a27090e556e0c1fa Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Sat, 4 Jul 2026 21:18:49 -0700 Subject: [PATCH 73/85] Add cuCtxCreate --- zluda32/src/lib.rs | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/zluda32/src/lib.rs b/zluda32/src/lib.rs index 6c0285b14..d0611577b 100644 --- a/zluda32/src/lib.rs +++ b/zluda32/src/lib.rs @@ -58,6 +58,7 @@ macro_rules! implemented { cuda_function_declarations! { not_implemented, implemented <= [ + cuCtxCreate, cuCtxCreate_v2, cuCtxDetach, cuCtxGetApiVersion, @@ -225,6 +226,14 @@ pub(crate) fn cu_init(flags: u32) -> Result<(), CUerror> { Ok(()) } +pub(crate) fn cu_ctx_create( + pctx: *mut CUcontext, + flags: ::core::ffi::c_uint, + dev: CUdevice, +) -> Result<(), CUerror> { + return cu_ctx_create_v2(pctx, flags, dev); +} + pub(crate) fn cu_ctx_create_v2( pctx: *mut CUcontext, _flags: ::core::ffi::c_uint, From 0d04984ad0489030519e74d0162862b14f385ef2 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Sun, 5 Jul 2026 18:27:59 -0700 Subject: [PATCH 74/85] Add cuEventQuery, cuEventRecord, cuCtxSetCacheConfig (Alice: Madness Returns) --- zluda32/src/lib.rs | 37 +++++++++++++++++++++++++++++-- zluda64_server/src/main.rs | 40 ++++++++++++++++++++++++++++++++++ zluda_server_common/src/lib.rs | 2 ++ 3 files changed, 77 insertions(+), 2 deletions(-) diff --git a/zluda32/src/lib.rs b/zluda32/src/lib.rs index d0611577b..e9042c006 100644 --- a/zluda32/src/lib.rs +++ b/zluda32/src/lib.rs @@ -58,12 +58,13 @@ macro_rules! implemented { cuda_function_declarations! { not_implemented, implemented <= [ - cuCtxCreate, cuCtxCreate_v2, + cuCtxCreate, cuCtxDetach, cuCtxGetApiVersion, cuCtxGetCurrent, cuCtxGetDevice, + cuCtxSetCacheConfig, cuCtxSynchronize, cuDeviceComputeCapability, cuDeviceGet, @@ -75,6 +76,8 @@ cuda_function_declarations! { cuDriverGetVersion, cuEventCreate, cuEventDestroy_v2, + cuEventQuery, + cuEventRecord, cuGetExportTable, cuInit, cuLaunchKernel, @@ -599,7 +602,7 @@ pub(crate) fn cu_mem_host_alloc( pub(crate) fn cu_mem_free_host(p: *mut ::core::ffi::c_void) -> Result<(), CUerror> { if p.is_null() { - return Err(CUerror::INVALID_VALUE); + return Ok(()); } unsafe { libc::free(p) }; Ok(()) @@ -899,6 +902,36 @@ pub(crate) fn cu_tex_ref_set_mipmap_level_clamp( Ok(()) } +pub(crate) fn cu_event_query(event: cuda_types::cuda::CUevent) -> Result<(), CUerror> { + GlobalState::remote_call_zero_copy::( + Opcode::cuEventQuery, + cuEventQueryIn { + hEvent: CudaEncode::encode(event), + }, + )?; + Ok(()) +} + +pub(crate) fn cu_event_record( + event: cuda_types::cuda::CUevent, + stream: cuda_types::cuda::CUstream, +) -> Result<(), CUerror> { + GlobalState::remote_call_zero_copy::( + Opcode::cuEventRecord, + cuEventRecordIn { + hEvent: CudaEncode::encode(event), + hStream: CudaEncode::encode(stream), + }, + )?; + Ok(()) +} + +pub(crate) fn cu_ctx_set_cache_config( + _config: cuda_types::cuda::CUfunc_cache, +) -> Result<(), CUerror> { + Ok(()) +} + struct UnknownBuffer { buffer: std::cell::UnsafeCell<[u32; S]>, } diff --git a/zluda64_server/src/main.rs b/zluda64_server/src/main.rs index 7beeae353..41339e8ee 100644 --- a/zluda64_server/src/main.rs +++ b/zluda64_server/src/main.rs @@ -552,6 +552,22 @@ async fn main() -> std::io::Result<()> { ) .await?; } + Some(Opcode::cuEventQuery) => { + buffer = handle_cuda_function::( + &mut client, + buffer, + |input| cu_event_query(&mut state, input), + ) + .await?; + } + Some(Opcode::cuEventRecord) => { + buffer = handle_cuda_function::( + &mut client, + buffer, + |input| cu_event_record(&mut state, input), + ) + .await?; + } _ => { client.write_u32_le(CUerror::NOT_SUPPORTED.0.get()).await?; return Err(std::io::Error::new( @@ -563,6 +579,28 @@ async fn main() -> std::io::Result<()> { } } +fn cu_event_query( + state: &mut State, + input: &ArchivedcuEventQueryIn, +) -> Result { + let event = input.hEvent.to_native(); + let cu_event = state.handles.get(event)?; + unsafe { cuEventQuery(cu_event) }?; + Ok(cuEventQueryOut {}) +} + +fn cu_event_record( + state: &mut State, + input: &ArchivedcuEventRecordIn, +) -> Result { + let event = input.hEvent.to_native(); + let cu_event = state.handles.get(event)?; + let stream = input.hStream.to_native(); + let cu_stream = CUstream(state.handles.get(stream)?); + unsafe { cuEventRecord(cu_event, cu_stream) }?; + Ok(cuEventRecordOut {}) +} + fn cu_memcpy_dto_d_v2( state: &mut State, input: &ArchivedcuMemcpyDtoD_v2In, @@ -1220,6 +1258,8 @@ cuda_function_declarations! { cuDriverGetVersion, cuEventCreate, cuEventDestroy_v2, + cuEventQuery, + cuEventRecord, cuGetExportTable, cuInit, cuLaunchKernel, diff --git a/zluda_server_common/src/lib.rs b/zluda_server_common/src/lib.rs index a610cbb92..94c8373e5 100644 --- a/zluda_server_common/src/lib.rs +++ b/zluda_server_common/src/lib.rs @@ -67,6 +67,8 @@ cuda_function_declarations! { cuDriverGetVersion, cuEventCreate, cuEventDestroy_v2, + cuEventQuery, + cuEventRecord, //cuGetExportTable, cuInit, // cuLaunchKernel, From dc827c3aea545e0aad77ae201949f4c622b5fea3 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Sun, 5 Jul 2026 20:35:43 -0700 Subject: [PATCH 75/85] Clean up warnings --- nvapi/src/lib.rs | 9 +--- nvapi_trace/src/lib.rs | 2 +- zluda32/src/ipc.rs | 10 ++--- zluda32/src/lib.rs | 79 +++++++++++++++++----------------- zluda_server_common/src/lib.rs | 68 ++++++++++++++--------------- zluda_trace/src/log.rs | 2 +- 6 files changed, 77 insertions(+), 93 deletions(-) diff --git a/nvapi/src/lib.rs b/nvapi/src/lib.rs index a44cd3582..7864f2b89 100644 --- a/nvapi/src/lib.rs +++ b/nvapi/src/lib.rs @@ -1,12 +1,5 @@ use crate::nvapi::*; -use libloading::Library; -use rustc_hash::FxHashMap; -use std::{ - collections::hash_map, - ffi::c_void, - mem, ptr, - sync::{LazyLock, Mutex}, -}; +use std::ffi::c_void; #[allow(warnings)] mod nvapi; diff --git a/nvapi_trace/src/lib.rs b/nvapi_trace/src/lib.rs index 9fcc8dd06..04840a8c4 100644 --- a/nvapi_trace/src/lib.rs +++ b/nvapi_trace/src/lib.rs @@ -3,7 +3,7 @@ use rustc_hash::FxHashMap; use std::{ collections::hash_map, ffi::c_void, - mem, ptr, + ptr, sync::{LazyLock, Mutex}, }; use zluda_trace_common::ReprUsize; diff --git a/zluda32/src/ipc.rs b/zluda32/src/ipc.rs index ea6cd1479..f4435c113 100644 --- a/zluda32/src/ipc.rs +++ b/zluda32/src/ipc.rs @@ -3,20 +3,16 @@ use rand::distr::{Alphanumeric, SampleString}; use rkyv::api::high::HighSerializer; use rkyv::de::Pool; use rkyv::rancor::{Failure, Strategy}; -use rkyv::rend::u32_le; use rkyv::ser::allocator::ArenaHandle; use rkyv::util::AlignedVec; -use rkyv::{rancor, Archive, Deserialize, Portable, Serialize}; -use rustc_hash::FxHashMap; +use rkyv::{Archive, Deserialize, Portable, Serialize}; use std::io::{Read, Write}; use std::os::windows::io::{AsHandle, AsRawHandle, FromRawHandle}; // use rkyv::util::AlignedVec; +use std::mem; use std::num::NonZeroU32; use std::process::{Child, Command, Stdio}; -use std::sync::{Mutex, OnceLock}; -use std::{mem, ptr}; -use widestring::{u16str, U16CString}; -use windows::core::{Error, Owned, PCSTR}; +use windows::core::{Error, PCSTR}; use windows::Win32::Foundation::*; use windows::Win32::System::Pipes::*; use zluda_server_common::Opcode; diff --git a/zluda32/src/lib.rs b/zluda32/src/lib.rs index e9042c006..f7537583f 100644 --- a/zluda32/src/lib.rs +++ b/zluda32/src/lib.rs @@ -12,11 +12,10 @@ use rkyv::util::AlignedVec; use rkyv::{Archive, Deserialize, Portable, Serialize}; use rustc_hash::FxHashMap; use std::alloc::Layout; -use std::slice; use std::sync::atomic::AtomicBool; use std::sync::{Mutex, OnceLock}; use std::{cell::RefCell, ffi::c_void, ptr}; -use zluda_common::{CodeLibraryRef, CodeModuleRef, CudaErrorType}; +use zluda_common::{CodeLibraryRef, CodeModuleRef}; use zluda_server_common::*; mod ipc; @@ -1013,31 +1012,31 @@ impl CudaDarkApi for DarkApi32 { } unsafe extern "system" fn get_module_from_cubin_ext1( - result: *mut cuda_types::cuda::CUmodule, - fatbinc_wrapper: *const cuda_types::dark_api::FatbincWrapper, - arg3: *mut std::ffi::c_void, - arg4: *mut std::ffi::c_void, - arg5: u32, + _result: *mut cuda_types::cuda::CUmodule, + _fatbinc_wrapper: *const cuda_types::dark_api::FatbincWrapper, + _arg3: *mut std::ffi::c_void, + _arg4: *mut std::ffi::c_void, + _arg5: u32, ) -> cuda_types::cuda::CUresult { - unimplemented!() + Err(CUerror::NOT_SUPPORTED) } - unsafe extern "system" fn cudart_interface_fn7(arg1: usize) -> () { - unimplemented!() + unsafe extern "system" fn cudart_interface_fn7(_arg1: usize) -> () { + () } unsafe extern "system" fn get_module_from_cubin_ext2( - fatbin_header: *const cuda_types::dark_api::FatbinHeader, - result: *mut cuda_types::cuda::CUmodule, - arg3: *mut std::ffi::c_void, - arg4: *mut std::ffi::c_void, - arg5: u32, + _fatbin_header: *const cuda_types::dark_api::FatbinHeader, + _result: *mut cuda_types::cuda::CUmodule, + _arg3: *mut std::ffi::c_void, + _arg4: *mut std::ffi::c_void, + _arg5: u32, ) -> cuda_types::cuda::CUresult { - unimplemented!() + Err(CUerror::NOT_SUPPORTED) } unsafe extern "system" fn load_compilers() -> cuda_types::cuda::CUresult { - unimplemented!() + Err(CUerror::NOT_SUPPORTED) } unsafe extern "system" fn get_unknown_buffer1( @@ -1157,51 +1156,51 @@ impl CudaDarkApi for DarkApi32 { } unsafe extern "system" fn device_get_attribute_ext( - dev: cuda_types::cuda::CUdevice, - attribute: std::ffi::c_uint, - unknown: std::ffi::c_int, - result: *mut [usize; 2], + _dev: cuda_types::cuda::CUdevice, + _attribute: std::ffi::c_uint, + _unknown: std::ffi::c_int, + _result: *mut [usize; 2], ) -> cuda_types::cuda::CUresult { - unimplemented!() + Err(CUerror::NOT_SUPPORTED) } unsafe extern "system" fn device_get_something( - result: *mut std::ffi::c_uchar, - dev: cuda_types::cuda::CUdevice, + _result: *mut std::ffi::c_uchar, + _dev: cuda_types::cuda::CUdevice, ) -> cuda_types::cuda::CUresult { - unimplemented!() + Err(CUerror::NOT_SUPPORTED) } unsafe extern "system" fn integrity_check( - version: u32, - unix_seconds: u64, - result: *mut [u64; 2], + _version: u32, + _unix_seconds: u64, + _result: *mut [u64; 2], ) -> cuda_types::cuda::CUresult { - unimplemented!() + Err(CUerror::NOT_SUPPORTED) } unsafe extern "system" fn context_check( - ctx_in: cuda_types::cuda::CUcontext, - result1: *mut u32, - result2: *mut *const std::ffi::c_void, + _ctx_in: cuda_types::cuda::CUcontext, + _result1: *mut u32, + _result2: *mut *const std::ffi::c_void, ) -> cuda_types::cuda::CUresult { - unimplemented!() + Err(CUerror::NOT_SUPPORTED) } unsafe extern "system" fn check_fn3() -> u32 { - unimplemented!() + 0 } unsafe extern "system" fn hybrid_runtime_load_get_proc_address( - name: *const std::ffi::c_char, - fn_ptr: *mut *const std::ffi::c_void, - token: *mut usize, + _name: *const std::ffi::c_char, + _fn_ptr: *mut *const std::ffi::c_void, + _token: *mut usize, ) -> cuda_types::cuda::CUresult { - unimplemented!() + Err(CUerror::NOT_SUPPORTED) } - unsafe extern "system" fn hybrid_runtime_free(token: usize) -> cuda_types::cuda::CUresult { - unimplemented!() + unsafe extern "system" fn hybrid_runtime_free(_token: usize) -> cuda_types::cuda::CUresult { + Err(CUerror::NOT_SUPPORTED) } } diff --git a/zluda_server_common/src/lib.rs b/zluda_server_common/src/lib.rs index 94c8373e5..a22c5b1f3 100644 --- a/zluda_server_common/src/lib.rs +++ b/zluda_server_common/src/lib.rs @@ -1,12 +1,7 @@ -use bincode::{Decode, Encode}; use cuda_macros::{cuda_function_declarations, generate_input_struct, generate_output_struct}; use cuda_types::cuda::*; -use paste::paste; use rkyv::rend::{u32_le, u64_le}; -use rkyv::{rend, Archive, Deserialize, Portable, Serialize}; -use std::ffi::CString; -use std::num::NonZeroU32; -use std::{ffi::CStr, num::NonZero}; +use rkyv::{Archive, Deserialize, Portable, Serialize}; use strum_macros::FromRepr; macro_rules! noop { @@ -22,6 +17,7 @@ macro_rules! generate_messages_inout { #[repr(u32)] #[derive(FromRepr)] + #[allow(non_camel_case_types)] pub enum Opcode { System = 0, $( @@ -184,31 +180,31 @@ impl CudaEncode for usize { #[repr(C)] #[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)] pub struct CUdevprop_v1_Wire { - pub maxThreadsPerBlock: ::core::ffi::c_int, - pub maxThreadsDim: [::core::ffi::c_int; 3usize], - pub maxGridSize: [::core::ffi::c_int; 3usize], - pub sharedMemPerBlock: ::core::ffi::c_int, - pub totalConstantMemory: ::core::ffi::c_int, - pub SIMDWidth: ::core::ffi::c_int, - pub memPitch: ::core::ffi::c_int, - pub regsPerBlock: ::core::ffi::c_int, - pub clockRate: ::core::ffi::c_int, - pub textureAlign: ::core::ffi::c_int, + pub max_threads_per_block: ::core::ffi::c_int, + pub max_threads_dim: [::core::ffi::c_int; 3usize], + pub max_grid_size: [::core::ffi::c_int; 3usize], + pub shared_mem_per_block: ::core::ffi::c_int, + pub total_constant_memory: ::core::ffi::c_int, + pub simd_width: ::core::ffi::c_int, + pub mem_pitch: ::core::ffi::c_int, + pub regs_per_block: ::core::ffi::c_int, + pub clock_rate: ::core::ffi::c_int, + pub texture_align: ::core::ffi::c_int, } impl From for CUdevprop_v1_Wire { fn from(devprop: CUdevprop_v1) -> Self { Self { - maxThreadsPerBlock: devprop.maxThreadsPerBlock, - maxThreadsDim: devprop.maxThreadsDim, - maxGridSize: devprop.maxGridSize, - sharedMemPerBlock: devprop.sharedMemPerBlock, - totalConstantMemory: devprop.totalConstantMemory, - SIMDWidth: devprop.SIMDWidth, - memPitch: devprop.memPitch, - regsPerBlock: devprop.regsPerBlock, - clockRate: devprop.clockRate, - textureAlign: devprop.textureAlign, + max_threads_per_block: devprop.maxThreadsPerBlock, + max_threads_dim: devprop.maxThreadsDim, + max_grid_size: devprop.maxGridSize, + shared_mem_per_block: devprop.sharedMemPerBlock, + total_constant_memory: devprop.totalConstantMemory, + simd_width: devprop.SIMDWidth, + mem_pitch: devprop.memPitch, + regs_per_block: devprop.regsPerBlock, + clock_rate: devprop.clockRate, + texture_align: devprop.textureAlign, } } } @@ -216,16 +212,16 @@ impl From for CUdevprop_v1_Wire { impl Into for CUdevprop_v1_Wire { fn into(self) -> CUdevprop_v1 { CUdevprop_v1 { - maxThreadsPerBlock: self.maxThreadsPerBlock, - maxThreadsDim: self.maxThreadsDim, - maxGridSize: self.maxGridSize, - sharedMemPerBlock: self.sharedMemPerBlock, - totalConstantMemory: self.totalConstantMemory, - SIMDWidth: self.SIMDWidth, - memPitch: self.memPitch, - regsPerBlock: self.regsPerBlock, - clockRate: self.clockRate, - textureAlign: self.textureAlign, + maxThreadsPerBlock: self.max_threads_per_block, + maxThreadsDim: self.max_threads_dim, + maxGridSize: self.max_grid_size, + sharedMemPerBlock: self.shared_mem_per_block, + totalConstantMemory: self.total_constant_memory, + SIMDWidth: self.simd_width, + memPitch: self.mem_pitch, + regsPerBlock: self.regs_per_block, + clockRate: self.clock_rate, + textureAlign: self.texture_align, } } } diff --git a/zluda_trace/src/log.rs b/zluda_trace/src/log.rs index 023d7979d..7b6ec98bc 100644 --- a/zluda_trace/src/log.rs +++ b/zluda_trace/src/log.rs @@ -236,7 +236,7 @@ impl Write for WriteBuffer { pub(crate) enum CudaFunctionName { Normal(&'static str), Dark { guid: CUuuid, index: usize }, - Nvapi(u32) + Nvapi(u32), } impl Display for CudaFunctionName { From d8b9b8a929e9cd13f136849134847353a986b1af Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Sun, 5 Jul 2026 20:43:09 -0700 Subject: [PATCH 76/85] EOL --- nvapi/src/nvapi.rs | 39758 +++++++++++++++++++++---------------------- 1 file changed, 19879 insertions(+), 19879 deletions(-) diff --git a/nvapi/src/nvapi.rs b/nvapi/src/nvapi.rs index 718bd0a38..8b08ecf38 100644 --- a/nvapi/src/nvapi.rs +++ b/nvapi/src/nvapi.rs @@ -1,19879 +1,19879 @@ -// bindgen nvapi.h -o nvapi.rs --no-layout-tests --allowlist-type "Nv.*" --allowlist-type "NV_.*" -/* automatically generated by rust-bindgen 0.72.1 */ - -#[repr(C)] -#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] -pub struct __BindgenBitfieldUnit { - storage: Storage, -} -impl __BindgenBitfieldUnit { - #[inline] - pub const fn new(storage: Storage) -> Self { - Self { storage } - } -} -impl __BindgenBitfieldUnit -where - Storage: AsRef<[u8]> + AsMut<[u8]>, -{ - #[inline] - fn extract_bit(byte: u8, index: usize) -> bool { - let bit_index = if cfg!(target_endian = "big") { - 7 - (index % 8) - } else { - index % 8 - }; - let mask = 1 << bit_index; - byte & mask == mask - } - #[inline] - pub fn get_bit(&self, index: usize) -> bool { - debug_assert!(index / 8 < self.storage.as_ref().len()); - let byte_index = index / 8; - let byte = self.storage.as_ref()[byte_index]; - Self::extract_bit(byte, index) - } - #[inline] - pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { - debug_assert!(index / 8 < core::mem::size_of::()); - let byte_index = index / 8; - let byte = unsafe { - *(core::ptr::addr_of!((*this).storage) as *const u8).offset(byte_index as isize) - }; - Self::extract_bit(byte, index) - } - #[inline] - fn change_bit(byte: u8, index: usize, val: bool) -> u8 { - let bit_index = if cfg!(target_endian = "big") { - 7 - (index % 8) - } else { - index % 8 - }; - let mask = 1 << bit_index; - if val { - byte | mask - } else { - byte & !mask - } - } - #[inline] - pub fn set_bit(&mut self, index: usize, val: bool) { - debug_assert!(index / 8 < self.storage.as_ref().len()); - let byte_index = index / 8; - let byte = &mut self.storage.as_mut()[byte_index]; - *byte = Self::change_bit(*byte, index, val); - } - #[inline] - pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { - debug_assert!(index / 8 < core::mem::size_of::()); - let byte_index = index / 8; - let byte = unsafe { - (core::ptr::addr_of_mut!((*this).storage) as *mut u8).offset(byte_index as isize) - }; - unsafe { *byte = Self::change_bit(*byte, index, val) }; - } - #[inline] - pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { - debug_assert!(bit_width <= 64); - debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); - debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); - let mut val = 0; - for i in 0..(bit_width as usize) { - if self.get_bit(i + bit_offset) { - let index = if cfg!(target_endian = "big") { - bit_width as usize - 1 - i - } else { - i - }; - val |= 1 << index; - } - } - val - } - #[inline] - pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { - debug_assert!(bit_width <= 64); - debug_assert!(bit_offset / 8 < core::mem::size_of::()); - debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::()); - let mut val = 0; - for i in 0..(bit_width as usize) { - if unsafe { Self::raw_get_bit(this, i + bit_offset) } { - let index = if cfg!(target_endian = "big") { - bit_width as usize - 1 - i - } else { - i - }; - val |= 1 << index; - } - } - val - } - #[inline] - pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { - debug_assert!(bit_width <= 64); - debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); - debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); - for i in 0..(bit_width as usize) { - let mask = 1 << i; - let val_bit_is_set = val & mask == mask; - let index = if cfg!(target_endian = "big") { - bit_width as usize - 1 - i - } else { - i - }; - self.set_bit(index + bit_offset, val_bit_is_set); - } - } - #[inline] - pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { - debug_assert!(bit_width <= 64); - debug_assert!(bit_offset / 8 < core::mem::size_of::()); - debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::()); - for i in 0..(bit_width as usize) { - let mask = 1 << i; - let val_bit_is_set = val & mask == mask; - let index = if cfg!(target_endian = "big") { - bit_width as usize - 1 - i - } else { - i - }; - unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; - } - } -} -pub type DWORD = ::std::os::raw::c_ulong; -pub type ULONG_PTR = ::std::os::raw::c_ulonglong; -pub type SIZE_T = ULONG_PTR; -pub type LONG = ::std::os::raw::c_long; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _LUID { - pub LowPart: DWORD, - pub HighPart: LONG, -} -pub type LUID = _LUID; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MEMORY_RANGE { - pub BaseAddress: *mut ::std::os::raw::c_void, - pub Length: SIZE_T, -} -pub type NV_MEMORY_RANGE = _NV_MEMORY_RANGE; -pub type NvU64 = ::std::os::raw::c_ulonglong; -pub type NvS64 = ::std::os::raw::c_longlong; -pub type NvS32 = ::std::os::raw::c_int; -pub type NvU32 = ::std::os::raw::c_uint; -pub type NvS16 = ::std::os::raw::c_short; -pub type NvU16 = ::std::os::raw::c_ushort; -pub type NvU8 = ::std::os::raw::c_uchar; -pub type NvS8 = ::std::os::raw::c_schar; -pub type NvF32 = f32; -pub type NvF64 = f64; -pub type NvBool = NvU8; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_RECT { - pub left: NvU32, - pub top: NvU32, - pub right: NvU32, - pub bottom: NvU32, -} -pub type NV_RECT = _NV_RECT; -#[doc = "! \\addtogroup nvapihandles\n! NVAPI Handles - These handles are retrieved from various calls and passed in to others in NvAPI\n! These are meant to be opaque types. Do not assume they correspond to indices, HDCs,\n! display indexes or anything else.\n!\n! Most handles remain valid until a display re-configuration (display mode set) or GPU\n! reconfiguration (going into or out of SLI modes) occurs. If NVAPI_HANDLE_INVALIDATED\n! is received by an app, it should discard all handles, and re-enumerate them.\n! @{"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvLogicalGpuHandle__ { - pub unused: ::std::os::raw::c_int, -} -#[doc = "! \\addtogroup nvapihandles\n! NVAPI Handles - These handles are retrieved from various calls and passed in to others in NvAPI\n! These are meant to be opaque types. Do not assume they correspond to indices, HDCs,\n! display indexes or anything else.\n!\n! Most handles remain valid until a display re-configuration (display mode set) or GPU\n! reconfiguration (going into or out of SLI modes) occurs. If NVAPI_HANDLE_INVALIDATED\n! is received by an app, it should discard all handles, and re-enumerate them.\n! @{"] -pub type NvLogicalGpuHandle = *mut NvLogicalGpuHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvPhysicalGpuHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvPhysicalGpuHandle = *mut NvPhysicalGpuHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvDisplayHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvDisplayHandle = *mut NvDisplayHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvMonitorHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvMonitorHandle = *mut NvMonitorHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvUnAttachedDisplayHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvUnAttachedDisplayHandle = *mut NvUnAttachedDisplayHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvVisualComputingDeviceHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvVisualComputingDeviceHandle = *mut NvVisualComputingDeviceHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvEventHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvEventHandle = *mut NvEventHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvHICHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvHICHandle = *mut NvHICHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvGSyncDeviceHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvGSyncDeviceHandle = *mut NvGSyncDeviceHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvVioHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvVioHandle = *mut NvVioHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvTransitionHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvTransitionHandle = *mut NvTransitionHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvAudioHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvAudioHandle = *mut NvAudioHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Nv3DVPContextHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type Nv3DVPContextHandle = *mut Nv3DVPContextHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Nv3DVPTransceiverHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type Nv3DVPTransceiverHandle = *mut Nv3DVPTransceiverHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Nv3DVPGlassesHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type Nv3DVPGlassesHandle = *mut Nv3DVPGlassesHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvPcfClientHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvPcfClientHandle = *mut NvPcfClientHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvSourceHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvSourceHandle = *mut NvSourceHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvTargetHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvTargetHandle = *mut NvTargetHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvPresentBarrierClientHandle__ { - pub unused: ::std::os::raw::c_int, -} -pub type NvPresentBarrierClientHandle = *mut NvPresentBarrierClientHandle__; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvSBox { - pub sX: NvS32, - pub sY: NvS32, - pub sWidth: NvS32, - pub sHeight: NvS32, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NvGUID { - pub data1: NvU32, - pub data2: NvU16, - pub data3: NvU16, - pub data4: [NvU8; 8usize], -} -pub type NvLUID = NvGUID; -pub type NvAPI_String = [::std::os::raw::c_char; 4096usize]; -pub type NvAPI_LongString = [::std::os::raw::c_char; 256usize]; -pub type NvAPI_ShortString = [::std::os::raw::c_char; 64usize]; -pub type NvAPI_UnicodeShortString = [NvU16; 64usize]; -#[doc = "!< Success. Request is completed."] -pub const _NvAPI_Status_NVAPI_OK: _NvAPI_Status = 0; -#[doc = "!< Generic error"] -pub const _NvAPI_Status_NVAPI_ERROR: _NvAPI_Status = -1; -#[doc = "!< NVAPI support library cannot be loaded."] -pub const _NvAPI_Status_NVAPI_LIBRARY_NOT_FOUND: _NvAPI_Status = -2; -#[doc = "!< not implemented in current driver installation"] -pub const _NvAPI_Status_NVAPI_NO_IMPLEMENTATION: _NvAPI_Status = -3; -#[doc = "!< NvAPI_Initialize has not been called (successfully)"] -pub const _NvAPI_Status_NVAPI_API_NOT_INITIALIZED: _NvAPI_Status = -4; -#[doc = "!< The argument/parameter value is not valid or NULL."] -pub const _NvAPI_Status_NVAPI_INVALID_ARGUMENT: _NvAPI_Status = -5; -#[doc = "!< No NVIDIA display driver, or NVIDIA GPU driving a display, was found."] -pub const _NvAPI_Status_NVAPI_NVIDIA_DEVICE_NOT_FOUND: _NvAPI_Status = -6; -#[doc = "!< No more items to enumerate"] -pub const _NvAPI_Status_NVAPI_END_ENUMERATION: _NvAPI_Status = -7; -#[doc = "!< Invalid handle"] -pub const _NvAPI_Status_NVAPI_INVALID_HANDLE: _NvAPI_Status = -8; -#[doc = "!< An argument's structure version is not supported"] -pub const _NvAPI_Status_NVAPI_INCOMPATIBLE_STRUCT_VERSION: _NvAPI_Status = -9; -#[doc = "!< The handle is no longer valid (likely due to GPU or display re-configuration)"] -pub const _NvAPI_Status_NVAPI_HANDLE_INVALIDATED: _NvAPI_Status = -10; -#[doc = "!< No NVIDIA OpenGL context is current (but needs to be)"] -pub const _NvAPI_Status_NVAPI_OPENGL_CONTEXT_NOT_CURRENT: _NvAPI_Status = -11; -#[doc = "!< An invalid pointer, usually NULL, was passed as a parameter"] -pub const _NvAPI_Status_NVAPI_INVALID_POINTER: _NvAPI_Status = -14; -#[doc = "!< OpenGL Expert is not supported by the current drivers"] -pub const _NvAPI_Status_NVAPI_NO_GL_EXPERT: _NvAPI_Status = -12; -#[doc = "!< OpenGL Expert is supported, but driver instrumentation is currently disabled"] -pub const _NvAPI_Status_NVAPI_INSTRUMENTATION_DISABLED: _NvAPI_Status = -13; -#[doc = "!< OpenGL does not support Nsight"] -pub const _NvAPI_Status_NVAPI_NO_GL_NSIGHT: _NvAPI_Status = -15; -#[doc = "!< Expected a logical GPU handle for one or more parameters"] -pub const _NvAPI_Status_NVAPI_EXPECTED_LOGICAL_GPU_HANDLE: _NvAPI_Status = -100; -#[doc = "!< Expected a physical GPU handle for one or more parameters"] -pub const _NvAPI_Status_NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE: _NvAPI_Status = -101; -#[doc = "!< Expected an NV display handle for one or more parameters"] -pub const _NvAPI_Status_NVAPI_EXPECTED_DISPLAY_HANDLE: _NvAPI_Status = -102; -#[doc = "!< The combination of parameters is not valid."] -pub const _NvAPI_Status_NVAPI_INVALID_COMBINATION: _NvAPI_Status = -103; -#[doc = "!< Requested feature is not supported in the selected GPU"] -pub const _NvAPI_Status_NVAPI_NOT_SUPPORTED: _NvAPI_Status = -104; -#[doc = "!< No port ID was found for the I2C transaction"] -pub const _NvAPI_Status_NVAPI_PORTID_NOT_FOUND: _NvAPI_Status = -105; -#[doc = "!< Expected an unattached display handle as one of the input parameters."] -pub const _NvAPI_Status_NVAPI_EXPECTED_UNATTACHED_DISPLAY_HANDLE: _NvAPI_Status = -106; -#[doc = "!< Invalid perf level"] -pub const _NvAPI_Status_NVAPI_INVALID_PERF_LEVEL: _NvAPI_Status = -107; -#[doc = "!< Device is busy; request not fulfilled"] -pub const _NvAPI_Status_NVAPI_DEVICE_BUSY: _NvAPI_Status = -108; -#[doc = "!< NV persist file is not found"] -pub const _NvAPI_Status_NVAPI_NV_PERSIST_FILE_NOT_FOUND: _NvAPI_Status = -109; -#[doc = "!< NV persist data is not found"] -pub const _NvAPI_Status_NVAPI_PERSIST_DATA_NOT_FOUND: _NvAPI_Status = -110; -#[doc = "!< Expected a TV output display"] -pub const _NvAPI_Status_NVAPI_EXPECTED_TV_DISPLAY: _NvAPI_Status = -111; -#[doc = "!< Expected a TV output on the D Connector - HDTV_EIAJ4120."] -pub const _NvAPI_Status_NVAPI_EXPECTED_TV_DISPLAY_ON_DCONNECTOR: _NvAPI_Status = -112; -#[doc = "!< SLI is not active on this device."] -pub const _NvAPI_Status_NVAPI_NO_ACTIVE_SLI_TOPOLOGY: _NvAPI_Status = -113; -#[doc = "!< Setup of SLI rendering mode is not possible right now."] -pub const _NvAPI_Status_NVAPI_SLI_RENDERING_MODE_NOTALLOWED: _NvAPI_Status = -114; -#[doc = "!< Expected a digital flat panel."] -pub const _NvAPI_Status_NVAPI_EXPECTED_DIGITAL_FLAT_PANEL: _NvAPI_Status = -115; -#[doc = "!< Argument exceeds the expected size."] -pub const _NvAPI_Status_NVAPI_ARGUMENT_EXCEED_MAX_SIZE: _NvAPI_Status = -116; -#[doc = "!< Inhibit is ON due to one of the flags in NV_GPU_DISPLAY_CHANGE_INHIBIT or SLI active."] -pub const _NvAPI_Status_NVAPI_DEVICE_SWITCHING_NOT_ALLOWED: _NvAPI_Status = -117; -#[doc = "!< Testing of clocks is not supported."] -pub const _NvAPI_Status_NVAPI_TESTING_CLOCKS_NOT_SUPPORTED: _NvAPI_Status = -118; -#[doc = "!< The specified underscan config is from an unknown source (e.g. INF)"] -pub const _NvAPI_Status_NVAPI_UNKNOWN_UNDERSCAN_CONFIG: _NvAPI_Status = -119; -#[doc = "!< Timeout while reconfiguring GPUs"] -pub const _NvAPI_Status_NVAPI_TIMEOUT_RECONFIGURING_GPU_TOPO: _NvAPI_Status = -120; -#[doc = "!< Requested data was not found"] -pub const _NvAPI_Status_NVAPI_DATA_NOT_FOUND: _NvAPI_Status = -121; -#[doc = "!< Expected an analog display"] -pub const _NvAPI_Status_NVAPI_EXPECTED_ANALOG_DISPLAY: _NvAPI_Status = -122; -#[doc = "!< No SLI video bridge is present"] -pub const _NvAPI_Status_NVAPI_NO_VIDLINK: _NvAPI_Status = -123; -#[doc = "!< NVAPI requires a reboot for the settings to take effect"] -pub const _NvAPI_Status_NVAPI_REQUIRES_REBOOT: _NvAPI_Status = -124; -#[doc = "!< The function is not supported with the current Hybrid mode."] -pub const _NvAPI_Status_NVAPI_INVALID_HYBRID_MODE: _NvAPI_Status = -125; -#[doc = "!< The target types are not all the same"] -pub const _NvAPI_Status_NVAPI_MIXED_TARGET_TYPES: _NvAPI_Status = -126; -#[doc = "!< The function is not supported from 32-bit on a 64-bit system."] -pub const _NvAPI_Status_NVAPI_SYSWOW64_NOT_SUPPORTED: _NvAPI_Status = -127; -#[doc = "!< There is no implicit GPU topology active. Use NVAPI_SetHybridMode to change topology."] -pub const _NvAPI_Status_NVAPI_IMPLICIT_SET_GPU_TOPOLOGY_CHANGE_NOT_ALLOWED: _NvAPI_Status = -128; -#[doc = "!< Prompt the user to close all non-migratable applications."] -pub const _NvAPI_Status_NVAPI_REQUEST_USER_TO_CLOSE_NON_MIGRATABLE_APPS: _NvAPI_Status = -129; -#[doc = "!< Could not allocate sufficient memory to complete the call."] -pub const _NvAPI_Status_NVAPI_OUT_OF_MEMORY: _NvAPI_Status = -130; -#[doc = "!< The previous operation that is transferring information to or from this surface is incomplete."] -pub const _NvAPI_Status_NVAPI_WAS_STILL_DRAWING: _NvAPI_Status = -131; -#[doc = "!< The file was not found."] -pub const _NvAPI_Status_NVAPI_FILE_NOT_FOUND: _NvAPI_Status = -132; -#[doc = "!< There are too many unique instances of a particular type of state object."] -pub const _NvAPI_Status_NVAPI_TOO_MANY_UNIQUE_STATE_OBJECTS: _NvAPI_Status = -133; -#[doc = "!< The method call is invalid. For example, a method's parameter may not be a valid pointer."] -pub const _NvAPI_Status_NVAPI_INVALID_CALL: _NvAPI_Status = -134; -#[doc = "!< d3d10_1.dll cannot be loaded."] -pub const _NvAPI_Status_NVAPI_D3D10_1_LIBRARY_NOT_FOUND: _NvAPI_Status = -135; -#[doc = "!< Couldn't find the function in the loaded DLL."] -pub const _NvAPI_Status_NVAPI_FUNCTION_NOT_FOUND: _NvAPI_Status = -136; -#[doc = "!< The application will require Administrator privileges to access this API.\n!< The application can be elevated to a higher permission level by selecting \"Run as Administrator\"."] -pub const _NvAPI_Status_NVAPI_INVALID_USER_PRIVILEGE: _NvAPI_Status = -137; -#[doc = "!< The handle corresponds to GDIPrimary."] -pub const _NvAPI_Status_NVAPI_EXPECTED_NON_PRIMARY_DISPLAY_HANDLE: _NvAPI_Status = -138; -#[doc = "!< Setting Physx GPU requires that the GPU is compute-capable."] -pub const _NvAPI_Status_NVAPI_EXPECTED_COMPUTE_GPU_HANDLE: _NvAPI_Status = -139; -#[doc = "!< The Stereo part of NVAPI failed to initialize completely. Check if the stereo driver is installed."] -pub const _NvAPI_Status_NVAPI_STEREO_NOT_INITIALIZED: _NvAPI_Status = -140; -#[doc = "!< Access to stereo-related registry keys or values has failed."] -pub const _NvAPI_Status_NVAPI_STEREO_REGISTRY_ACCESS_FAILED: _NvAPI_Status = -141; -#[doc = "!< The given registry profile type is not supported."] -pub const _NvAPI_Status_NVAPI_STEREO_REGISTRY_PROFILE_TYPE_NOT_SUPPORTED: _NvAPI_Status = -142; -#[doc = "!< The given registry value is not supported."] -pub const _NvAPI_Status_NVAPI_STEREO_REGISTRY_VALUE_NOT_SUPPORTED: _NvAPI_Status = -143; -#[doc = "!< Stereo is not enabled and the function needed it to execute completely."] -pub const _NvAPI_Status_NVAPI_STEREO_NOT_ENABLED: _NvAPI_Status = -144; -#[doc = "!< Stereo is not turned on and the function needed it to execute completely."] -pub const _NvAPI_Status_NVAPI_STEREO_NOT_TURNED_ON: _NvAPI_Status = -145; -#[doc = "!< Invalid device interface."] -pub const _NvAPI_Status_NVAPI_STEREO_INVALID_DEVICE_INTERFACE: _NvAPI_Status = -146; -#[doc = "!< Separation percentage or JPEG image capture quality is out of [0-100] range."] -pub const _NvAPI_Status_NVAPI_STEREO_PARAMETER_OUT_OF_RANGE: _NvAPI_Status = -147; -#[doc = "!< The given frustum adjust mode is not supported."] -pub const _NvAPI_Status_NVAPI_STEREO_FRUSTUM_ADJUST_MODE_NOT_SUPPORTED: _NvAPI_Status = -148; -#[doc = "!< The mosaic topology is not possible given the current state of the hardware."] -pub const _NvAPI_Status_NVAPI_TOPO_NOT_POSSIBLE: _NvAPI_Status = -149; -#[doc = "!< An attempt to do a display resolution mode change has failed."] -pub const _NvAPI_Status_NVAPI_MODE_CHANGE_FAILED: _NvAPI_Status = -150; -#[doc = "!< d3d11.dll/d3d11_beta.dll cannot be loaded."] -pub const _NvAPI_Status_NVAPI_D3D11_LIBRARY_NOT_FOUND: _NvAPI_Status = -151; -#[doc = "!< Address is outside of valid range."] -pub const _NvAPI_Status_NVAPI_INVALID_ADDRESS: _NvAPI_Status = -152; -#[doc = "!< The pre-allocated string is too small to hold the result."] -pub const _NvAPI_Status_NVAPI_STRING_TOO_SMALL: _NvAPI_Status = -153; -#[doc = "!< The input does not match any of the available devices."] -pub const _NvAPI_Status_NVAPI_MATCHING_DEVICE_NOT_FOUND: _NvAPI_Status = -154; -#[doc = "!< Driver is running."] -pub const _NvAPI_Status_NVAPI_DRIVER_RUNNING: _NvAPI_Status = -155; -#[doc = "!< Driver is not running."] -pub const _NvAPI_Status_NVAPI_DRIVER_NOTRUNNING: _NvAPI_Status = -156; -#[doc = "!< A driver reload is required to apply these settings."] -pub const _NvAPI_Status_NVAPI_ERROR_DRIVER_RELOAD_REQUIRED: _NvAPI_Status = -157; -#[doc = "!< Intended setting is not allowed."] -pub const _NvAPI_Status_NVAPI_SET_NOT_ALLOWED: _NvAPI_Status = -158; -#[doc = "!< Information can't be returned due to \"advanced display topology\"."] -pub const _NvAPI_Status_NVAPI_ADVANCED_DISPLAY_TOPOLOGY_REQUIRED: _NvAPI_Status = -159; -#[doc = "!< Setting is not found."] -pub const _NvAPI_Status_NVAPI_SETTING_NOT_FOUND: _NvAPI_Status = -160; -#[doc = "!< Setting size is too large."] -pub const _NvAPI_Status_NVAPI_SETTING_SIZE_TOO_LARGE: _NvAPI_Status = -161; -#[doc = "!< There are too many settings for a profile."] -pub const _NvAPI_Status_NVAPI_TOO_MANY_SETTINGS_IN_PROFILE: _NvAPI_Status = -162; -#[doc = "!< Profile is not found."] -pub const _NvAPI_Status_NVAPI_PROFILE_NOT_FOUND: _NvAPI_Status = -163; -#[doc = "!< Profile name is duplicated."] -pub const _NvAPI_Status_NVAPI_PROFILE_NAME_IN_USE: _NvAPI_Status = -164; -#[doc = "!< Profile name is empty."] -pub const _NvAPI_Status_NVAPI_PROFILE_NAME_EMPTY: _NvAPI_Status = -165; -#[doc = "!< Application not found in the Profile."] -pub const _NvAPI_Status_NVAPI_EXECUTABLE_NOT_FOUND: _NvAPI_Status = -166; -#[doc = "!< Application already exists in the other profile."] -pub const _NvAPI_Status_NVAPI_EXECUTABLE_ALREADY_IN_USE: _NvAPI_Status = -167; -#[doc = "!< Data Type mismatch"] -pub const _NvAPI_Status_NVAPI_DATATYPE_MISMATCH: _NvAPI_Status = -168; -#[doc = "!< The profile passed as parameter has been removed and is no longer valid."] -pub const _NvAPI_Status_NVAPI_PROFILE_REMOVED: _NvAPI_Status = -169; -#[doc = "!< An unregistered resource was passed as a parameter."] -pub const _NvAPI_Status_NVAPI_UNREGISTERED_RESOURCE: _NvAPI_Status = -170; -#[doc = "!< The DisplayId corresponds to a display which is not within the normal outputId range."] -pub const _NvAPI_Status_NVAPI_ID_OUT_OF_RANGE: _NvAPI_Status = -171; -#[doc = "!< Display topology is not valid so the driver cannot do a mode set on this configuration."] -pub const _NvAPI_Status_NVAPI_DISPLAYCONFIG_VALIDATION_FAILED: _NvAPI_Status = -172; -#[doc = "!< Display Port Multi-Stream topology has been changed."] -pub const _NvAPI_Status_NVAPI_DPMST_CHANGED: _NvAPI_Status = -173; -#[doc = "!< Input buffer is insufficient to hold the contents."] -pub const _NvAPI_Status_NVAPI_INSUFFICIENT_BUFFER: _NvAPI_Status = -174; -#[doc = "!< No access to the caller."] -pub const _NvAPI_Status_NVAPI_ACCESS_DENIED: _NvAPI_Status = -175; -#[doc = "!< The requested action cannot be performed without Mosaic being enabled."] -pub const _NvAPI_Status_NVAPI_MOSAIC_NOT_ACTIVE: _NvAPI_Status = -176; -#[doc = "!< The surface is relocated away from video memory."] -pub const _NvAPI_Status_NVAPI_SHARE_RESOURCE_RELOCATED: _NvAPI_Status = -177; -#[doc = "!< The user should disable DWM before calling NvAPI."] -pub const _NvAPI_Status_NVAPI_REQUEST_USER_TO_DISABLE_DWM: _NvAPI_Status = -178; -#[doc = "!< D3D device status is D3DERR_DEVICELOST or D3DERR_DEVICENOTRESET - the user has to reset the device."] -pub const _NvAPI_Status_NVAPI_D3D_DEVICE_LOST: _NvAPI_Status = -179; -#[doc = "!< The requested action cannot be performed in the current state."] -pub const _NvAPI_Status_NVAPI_INVALID_CONFIGURATION: _NvAPI_Status = -180; -#[doc = "!< Call failed as stereo handshake not completed."] -pub const _NvAPI_Status_NVAPI_STEREO_HANDSHAKE_NOT_DONE: _NvAPI_Status = -181; -#[doc = "!< The path provided was too short to determine the correct NVDRS_APPLICATION"] -pub const _NvAPI_Status_NVAPI_EXECUTABLE_PATH_IS_AMBIGUOUS: _NvAPI_Status = -182; -#[doc = "!< Default stereo profile is not currently defined"] -pub const _NvAPI_Status_NVAPI_DEFAULT_STEREO_PROFILE_IS_NOT_DEFINED: _NvAPI_Status = -183; -#[doc = "!< Default stereo profile does not exist"] -pub const _NvAPI_Status_NVAPI_DEFAULT_STEREO_PROFILE_DOES_NOT_EXIST: _NvAPI_Status = -184; -#[doc = "!< A cluster is already defined with the given configuration."] -pub const _NvAPI_Status_NVAPI_CLUSTER_ALREADY_EXISTS: _NvAPI_Status = -185; -#[doc = "!< The input display id is not that of a multi stream enabled connector or a display device in a multi stream topology"] -pub const _NvAPI_Status_NVAPI_DPMST_DISPLAY_ID_EXPECTED: _NvAPI_Status = -186; -#[doc = "!< The input display id is not valid or the monitor associated to it does not support the current operation"] -pub const _NvAPI_Status_NVAPI_INVALID_DISPLAY_ID: _NvAPI_Status = -187; -#[doc = "!< While playing secure audio stream, stream goes out of sync"] -pub const _NvAPI_Status_NVAPI_STREAM_IS_OUT_OF_SYNC: _NvAPI_Status = -188; -#[doc = "!< Older audio driver version than required"] -pub const _NvAPI_Status_NVAPI_INCOMPATIBLE_AUDIO_DRIVER: _NvAPI_Status = -189; -#[doc = "!< Value already set, setting again not allowed."] -pub const _NvAPI_Status_NVAPI_VALUE_ALREADY_SET: _NvAPI_Status = -190; -#[doc = "!< Requested operation timed out"] -pub const _NvAPI_Status_NVAPI_TIMEOUT: _NvAPI_Status = -191; -#[doc = "!< The requested workstation feature set has incomplete driver internal allocation resources"] -pub const _NvAPI_Status_NVAPI_GPU_WORKSTATION_FEATURE_INCOMPLETE: _NvAPI_Status = -192; -#[doc = "!< Call failed because InitActivation was not called."] -pub const _NvAPI_Status_NVAPI_STEREO_INIT_ACTIVATION_NOT_DONE: _NvAPI_Status = -193; -#[doc = "!< The requested action cannot be performed without Sync being enabled."] -pub const _NvAPI_Status_NVAPI_SYNC_NOT_ACTIVE: _NvAPI_Status = -194; -#[doc = "!< The requested action cannot be performed without Sync Master being enabled."] -pub const _NvAPI_Status_NVAPI_SYNC_MASTER_NOT_FOUND: _NvAPI_Status = -195; -#[doc = "!< Invalid displays passed in the NV_GSYNC_DISPLAY pointer."] -pub const _NvAPI_Status_NVAPI_INVALID_SYNC_TOPOLOGY: _NvAPI_Status = -196; -#[doc = "!< The specified signing algorithm is not supported. Either an incorrect value was entered or the current installed driver/hardware does not support the input value."] -pub const _NvAPI_Status_NVAPI_ECID_SIGN_ALGO_UNSUPPORTED: _NvAPI_Status = -197; -#[doc = "!< The encrypted public key verification has failed."] -pub const _NvAPI_Status_NVAPI_ECID_KEY_VERIFICATION_FAILED: _NvAPI_Status = -198; -#[doc = "!< The device's firmware is out of date."] -pub const _NvAPI_Status_NVAPI_FIRMWARE_OUT_OF_DATE: _NvAPI_Status = -199; -#[doc = "!< The device's firmware is not supported."] -pub const _NvAPI_Status_NVAPI_FIRMWARE_REVISION_NOT_SUPPORTED: _NvAPI_Status = -200; -#[doc = "!< The caller is not authorized to modify the License."] -pub const _NvAPI_Status_NVAPI_LICENSE_CALLER_AUTHENTICATION_FAILED: _NvAPI_Status = -201; -#[doc = "!< The user tried to use a deferred context without registering the device first"] -pub const _NvAPI_Status_NVAPI_D3D_DEVICE_NOT_REGISTERED: _NvAPI_Status = -202; -#[doc = "!< Head or SourceId was not reserved for the VR Display before doing the Modeset or the dedicated display."] -pub const _NvAPI_Status_NVAPI_RESOURCE_NOT_ACQUIRED: _NvAPI_Status = -203; -#[doc = "!< Provided timing is not supported."] -pub const _NvAPI_Status_NVAPI_TIMING_NOT_SUPPORTED: _NvAPI_Status = -204; -#[doc = "!< HDCP Encryption Failed for the device. Would be applicable when the device is HDCP Capable."] -pub const _NvAPI_Status_NVAPI_HDCP_ENCRYPTION_FAILED: _NvAPI_Status = -205; -#[doc = "!< Provided mode is over sink device pclk limitation."] -pub const _NvAPI_Status_NVAPI_PCLK_LIMITATION_FAILED: _NvAPI_Status = -206; -#[doc = "!< No connector on GPU found."] -pub const _NvAPI_Status_NVAPI_NO_CONNECTOR_FOUND: _NvAPI_Status = -207; -#[doc = "!< When a non-HDCP capable HMD is connected, we would inform user by this code."] -pub const _NvAPI_Status_NVAPI_HDCP_DISABLED: _NvAPI_Status = -208; -#[doc = "!< Atleast an API is still being called"] -pub const _NvAPI_Status_NVAPI_API_IN_USE: _NvAPI_Status = -209; -#[doc = "!< No display found on Nvidia GPU(s)."] -pub const _NvAPI_Status_NVAPI_NVIDIA_DISPLAY_NOT_FOUND: _NvAPI_Status = -210; -#[doc = "!< Priv security violation, improper access to a secured register."] -pub const _NvAPI_Status_NVAPI_PRIV_SEC_VIOLATION: _NvAPI_Status = -211; -#[doc = "!< NVAPI cannot be called by this vendor"] -pub const _NvAPI_Status_NVAPI_INCORRECT_VENDOR: _NvAPI_Status = -212; -#[doc = "!< DirectMode Display is already in use"] -pub const _NvAPI_Status_NVAPI_DISPLAY_IN_USE: _NvAPI_Status = -213; -#[doc = "!< The Config is having Non-NVidia GPU with Non-HDCP HMD connected"] -pub const _NvAPI_Status_NVAPI_UNSUPPORTED_CONFIG_NON_HDCP_HMD: _NvAPI_Status = -214; -#[doc = "!< GPU's Max Display Limit has Reached"] -pub const _NvAPI_Status_NVAPI_MAX_DISPLAY_LIMIT_REACHED: _NvAPI_Status = -215; -#[doc = "!< DirectMode not Enabled on the Display"] -pub const _NvAPI_Status_NVAPI_INVALID_DIRECT_MODE_DISPLAY: _NvAPI_Status = -216; -#[doc = "!< GPU is in debug mode, OC is NOT allowed."] -pub const _NvAPI_Status_NVAPI_GPU_IN_DEBUG_MODE: _NvAPI_Status = -217; -#[doc = "!< No NvAPI context was found for this D3D object"] -pub const _NvAPI_Status_NVAPI_D3D_CONTEXT_NOT_FOUND: _NvAPI_Status = -218; -#[doc = "!< there is version mismatch between stereo driver and dx driver"] -pub const _NvAPI_Status_NVAPI_STEREO_VERSION_MISMATCH: _NvAPI_Status = -219; -#[doc = "!< GPU is not powered and so the request cannot be completed."] -pub const _NvAPI_Status_NVAPI_GPU_NOT_POWERED: _NvAPI_Status = -220; -#[doc = "!< The display driver update in progress."] -pub const _NvAPI_Status_NVAPI_ERROR_DRIVER_RELOAD_IN_PROGRESS: _NvAPI_Status = -221; -#[doc = "!< Wait for HW resources allocation"] -pub const _NvAPI_Status_NVAPI_WAIT_FOR_HW_RESOURCE: _NvAPI_Status = -222; -#[doc = "!< operation requires further HDCP action"] -pub const _NvAPI_Status_NVAPI_REQUIRE_FURTHER_HDCP_ACTION: _NvAPI_Status = -223; -#[doc = "!< Dynamic Mux transition failure"] -pub const _NvAPI_Status_NVAPI_DISPLAY_MUX_TRANSITION_FAILED: _NvAPI_Status = -224; -#[doc = "!< Invalid DSC version"] -pub const _NvAPI_Status_NVAPI_INVALID_DSC_VERSION: _NvAPI_Status = -225; -#[doc = "!< Invalid DSC slice count"] -pub const _NvAPI_Status_NVAPI_INVALID_DSC_SLICECOUNT: _NvAPI_Status = -226; -#[doc = "!< Invalid DSC output BPP"] -pub const _NvAPI_Status_NVAPI_INVALID_DSC_OUTPUT_BPP: _NvAPI_Status = -227; -#[doc = "!< There was an error while loading nvapi.dll from the driver store."] -pub const _NvAPI_Status_NVAPI_FAILED_TO_LOAD_FROM_DRIVER_STORE: _NvAPI_Status = -228; -#[doc = "!< OpenGL does not export Vulkan fake extensions"] -pub const _NvAPI_Status_NVAPI_NO_VULKAN: _NvAPI_Status = -229; -#[doc = "!< A request for NvTOPPs telemetry CData has already been made and is pending a response."] -pub const _NvAPI_Status_NVAPI_REQUEST_PENDING: _NvAPI_Status = -230; -#[doc = "!< Operation cannot be performed because the resource is in use."] -pub const _NvAPI_Status_NVAPI_RESOURCE_IN_USE: _NvAPI_Status = -231; -#[doc = "!< Device kernel image is invalid"] -pub const _NvAPI_Status_NVAPI_INVALID_IMAGE: _NvAPI_Status = -232; -#[doc = "!< PTX JIT compilation failed"] -pub const _NvAPI_Status_NVAPI_INVALID_PTX: _NvAPI_Status = -233; -#[doc = "!< Uncorrectable NVLink error was detected during the execution"] -pub const _NvAPI_Status_NVAPI_NVLINK_UNCORRECTABLE: _NvAPI_Status = -234; -#[doc = "!< PTX JIT compiler library was not found."] -pub const _NvAPI_Status_NVAPI_JIT_COMPILER_NOT_FOUND: _NvAPI_Status = -235; -#[doc = "!< Device kernel source is invalid."] -pub const _NvAPI_Status_NVAPI_INVALID_SOURCE: _NvAPI_Status = -236; -#[doc = "!< While executing a kernel, the device encountered an illegal instruction."] -pub const _NvAPI_Status_NVAPI_ILLEGAL_INSTRUCTION: _NvAPI_Status = -237; -#[doc = "!< While executing a kernel, the device program counter wrapped its address space"] -pub const _NvAPI_Status_NVAPI_INVALID_PC: _NvAPI_Status = -238; -#[doc = "!< An exception occurred on the device while executing a kernel"] -pub const _NvAPI_Status_NVAPI_LAUNCH_FAILED: _NvAPI_Status = -239; -#[doc = "!< Attempted operation is not permitted."] -pub const _NvAPI_Status_NVAPI_NOT_PERMITTED: _NvAPI_Status = -240; -#[doc = "!< The callback function has already been registered."] -pub const _NvAPI_Status_NVAPI_CALLBACK_ALREADY_REGISTERED: _NvAPI_Status = -241; -#[doc = "!< The callback function is not found or not registered."] -pub const _NvAPI_Status_NVAPI_CALLBACK_NOT_FOUND: _NvAPI_Status = -242; -#[doc = "!< Invalid Wire Format for the VR HMD"] -pub const _NvAPI_Status_NVAPI_INVALID_OUTPUT_WIRE_FORMAT: _NvAPI_Status = -243; -#[doc = "! NvAPI Status Values\n! All NvAPI functions return one of these codes.\n! \\ingroup nvapistatus"] -pub type _NvAPI_Status = ::std::os::raw::c_int; -#[doc = "! NvAPI Status Values\n! All NvAPI functions return one of these codes.\n! \\ingroup nvapistatus"] -pub use self::_NvAPI_Status as NvAPI_Status; -#[doc = "! \\ingroup driverapi\n! Used in NvAPI_GPU_GetMemoryInfo()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_DISPLAY_DRIVER_MEMORY_INFO_V1 { - #[doc = "!< Version info"] - pub version: NvU32, - #[doc = "!< Size(in kb) of the physical framebuffer."] - pub dedicatedVideoMemory: NvU32, - #[doc = "!< Size(in kb) of the available physical framebuffer for allocating video memory surfaces."] - pub availableDedicatedVideoMemory: NvU32, - #[doc = "!< Size(in kb) of system memory the driver allocates at load time."] - pub systemVideoMemory: NvU32, - #[doc = "!< Size(in kb) of shared system memory that driver is allowed to commit for surfaces across all allocations."] - pub sharedSystemMemory: NvU32, -} -#[doc = "! \\ingroup driverapi\n! Used in NvAPI_GPU_GetMemoryInfo()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_DISPLAY_DRIVER_MEMORY_INFO_V2 { - #[doc = "!< Version info"] - pub version: NvU32, - #[doc = "!< Size(in kb) of the physical framebuffer."] - pub dedicatedVideoMemory: NvU32, - #[doc = "!< Size(in kb) of the available physical framebuffer for allocating video memory surfaces."] - pub availableDedicatedVideoMemory: NvU32, - #[doc = "!< Size(in kb) of system memory the driver allocates at load time."] - pub systemVideoMemory: NvU32, - #[doc = "!< Size(in kb) of shared system memory that driver is allowed to commit for surfaces across all allocations."] - pub sharedSystemMemory: NvU32, - #[doc = "!< Size(in kb) of the current available physical framebuffer for allocating video memory surfaces."] - pub curAvailableDedicatedVideoMemory: NvU32, -} -#[doc = "! \\ingroup driverapi\n! Used in NvAPI_GPU_GetMemoryInfo()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_DISPLAY_DRIVER_MEMORY_INFO_V3 { - #[doc = "!< Version info"] - pub version: NvU32, - #[doc = "!< Size(in kb) of the physical framebuffer."] - pub dedicatedVideoMemory: NvU32, - #[doc = "!< Size(in kb) of the available physical framebuffer for allocating video memory surfaces."] - pub availableDedicatedVideoMemory: NvU32, - #[doc = "!< Size(in kb) of system memory the driver allocates at load time."] - pub systemVideoMemory: NvU32, - #[doc = "!< Size(in kb) of shared system memory that driver is allowed to commit for surfaces across all allocations."] - pub sharedSystemMemory: NvU32, - #[doc = "!< Size(in kb) of the current available physical framebuffer for allocating video memory surfaces."] - pub curAvailableDedicatedVideoMemory: NvU32, - #[doc = "!< Size(in kb) of the total size of memory released as a result of the evictions."] - pub dedicatedVideoMemoryEvictionsSize: NvU32, - #[doc = "!< Indicates the number of eviction events that caused an allocation to be removed from dedicated video memory to free GPU\n!< video memory to make room for other allocations."] - pub dedicatedVideoMemoryEvictionCount: NvU32, -} -#[doc = "! \\ingroup driverapi"] -pub type NV_DISPLAY_DRIVER_MEMORY_INFO = NV_DISPLAY_DRIVER_MEMORY_INFO_V3; -#[doc = "! \\ingroup driverapi\n! Used in NvAPI_GPU_GetMemoryInfoEx()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_MEMORY_INFO_EX_V1 { - #[doc = "!< Structure version"] - pub version: NvU32, - #[doc = "!< Size(in bytes) of the physical framebuffer. Refers to the dedicated video memory on discrete GPUs."] - pub dedicatedVideoMemory: NvU64, - #[doc = "!< Size(in bytes) of the available physical framebuffer for allocating video memory surfaces."] - pub availableDedicatedVideoMemory: NvU64, - #[doc = "!< Size(in bytes) of system memory the driver allocates at load time. It is a substitute for dedicated video memory.\n!< Typically used with integrated GPUs that do not have dedicated video memory."] - pub systemVideoMemory: NvU64, - #[doc = "!< Size(in bytes) of shared system memory that driver is allowed to commit for surfaces across all allocations.\n!< On discrete GPUs, it is used to utilize system memory for various operations. It does not need to be reserved during boot.\n!< It may be used by both GPU and CPU, and has an \"on-demand\" type of usage."] - pub sharedSystemMemory: NvU64, - #[doc = "!< Size(in bytes) of the current available physical framebuffer for allocating video memory surfaces."] - pub curAvailableDedicatedVideoMemory: NvU64, - #[doc = "!< Size(in bytes) of the total size of memory released as a result of the evictions."] - pub dedicatedVideoMemoryEvictionsSize: NvU64, - #[doc = "!< Indicates the number of eviction events that caused an allocation to be removed from dedicated video memory to free GPU\n!< video memory to make room for other allocations."] - pub dedicatedVideoMemoryEvictionCount: NvU64, - #[doc = "!< Size(in bytes) of the total size of memory allocated as a result of the promotions."] - pub dedicatedVideoMemoryPromotionsSize: NvU64, - #[doc = "!< Indicates the number of promotion events that caused an allocation to be promoted to dedicated video memory"] - pub dedicatedVideoMemoryPromotionCount: NvU64, -} -#[doc = "! \\ingroup driverapi"] -pub type NV_GPU_MEMORY_INFO_EX = NV_GPU_MEMORY_INFO_EX_V1; -#[doc = "! \\ingroup dx\n! Used in NvAPI_D3D10_GetCurrentSLIState(), and NvAPI_D3D_GetCurrentSLIState()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GET_CURRENT_SLI_STATE_V1 { - #[doc = "!< Structure version"] - pub version: NvU32, - #[doc = "!< [OUT] The maximum possible value of numAFRGroups"] - pub maxNumAFRGroups: NvU32, - #[doc = "!< [OUT] The number of AFR groups enabled in the system"] - pub numAFRGroups: NvU32, - #[doc = "!< [OUT] The AFR group index for the frame currently being rendered"] - pub currentAFRIndex: NvU32, - #[doc = "!< [OUT] What the AFR group index will be for the next frame (i.e. after calling Present)"] - pub nextFrameAFRIndex: NvU32, - #[doc = "!< [OUT] The AFR group index that was used for the previous frame (~0 if more than one frame has not been rendered yet)"] - pub previousFrameAFRIndex: NvU32, - #[doc = "!< [OUT] Boolean: Is this frame the first time running on the current AFR group"] - pub bIsCurAFRGroupNew: NvU32, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GET_CURRENT_SLI_STATE_V2 { - #[doc = "!< Structure version"] - pub version: NvU32, - #[doc = "!< [OUT] The maximum possible value of numAFRGroups"] - pub maxNumAFRGroups: NvU32, - #[doc = "!< [OUT] The number of AFR groups enabled in the system"] - pub numAFRGroups: NvU32, - #[doc = "!< [OUT] The AFR group index for the frame currently being rendered"] - pub currentAFRIndex: NvU32, - #[doc = "!< [OUT] What the AFR group index will be for the next frame (i.e. after calling Present)"] - pub nextFrameAFRIndex: NvU32, - #[doc = "!< [OUT] The AFR group index that was used for the previous frame (~0 if more than one frame has not been rendered yet)"] - pub previousFrameAFRIndex: NvU32, - #[doc = "!< [OUT] Boolean: Is this frame the first time running on the current AFR group"] - pub bIsCurAFRGroupNew: NvU32, - #[doc = "!< [OUT] The number of GPUs used in VR-SLI. If it is 0 VR-SLI is not active"] - pub numVRSLIGpus: NvU32, -} -pub const _NV_StereoActiveEye_NVAPI_STEREO_EYE_RIGHT: _NV_StereoActiveEye = 1; -pub const _NV_StereoActiveEye_NVAPI_STEREO_EYE_LEFT: _NV_StereoActiveEye = 2; -pub const _NV_StereoActiveEye_NVAPI_STEREO_EYE_MONO: _NV_StereoActiveEye = 3; -#[doc = "! \\ingroup stereoapi"] -pub type _NV_StereoActiveEye = ::std::os::raw::c_int; -#[doc = "! \\ingroup stereoapi"] -pub use self::_NV_StereoActiveEye as NV_STEREO_ACTIVE_EYE; -pub const _NV_StereoDriverMode_NVAPI_STEREO_DRIVER_MODE_AUTOMATIC: _NV_StereoDriverMode = 0; -pub const _NV_StereoDriverMode_NVAPI_STEREO_DRIVER_MODE_DIRECT: _NV_StereoDriverMode = 2; -#[doc = "! \\ingroup stereoapi"] -pub type _NV_StereoDriverMode = ::std::os::raw::c_int; -#[doc = "! \\ingroup stereoapi"] -pub use self::_NV_StereoDriverMode as NV_STEREO_DRIVER_MODE; -pub const _NV_DP_LINK_RATE_NV_DP_1_62GBPS: _NV_DP_LINK_RATE = 6; -pub const _NV_DP_LINK_RATE_NV_DP_2_70GBPS: _NV_DP_LINK_RATE = 10; -pub const _NV_DP_LINK_RATE_NV_DP_5_40GBPS: _NV_DP_LINK_RATE = 20; -pub const _NV_DP_LINK_RATE_NV_DP_8_10GBPS: _NV_DP_LINK_RATE = 30; -pub const _NV_DP_LINK_RATE_NV_EDP_2_16GBPS: _NV_DP_LINK_RATE = 8; -pub const _NV_DP_LINK_RATE_NV_EDP_2_43GBPS: _NV_DP_LINK_RATE = 9; -pub const _NV_DP_LINK_RATE_NV_EDP_3_24GBPS: _NV_DP_LINK_RATE = 12; -pub const _NV_DP_LINK_RATE_NV_EDP_4_32GBPS: _NV_DP_LINK_RATE = 16; -#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] -pub type _NV_DP_LINK_RATE = ::std::os::raw::c_int; -#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] -pub use self::_NV_DP_LINK_RATE as NV_DP_LINK_RATE; -pub const _NV_DP2X_LINK_RATE_NV_DP2X_1_62Gbps: _NV_DP2X_LINK_RATE = 162; -pub const _NV_DP2X_LINK_RATE_NV_DP2X_2_16Gbps: _NV_DP2X_LINK_RATE = 216; -pub const _NV_DP2X_LINK_RATE_NV_DP2X_2_43Gbps: _NV_DP2X_LINK_RATE = 243; -pub const _NV_DP2X_LINK_RATE_NV_DP2X_2_50Gbps: _NV_DP2X_LINK_RATE = 250; -pub const _NV_DP2X_LINK_RATE_NV_DP2X_2_70Gbps: _NV_DP2X_LINK_RATE = 270; -pub const _NV_DP2X_LINK_RATE_NV_DP2X_3_24Gbps: _NV_DP2X_LINK_RATE = 324; -pub const _NV_DP2X_LINK_RATE_NV_DP2X_4_32Gbps: _NV_DP2X_LINK_RATE = 432; -pub const _NV_DP2X_LINK_RATE_NV_DP2X_5_40Gbps: _NV_DP2X_LINK_RATE = 540; -pub const _NV_DP2X_LINK_RATE_NV_DP2X_6_75Gbps: _NV_DP2X_LINK_RATE = 675; -pub const _NV_DP2X_LINK_RATE_NV_DP2X_8_10Gbps: _NV_DP2X_LINK_RATE = 810; -pub const _NV_DP2X_LINK_RATE_NV_DP2X_10_0Gbps: _NV_DP2X_LINK_RATE = 1000; -pub const _NV_DP2X_LINK_RATE_NV_DP2X_13_5Gbps: _NV_DP2X_LINK_RATE = 1350; -pub const _NV_DP2X_LINK_RATE_NV_DP2X_20_0Gbps: _NV_DP2X_LINK_RATE = 2000; -pub type _NV_DP2X_LINK_RATE = ::std::os::raw::c_int; -pub use self::_NV_DP2X_LINK_RATE as NV_DP2X_LINK_RATE; -pub const _NV_DP_LANE_COUNT_NV_DP_1_LANE: _NV_DP_LANE_COUNT = 1; -pub const _NV_DP_LANE_COUNT_NV_DP_2_LANE: _NV_DP_LANE_COUNT = 2; -pub const _NV_DP_LANE_COUNT_NV_DP_4_LANE: _NV_DP_LANE_COUNT = 4; -#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] -pub type _NV_DP_LANE_COUNT = ::std::os::raw::c_int; -#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] -pub use self::_NV_DP_LANE_COUNT as NV_DP_LANE_COUNT; -pub const _NV_DP_COLOR_FORMAT_NV_DP_COLOR_FORMAT_RGB: _NV_DP_COLOR_FORMAT = 0; -pub const _NV_DP_COLOR_FORMAT_NV_DP_COLOR_FORMAT_YCbCr422: _NV_DP_COLOR_FORMAT = 1; -pub const _NV_DP_COLOR_FORMAT_NV_DP_COLOR_FORMAT_YCbCr444: _NV_DP_COLOR_FORMAT = 2; -#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] -pub type _NV_DP_COLOR_FORMAT = ::std::os::raw::c_int; -#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] -pub use self::_NV_DP_COLOR_FORMAT as NV_DP_COLOR_FORMAT; -pub const _NV_DP_COLORIMETRY_NV_DP_COLORIMETRY_RGB: _NV_DP_COLORIMETRY = 0; -pub const _NV_DP_COLORIMETRY_NV_DP_COLORIMETRY_YCbCr_ITU601: _NV_DP_COLORIMETRY = 1; -pub const _NV_DP_COLORIMETRY_NV_DP_COLORIMETRY_YCbCr_ITU709: _NV_DP_COLORIMETRY = 2; -#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] -pub type _NV_DP_COLORIMETRY = ::std::os::raw::c_int; -#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] -pub use self::_NV_DP_COLORIMETRY as NV_DP_COLORIMETRY; -pub const _NV_DP_DYNAMIC_RANGE_NV_DP_DYNAMIC_RANGE_VESA: _NV_DP_DYNAMIC_RANGE = 0; -pub const _NV_DP_DYNAMIC_RANGE_NV_DP_DYNAMIC_RANGE_CEA: _NV_DP_DYNAMIC_RANGE = 1; -#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] -pub type _NV_DP_DYNAMIC_RANGE = ::std::os::raw::c_int; -#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] -pub use self::_NV_DP_DYNAMIC_RANGE as NV_DP_DYNAMIC_RANGE; -pub const _NV_DP_BPC_NV_DP_BPC_DEFAULT: _NV_DP_BPC = 0; -pub const _NV_DP_BPC_NV_DP_BPC_6: _NV_DP_BPC = 1; -pub const _NV_DP_BPC_NV_DP_BPC_8: _NV_DP_BPC = 2; -pub const _NV_DP_BPC_NV_DP_BPC_10: _NV_DP_BPC = 3; -pub const _NV_DP_BPC_NV_DP_BPC_12: _NV_DP_BPC = 4; -pub const _NV_DP_BPC_NV_DP_BPC_16: _NV_DP_BPC = 5; -#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] -pub type _NV_DP_BPC = ::std::os::raw::c_int; -#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] -pub use self::_NV_DP_BPC as NV_DP_BPC; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_EDID_V1 { - pub version: NvU32, - pub EDID_Data: [NvU8; 256usize], -} -#[doc = "! Used in NvAPI_GPU_GetEDID()"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_EDID_V2 { - #[doc = "!< Structure version"] - pub version: NvU32, - pub EDID_Data: [NvU8; 256usize], - pub sizeofEDID: NvU32, -} -#[doc = "! Used in NvAPI_GPU_GetEDID()"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_EDID_V3 { - #[doc = "!< Structure version"] - pub version: NvU32, - pub EDID_Data: [NvU8; 256usize], - pub sizeofEDID: NvU32, - #[doc = "!< ID which always returned in a monotonically increasing counter.\n!< Across a split-EDID read we need to verify that all calls returned the same edidId.\n!< This counter is incremented if we get the updated EDID."] - pub edidId: NvU32, - #[doc = "!< Which 256-byte page of the EDID we want to read. Start at 0.\n!< If the read succeeds with edidSize > NV_EDID_DATA_SIZE,\n!< call back again with offset+256 until we have read the entire buffer"] - pub offset: NvU32, -} -#[doc = "! Used in NvAPI_GPU_GetEDID()"] -pub type NV_EDID = NV_EDID_V3; -#[doc = "!< the EDID which is actively used by the driver, it could be _RAW/_COOKED/_FORCED/_INF."] -pub const NV_EDID_FLAG_NV_EDID_FLAG_DEFAULT: NV_EDID_FLAG = 0; -#[doc = "!< the EDID which is not modified by the driver. If there's no _FORCED edid engaged, it\n!< will be the unmodified monitor EDID from the I2C bus. Otherwise it is original _FORCED edid."] -pub const NV_EDID_FLAG_NV_EDID_FLAG_RAW: NV_EDID_FLAG = 1; -#[doc = "!< the EDID has been modified by the driver for compatibility"] -pub const NV_EDID_FLAG_NV_EDID_FLAG_COOKED: NV_EDID_FLAG = 2; -#[doc = "!< the EDID is forced by the end-user over s/w interface,"] -pub const NV_EDID_FLAG_NV_EDID_FLAG_FORCED: NV_EDID_FLAG = 3; -#[doc = "!< the EDID is from monitor INF"] -pub const NV_EDID_FLAG_NV_EDID_FLAG_INF: NV_EDID_FLAG = 4; -#[doc = "!< the EDID is from the monitor over I2C bus without any modification."] -pub const NV_EDID_FLAG_NV_EDID_FLAG_HW: NV_EDID_FLAG = 5; -pub type NV_EDID_FLAG = ::std::os::raw::c_int; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_VGA_15_PIN: _NV_GPU_CONNECTOR_TYPE = 0; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_TV_COMPOSITE: _NV_GPU_CONNECTOR_TYPE = 16; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_TV_SVIDEO: _NV_GPU_CONNECTOR_TYPE = 17; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_TV_HDTV_COMPONENT: _NV_GPU_CONNECTOR_TYPE = 19; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_TV_SCART: _NV_GPU_CONNECTOR_TYPE = 20; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_TV_COMPOSITE_SCART_ON_EIAJ4120: - _NV_GPU_CONNECTOR_TYPE = 22; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_TV_HDTV_EIAJ4120: _NV_GPU_CONNECTOR_TYPE = 23; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_PC_POD_HDTV_YPRPB: _NV_GPU_CONNECTOR_TYPE = 24; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_PC_POD_SVIDEO: _NV_GPU_CONNECTOR_TYPE = 25; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_PC_POD_COMPOSITE: _NV_GPU_CONNECTOR_TYPE = 26; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DVI_I_TV_SVIDEO: _NV_GPU_CONNECTOR_TYPE = 32; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DVI_I_TV_COMPOSITE: _NV_GPU_CONNECTOR_TYPE = - 33; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DVI_I: _NV_GPU_CONNECTOR_TYPE = 48; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DVI_D: _NV_GPU_CONNECTOR_TYPE = 49; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_ADC: _NV_GPU_CONNECTOR_TYPE = 50; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_LFH_DVI_I_1: _NV_GPU_CONNECTOR_TYPE = 56; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_LFH_DVI_I_2: _NV_GPU_CONNECTOR_TYPE = 57; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_SPWG: _NV_GPU_CONNECTOR_TYPE = 64; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_OEM: _NV_GPU_CONNECTOR_TYPE = 65; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DISPLAYPORT_EXTERNAL: _NV_GPU_CONNECTOR_TYPE = - 70; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DISPLAYPORT_INTERNAL: _NV_GPU_CONNECTOR_TYPE = - 71; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DISPLAYPORT_MINI_EXT: _NV_GPU_CONNECTOR_TYPE = - 72; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_HDMI_A: _NV_GPU_CONNECTOR_TYPE = 97; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_HDMI_C_MINI: _NV_GPU_CONNECTOR_TYPE = 99; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_LFH_DISPLAYPORT_1: _NV_GPU_CONNECTOR_TYPE = - 100; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_LFH_DISPLAYPORT_2: _NV_GPU_CONNECTOR_TYPE = - 101; -#[doc = "!< Deprecated."] -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_VIRTUAL_WFD: _NV_GPU_CONNECTOR_TYPE = 112; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_USB_C: _NV_GPU_CONNECTOR_TYPE = 113; -pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_UNKNOWN: _NV_GPU_CONNECTOR_TYPE = -1; -#[doc = "! \\ingroup gpu\n! Used in NV_GPU_CONNECTOR_DATA"] -pub type _NV_GPU_CONNECTOR_TYPE = ::std::os::raw::c_int; -#[doc = "! \\ingroup gpu\n! Used in NV_GPU_CONNECTOR_DATA"] -pub use self::_NV_GPU_CONNECTOR_TYPE as NV_GPU_CONNECTOR_TYPE; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_NONE: _NV_DISPLAY_TV_FORMAT = 0; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_NTSCM: _NV_DISPLAY_TV_FORMAT = 1; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_NTSCJ: _NV_DISPLAY_TV_FORMAT = 2; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_PALM: _NV_DISPLAY_TV_FORMAT = 4; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_PALBDGH: _NV_DISPLAY_TV_FORMAT = 8; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_PALN: _NV_DISPLAY_TV_FORMAT = 16; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_PALNC: _NV_DISPLAY_TV_FORMAT = 32; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_576i: _NV_DISPLAY_TV_FORMAT = 256; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_480i: _NV_DISPLAY_TV_FORMAT = 512; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_ED_480p: _NV_DISPLAY_TV_FORMAT = 1024; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_ED_576p: _NV_DISPLAY_TV_FORMAT = 2048; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_720p: _NV_DISPLAY_TV_FORMAT = 4096; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_1080i: _NV_DISPLAY_TV_FORMAT = 8192; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_1080p: _NV_DISPLAY_TV_FORMAT = 16384; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_720p50: _NV_DISPLAY_TV_FORMAT = 32768; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_1080p24: _NV_DISPLAY_TV_FORMAT = 65536; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_1080i50: _NV_DISPLAY_TV_FORMAT = 131072; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_1080p50: _NV_DISPLAY_TV_FORMAT = 262144; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp30: _NV_DISPLAY_TV_FORMAT = 524288; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp30_3840: _NV_DISPLAY_TV_FORMAT = 524288; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp25: _NV_DISPLAY_TV_FORMAT = 1048576; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp25_3840: _NV_DISPLAY_TV_FORMAT = - 1048576; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp24: _NV_DISPLAY_TV_FORMAT = 2097152; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp24_3840: _NV_DISPLAY_TV_FORMAT = - 2097152; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp24_SMPTE: _NV_DISPLAY_TV_FORMAT = - 4194304; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp50_3840: _NV_DISPLAY_TV_FORMAT = - 8388608; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp60_3840: _NV_DISPLAY_TV_FORMAT = - 9437184; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp30_4096: _NV_DISPLAY_TV_FORMAT = - 10485760; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp25_4096: _NV_DISPLAY_TV_FORMAT = - 11534336; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp24_4096: _NV_DISPLAY_TV_FORMAT = - 12582912; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp50_4096: _NV_DISPLAY_TV_FORMAT = - 13631488; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp60_4096: _NV_DISPLAY_TV_FORMAT = - 14680064; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp24_7680: _NV_DISPLAY_TV_FORMAT = - 16777216; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp25_7680: _NV_DISPLAY_TV_FORMAT = - 33554432; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp30_7680: _NV_DISPLAY_TV_FORMAT = - 67108864; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp48_7680: _NV_DISPLAY_TV_FORMAT = - 134217728; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp50_7680: _NV_DISPLAY_TV_FORMAT = - 150994944; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp60_7680: _NV_DISPLAY_TV_FORMAT = - 167772160; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp100_7680: _NV_DISPLAY_TV_FORMAT = - 184549376; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp120_7680: _NV_DISPLAY_TV_FORMAT = - 201326592; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp48_3840: _NV_DISPLAY_TV_FORMAT = - 218103808; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp48_4096: _NV_DISPLAY_TV_FORMAT = - 234881024; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp100_4096: _NV_DISPLAY_TV_FORMAT = - 251658240; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp100_3840: _NV_DISPLAY_TV_FORMAT = - 268435456; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp120_4096: _NV_DISPLAY_TV_FORMAT = - 285212672; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp120_3840: _NV_DISPLAY_TV_FORMAT = - 301989888; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp100_5120: _NV_DISPLAY_TV_FORMAT = - 318767104; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp120_5120: _NV_DISPLAY_TV_FORMAT = - 335544320; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp24_5120: _NV_DISPLAY_TV_FORMAT = - 352321536; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp25_5120: _NV_DISPLAY_TV_FORMAT = - 369098752; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp30_5120: _NV_DISPLAY_TV_FORMAT = - 385875968; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp48_5120: _NV_DISPLAY_TV_FORMAT = - 402653184; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp50_5120: _NV_DISPLAY_TV_FORMAT = - 419430400; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp60_5120: _NV_DISPLAY_TV_FORMAT = - 536870912; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp24_10240: _NV_DISPLAY_TV_FORMAT = - 553648128; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp25_10240: _NV_DISPLAY_TV_FORMAT = - 570425344; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp30_10240: _NV_DISPLAY_TV_FORMAT = - 587202560; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp48_10240: _NV_DISPLAY_TV_FORMAT = - 603979776; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp50_10240: _NV_DISPLAY_TV_FORMAT = - 620756992; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp60_10240: _NV_DISPLAY_TV_FORMAT = - 637534208; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp100_10240: _NV_DISPLAY_TV_FORMAT = - 654311424; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp120_10240: _NV_DISPLAY_TV_FORMAT = - 671088640; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_OTHER: _NV_DISPLAY_TV_FORMAT = 805306368; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_ED_OTHER: _NV_DISPLAY_TV_FORMAT = 1073741824; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_OTHER: _NV_DISPLAY_TV_FORMAT = 1342177280; -pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_ANY: _NV_DISPLAY_TV_FORMAT = -2147483648; -#[doc = "! \\ingroup tvapi\n! Used in NV_DISPLAY_TV_OUTPUT_INFO"] -pub type _NV_DISPLAY_TV_FORMAT = ::std::os::raw::c_int; -#[doc = "! \\ingroup tvapi\n! Used in NV_DISPLAY_TV_OUTPUT_INFO"] -pub use self::_NV_DISPLAY_TV_FORMAT as NV_DISPLAY_TV_FORMAT; -pub const _NV_TARGET_VIEW_MODE_NV_VIEW_MODE_STANDARD: _NV_TARGET_VIEW_MODE = 0; -pub const _NV_TARGET_VIEW_MODE_NV_VIEW_MODE_CLONE: _NV_TARGET_VIEW_MODE = 1; -pub const _NV_TARGET_VIEW_MODE_NV_VIEW_MODE_HSPAN: _NV_TARGET_VIEW_MODE = 2; -pub const _NV_TARGET_VIEW_MODE_NV_VIEW_MODE_VSPAN: _NV_TARGET_VIEW_MODE = 3; -pub const _NV_TARGET_VIEW_MODE_NV_VIEW_MODE_DUALVIEW: _NV_TARGET_VIEW_MODE = 4; -pub const _NV_TARGET_VIEW_MODE_NV_VIEW_MODE_MULTIVIEW: _NV_TARGET_VIEW_MODE = 5; -#[doc = "! Used in NvAPI_SetView()."] -pub type _NV_TARGET_VIEW_MODE = ::std::os::raw::c_int; -#[doc = "! Used in NvAPI_SetView()."] -pub use self::_NV_TARGET_VIEW_MODE as NV_TARGET_VIEW_MODE; -#[doc = "!< No change"] -pub const _NV_SCALING_NV_SCALING_DEFAULT: _NV_SCALING = 0; -#[doc = "!< Balanced - Full Screen"] -pub const _NV_SCALING_NV_SCALING_GPU_SCALING_TO_CLOSEST: _NV_SCALING = 1; -#[doc = "!< Force GPU - Full Screen"] -pub const _NV_SCALING_NV_SCALING_GPU_SCALING_TO_NATIVE: _NV_SCALING = 2; -#[doc = "!< Force GPU - Centered\\No Scaling"] -pub const _NV_SCALING_NV_SCALING_GPU_SCANOUT_TO_NATIVE: _NV_SCALING = 3; -#[doc = "!< Force GPU - Aspect Ratio"] -pub const _NV_SCALING_NV_SCALING_GPU_SCALING_TO_ASPECT_SCANOUT_TO_NATIVE: _NV_SCALING = 5; -#[doc = "!< Balanced - Aspect Ratio"] -pub const _NV_SCALING_NV_SCALING_GPU_SCALING_TO_ASPECT_SCANOUT_TO_CLOSEST: _NV_SCALING = 6; -#[doc = "!< Balanced - Centered\\No Scaling"] -pub const _NV_SCALING_NV_SCALING_GPU_SCANOUT_TO_CLOSEST: _NV_SCALING = 7; -#[doc = "!< Force GPU - Integer Scaling"] -pub const _NV_SCALING_NV_SCALING_GPU_INTEGER_ASPECT_SCALING: _NV_SCALING = 8; -pub const _NV_SCALING_NV_SCALING_MONITOR_SCALING: _NV_SCALING = 1; -pub const _NV_SCALING_NV_SCALING_ADAPTER_SCALING: _NV_SCALING = 2; -pub const _NV_SCALING_NV_SCALING_CENTERED: _NV_SCALING = 3; -pub const _NV_SCALING_NV_SCALING_ASPECT_SCALING: _NV_SCALING = 5; -#[doc = "!< For future use"] -pub const _NV_SCALING_NV_SCALING_CUSTOMIZED: _NV_SCALING = 255; -#[doc = "! Scaling modes - used in NvAPI_SetViewEx().\n! \\ingroup dispcontrol"] -pub type _NV_SCALING = ::std::os::raw::c_int; -#[doc = "! Scaling modes - used in NvAPI_SetViewEx().\n! \\ingroup dispcontrol"] -pub use self::_NV_SCALING as NV_SCALING; -pub const _NV_ROTATE_NV_ROTATE_0: _NV_ROTATE = 0; -pub const _NV_ROTATE_NV_ROTATE_90: _NV_ROTATE = 1; -pub const _NV_ROTATE_NV_ROTATE_180: _NV_ROTATE = 2; -pub const _NV_ROTATE_NV_ROTATE_270: _NV_ROTATE = 3; -pub const _NV_ROTATE_NV_ROTATE_IGNORED: _NV_ROTATE = 4; -#[doc = "! \\ingroup dispcontrol"] -pub type _NV_ROTATE = ::std::os::raw::c_int; -#[doc = "! \\ingroup dispcontrol"] -pub use self::_NV_ROTATE as NV_ROTATE; -#[doc = "!< unknown. Driver will choose one as following value."] -pub const _NV_FORMAT_NV_FORMAT_UNKNOWN: _NV_FORMAT = 0; -#[doc = "!< for 8bpp mode"] -pub const _NV_FORMAT_NV_FORMAT_P8: _NV_FORMAT = 41; -#[doc = "!< for 16bpp mode"] -pub const _NV_FORMAT_NV_FORMAT_R5G6B5: _NV_FORMAT = 23; -#[doc = "!< for 32bpp mode"] -pub const _NV_FORMAT_NV_FORMAT_A8R8G8B8: _NV_FORMAT = 21; -#[doc = "!< for 64bpp(floating point) mode."] -pub const _NV_FORMAT_NV_FORMAT_A16B16G16R16F: _NV_FORMAT = 113; -#[doc = "! Color formats- used in NvAPI_SetViewEx().\n! \\ingroup dispcontrol"] -pub type _NV_FORMAT = ::std::os::raw::c_int; -#[doc = "! Color formats- used in NvAPI_SetViewEx().\n! \\ingroup dispcontrol"] -pub use self::_NV_FORMAT as NV_FORMAT; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_VIEWPORTF { - #[doc = "!< x-coordinate of the viewport top-left point"] - pub x: f32, - #[doc = "!< y-coordinate of the viewport top-left point"] - pub y: f32, - #[doc = "!< Width of the viewport"] - pub w: f32, - #[doc = "!< Height of the viewport"] - pub h: f32, -} -#[doc = "!< get the current timing"] -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_CURRENT: _NV_TIMING_OVERRIDE = 0; -#[doc = "!< the timing the driver will use based the current policy"] -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_AUTO: _NV_TIMING_OVERRIDE = 1; -#[doc = "!< EDID timing"] -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_EDID: _NV_TIMING_OVERRIDE = 2; -#[doc = "!< VESA DMT timing"] -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_DMT: _NV_TIMING_OVERRIDE = 3; -#[doc = "!< VESA DMT timing with reduced blanking"] -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_DMT_RB: _NV_TIMING_OVERRIDE = 4; -#[doc = "!< VESA CVT timing"] -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_CVT: _NV_TIMING_OVERRIDE = 5; -#[doc = "!< VESA CVT timing with reduced blanking"] -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_CVT_RB: _NV_TIMING_OVERRIDE = 6; -#[doc = "!< VESA GTF timing"] -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_GTF: _NV_TIMING_OVERRIDE = 7; -#[doc = "!< EIA 861x pre-defined timing"] -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_EIA861: _NV_TIMING_OVERRIDE = 8; -#[doc = "!< analog SD/HDTV timing"] -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_ANALOG_TV: _NV_TIMING_OVERRIDE = 9; -#[doc = "!< NV custom timings"] -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_CUST: _NV_TIMING_OVERRIDE = 10; -#[doc = "!< NV pre-defined timing (basically the PsF timings)"] -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_NV_PREDEFINED: _NV_TIMING_OVERRIDE = 11; -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_NV_PSF: _NV_TIMING_OVERRIDE = 11; -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_NV_ASPR: _NV_TIMING_OVERRIDE = 12; -#[doc = "!< Override for SDI timing"] -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_SDI: _NV_TIMING_OVERRIDE = 13; -pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVRRIDE_MAX: _NV_TIMING_OVERRIDE = 14; -#[doc = "! \\ingroup dispcontrol\n! The timing override is not supported yet; must be set to _AUTO. \\n"] -pub type _NV_TIMING_OVERRIDE = ::std::os::raw::c_int; -#[doc = "! \\ingroup dispcontrol\n! The timing override is not supported yet; must be set to _AUTO. \\n"] -pub use self::_NV_TIMING_OVERRIDE as NV_TIMING_OVERRIDE; -#[doc = "! \\ingroup dispcontrol\n! NVIDIA-specific timing extras \\n\n! Used in NV_TIMING."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct tagNV_TIMINGEXT { - #[doc = "!< Reserved for NVIDIA hardware-based enhancement, such as double-scan."] - pub flag: NvU32, - #[doc = "!< Logical refresh rate to present"] - pub rr: NvU16, - #[doc = "!< Physical vertical refresh rate in 0.001Hz"] - pub rrx1k: NvU32, - #[doc = "!< Display aspect ratio Hi(aspect):horizontal-aspect, Low(aspect):vertical-aspect"] - pub aspect: NvU32, - #[doc = "!< Bit-wise pixel repetition factor: 0x1:no pixel repetition; 0x2:each pixel repeats twice horizontally,.."] - pub rep: NvU16, - #[doc = "!< Timing standard"] - pub status: NvU32, - #[doc = "!< Timing name"] - pub name: [NvU8; 40usize], -} -#[doc = "! \\ingroup dispcontrol\n! NVIDIA-specific timing extras \\n\n! Used in NV_TIMING."] -pub type NV_TIMINGEXT = tagNV_TIMINGEXT; -#[doc = "! \\ingroup dispcontrol\n!The very basic timing structure based on the VESA standard:\n! \\code\n! |<----------------------------htotal--------------------------->|\n! ---------\"active\" video-------->|<-------blanking------>|<-----\n! |<-------hvisible-------->|<-hb->|<-hfp->|<-hsw->|<-hbp->|<-hb->|\n! --------- -+-------------------------+ | | | | |\n! A A | | | | | | |\n! : : | | | | | | |\n! : : | | | | | | |\n! :vertical| addressable video | | | | | |\n! : visible| | | | | | |\n! : : | | | | | | |\n! : : | | | | | | |\n! vertical V | | | | | | |\n! total --+-------------------------+ | | | | |\n! : vb border | | | | |\n! : -----------------------------------+ | | | |\n! : vfp front porch | | | |\n! : -------------------------------------------+ | | |\n! : vsw sync width | | |\n! : ---------------------------------------------------+ | |\n! : vbp back porch | |\n! : -----------------------------------------------------------+ |\n! V vb border |\n! ---------------------------------------------------------------------------+\n! \\endcode"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_TIMING { - #[doc = "!< horizontal visible"] - pub HVisible: NvU16, - #[doc = "!< horizontal border"] - pub HBorder: NvU16, - #[doc = "!< horizontal front porch"] - pub HFrontPorch: NvU16, - #[doc = "!< horizontal sync width"] - pub HSyncWidth: NvU16, - #[doc = "!< horizontal total"] - pub HTotal: NvU16, - #[doc = "!< horizontal sync polarity: 1-negative, 0-positive"] - pub HSyncPol: NvU8, - #[doc = "!< vertical visible"] - pub VVisible: NvU16, - #[doc = "!< vertical border"] - pub VBorder: NvU16, - #[doc = "!< vertical front porch"] - pub VFrontPorch: NvU16, - #[doc = "!< vertical sync width"] - pub VSyncWidth: NvU16, - #[doc = "!< vertical total"] - pub VTotal: NvU16, - #[doc = "!< vertical sync polarity: 1-negative, 0-positive"] - pub VSyncPol: NvU8, - #[doc = "!< 1-interlaced, 0-progressive"] - pub interlaced: NvU16, - #[doc = "!< pixel clock in 10 kHz"] - pub pclk: NvU32, - pub etc: NV_TIMINGEXT, -} -#[doc = "! \\ingroup dispcontrol\n!The very basic timing structure based on the VESA standard:\n! \\code\n! |<----------------------------htotal--------------------------->|\n! ---------\"active\" video-------->|<-------blanking------>|<-----\n! |<-------hvisible-------->|<-hb->|<-hfp->|<-hsw->|<-hbp->|<-hb->|\n! --------- -+-------------------------+ | | | | |\n! A A | | | | | | |\n! : : | | | | | | |\n! : : | | | | | | |\n! :vertical| addressable video | | | | | |\n! : visible| | | | | | |\n! : : | | | | | | |\n! : : | | | | | | |\n! vertical V | | | | | | |\n! total --+-------------------------+ | | | | |\n! : vb border | | | | |\n! : -----------------------------------+ | | | |\n! : vfp front porch | | | |\n! : -------------------------------------------+ | | |\n! : vsw sync width | | |\n! : ---------------------------------------------------+ | |\n! : vbp back porch | |\n! : -----------------------------------------------------------+ |\n! V vb border |\n! ---------------------------------------------------------------------------+\n! \\endcode"] -pub type NV_TIMING = _NV_TIMING; -#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_SetView() and NvAPI_GetView()"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_VIEW_TARGET_INFO { - #[doc = "!< (IN) structure version"] - pub version: NvU32, - #[doc = "!< (IN) target count"] - pub count: NvU32, - pub target: [NV_VIEW_TARGET_INFO__bindgen_ty_1; 2usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_VIEW_TARGET_INFO__bindgen_ty_1 { - #[doc = "!< (IN/OUT) Device mask"] - pub deviceMask: NvU32, - #[doc = "!< (IN/OUT) Source ID - values will be based on the number of heads exposed per GPU."] - pub sourceId: NvU32, - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, - pub __bindgen_padding_0: [u8; 3usize], -} -impl NV_VIEW_TARGET_INFO__bindgen_ty_1 { - #[inline] - pub fn bPrimary(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bPrimary(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bPrimary_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bPrimary_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bInterlaced(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_bInterlaced(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bInterlaced_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bInterlaced_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bGDIPrimary(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_bGDIPrimary(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bGDIPrimary_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bGDIPrimary_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bForceModeSet(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_bForceModeSet(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bForceModeSet_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bForceModeSet_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bPrimary: NvU32, - bInterlaced: NvU32, - bGDIPrimary: NvU32, - bForceModeSet: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bPrimary: u32 = unsafe { ::std::mem::transmute(bPrimary) }; - bPrimary as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let bInterlaced: u32 = unsafe { ::std::mem::transmute(bInterlaced) }; - bInterlaced as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let bGDIPrimary: u32 = unsafe { ::std::mem::transmute(bGDIPrimary) }; - bGDIPrimary as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let bForceModeSet: u32 = unsafe { ::std::mem::transmute(bForceModeSet) }; - bForceModeSet as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PATH_INFO."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_DISPLAY_PATH { - #[doc = "!< (IN) Device mask"] - pub deviceMask: NvU32, - #[doc = "!< (IN) Values will be based on the number of heads exposed per GPU(0, 1?)"] - pub sourceId: NvU32, - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, - #[doc = "!< (IN) Specify connector type. For TV only."] - pub connector: NV_GPU_CONNECTOR_TYPE, - #[doc = "!< (IN) Width of the mode"] - pub width: NvU32, - #[doc = "!< (IN) Height of the mode"] - pub height: NvU32, - #[doc = "!< (IN) Depth of the mode"] - pub depth: NvU32, - #[doc = "!< Color format if it needs to be specified. Not used now."] - pub colorFormat: NV_FORMAT, - #[doc = "!< (IN) Rotation setting."] - pub rotation: NV_ROTATE, - #[doc = "!< (IN) Scaling setting"] - pub scaling: NV_SCALING, - #[doc = "!< (IN) Refresh rate of the mode"] - pub refreshRate: NvU32, - pub _bitfield_align_2: [u8; 0], - pub _bitfield_2: __BindgenBitfieldUnit<[u8; 1usize]>, - #[doc = "!< (IN) To choose the last TV format set this value to NV_DISPLAY_TV_FORMAT_NONE"] - pub tvFormat: NV_DISPLAY_TV_FORMAT, - #[doc = "!< (IN/OUT) X-offset of this display on the Windows desktop"] - pub posx: NvU32, - #[doc = "!< (IN/OUT) Y-offset of this display on the Windows desktop"] - pub posy: NvU32, - pub _bitfield_align_3: [u32; 0], - pub _bitfield_3: __BindgenBitfieldUnit<[u8; 4usize]>, -} -impl NV_DISPLAY_PATH { - #[inline] - pub fn bPrimary(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bPrimary(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bPrimary_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bPrimary_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1(bPrimary: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bPrimary: u32 = unsafe { ::std::mem::transmute(bPrimary) }; - bPrimary as u64 - }); - __bindgen_bitfield_unit - } - #[inline] - pub fn interlaced(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_interlaced(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_2.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn interlaced_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_2), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_interlaced_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_2), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_2(interlaced: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let interlaced: u32 = unsafe { ::std::mem::transmute(interlaced) }; - interlaced as u64 - }); - __bindgen_bitfield_unit - } - #[inline] - pub fn bGDIPrimary(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_3.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bGDIPrimary(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_3.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bGDIPrimary_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_3), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bGDIPrimary_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_3), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bForceModeSet(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_3.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_bForceModeSet(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_3.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bForceModeSet_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_3), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bForceModeSet_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_3), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bFocusDisplay(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_3.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_bFocusDisplay(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_3.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bFocusDisplay_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_3), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bFocusDisplay_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_3), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn gpuId(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_3.get(3usize, 24u8) as u32) } - } - #[inline] - pub fn set_gpuId(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_3.set(3usize, 24u8, val as u64) - } - } - #[inline] - pub unsafe fn gpuId_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_3), - 3usize, - 24u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_gpuId_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_3), - 3usize, - 24u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_3( - bGDIPrimary: NvU32, - bForceModeSet: NvU32, - bFocusDisplay: NvU32, - gpuId: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bGDIPrimary: u32 = unsafe { ::std::mem::transmute(bGDIPrimary) }; - bGDIPrimary as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let bForceModeSet: u32 = unsafe { ::std::mem::transmute(bForceModeSet) }; - bForceModeSet as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let bFocusDisplay: u32 = unsafe { ::std::mem::transmute(bFocusDisplay) }; - bFocusDisplay as u64 - }); - __bindgen_bitfield_unit.set(3usize, 24u8, { - let gpuId: u32 = unsafe { ::std::mem::transmute(gpuId) }; - gpuId as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_SetViewEx() and NvAPI_GetViewEx()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_DISPLAY_PATH_INFO_V3 { - #[doc = "!< (IN) Structure version"] - pub version: NvU32, - #[doc = "!< (IN) Path count"] - pub count: NvU32, - pub path: [NV_DISPLAY_PATH; 2usize], -} -#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_SetViewEx() and NvAPI_GetViewEx()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_DISPLAY_PATH_INFO { - #[doc = "!< (IN) Structure version"] - pub version: NvU32, - #[doc = "!< (IN) Path count"] - pub count: NvU32, - pub path: [NV_DISPLAY_PATH; 4usize], -} -#[doc = "\n! \\ingroup dispcontrol"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_POSITION { - pub x: NvS32, - pub y: NvS32, -} -#[doc = "\n! \\ingroup dispcontrol"] -pub type NV_POSITION = _NV_POSITION; -#[doc = "! \\ingroup dispcontrol"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_RESOLUTION { - pub width: NvU32, - pub height: NvU32, - pub colorDepth: NvU32, -} -#[doc = "! \\ingroup dispcontrol"] -pub type NV_RESOLUTION = _NV_RESOLUTION; -#[doc = "! \\ingroup dispcontrol"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO_V1 { - pub version: NvU32, - #[doc = "!< (IN) rotation setting."] - pub rotation: NV_ROTATE, - #[doc = "!< (IN) scaling setting."] - pub scaling: NV_SCALING, - #[doc = "!< (IN) Non-interlaced Refresh Rate of the mode, multiplied by 1000, 0 = ignored\n!< This is the value which driver reports to the OS."] - pub refreshRate1K: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Specify connector type. For TV only, ignored if tvFormat == NV_DISPLAY_TV_FORMAT_NONE"] - pub connector: NV_GPU_CONNECTOR_TYPE, - #[doc = "!< (IN) to choose the last TV format set this value to NV_DISPLAY_TV_FORMAT_NONE\n!< In case of NvAPI_DISP_GetDisplayConfig(), this field will indicate the currently applied TV format;\n!< if no TV format is applied, this field will have NV_DISPLAY_TV_FORMAT_NONE value.\n!< In case of NvAPI_DISP_SetDisplayConfig(), this field should only be set in case of TVs;\n!< for other displays this field will be ignored and resolution & refresh rate specified in input will be used to apply the TV format."] - pub tvFormat: NV_DISPLAY_TV_FORMAT, - #[doc = "!< Ignored if timingOverride == NV_TIMING_OVERRIDE_CURRENT"] - pub timingOverride: NV_TIMING_OVERRIDE, - #[doc = "!< Scan out timing, valid only if timingOverride == NV_TIMING_OVERRIDE_CUST\n!< The value NV_TIMING::NV_TIMINGEXT::rrx1k is obtained from the EDID. The driver may\n!< tweak this value for HDTV, stereo, etc., before reporting it to the OS."] - pub timing: NV_TIMING, -} -impl _NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO_V1 { - #[inline] - pub fn interlaced(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_interlaced(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn interlaced_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_interlaced_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn primary(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_primary(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn primary_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_primary_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reservedBit1(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_reservedBit1(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn reservedBit1_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reservedBit1_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn disableVirtualModeSupport(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_disableVirtualModeSupport(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn disableVirtualModeSupport_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_disableVirtualModeSupport_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isPreferredUnscaledTarget(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } - } - #[inline] - pub fn set_isPreferredUnscaledTarget(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isPreferredUnscaledTarget_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isPreferredUnscaledTarget_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 27u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 27u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 27u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - interlaced: NvU32, - primary: NvU32, - reservedBit1: NvU32, - disableVirtualModeSupport: NvU32, - isPreferredUnscaledTarget: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let interlaced: u32 = unsafe { ::std::mem::transmute(interlaced) }; - interlaced as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let primary: u32 = unsafe { ::std::mem::transmute(primary) }; - primary as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let reservedBit1: u32 = unsafe { ::std::mem::transmute(reservedBit1) }; - reservedBit1 as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let disableVirtualModeSupport: u32 = - unsafe { ::std::mem::transmute(disableVirtualModeSupport) }; - disableVirtualModeSupport as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let isPreferredUnscaledTarget: u32 = - unsafe { ::std::mem::transmute(isPreferredUnscaledTarget) }; - isPreferredUnscaledTarget as u64 - }); - __bindgen_bitfield_unit.set(5usize, 27u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! \\ingroup dispcontrol"] -pub type NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO_V1 = - _NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO_V1; -#[doc = "! \\ingroup dispcontrol"] -pub type NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO = NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO_V1; -#[doc = "! \\ingroup dispcontrol"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_DISPLAYCONFIG_PATH_TARGET_INFO_V1 { - #[doc = "!< Display ID"] - pub displayId: NvU32, - #[doc = "!< May be NULL if no advanced settings are required. NULL for Non-NVIDIA Display."] - pub details: *mut NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO, -} -#[doc = "! \\ingroup dispcontrol"] -pub type NV_DISPLAYCONFIG_PATH_TARGET_INFO_V1 = _NV_DISPLAYCONFIG_PATH_TARGET_INFO_V1; -#[doc = "! \\ingroup dispcontrol"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_DISPLAYCONFIG_PATH_TARGET_INFO_V2 { - #[doc = "!< Display ID"] - pub displayId: NvU32, - #[doc = "!< May be NULL if no advanced settings are required"] - pub details: *mut NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO, - #[doc = "!< Windows CCD target ID. Must be present only for non-NVIDIA adapter, for NVIDIA adapter this parameter is ignored."] - pub targetId: NvU32, -} -#[doc = "! \\ingroup dispcontrol"] -pub type NV_DISPLAYCONFIG_PATH_TARGET_INFO_V2 = _NV_DISPLAYCONFIG_PATH_TARGET_INFO_V2; -#[doc = "! \\ingroup dispcontrol\n! As version is not defined for this structure, we will be using version of NV_DISPLAYCONFIG_PATH_INFO"] -pub type NV_DISPLAYCONFIG_PATH_TARGET_INFO = NV_DISPLAYCONFIG_PATH_TARGET_INFO_V2; -pub const _NV_DISPLAYCONFIG_SPANNING_ORIENTATION_NV_DISPLAYCONFIG_SPAN_NONE: - _NV_DISPLAYCONFIG_SPANNING_ORIENTATION = 0; -pub const _NV_DISPLAYCONFIG_SPANNING_ORIENTATION_NV_DISPLAYCONFIG_SPAN_HORIZONTAL: - _NV_DISPLAYCONFIG_SPANNING_ORIENTATION = 1; -pub const _NV_DISPLAYCONFIG_SPANNING_ORIENTATION_NV_DISPLAYCONFIG_SPAN_VERTICAL: - _NV_DISPLAYCONFIG_SPANNING_ORIENTATION = 2; -#[doc = "! \\ingroup dispcontrol"] -pub type _NV_DISPLAYCONFIG_SPANNING_ORIENTATION = ::std::os::raw::c_int; -#[doc = "! \\ingroup dispcontrol"] -pub use self::_NV_DISPLAYCONFIG_SPANNING_ORIENTATION as NV_DISPLAYCONFIG_SPANNING_ORIENTATION; -#[doc = "! \\ingroup dispcontrol"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1 { - pub resolution: NV_RESOLUTION, - #[doc = "!< Ignored at present, must be NV_FORMAT_UNKNOWN (0)"] - pub colorFormat: NV_FORMAT, - #[doc = "!< Is all positions are 0 or invalid, displays will be automatically\n!< positioned from left to right with GDI Primary at 0,0, and all\n!< other displays in the order of the path array."] - pub position: NV_POSITION, - #[doc = "!< Spanning is only supported on XP"] - pub spanningOrientation: NV_DISPLAYCONFIG_SPANNING_ORIENTATION, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, -} -impl _NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1 { - #[inline] - pub fn bGDIPrimary(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bGDIPrimary(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bGDIPrimary_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bGDIPrimary_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bSLIFocus(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_bSLIFocus(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bSLIFocus_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bSLIFocus_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 30u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 30u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 30u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bGDIPrimary: NvU32, - bSLIFocus: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bGDIPrimary: u32 = unsafe { ::std::mem::transmute(bGDIPrimary) }; - bGDIPrimary as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let bSLIFocus: u32 = unsafe { ::std::mem::transmute(bSLIFocus) }; - bSLIFocus as u64 - }); - __bindgen_bitfield_unit.set(2usize, 30u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! \\ingroup dispcontrol"] -pub type NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1 = _NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1; -#[doc = "! \\ingroup dispcontrol"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_DISPLAYCONFIG_PATH_INFO_V1 { - pub version: NvU32, - #[doc = "!< This field is reserved. There is ongoing debate if we need this field.\n!< Identifies sourceIds used by Windows. If all sourceIds are 0,\n!< these will be computed automatically."] - pub reserved_sourceId: NvU32, - #[doc = "!< Number of elements in targetInfo array"] - pub targetInfoCount: NvU32, - pub targetInfo: *mut NV_DISPLAYCONFIG_PATH_TARGET_INFO_V1, - #[doc = "!< May be NULL if mode info is not important"] - pub sourceModeInfo: *mut NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1, -} -#[doc = "! \\ingroup dispcontrol"] -pub type NV_DISPLAYCONFIG_PATH_INFO_V1 = _NV_DISPLAYCONFIG_PATH_INFO_V1; -#[doc = "! \\ingroup dispcontrol"] -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_DISPLAYCONFIG_PATH_INFO { - pub version: NvU32, - pub __bindgen_anon_1: _NV_DISPLAYCONFIG_PATH_INFO__bindgen_ty_1, - #[doc = "!< Number of elements in targetInfo array"] - pub targetInfoCount: NvU32, - pub targetInfo: *mut NV_DISPLAYCONFIG_PATH_TARGET_INFO_V2, - #[doc = "!< May be NULL if mode info is not important"] - pub sourceModeInfo: *mut NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Used by Non-NVIDIA adapter for pointer to OS Adapter of LUID\n!< type, type casted to void *."] - pub pOSAdapterID: *mut ::std::os::raw::c_void, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union _NV_DISPLAYCONFIG_PATH_INFO__bindgen_ty_1 { - #[doc = "!< Identifies sourceId used by Windows CCD. This can be optionally set."] - pub sourceId: NvU32, - #[doc = "!< Only for compatibility"] - pub reserved_sourceId: NvU32, -} -impl _NV_DISPLAYCONFIG_PATH_INFO { - #[inline] - pub fn IsNonNVIDIAAdapter(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_IsNonNVIDIAAdapter(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn IsNonNVIDIAAdapter_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_IsNonNVIDIAAdapter_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - IsNonNVIDIAAdapter: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let IsNonNVIDIAAdapter: u32 = unsafe { ::std::mem::transmute(IsNonNVIDIAAdapter) }; - IsNonNVIDIAAdapter as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! \\ingroup dispcontrol"] -pub type NV_DISPLAYCONFIG_PATH_INFO_V2 = _NV_DISPLAYCONFIG_PATH_INFO; -#[doc = "! \\ingroup dispcontrol"] -pub type NV_DISPLAYCONFIG_PATH_INFO = NV_DISPLAYCONFIG_PATH_INFO_V2; -#[doc = "! \\ingroup dispcontrol"] -pub type NV_DISPLAYCONFIG_SOURCE_MODE_INFO = NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1; -pub const _NV_DISPLAYCONFIG_FLAGS_NV_DISPLAYCONFIG_VALIDATE_ONLY: _NV_DISPLAYCONFIG_FLAGS = 1; -pub const _NV_DISPLAYCONFIG_FLAGS_NV_DISPLAYCONFIG_SAVE_TO_PERSISTENCE: _NV_DISPLAYCONFIG_FLAGS = 2; -#[doc = "!< Driver reload is permitted if necessary"] -pub const _NV_DISPLAYCONFIG_FLAGS_NV_DISPLAYCONFIG_DRIVER_RELOAD_ALLOWED: _NV_DISPLAYCONFIG_FLAGS = - 4; -#[doc = "!< Refresh OS mode list."] -pub const _NV_DISPLAYCONFIG_FLAGS_NV_DISPLAYCONFIG_FORCE_MODE_ENUMERATION: _NV_DISPLAYCONFIG_FLAGS = - 8; -#[doc = "!< Tell OS to avoid optimizing CommitVidPn call during a modeset"] -pub const _NV_DISPLAYCONFIG_FLAGS_NV_FORCE_COMMIT_VIDPN: _NV_DISPLAYCONFIG_FLAGS = 16; -#[doc = "! \\ingroup dispcontrol"] -pub type _NV_DISPLAYCONFIG_FLAGS = ::std::os::raw::c_int; -#[doc = "! \\ingroup dispcontrol"] -pub use self::_NV_DISPLAYCONFIG_FLAGS as NV_DISPLAYCONFIG_FLAGS; -pub type NvAPI_UnicodeString = [NvU16; 2048usize]; -pub type NvAPI_LPCWSTR = *const NvU16; -pub const _NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID_NVAPI_GPU_PERF_VOLTAGE_INFO_DOMAIN_CORE: - _NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID = 0; -pub const _NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID_NVAPI_GPU_PERF_VOLTAGE_INFO_DOMAIN_UNDEFINED: - _NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID = 16; -#[doc = "! \\ingroup gpuclock"] -pub type _NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID = ::std::os::raw::c_int; -#[doc = "! \\ingroup gpuclock"] -pub use self::_NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID as NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID; -pub const _NV_GPU_PUBLIC_CLOCK_ID_NVAPI_GPU_PUBLIC_CLOCK_GRAPHICS: _NV_GPU_PUBLIC_CLOCK_ID = 0; -pub const _NV_GPU_PUBLIC_CLOCK_ID_NVAPI_GPU_PUBLIC_CLOCK_MEMORY: _NV_GPU_PUBLIC_CLOCK_ID = 4; -pub const _NV_GPU_PUBLIC_CLOCK_ID_NVAPI_GPU_PUBLIC_CLOCK_PROCESSOR: _NV_GPU_PUBLIC_CLOCK_ID = 7; -pub const _NV_GPU_PUBLIC_CLOCK_ID_NVAPI_GPU_PUBLIC_CLOCK_VIDEO: _NV_GPU_PUBLIC_CLOCK_ID = 8; -pub const _NV_GPU_PUBLIC_CLOCK_ID_NVAPI_GPU_PUBLIC_CLOCK_UNDEFINED: _NV_GPU_PUBLIC_CLOCK_ID = 32; -#[doc = "! \\ingroup gpuclock"] -pub type _NV_GPU_PUBLIC_CLOCK_ID = ::std::os::raw::c_int; -#[doc = "! \\ingroup gpuclock"] -pub use self::_NV_GPU_PUBLIC_CLOCK_ID as NV_GPU_PUBLIC_CLOCK_ID; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P0: _NV_GPU_PERF_PSTATE_ID = 0; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P1: _NV_GPU_PERF_PSTATE_ID = 1; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P2: _NV_GPU_PERF_PSTATE_ID = 2; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P3: _NV_GPU_PERF_PSTATE_ID = 3; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P4: _NV_GPU_PERF_PSTATE_ID = 4; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P5: _NV_GPU_PERF_PSTATE_ID = 5; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P6: _NV_GPU_PERF_PSTATE_ID = 6; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P7: _NV_GPU_PERF_PSTATE_ID = 7; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P8: _NV_GPU_PERF_PSTATE_ID = 8; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P9: _NV_GPU_PERF_PSTATE_ID = 9; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P10: _NV_GPU_PERF_PSTATE_ID = 10; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P11: _NV_GPU_PERF_PSTATE_ID = 11; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P12: _NV_GPU_PERF_PSTATE_ID = 12; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P13: _NV_GPU_PERF_PSTATE_ID = 13; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P14: _NV_GPU_PERF_PSTATE_ID = 14; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P15: _NV_GPU_PERF_PSTATE_ID = 15; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_UNDEFINED: _NV_GPU_PERF_PSTATE_ID = 16; -pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_ALL: _NV_GPU_PERF_PSTATE_ID = 17; -#[doc = "! \\addtogroup gpupstate\n! @{"] -pub type _NV_GPU_PERF_PSTATE_ID = ::std::os::raw::c_int; -#[doc = "! \\addtogroup gpupstate\n! @{"] -pub use self::_NV_GPU_PERF_PSTATE_ID as NV_GPU_PERF_PSTATE_ID; -#[doc = "! Clock domains that use single frequency value within given pstate"] -pub const NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID_NVAPI_GPU_PERF_PSTATE20_CLOCK_TYPE_SINGLE: - NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID = 0; -#[doc = "! Clock domains that allow range of frequency values within given pstate"] -pub const NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID_NVAPI_GPU_PERF_PSTATE20_CLOCK_TYPE_RANGE: - NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID = 1; -#[doc = "! Used to identify clock type"] -pub type NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID = ::std::os::raw::c_int; -#[doc = "! Used to describe both voltage and frequency deltas"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_PERF_PSTATES20_PARAM_DELTA { - #[doc = "! Value of parameter delta (in respective units [kHz, uV])"] - pub value: NvS32, - pub valueRange: NV_GPU_PERF_PSTATES20_PARAM_DELTA__bindgen_ty_1, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_PERF_PSTATES20_PARAM_DELTA__bindgen_ty_1 { - #[doc = "! Min value allowed for parameter delta (in respective units [kHz, uV])"] - pub min: NvS32, - #[doc = "! Max value allowed for parameter delta (in respective units [kHz, uV])"] - pub max: NvS32, -} -#[doc = "! Used to describe single clock entry"] -#[repr(C)] -#[derive(Copy, Clone)] -pub struct NV_GPU_PSTATE20_CLOCK_ENTRY_V1 { - #[doc = "! ID of the clock domain"] - pub domainId: NV_GPU_PUBLIC_CLOCK_ID, - #[doc = "! Clock type ID"] - pub typeId: NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "! Current frequency delta from nominal settings in (kHz)"] - pub freqDelta_kHz: NV_GPU_PERF_PSTATES20_PARAM_DELTA, - pub data: NV_GPU_PSTATE20_CLOCK_ENTRY_V1__bindgen_ty_1, -} -#[doc = "! Clock domain type dependant information"] -#[repr(C)] -#[derive(Copy, Clone)] -pub union NV_GPU_PSTATE20_CLOCK_ENTRY_V1__bindgen_ty_1 { - pub single: NV_GPU_PSTATE20_CLOCK_ENTRY_V1__bindgen_ty_1__bindgen_ty_1, - pub range: NV_GPU_PSTATE20_CLOCK_ENTRY_V1__bindgen_ty_1__bindgen_ty_2, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_PSTATE20_CLOCK_ENTRY_V1__bindgen_ty_1__bindgen_ty_1 { - #[doc = "! Clock frequency within given pstate in (kHz)"] - pub freq_kHz: NvU32, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_PSTATE20_CLOCK_ENTRY_V1__bindgen_ty_1__bindgen_ty_2 { - #[doc = "! Min clock frequency within given pstate in (kHz)"] - pub minFreq_kHz: NvU32, - #[doc = "! Max clock frequency within given pstate in (kHz)"] - pub maxFreq_kHz: NvU32, - #[doc = "! Voltage domain ID and value range in (uV) required for this clock"] - pub domainId: NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID, - pub minVoltage_uV: NvU32, - pub maxVoltage_uV: NvU32, -} -impl NV_GPU_PSTATE20_CLOCK_ENTRY_V1 { - #[inline] - pub fn bIsEditable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsEditable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsEditable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsEditable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bIsEditable: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsEditable: u32 = unsafe { ::std::mem::transmute(bIsEditable) }; - bIsEditable as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! Used to describe single base voltage entry"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY_V1 { - #[doc = "! ID of the voltage domain"] - pub domainId: NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "! Current base voltage settings in [uV]"] - pub volt_uV: NvU32, - pub voltDelta_uV: NV_GPU_PERF_PSTATES20_PARAM_DELTA, -} -impl NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY_V1 { - #[inline] - pub fn bIsEditable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsEditable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsEditable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsEditable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bIsEditable: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsEditable: u32 = unsafe { ::std::mem::transmute(bIsEditable) }; - bIsEditable as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! Used in NvAPI_GPU_GetPstates20() interface call."] -#[repr(C)] -#[derive(Copy, Clone)] -pub struct NV_GPU_PERF_PSTATES20_INFO_V1 { - #[doc = "! Version info of the structure (NV_GPU_PERF_PSTATES20_INFO_VER)"] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "! Number of populated pstates"] - pub numPstates: NvU32, - #[doc = "! Number of populated clocks (per pstate)"] - pub numClocks: NvU32, - #[doc = "! Number of populated base voltages (per pstate)"] - pub numBaseVoltages: NvU32, - pub pstates: [NV_GPU_PERF_PSTATES20_INFO_V1__bindgen_ty_1; 16usize], -} -#[doc = "! Performance state (P-State) settings\n! Valid index range is 0 to numPstates-1"] -#[repr(C)] -#[derive(Copy, Clone)] -pub struct NV_GPU_PERF_PSTATES20_INFO_V1__bindgen_ty_1 { - #[doc = "! ID of the P-State"] - pub pstateId: NV_GPU_PERF_PSTATE_ID, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "! Array of clock entries\n! Valid index range is 0 to numClocks-1"] - pub clocks: [NV_GPU_PSTATE20_CLOCK_ENTRY_V1; 8usize], - #[doc = "! Array of baseVoltage entries\n! Valid index range is 0 to numBaseVoltages-1"] - pub baseVoltages: [NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY_V1; 4usize], -} -impl NV_GPU_PERF_PSTATES20_INFO_V1__bindgen_ty_1 { - #[inline] - pub fn bIsEditable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsEditable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsEditable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsEditable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bIsEditable: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsEditable: u32 = unsafe { ::std::mem::transmute(bIsEditable) }; - bIsEditable as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -impl NV_GPU_PERF_PSTATES20_INFO_V1 { - #[inline] - pub fn bIsEditable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsEditable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsEditable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsEditable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bIsEditable: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsEditable: u32 = unsafe { ::std::mem::transmute(bIsEditable) }; - bIsEditable as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! Used in NvAPI_GPU_GetPstates20() interface call."] -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_GPU_PERF_PSTATES20_INFO_V2 { - #[doc = "! Version info of the structure (NV_GPU_PERF_PSTATES20_INFO_VER)"] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "! Number of populated pstates"] - pub numPstates: NvU32, - #[doc = "! Number of populated clocks (per pstate)"] - pub numClocks: NvU32, - #[doc = "! Number of populated base voltages (per pstate)"] - pub numBaseVoltages: NvU32, - pub pstates: [_NV_GPU_PERF_PSTATES20_INFO_V2__bindgen_ty_1; 16usize], - pub ov: _NV_GPU_PERF_PSTATES20_INFO_V2__bindgen_ty_2, -} -#[doc = "! Performance state (P-State) settings\n! Valid index range is 0 to numPstates-1"] -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_GPU_PERF_PSTATES20_INFO_V2__bindgen_ty_1 { - #[doc = "! ID of the P-State"] - pub pstateId: NV_GPU_PERF_PSTATE_ID, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "! Array of clock entries\n! Valid index range is 0 to numClocks-1"] - pub clocks: [NV_GPU_PSTATE20_CLOCK_ENTRY_V1; 8usize], - #[doc = "! Array of baseVoltage entries\n! Valid index range is 0 to numBaseVoltages-1"] - pub baseVoltages: [NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY_V1; 4usize], -} -impl _NV_GPU_PERF_PSTATES20_INFO_V2__bindgen_ty_1 { - #[inline] - pub fn bIsEditable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsEditable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsEditable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsEditable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bIsEditable: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsEditable: u32 = unsafe { ::std::mem::transmute(bIsEditable) }; - bIsEditable as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! OV settings - Please refer to NVIDIA over-volting recommendation to understand impact of this functionality\n! Valid index range is 0 to numVoltages-1"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_PERF_PSTATES20_INFO_V2__bindgen_ty_2 { - #[doc = "! Number of populated voltages"] - pub numVoltages: NvU32, - #[doc = "! Array of voltage entries\n! Valid index range is 0 to numVoltages-1"] - pub voltages: [NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY_V1; 4usize], -} -impl _NV_GPU_PERF_PSTATES20_INFO_V2 { - #[inline] - pub fn bIsEditable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsEditable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsEditable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsEditable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bIsEditable: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsEditable: u32 = unsafe { ::std::mem::transmute(bIsEditable) }; - bIsEditable as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! Used in NvAPI_GPU_GetPstates20() interface call."] -pub type NV_GPU_PERF_PSTATES20_INFO_V2 = _NV_GPU_PERF_PSTATES20_INFO_V2; -#[doc = "! Used in NvAPI_GPU_GetPstates20() interface call."] -pub type NV_GPU_PERF_PSTATES20_INFO = NV_GPU_PERF_PSTATES20_INFO_V2; -#[doc = "! \\ingroup driverapi\n! Used in NvAPI_GetDisplayDriverVersion()"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_DISPLAY_DRIVER_VERSION { - pub version: NvU32, - pub drvVersion: NvU32, - pub bldChangeListNum: NvU32, - pub szBuildBranchString: NvAPI_ShortString, - pub szAdapterString: NvAPI_ShortString, -} -pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_UNINITIALIZED: NV_MONITOR_CONN_TYPE = 0; -pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_VGA: NV_MONITOR_CONN_TYPE = 1; -pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_COMPONENT: NV_MONITOR_CONN_TYPE = 2; -pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_SVIDEO: NV_MONITOR_CONN_TYPE = 3; -pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_HDMI: NV_MONITOR_CONN_TYPE = 4; -pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_DVI: NV_MONITOR_CONN_TYPE = 5; -pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_LVDS: NV_MONITOR_CONN_TYPE = 6; -pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_DP: NV_MONITOR_CONN_TYPE = 7; -pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_COMPOSITE: NV_MONITOR_CONN_TYPE = 8; -pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_UNKNOWN: NV_MONITOR_CONN_TYPE = -1; -#[doc = "! \\ingroup gpu"] -pub type NV_MONITOR_CONN_TYPE = ::std::os::raw::c_int; -#[doc = "! \\ingroup gpu"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_DISPLAYIDS { - pub version: NvU32, - #[doc = "!< out: vga, tv, dvi, hdmi and dp. This is reserved for future use and clients should not rely on this information. Instead get the\n!< GPU connector type from NvAPI_GPU_GetConnectorInfo/NvAPI_GPU_GetConnectorInfoEx"] - pub connectorType: NV_MONITOR_CONN_TYPE, - #[doc = "!< this is a unique identifier for each device"] - pub displayId: NvU32, - pub _bitfield_align_1: [u16; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, -} -impl _NV_GPU_DISPLAYIDS { - #[inline] - pub fn isDynamic(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isDynamic(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isDynamic_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isDynamic_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMultiStreamRootNode(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMultiStreamRootNode(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMultiStreamRootNode_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMultiStreamRootNode_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isActive(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_isActive(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isActive_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isActive_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isCluster(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_isCluster(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isCluster_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isCluster_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isOSVisible(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } - } - #[inline] - pub fn set_isOSVisible(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isOSVisible_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isOSVisible_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isWFD(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } - } - #[inline] - pub fn set_isWFD(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isWFD_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isWFD_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isConnected(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } - } - #[inline] - pub fn set_isConnected(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(6usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isConnected_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 6usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isConnected_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 6usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reservedInternal(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 10u8) as u32) } - } - #[inline] - pub fn set_reservedInternal(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(7usize, 10u8, val as u64) - } - } - #[inline] - pub unsafe fn reservedInternal_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 7usize, - 10u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reservedInternal_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 7usize, - 10u8, - val as u64, - ) - } - } - #[inline] - pub fn isPhysicallyConnected(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) } - } - #[inline] - pub fn set_isPhysicallyConnected(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(17usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isPhysicallyConnected_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 17usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isPhysicallyConnected_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 17usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 14u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(18usize, 14u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 18usize, - 14u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 18usize, - 14u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isDynamic: NvU32, - isMultiStreamRootNode: NvU32, - isActive: NvU32, - isCluster: NvU32, - isOSVisible: NvU32, - isWFD: NvU32, - isConnected: NvU32, - reservedInternal: NvU32, - isPhysicallyConnected: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isDynamic: u32 = unsafe { ::std::mem::transmute(isDynamic) }; - isDynamic as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let isMultiStreamRootNode: u32 = - unsafe { ::std::mem::transmute(isMultiStreamRootNode) }; - isMultiStreamRootNode as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let isActive: u32 = unsafe { ::std::mem::transmute(isActive) }; - isActive as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let isCluster: u32 = unsafe { ::std::mem::transmute(isCluster) }; - isCluster as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let isOSVisible: u32 = unsafe { ::std::mem::transmute(isOSVisible) }; - isOSVisible as u64 - }); - __bindgen_bitfield_unit.set(5usize, 1u8, { - let isWFD: u32 = unsafe { ::std::mem::transmute(isWFD) }; - isWFD as u64 - }); - __bindgen_bitfield_unit.set(6usize, 1u8, { - let isConnected: u32 = unsafe { ::std::mem::transmute(isConnected) }; - isConnected as u64 - }); - __bindgen_bitfield_unit.set(7usize, 10u8, { - let reservedInternal: u32 = unsafe { ::std::mem::transmute(reservedInternal) }; - reservedInternal as u64 - }); - __bindgen_bitfield_unit.set(17usize, 1u8, { - let isPhysicallyConnected: u32 = - unsafe { ::std::mem::transmute(isPhysicallyConnected) }; - isPhysicallyConnected as u64 - }); - __bindgen_bitfield_unit.set(18usize, 14u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! \\ingroup gpu"] -pub type NV_GPU_DISPLAYIDS = _NV_GPU_DISPLAYIDS; -pub const NV_SYSTEM_TYPE_NV_SYSTEM_TYPE_UNKNOWN: NV_SYSTEM_TYPE = 0; -pub const NV_SYSTEM_TYPE_NV_SYSTEM_TYPE_LAPTOP: NV_SYSTEM_TYPE = 1; -pub const NV_SYSTEM_TYPE_NV_SYSTEM_TYPE_DESKTOP: NV_SYSTEM_TYPE = 2; -#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetSystemType()"] -pub type NV_SYSTEM_TYPE = ::std::os::raw::c_int; -pub const _NV_GPU_OUTPUT_TYPE_NVAPI_GPU_OUTPUT_UNKNOWN: _NV_GPU_OUTPUT_TYPE = 0; -#[doc = "!< CRT display device"] -pub const _NV_GPU_OUTPUT_TYPE_NVAPI_GPU_OUTPUT_CRT: _NV_GPU_OUTPUT_TYPE = 1; -#[doc = "!< Digital Flat Panel display device"] -pub const _NV_GPU_OUTPUT_TYPE_NVAPI_GPU_OUTPUT_DFP: _NV_GPU_OUTPUT_TYPE = 2; -#[doc = "!< TV display device"] -pub const _NV_GPU_OUTPUT_TYPE_NVAPI_GPU_OUTPUT_TV: _NV_GPU_OUTPUT_TYPE = 3; -#[doc = "! \\ingroup gpu\n! used in NvAPI_GPU_GetOutputType()"] -pub type _NV_GPU_OUTPUT_TYPE = ::std::os::raw::c_int; -#[doc = "! \\ingroup gpu\n! used in NvAPI_GPU_GetOutputType()"] -pub use self::_NV_GPU_OUTPUT_TYPE as NV_GPU_OUTPUT_TYPE; -pub const _NV_GPU_TYPE_NV_SYSTEM_TYPE_GPU_UNKNOWN: _NV_GPU_TYPE = 0; -#[doc = "!< Integrated GPU"] -pub const _NV_GPU_TYPE_NV_SYSTEM_TYPE_IGPU: _NV_GPU_TYPE = 1; -#[doc = "!< Discrete GPU"] -pub const _NV_GPU_TYPE_NV_SYSTEM_TYPE_DGPU: _NV_GPU_TYPE = 2; -#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetGPUType()."] -pub type _NV_GPU_TYPE = ::std::os::raw::c_int; -#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetGPUType()."] -pub use self::_NV_GPU_TYPE as NV_GPU_TYPE; -pub const _NV_GPU_BUS_TYPE_NVAPI_GPU_BUS_TYPE_UNDEFINED: _NV_GPU_BUS_TYPE = 0; -pub const _NV_GPU_BUS_TYPE_NVAPI_GPU_BUS_TYPE_PCI: _NV_GPU_BUS_TYPE = 1; -pub const _NV_GPU_BUS_TYPE_NVAPI_GPU_BUS_TYPE_AGP: _NV_GPU_BUS_TYPE = 2; -pub const _NV_GPU_BUS_TYPE_NVAPI_GPU_BUS_TYPE_PCI_EXPRESS: _NV_GPU_BUS_TYPE = 3; -pub const _NV_GPU_BUS_TYPE_NVAPI_GPU_BUS_TYPE_FPCI: _NV_GPU_BUS_TYPE = 4; -pub const _NV_GPU_BUS_TYPE_NVAPI_GPU_BUS_TYPE_AXI: _NV_GPU_BUS_TYPE = 5; -#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetBusType()"] -pub type _NV_GPU_BUS_TYPE = ::std::os::raw::c_int; -#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetBusType()"] -pub use self::_NV_GPU_BUS_TYPE as NV_GPU_BUS_TYPE; -#[doc = "! \\ingroup gpu"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_BOARD_INFO { - #[doc = "!< structure version"] - pub version: NvU32, - #[doc = "!< Board Serial Number"] - pub BoardNum: [NvU8; 16usize], -} -#[doc = "! \\ingroup gpu"] -pub type NV_BOARD_INFO_V1 = _NV_BOARD_INFO; -#[doc = "! \\ingroup gpu"] -pub type NV_BOARD_INFO = NV_BOARD_INFO_V1; -#[doc = "! Used in NvAPI_GPU_GetArchInfo()"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_ARCH_INFO_V1 { - pub version: NvU32, - pub architecture: NvU32, - pub implementation: NvU32, - pub revision: NvU32, -} -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_T2X: _NV_GPU_ARCHITECTURE_ID = -536870880; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_T3X: _NV_GPU_ARCHITECTURE_ID = -536870864; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_T4X: _NV_GPU_ARCHITECTURE_ID = -536870848; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_T12X: _NV_GPU_ARCHITECTURE_ID = -536870848; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_NV40: _NV_GPU_ARCHITECTURE_ID = 64; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_NV50: _NV_GPU_ARCHITECTURE_ID = 80; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_G78: _NV_GPU_ARCHITECTURE_ID = 96; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_G80: _NV_GPU_ARCHITECTURE_ID = 128; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_G90: _NV_GPU_ARCHITECTURE_ID = 144; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GT200: _NV_GPU_ARCHITECTURE_ID = 160; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GF100: _NV_GPU_ARCHITECTURE_ID = 192; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GF110: _NV_GPU_ARCHITECTURE_ID = 208; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GK100: _NV_GPU_ARCHITECTURE_ID = 224; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GK110: _NV_GPU_ARCHITECTURE_ID = 240; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GK200: _NV_GPU_ARCHITECTURE_ID = 256; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GM000: _NV_GPU_ARCHITECTURE_ID = 272; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GM200: _NV_GPU_ARCHITECTURE_ID = 288; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GP100: _NV_GPU_ARCHITECTURE_ID = 304; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GV100: _NV_GPU_ARCHITECTURE_ID = 320; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GV110: _NV_GPU_ARCHITECTURE_ID = 336; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_TU100: _NV_GPU_ARCHITECTURE_ID = 352; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GA100: _NV_GPU_ARCHITECTURE_ID = 368; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_AD100: _NV_GPU_ARCHITECTURE_ID = 400; -pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GB200: _NV_GPU_ARCHITECTURE_ID = 432; -#[doc = "! NV_GPU_ARCH_INFO() values to identify Architecture level for the GPU."] -pub type _NV_GPU_ARCHITECTURE_ID = ::std::os::raw::c_int; -#[doc = "! NV_GPU_ARCH_INFO() values to identify Architecture level for the GPU."] -pub use self::_NV_GPU_ARCHITECTURE_ID as NV_GPU_ARCHITECTURE_ID; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_T20: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_T30: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_T35: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 5; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_T40: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_T124: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV40: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV41: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 1; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV42: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV43: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 3; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV44: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV44A: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 10; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV46: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV47: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 7; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV49: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 9; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV4B: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 11; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV4C: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 12; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV4E: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 14; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV50: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV63: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 3; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV67: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 7; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_G84: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_G86: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_G92: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_G94: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_G96: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_G98: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 8; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT200: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT212: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT214: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT215: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 3; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT216: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 5; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT218: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 8; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_MCP77: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 10; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT21C: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 11; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_MCP79: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 12; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT21A: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 13; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_MCP89: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 15; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF100: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF104: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF106: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 3; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF108: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 1; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF110: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF116: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF117: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 7; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF118: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 8; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF119: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 9; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GK104: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GK106: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GK107: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 7; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GK20A: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 10; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GK110: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GK208: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 8; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GM204: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GM206: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP100: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP000: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 1; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP102: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP104: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP106: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP107: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 7; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP108: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 8; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GV100: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GV10B: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 11; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU100: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU102: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU104: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU106: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU116: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 8; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU117: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 7; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU000: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 1; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GA100: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GA102: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GA104: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_AD102: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_AD103: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 3; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_AD104: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; -pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GB202: - _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; -#[doc = "! NV_GPU_ARCH_INFO() values to identify GPU Architecture Implementation."] -pub type _NV_GPU_ARCH_IMPLEMENTATION_ID = ::std::os::raw::c_int; -#[doc = "! NV_GPU_ARCH_INFO() values to identify GPU Architecture Implementation."] -pub use self::_NV_GPU_ARCH_IMPLEMENTATION_ID as NV_GPU_ARCH_IMPLEMENTATION_ID; -#[doc = "!< QT chip"] -pub const _NV_GPU_CHIP_REVISION_NV_GPU_CHIP_REV_EMULATION_QT: _NV_GPU_CHIP_REVISION = 0; -#[doc = "!< FPGA implementation of the chipset"] -pub const _NV_GPU_CHIP_REVISION_NV_GPU_CHIP_REV_EMULATION_FPGA: _NV_GPU_CHIP_REVISION = 1; -#[doc = "!< First silicon chipset revision"] -pub const _NV_GPU_CHIP_REVISION_NV_GPU_CHIP_REV_A01: _NV_GPU_CHIP_REVISION = 17; -#[doc = "!< Second Silicon chipset revision"] -pub const _NV_GPU_CHIP_REVISION_NV_GPU_CHIP_REV_A02: _NV_GPU_CHIP_REVISION = 18; -#[doc = "!< Third Silicon chipset revision"] -pub const _NV_GPU_CHIP_REVISION_NV_GPU_CHIP_REV_A03: _NV_GPU_CHIP_REVISION = 19; -#[doc = "!< Unknown chip revision"] -pub const _NV_GPU_CHIP_REVISION_NV_GPU_CHIP_REV_UNKNOWN: _NV_GPU_CHIP_REVISION = -1; -pub type _NV_GPU_CHIP_REVISION = ::std::os::raw::c_int; -pub use self::_NV_GPU_CHIP_REVISION as NV_GPU_CHIP_REVISION; -#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetArchInfo()"] -#[repr(C)] -#[derive(Copy, Clone)] -pub struct NV_GPU_ARCH_INFO_V2 { - pub version: NvU32, - pub __bindgen_anon_1: NV_GPU_ARCH_INFO_V2__bindgen_ty_1, - pub __bindgen_anon_2: NV_GPU_ARCH_INFO_V2__bindgen_ty_2, - pub __bindgen_anon_3: NV_GPU_ARCH_INFO_V2__bindgen_ty_3, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union NV_GPU_ARCH_INFO_V2__bindgen_ty_1 { - #[doc = "!< architecture and architecture_id are the same. The former is NvU32 while the latter is an enum made for readability."] - pub architecture: NvU32, - #[doc = "!< specifies the architecture level for the GPU."] - pub architecture_id: NV_GPU_ARCHITECTURE_ID, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union NV_GPU_ARCH_INFO_V2__bindgen_ty_2 { - #[doc = "!< implementation and implementation_id are the same. The former is NvU32 while the latter is an enum made for readability."] - pub implementation: NvU32, - #[doc = "!< specifies the implementation of the architecture for the GPU."] - pub implementation_id: NV_GPU_ARCH_IMPLEMENTATION_ID, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union NV_GPU_ARCH_INFO_V2__bindgen_ty_3 { - #[doc = "!< revision and revision_id are the same. The former is NvU32 while the latter is an enum made for readability."] - pub revision: NvU32, - #[doc = "!< specifies the architecture revision of the GPU."] - pub revision_id: NV_GPU_CHIP_REVISION, -} -#[doc = "! \\ingroup gpu"] -pub type NV_GPU_ARCH_INFO = NV_GPU_ARCH_INFO_V2; -#[doc = "!< Set i2cSpeedKhz to I2C_SPEED_DEFAULT if default I2C speed is to be chosen, ie.use the current frequency setting."] -pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_DEFAULT: NV_I2C_SPEED = 0; -pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_3KHZ: NV_I2C_SPEED = 1; -pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_10KHZ: NV_I2C_SPEED = 2; -pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_33KHZ: NV_I2C_SPEED = 3; -pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_100KHZ: NV_I2C_SPEED = 4; -pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_200KHZ: NV_I2C_SPEED = 5; -pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_400KHZ: NV_I2C_SPEED = 6; -pub type NV_I2C_SPEED = ::std::os::raw::c_int; -#[doc = "! Used in NvAPI_I2CRead() and NvAPI_I2CWrite()"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_I2C_INFO_V1 { - #[doc = "!< The structure version."] - pub version: NvU32, - #[doc = "!< The Display Mask of the concerned display."] - pub displayMask: NvU32, - #[doc = "!< This flag indicates either the DDC port (TRUE) or the communication port\n!< (FALSE) of the concerned display."] - pub bIsDDCPort: NvU8, - #[doc = "!< The address of the I2C slave. The address should be shifted left by one. For\n!< example, the I2C address 0x50, often used for reading EDIDs, would be stored\n!< here as 0xA0. This matches the position within the byte sent by the master, as\n!< the last bit is reserved to specify the read or write direction."] - pub i2cDevAddress: NvU8, - #[doc = "!< The I2C target register address. May be NULL, which indicates no register\n!< address should be sent."] - pub pbI2cRegAddress: *mut NvU8, - #[doc = "!< The size in bytes of target register address. If pbI2cRegAddress is NULL, this\n!< field must be 0."] - pub regAddrSize: NvU32, - #[doc = "!< The buffer of data which is to be read or written (depending on the command)."] - pub pbData: *mut NvU8, - #[doc = "!< The size of the data buffer, pbData, to be read or written."] - pub cbSize: NvU32, - #[doc = "!< The target speed of the transaction (between 28Kbps to 40Kbps; not guaranteed)."] - pub i2cSpeed: NvU32, -} -#[doc = "! Used in NvAPI_I2CRead() and NvAPI_I2CWrite()"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_I2C_INFO_V2 { - #[doc = "!< The structure version."] - pub version: NvU32, - #[doc = "!< The Display Mask of the concerned display."] - pub displayMask: NvU32, - #[doc = "!< This flag indicates either the DDC port (TRUE) or the communication port\n!< (FALSE) of the concerned display."] - pub bIsDDCPort: NvU8, - #[doc = "!< The address of the I2C slave. The address should be shifted left by one. For\n!< example, the I2C address 0x50, often used for reading EDIDs, would be stored\n!< here as 0xA0. This matches the position within the byte sent by the master, as\n!< the last bit is reserved to specify the read or write direction."] - pub i2cDevAddress: NvU8, - #[doc = "!< The I2C target register address. May be NULL, which indicates no register\n!< address should be sent."] - pub pbI2cRegAddress: *mut NvU8, - #[doc = "!< The size in bytes of target register address. If pbI2cRegAddress is NULL, this\n!< field must be 0."] - pub regAddrSize: NvU32, - #[doc = "!< The buffer of data which is to be read or written (depending on the command)."] - pub pbData: *mut NvU8, - #[doc = "!< The size of the data buffer, pbData, to be read or written."] - pub cbSize: NvU32, - #[doc = "!< Deprecated, Must be set to NVAPI_I2C_SPEED_DEPRECATED."] - pub i2cSpeed: NvU32, - #[doc = "!< The target speed of the transaction in (kHz) (Chosen from the enum NV_I2C_SPEED)."] - pub i2cSpeedKhz: NV_I2C_SPEED, -} -#[doc = "! Used in NvAPI_I2CRead() and NvAPI_I2CWrite()"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_I2C_INFO_V3 { - #[doc = "!< The structure version."] - pub version: NvU32, - #[doc = "!< The Display Mask of the concerned display."] - pub displayMask: NvU32, - #[doc = "!< This flag indicates either the DDC port (TRUE) or the communication port\n!< (FALSE) of the concerned display."] - pub bIsDDCPort: NvU8, - #[doc = "!< The address of the I2C slave. The address should be shifted left by one. For\n!< example, the I2C address 0x50, often used for reading EDIDs, would be stored\n!< here as 0xA0. This matches the position within the byte sent by the master, as\n!< the last bit is reserved to specify the read or write direction."] - pub i2cDevAddress: NvU8, - #[doc = "!< The I2C target register address. May be NULL, which indicates no register\n!< address should be sent."] - pub pbI2cRegAddress: *mut NvU8, - #[doc = "!< The size in bytes of target register address. If pbI2cRegAddress is NULL, this\n!< field must be 0."] - pub regAddrSize: NvU32, - #[doc = "!< The buffer of data which is to be read or written (depending on the command)."] - pub pbData: *mut NvU8, - #[doc = "!< The size of the data buffer, pbData, to be read or written."] - pub cbSize: NvU32, - #[doc = "!< Deprecated, Must be set to NVAPI_I2C_SPEED_DEPRECATED."] - pub i2cSpeed: NvU32, - #[doc = "!< The target speed of the transaction in (kHz) (Chosen from the enum NV_I2C_SPEED)."] - pub i2cSpeedKhz: NV_I2C_SPEED, - #[doc = "!< The portid on which device is connected (remember to set bIsPortIdSet if this value is set)\n!< Optional for pre-Kepler"] - pub portId: NvU8, - #[doc = "!< set this flag on if and only if portid value is set"] - pub bIsPortIdSet: NvU32, -} -#[doc = "! Used in NvAPI_I2CRead() and NvAPI_I2CWrite()"] -pub type NV_I2C_INFO = NV_I2C_INFO_V3; -pub const _NV_GPU_HDCP_FUSE_STATE_NV_GPU_HDCP_FUSE_STATE_UNKNOWN: _NV_GPU_HDCP_FUSE_STATE = 0; -pub const _NV_GPU_HDCP_FUSE_STATE_NV_GPU_HDCP_FUSE_STATE_DISABLED: _NV_GPU_HDCP_FUSE_STATE = 1; -pub const _NV_GPU_HDCP_FUSE_STATE_NV_GPU_HDCP_FUSE_STATE_ENABLED: _NV_GPU_HDCP_FUSE_STATE = 2; -#[doc = "! HDCP fuse states - used in NV_GPU_GET_HDCP_SUPPORT_STATUS"] -pub type _NV_GPU_HDCP_FUSE_STATE = ::std::os::raw::c_int; -#[doc = "! HDCP fuse states - used in NV_GPU_GET_HDCP_SUPPORT_STATUS"] -pub use self::_NV_GPU_HDCP_FUSE_STATE as NV_GPU_HDCP_FUSE_STATE; -pub const _NV_GPU_HDCP_KEY_SOURCE_NV_GPU_HDCP_KEY_SOURCE_UNKNOWN: _NV_GPU_HDCP_KEY_SOURCE = 0; -pub const _NV_GPU_HDCP_KEY_SOURCE_NV_GPU_HDCP_KEY_SOURCE_NONE: _NV_GPU_HDCP_KEY_SOURCE = 1; -pub const _NV_GPU_HDCP_KEY_SOURCE_NV_GPU_HDCP_KEY_SOURCE_CRYPTO_ROM: _NV_GPU_HDCP_KEY_SOURCE = 2; -pub const _NV_GPU_HDCP_KEY_SOURCE_NV_GPU_HDCP_KEY_SOURCE_SBIOS: _NV_GPU_HDCP_KEY_SOURCE = 3; -pub const _NV_GPU_HDCP_KEY_SOURCE_NV_GPU_HDCP_KEY_SOURCE_I2C_ROM: _NV_GPU_HDCP_KEY_SOURCE = 4; -pub const _NV_GPU_HDCP_KEY_SOURCE_NV_GPU_HDCP_KEY_SOURCE_FUSES: _NV_GPU_HDCP_KEY_SOURCE = 5; -#[doc = "! HDCP key sources - used in NV_GPU_GET_HDCP_SUPPORT_STATUS"] -pub type _NV_GPU_HDCP_KEY_SOURCE = ::std::os::raw::c_int; -#[doc = "! HDCP key sources - used in NV_GPU_GET_HDCP_SUPPORT_STATUS"] -pub use self::_NV_GPU_HDCP_KEY_SOURCE as NV_GPU_HDCP_KEY_SOURCE; -pub const _NV_GPU_HDCP_KEY_SOURCE_STATE_NV_GPU_HDCP_KEY_SOURCE_STATE_UNKNOWN: - _NV_GPU_HDCP_KEY_SOURCE_STATE = 0; -pub const _NV_GPU_HDCP_KEY_SOURCE_STATE_NV_GPU_HDCP_KEY_SOURCE_STATE_ABSENT: - _NV_GPU_HDCP_KEY_SOURCE_STATE = 1; -pub const _NV_GPU_HDCP_KEY_SOURCE_STATE_NV_GPU_HDCP_KEY_SOURCE_STATE_PRESENT: - _NV_GPU_HDCP_KEY_SOURCE_STATE = 2; -#[doc = "! HDCP key source states - used in NV_GPU_GET_HDCP_SUPPORT_STATUS"] -pub type _NV_GPU_HDCP_KEY_SOURCE_STATE = ::std::os::raw::c_int; -#[doc = "! HDCP key source states - used in NV_GPU_GET_HDCP_SUPPORT_STATUS"] -pub use self::_NV_GPU_HDCP_KEY_SOURCE_STATE as NV_GPU_HDCP_KEY_SOURCE_STATE; -#[doc = "! HDPC support status - used in NvAPI_GPU_GetHDCPSupportStatus()"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_GET_HDCP_SUPPORT_STATUS { - pub version: NvU32, - #[doc = "! Structure version constucted by macro #NV_GPU_GET_HDCP_SUPPORT_STATUS"] - pub hdcpFuseState: NV_GPU_HDCP_FUSE_STATE, - #[doc = "! GPU's HDCP fuse state"] - pub hdcpKeySource: NV_GPU_HDCP_KEY_SOURCE, - #[doc = "! GPU's HDCP key source"] - pub hdcpKeySourceState: NV_GPU_HDCP_KEY_SOURCE_STATE, -} -#[doc = "! @}"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_COMPUTE_GPU_TOPOLOGY_V1 { - #[doc = "!< Structure version"] - pub version: NvU32, - #[doc = "!< Total number of compute-capable GPUs"] - pub gpuCount: NvU32, - #[doc = "!< Array of compute-capable physical GPUs."] - pub computeGpus: [NV_COMPUTE_GPU_TOPOLOGY_V1__bindgen_ty_1; 8usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_COMPUTE_GPU_TOPOLOGY_V1__bindgen_ty_1 { - #[doc = "!< Compute-capable physical GPU handle"] - pub hPhysicalGpu: NvPhysicalGpuHandle, - #[doc = "!< One or more flags from \\ref nvcomp_gpu_top"] - pub flags: NvU32, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_COMPUTE_GPU { - #[doc = "!< Compute-capable physical GPU handle"] - pub hPhysicalGpu: NvPhysicalGpuHandle, - #[doc = "!< One or more flags from \\ref nvcomp_gpu_top"] - pub flags: NvU32, -} -pub type NV_COMPUTE_GPU = _NV_COMPUTE_GPU; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_COMPUTE_GPU_TOPOLOGY_V2 { - #[doc = "!< Structure version"] - pub version: NvU32, - #[doc = "!< Size of array"] - pub gpuCount: NvU32, - #[doc = "!< Array of compute-capable physical GPUs (allocate memory of size of Physical gpuCount of system)."] - pub computeGpus: *mut NV_COMPUTE_GPU, -} -pub type NV_COMPUTE_GPU_TOPOLOGY_V2 = _NV_COMPUTE_GPU_TOPOLOGY_V2; -pub type NV_COMPUTE_GPU_TOPOLOGY = NV_COMPUTE_GPU_TOPOLOGY_V2; -pub const _NV_ECC_CONFIGURATION_NV_ECC_CONFIGURATION_NOT_SUPPORTED: _NV_ECC_CONFIGURATION = 0; -#[doc = "!< Changes require a POST to take effect"] -pub const _NV_ECC_CONFIGURATION_NV_ECC_CONFIGURATION_DEFERRED: _NV_ECC_CONFIGURATION = 1; -#[doc = "!< Changes can optionally be made to take effect immediately"] -pub const _NV_ECC_CONFIGURATION_NV_ECC_CONFIGURATION_IMMEDIATE: _NV_ECC_CONFIGURATION = 2; -#[doc = "! \\addtogroup gpuecc\n! Used in NV_GPU_ECC_STATUS_INFO."] -pub type _NV_ECC_CONFIGURATION = ::std::os::raw::c_int; -#[doc = "! \\addtogroup gpuecc\n! Used in NV_GPU_ECC_STATUS_INFO."] -pub use self::_NV_ECC_CONFIGURATION as NV_ECC_CONFIGURATION; -#[doc = "! \\ingroup gpuecc\n! Used in NvAPI_GPU_GetECCStatusInfo()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_ECC_STATUS_INFO { - #[doc = "!< Structure version"] - pub version: NvU32, - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, - #[doc = "!< Supported ECC memory feature configuration options"] - pub configurationOptions: NV_ECC_CONFIGURATION, - pub _bitfield_align_2: [u8; 0], - pub _bitfield_2: __BindgenBitfieldUnit<[u8; 1usize]>, - pub __bindgen_padding_0: [u8; 3usize], -} -impl NV_GPU_ECC_STATUS_INFO { - #[inline] - pub fn isSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1(isSupported: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isSupported: u32 = unsafe { ::std::mem::transmute(isSupported) }; - isSupported as u64 - }); - __bindgen_bitfield_unit - } - #[inline] - pub fn isEnabled(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isEnabled(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_2.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isEnabled_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_2), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isEnabled_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_2), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_2(isEnabled: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isEnabled: u32 = unsafe { ::std::mem::transmute(isEnabled) }; - isEnabled as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! \\ingroup gpuecc\n! Used in NvAPI_GPU_GetECCErrorInfo()/"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_ECC_ERROR_INFO { - #[doc = "!< Structure version"] - pub version: NvU32, - pub current: NV_GPU_ECC_ERROR_INFO__bindgen_ty_1, - pub aggregate: NV_GPU_ECC_ERROR_INFO__bindgen_ty_2, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_ECC_ERROR_INFO__bindgen_ty_1 { - #[doc = "!< Number of single-bit ECC errors detected since last boot"] - pub singleBitErrors: NvU64, - #[doc = "!< Number of double-bit ECC errors detected since last boot"] - pub doubleBitErrors: NvU64, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_ECC_ERROR_INFO__bindgen_ty_2 { - #[doc = "!< Number of single-bit ECC errors detected since last counter reset"] - pub singleBitErrors: NvU64, - #[doc = "!< Number of double-bit ECC errors detected since last counter reset"] - pub doubleBitErrors: NvU64, -} -#[doc = "! \\ingroup gpuecc\n! Used in NvAPI_GPU_GetECCConfigurationInfo()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_ECC_CONFIGURATION_INFO { - pub version: NvU32, - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, - pub __bindgen_padding_0: [u8; 3usize], -} -impl NV_GPU_ECC_CONFIGURATION_INFO { - #[inline] - pub fn isEnabled(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isEnabled(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isEnabled_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isEnabled_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isEnabledByDefault(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_isEnabledByDefault(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isEnabledByDefault_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isEnabledByDefault_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isEnabled: NvU32, - isEnabledByDefault: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isEnabled: u32 = unsafe { ::std::mem::transmute(isEnabled) }; - isEnabled as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let isEnabledByDefault: u32 = unsafe { ::std::mem::transmute(isEnabledByDefault) }; - isEnabledByDefault as u64 - }); - __bindgen_bitfield_unit - } -} -pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_NONE: NV_QSYNC_EVENT = 0; -pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_SYNC_LOSS: NV_QSYNC_EVENT = 1; -pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_SYNC_GAIN: NV_QSYNC_EVENT = 2; -pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_HOUSESYNC_GAIN: NV_QSYNC_EVENT = 3; -pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_HOUSESYNC_LOSS: NV_QSYNC_EVENT = 4; -pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_RJ45_GAIN: NV_QSYNC_EVENT = 5; -pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_RJ45_LOSS: NV_QSYNC_EVENT = 6; -pub type NV_QSYNC_EVENT = ::std::os::raw::c_int; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_QSYNC_EVENT_DATA { - pub qsyncEvent: NV_QSYNC_EVENT, - pub reserved: [NvU32; 7usize], -} -#[doc = "! Callback for QSYNC event"] -pub type NVAPI_CALLBACK_QSYNCEVENT = ::std::option::Option< - unsafe extern "C" fn( - qyncEventData: NV_QSYNC_EVENT_DATA, - callbackParam: *mut ::std::os::raw::c_void, - ), ->; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_DISPLAY_OUTPUT_MODE_CHANGE_EVENT_DATA { - #[doc = "!< displayId of the display"] - pub displayId: NvU32, - #[doc = "!< display output mode"] - pub outputMode: NvU32, -} -pub type NV_DISPLAY_OUTPUT_MODE_CHANGE_EVENT_DATA = _NV_DISPLAY_OUTPUT_MODE_CHANGE_EVENT_DATA; -#[doc = "! Callback for Display Output Mode change events"] -pub type NVAPI_CALLBACK_DISPLAY_OUTPUT_MODE_CHANGE_EVENT = ::std::option::Option< - unsafe extern "C" fn( - pEventData: *mut NV_DISPLAY_OUTPUT_MODE_CHANGE_EVENT_DATA, - callbackParam: *mut ::std::os::raw::c_void, - ), ->; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_DISPLAY_COLORIMETRY_CHANGE_EVENT_DATA { - #[doc = "!< displayId of the monitor"] - pub displayId: NvU32, - #[doc = "!< min luminance, cd/m^2"] - pub min_luminance: f32, - #[doc = "!< max 100% frame luminance, cd/m^2"] - pub max_full_frame_luminance: f32, - #[doc = "!< max 10% frame luminance, cd/m^2"] - pub max_luminance: f32, - #[doc = "!< HDR brightness luminance scaling factor applied by GPU on output pixels"] - pub hdrBrightnessLuminanceScalingFactor: f32, - #[doc = "!< red primary chromaticity coordinate x"] - pub red_primary_x: f32, - #[doc = "!< red primary chromaticity coordinate y"] - pub red_primary_y: f32, - #[doc = "!< green primary chromaticity coordinate x"] - pub green_primary_x: f32, - #[doc = "!< green primary chromaticity coordinate y"] - pub green_primary_y: f32, - #[doc = "!< blue primary chromaticity coordinate x"] - pub blue_primary_x: f32, - #[doc = "!< blue primary chromaticity coordinate y"] - pub blue_primary_y: f32, - #[doc = "!< white point chromaticity coordinate x"] - pub white_point_x: f32, - #[doc = "!< white point chromaticity coordinate y"] - pub white_point_y: f32, -} -pub type NV_DISPLAY_COLORIMETRY_CHANGE_EVENT_DATA = _NV_DISPLAY_COLORIMETRY_CHANGE_EVENT_DATA; -#[doc = "! Callback for Display Colorimetry change events"] -pub type NVAPI_CALLBACK_DISPLAY_COLORIMETRY_CHANGE_EVENT = ::std::option::Option< - unsafe extern "C" fn( - pEventData: *mut NV_DISPLAY_COLORIMETRY_CHANGE_EVENT_DATA, - callbackParam: *mut ::std::os::raw::c_void, - ), ->; -pub const NV_EVENT_TYPE_NV_EVENT_TYPE_NONE: NV_EVENT_TYPE = 0; -pub const NV_EVENT_TYPE_NV_EVENT_TYPE_QSYNC: NV_EVENT_TYPE = 6; -pub const NV_EVENT_TYPE_NV_EVENT_TYPE_DISPLAY_OUTPUT_MODE_CHANGE: NV_EVENT_TYPE = 103; -pub const NV_EVENT_TYPE_NV_EVENT_TYPE_DISPLAY_COLORIMETRY_CHANGE: NV_EVENT_TYPE = 104; -#[doc = "! Enum for Event IDs"] -pub type NV_EVENT_TYPE = ::std::os::raw::c_int; -#[doc = "! Core NV_EVENT_REGISTER_CALLBACK structure declaration"] -#[repr(C)] -#[derive(Copy, Clone)] -pub struct NV_EVENT_REGISTER_CALLBACK { - #[doc = "!< version field to ensure minimum version compatibility"] - pub version: NvU32, - #[doc = "!< ID of the event being sent"] - pub eventId: NV_EVENT_TYPE, - #[doc = "!< This value will be passed back to the callback function when an event occurs"] - pub callbackParam: *mut ::std::os::raw::c_void, - pub nvCallBackFunc: NV_EVENT_REGISTER_CALLBACK__bindgen_ty_1, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union NV_EVENT_REGISTER_CALLBACK__bindgen_ty_1 { - #[doc = "!< Callback function pointer for QSYNC events"] - pub nvQSYNCEventCallback: NVAPI_CALLBACK_QSYNCEVENT, - #[doc = "!< Callback function pointer for Display Output Mode change events"] - pub nvDisplayOutputModeChangeEventCallback: NVAPI_CALLBACK_DISPLAY_OUTPUT_MODE_CHANGE_EVENT, - #[doc = "!< Callback function pointer for Display Colorimetry change events"] - pub nvDisplayColorimetryChangeEventCallback: NVAPI_CALLBACK_DISPLAY_COLORIMETRY_CHANGE_EVENT, -} -#[doc = "!< NVIDIA RTX VR Ready"] -pub const _NV_GPU_WORKSTATION_FEATURE_TYPE_NV_GPU_WORKSTATION_FEATURE_TYPE_NVIDIA_RTX_VR_READY: - _NV_GPU_WORKSTATION_FEATURE_TYPE = 1; -#[doc = "!< DEPRECATED name - do not use"] -pub const _NV_GPU_WORKSTATION_FEATURE_TYPE_NV_GPU_WORKSTATION_FEATURE_TYPE_QUADRO_VR_READY: - _NV_GPU_WORKSTATION_FEATURE_TYPE = 1; -pub const _NV_GPU_WORKSTATION_FEATURE_TYPE_NV_GPU_WORKSTATION_FEATURE_TYPE_PROVIZ: - _NV_GPU_WORKSTATION_FEATURE_TYPE = 2; -#[doc = "! \\ingroup gpu"] -pub type _NV_GPU_WORKSTATION_FEATURE_TYPE = ::std::os::raw::c_int; -#[doc = "! \\ingroup gpu"] -pub use self::_NV_GPU_WORKSTATION_FEATURE_TYPE as NV_GPU_WORKSTATION_FEATURE_TYPE; -#[doc = "! \\ingroup gpu"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_SCANOUT_INTENSITY_DATA_V1 { - #[doc = "!< version of this structure"] - pub version: NvU32, - #[doc = "!< width of the input texture"] - pub width: NvU32, - #[doc = "!< height of the input texture"] - pub height: NvU32, - #[doc = "!< array of floating values building an intensity RGB texture"] - pub blendingTexture: *mut f32, -} -#[doc = "! \\ingroup gpu"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_SCANOUT_INTENSITY_DATA_V2 { - #[doc = "!< version of this structure"] - pub version: NvU32, - #[doc = "!< width of the input texture"] - pub width: NvU32, - #[doc = "!< height of the input texture"] - pub height: NvU32, - #[doc = "!< array of floating values building an intensity RGB texture"] - pub blendingTexture: *mut f32, - #[doc = "!< array of floating values building an offset texture"] - pub offsetTexture: *mut f32, - #[doc = "!< number of channels per pixel in the offset texture"] - pub offsetTexChannels: NvU32, -} -#[doc = "! \\ingroup gpu"] -pub type NV_SCANOUT_INTENSITY_DATA = NV_SCANOUT_INTENSITY_DATA_V2; -#[doc = "! \\ingroup gpu"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_SCANOUT_INTENSITY_STATE_DATA { - #[doc = "!< version of this structure"] - pub version: NvU32, - #[doc = "!< intensity is enabled or not"] - pub bEnabled: NvU32, -} -#[doc = "! \\ingroup gpu"] -pub type NV_SCANOUT_INTENSITY_STATE_DATA = _NV_SCANOUT_INTENSITY_STATE_DATA; -pub const NV_GPU_WARPING_VERTICE_FORMAT_NV_GPU_WARPING_VERTICE_FORMAT_TRIANGLESTRIP_XYUVRQ: - NV_GPU_WARPING_VERTICE_FORMAT = 0; -pub const NV_GPU_WARPING_VERTICE_FORMAT_NV_GPU_WARPING_VERTICE_FORMAT_TRIANGLES_XYUVRQ: - NV_GPU_WARPING_VERTICE_FORMAT = 1; -#[doc = "! \\ingroup gpu"] -pub type NV_GPU_WARPING_VERTICE_FORMAT = ::std::os::raw::c_int; -#[doc = "! \\ingroup gpu"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_SCANOUT_WARPING_DATA { - #[doc = "!< version of this structure"] - pub version: NvU32, - #[doc = "!< width of the input texture"] - pub vertices: *mut f32, - #[doc = "!< format of the input vertices"] - pub vertexFormat: NV_GPU_WARPING_VERTICE_FORMAT, - #[doc = "!< number of the input vertices"] - pub numVertices: ::std::os::raw::c_int, - #[doc = "!< rectangle in desktop coordinates describing the source area for the warping"] - pub textureRect: *mut NvSBox, -} -#[doc = "! \\ingroup gpu"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_SCANOUT_WARPING_STATE_DATA { - #[doc = "!< version of this structure"] - pub version: NvU32, - #[doc = "!< warping is enabled or not"] - pub bEnabled: NvU32, -} -#[doc = "! \\ingroup gpu"] -pub type NV_SCANOUT_WARPING_STATE_DATA = _NV_SCANOUT_WARPING_STATE_DATA; -pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_WARPING_RESAMPLING_METHOD : NV_GPU_SCANOUT_COMPOSITION_PARAMETER = 0 ; -pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_SCANOUT_INTENSITY_METHOD : NV_GPU_SCANOUT_COMPOSITION_PARAMETER = 1 ; -pub type NV_GPU_SCANOUT_COMPOSITION_PARAMETER = ::std::os::raw::c_int; -pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_SET_TO_DEFAULT : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 0 ; -pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BILINEAR : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 256 ; -pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_TRIANGULAR : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 257 ; -pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_BELL_SHAPED : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 258 ; -pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_BSPLINE : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 259 ; -pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_ADAPTIVE_TRIANGULAR : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 260 ; -pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_ADAPTIVE_BELL_SHAPED : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 261 ; -pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_ADAPTIVE_BSPLINE : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 262 ; -pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_SCANOUT_INTENSITY_NO_GAMMA : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 512 ; -pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_SCANOUT_INTENSITY_COLOR_GAMMA : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 513 ; -pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_SCANOUT_INTENSITY_COLOR_AND_OFFSET_GAMMA : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 514 ; -#[doc = "! This enum defines a collection of scanout composition values that can be used to configure\n! the supported scanout composition settings"] -pub type NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = ::std::os::raw::c_int; -#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetScanoutConfigurationEx()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_SCANOUT_INFORMATION { - #[doc = "!< Structure version, needs to be initialized with NV_SCANOUT_INFORMATION_VER."] - pub version: NvU32, - #[doc = "!< Operating system display device rect in desktop coordinates displayId is scanning out from."] - pub sourceDesktopRect: NvSBox, - #[doc = "!< Area inside the sourceDesktopRect which is scanned out to the display."] - pub sourceViewportRect: NvSBox, - #[doc = "!< Area inside the rect described by targetDisplayWidth/Height sourceViewportRect is scanned out to."] - pub targetViewportRect: NvSBox, - #[doc = "!< Horizontal size of the active resolution scanned out to the display."] - pub targetDisplayWidth: NvU32, - #[doc = "!< Vertical size of the active resolution scanned out to the display."] - pub targetDisplayHeight: NvU32, - #[doc = "!< If targets are cloned views of the sourceDesktopRect the cloned targets have an importance assigned (0:primary,1 secondary,...)."] - pub cloneImportance: NvU32, - #[doc = "!< Rotation performed between the sourceViewportRect and the targetViewportRect."] - pub sourceToTargetRotation: NV_ROTATE, -} -#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetScanoutConfigurationEx()."] -pub type NV_SCANOUT_INFORMATION = _NV_SCANOUT_INFORMATION; -#[doc = "!< Represents Bare Metal GPU"] -pub const _NV_VIRTUALIZATION_MODE_NV_VIRTUALIZATION_MODE_NONE: _NV_VIRTUALIZATION_MODE = 0; -#[doc = "!< Represents GPU-Passthrough"] -pub const _NV_VIRTUALIZATION_MODE_NV_VIRTUALIZATION_MODE_NMOS: _NV_VIRTUALIZATION_MODE = 1; -#[doc = "!< Represents vGPU inside virtual machine"] -pub const _NV_VIRTUALIZATION_MODE_NV_VIRTUALIZATION_MODE_VGX: _NV_VIRTUALIZATION_MODE = 2; -#[doc = "!< Represents VGX hypervisor in vGPU mode"] -pub const _NV_VIRTUALIZATION_MODE_NV_VIRTUALIZATION_MODE_HOST_VGPU: _NV_VIRTUALIZATION_MODE = 3; -#[doc = "! \\ingroup gpu"] -pub type _NV_VIRTUALIZATION_MODE = ::std::os::raw::c_int; -#[doc = "! \\ingroup gpu"] -pub use self::_NV_VIRTUALIZATION_MODE as NV_VIRTUALIZATION_MODE; -#[doc = "! \\ingroup gpu"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_VIRTUALIZATION_INFO { - #[doc = "!< Structure version"] - pub version: NvU32, - #[doc = "!< one of NV_VIRTUALIZATION_MODE."] - pub virtualizationMode: NV_VIRTUALIZATION_MODE, - #[doc = "!< reserved for future use. Should be set to ZERO."] - pub reserved: NvU32, -} -#[doc = "! \\ingroup gpu"] -pub type NV_GPU_VIRTUALIZATION_INFO_V1 = _NV_GPU_VIRTUALIZATION_INFO; -#[doc = "! \\ingroup gpu"] -pub type NV_GPU_VIRTUALIZATION_INFO = NV_GPU_VIRTUALIZATION_INFO_V1; -#[doc = "! \\ingroup gpu"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LOGICAL_GPU_DATA_V1 { - #[doc = "!< [in] Structure version."] - pub version: NvU32, - #[doc = "!< [out] Returns OS-AdapterId. User must send memory buffer of size atleast equal to the size of LUID structure before calling the NVAPI."] - pub pOSAdapterId: *mut ::std::os::raw::c_void, - #[doc = "!< [out] Number of physical GPU handles associated with the specified logical GPU handle."] - pub physicalGpuCount: NvU32, - #[doc = "!< [out] This array will be filled with physical GPU handles associated with the given logical GPU handle.\n!< The array index refers to the Physical Gpu Index (Idx).\n!< Idx value is the same as D3D11 MultiGPUDevice GPU index, D3D12 node index, OpenGL GL_NV_gpu_multicast GPU index.\n!< When converted to a bit mask (1 << Idx), it matches:\n!< 1. Vulkan deviceNodeMask in VkPhysicalDeviceIDProperties\n!< 2. CUDA deviceNodeMask returned by cuDeviceGetLuid"] - pub physicalGpuHandles: [NvPhysicalGpuHandle; 64usize], - #[doc = "!< Reserved for future use. Should be set to ZERO."] - pub reserved: [NvU32; 8usize], -} -#[doc = "! \\ingroup gpu"] -pub type NV_LOGICAL_GPU_DATA_V1 = _NV_LOGICAL_GPU_DATA_V1; -#[doc = "! \\ingroup gpu"] -pub type NV_LOGICAL_GPU_DATA = NV_LOGICAL_GPU_DATA_V1; -#[doc = "! License string"] -pub type NvAPI_LicenseString = [::std::os::raw::c_char; 128usize]; -pub const _NV_LICENSE_FEATURE_TYPE_NV_LICENSE_FEATURE_UNKNOWN: _NV_LICENSE_FEATURE_TYPE = 0; -pub const _NV_LICENSE_FEATURE_TYPE_NV_LICENSE_FEATURE_VGPU: _NV_LICENSE_FEATURE_TYPE = 1; -pub const _NV_LICENSE_FEATURE_TYPE_NV_LICENSE_FEATURE_NVIDIA_RTX: _NV_LICENSE_FEATURE_TYPE = 2; -#[doc = "!< DEPRECATED name - do not use"] -pub const _NV_LICENSE_FEATURE_TYPE_NV_LICENSE_FEATURE_QUADRO: _NV_LICENSE_FEATURE_TYPE = 2; -pub const _NV_LICENSE_FEATURE_TYPE_NV_LICENSE_FEATURE_GAMING: _NV_LICENSE_FEATURE_TYPE = 3; -pub const _NV_LICENSE_FEATURE_TYPE_NV_LICENSE_FEATURE_COMPUTE: _NV_LICENSE_FEATURE_TYPE = 4; -#[doc = "! Used in NV_LICENSE_FEATURE_DETAILS"] -pub type _NV_LICENSE_FEATURE_TYPE = ::std::os::raw::c_int; -#[doc = "! Used in NV_LICENSE_FEATURE_DETAILS"] -pub use self::_NV_LICENSE_FEATURE_TYPE as NV_LICENSE_FEATURE_TYPE; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LICENSE_EXPIRY_DETAILS { - #[doc = "!< Year value of license expiry"] - pub year: NvU32, - #[doc = "!< Month value of license expiry"] - pub month: NvU16, - #[doc = "!< Day value of license expiry"] - pub day: NvU16, - #[doc = "!< Hour value of license expiry"] - pub hour: NvU16, - #[doc = "!< Minutes value of license expiry"] - pub min: NvU16, - #[doc = "!< Seconds value of license expiry"] - pub sec: NvU16, - #[doc = "!< License expiry status"] - pub status: NvU8, -} -pub type NV_LICENSE_EXPIRY_DETAILS = _NV_LICENSE_EXPIRY_DETAILS; -#[doc = "! Used in NV_LICENSABLE_FEATURES"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LICENSE_FEATURE_DETAILS_V1 { - #[doc = "!< IN - Structure version."] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Feature code that corresponds to the licensable feature."] - pub featureCode: NV_LICENSE_FEATURE_TYPE, - #[doc = "!< Deprecated"] - pub licenseInfo: NvAPI_LicenseString, -} -impl _NV_LICENSE_FEATURE_DETAILS_V1 { - #[inline] - pub fn isEnabled(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isEnabled(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isEnabled_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isEnabled_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isEnabled: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isEnabled: u32 = unsafe { ::std::mem::transmute(isEnabled) }; - isEnabled as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! Used in NV_LICENSABLE_FEATURES"] -pub type NV_LICENSE_FEATURE_DETAILS_V1 = _NV_LICENSE_FEATURE_DETAILS_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LICENSE_FEATURE_DETAILS_V2 { - #[doc = "!< Unused."] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Feature code that corresponds to the licensable feature."] - pub featureCode: NV_LICENSE_FEATURE_TYPE, - #[doc = "!< Deprecated"] - pub licenseInfo: NvAPI_LicenseString, - #[doc = "!< Nvidia Grid licensable product name."] - pub productName: NvAPI_LicenseString, -} -impl _NV_LICENSE_FEATURE_DETAILS_V2 { - #[inline] - pub fn isEnabled(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isEnabled(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isEnabled_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isEnabled_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isEnabled: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isEnabled: u32 = unsafe { ::std::mem::transmute(isEnabled) }; - isEnabled as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_LICENSE_FEATURE_DETAILS_V2 = _NV_LICENSE_FEATURE_DETAILS_V2; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LICENSE_FEATURE_DETAILS_V3 { - #[doc = "!< Unused."] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Feature code that corresponds to the licensable feature."] - pub featureCode: NV_LICENSE_FEATURE_TYPE, - #[doc = "!< Deprecated"] - pub licenseInfo: NvAPI_LicenseString, - #[doc = "!< Nvidia Grid licensable product name."] - pub productName: NvAPI_LicenseString, -} -impl _NV_LICENSE_FEATURE_DETAILS_V3 { - #[inline] - pub fn isEnabled(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isEnabled(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isEnabled_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isEnabled_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isFeatureEnabled(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_isFeatureEnabled(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isFeatureEnabled_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isFeatureEnabled_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 30u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 30u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 30u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isEnabled: NvU32, - isFeatureEnabled: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isEnabled: u32 = unsafe { ::std::mem::transmute(isEnabled) }; - isEnabled as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let isFeatureEnabled: u32 = unsafe { ::std::mem::transmute(isFeatureEnabled) }; - isFeatureEnabled as u64 - }); - __bindgen_bitfield_unit.set(2usize, 30u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_LICENSE_FEATURE_DETAILS_V3 = _NV_LICENSE_FEATURE_DETAILS_V3; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LICENSE_FEATURE_DETAILS_V4 { - #[doc = "!< Unused."] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Feature code that corresponds to the licensable feature."] - pub featureCode: NV_LICENSE_FEATURE_TYPE, - #[doc = "!< Deprecated"] - pub licenseInfo: NvAPI_LicenseString, - #[doc = "!< Nvidia Grid licensable product name."] - pub productName: NvAPI_LicenseString, - #[doc = "!< License expiry information."] - pub licenseExpiry: NV_LICENSE_EXPIRY_DETAILS, -} -impl _NV_LICENSE_FEATURE_DETAILS_V4 { - #[inline] - pub fn isEnabled(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isEnabled(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isEnabled_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isEnabled_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isFeatureEnabled(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_isFeatureEnabled(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isFeatureEnabled_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isFeatureEnabled_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 30u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 30u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 30u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isEnabled: NvU32, - isFeatureEnabled: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isEnabled: u32 = unsafe { ::std::mem::transmute(isEnabled) }; - isEnabled as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let isFeatureEnabled: u32 = unsafe { ::std::mem::transmute(isFeatureEnabled) }; - isFeatureEnabled as u64 - }); - __bindgen_bitfield_unit.set(2usize, 30u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_LICENSE_FEATURE_DETAILS_V4 = _NV_LICENSE_FEATURE_DETAILS_V4; -#[doc = "! Used in NV_LICENSABLE_FEATURES"] -pub type NV_LICENSE_FEATURE_DETAILS = NV_LICENSE_FEATURE_DETAILS_V1; -#[doc = "! Licensable features"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LICENSABLE_FEATURES_V1 { - #[doc = "!< IN - Structure version."] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< The number of licensable features."] - pub licensableFeatureCount: NvU32, - #[doc = "!< Dynamic signature required for Authentication of the components,\n!< signature length limited to NV_LICENSE_SIGNATURE_SIZE"] - pub signature: [NvU8; 128usize], - #[doc = "!< Array of licensable features"] - pub licenseDetails: [NV_LICENSE_FEATURE_DETAILS_V1; 3usize], -} -impl _NV_LICENSABLE_FEATURES_V1 { - #[inline] - pub fn isLicenseSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isLicenseSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isLicenseSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isLicenseSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isLicenseSupported: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isLicenseSupported: u32 = unsafe { ::std::mem::transmute(isLicenseSupported) }; - isLicenseSupported as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! Licensable features"] -pub type NV_LICENSABLE_FEATURES_V1 = _NV_LICENSABLE_FEATURES_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LICENSABLE_FEATURES_V2 { - #[doc = "!< IN - Structure version."] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< The number of licensable features."] - pub licensableFeatureCount: NvU32, - #[doc = "!< Dynamic signature required for Authentication of the components,\n!< signature length limited to NV_LICENSE_SIGNATURE_SIZE"] - pub signature: [NvU8; 128usize], - #[doc = "!< Array of licensable features"] - pub licenseDetails: [NV_LICENSE_FEATURE_DETAILS_V2; 3usize], -} -impl _NV_LICENSABLE_FEATURES_V2 { - #[inline] - pub fn isLicenseSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isLicenseSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isLicenseSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isLicenseSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isLicenseSupported: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isLicenseSupported: u32 = unsafe { ::std::mem::transmute(isLicenseSupported) }; - isLicenseSupported as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_LICENSABLE_FEATURES_V2 = _NV_LICENSABLE_FEATURES_V2; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LICENSABLE_FEATURES_V3 { - #[doc = "!< IN - Structure version."] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< The number of licensable features."] - pub licensableFeatureCount: NvU32, - #[doc = "!< Dynamic signature required for Authentication of the components,\n!< signature length limited to NV_LICENSE_SIGNATURE_SIZE"] - pub signature: [NvU8; 128usize], - #[doc = "!< Array of licensable features"] - pub licenseDetails: [NV_LICENSE_FEATURE_DETAILS_V3; 3usize], -} -impl _NV_LICENSABLE_FEATURES_V3 { - #[inline] - pub fn isLicenseSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isLicenseSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isLicenseSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isLicenseSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isLicenseSupported: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isLicenseSupported: u32 = unsafe { ::std::mem::transmute(isLicenseSupported) }; - isLicenseSupported as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_LICENSABLE_FEATURES_V3 = _NV_LICENSABLE_FEATURES_V3; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LICENSABLE_FEATURES_V4 { - #[doc = "!< IN - Structure version."] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< The number of licensable features."] - pub licensableFeatureCount: NvU32, - #[doc = "!< Dynamic signature required for Authentication of the components,\n!< signature length limited to NV_LICENSE_SIGNATURE_SIZE"] - pub signature: [NvU8; 128usize], - #[doc = "!< Array of licensable features"] - pub licenseDetails: [NV_LICENSE_FEATURE_DETAILS_V4; 3usize], -} -impl _NV_LICENSABLE_FEATURES_V4 { - #[inline] - pub fn isLicenseSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isLicenseSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isLicenseSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isLicenseSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isLicenseSupported: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isLicenseSupported: u32 = unsafe { ::std::mem::transmute(isLicenseSupported) }; - isLicenseSupported as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_LICENSABLE_FEATURES_V4 = _NV_LICENSABLE_FEATURES_V4; -pub type NV_LICENSABLE_FEATURES = NV_LICENSABLE_FEATURES_V4; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_ENCODER_STATISTICS_V1 { - #[doc = "!< [in] Structure version value."] - pub version: NvU32, - #[doc = "!< [out] Count of active encoder sessions."] - pub sessionsCount: NvU32, - #[doc = "!< [out] Trailing average FPS of all active sessions."] - pub averageFps: NvU32, - #[doc = "!< [out] Encode latency in microseconds."] - pub averageLatency: NvU32, -} -pub type NV_ENCODER_STATISTICS_V1 = _NV_ENCODER_STATISTICS_V1; -pub type NV_ENCODER_STATISTICS = NV_ENCODER_STATISTICS_V1; -pub const _NV_ENCODER_TYPE_NV_ENCODER_H264: _NV_ENCODER_TYPE = 0; -pub const _NV_ENCODER_TYPE_NV_ENCODER_HEVC: _NV_ENCODER_TYPE = 1; -pub const _NV_ENCODER_TYPE_NV_ENCODER_UNKNOWN: _NV_ENCODER_TYPE = -1; -pub type _NV_ENCODER_TYPE = ::std::os::raw::c_int; -pub use self::_NV_ENCODER_TYPE as NV_ENCODER_TYPE; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_ENCODER_PER_SESSION_INFO_V1 { - #[doc = "!< Unique session ID."] - pub sessionId: NvU32, - #[doc = "!< Owning process ID."] - pub processId: NvU32, - #[doc = "!< Owning vGPU instance ID (only valid on vGPU hosts, otherwise zero)."] - pub vgpuInstance: NvU32, - #[doc = "!< Video encoder type."] - pub codecType: NV_ENCODER_TYPE, - #[doc = "!< Current encode horizontal resolution."] - pub hResolution: NvU32, - #[doc = "!< Current encode vertical resolution."] - pub vResolution: NvU32, - #[doc = "!< Moving average encode frames per second."] - pub averageEncodeFps: NvU32, - #[doc = "!< Moving average encode latency in microseconds."] - pub averageEncodeLatency: NvU32, -} -pub type NV_ENCODER_PER_SESSION_INFO_V1 = _NV_ENCODER_PER_SESSION_INFO_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_ENCODER_SESSIONS_INFO_V1 { - #[doc = "!< [in] Structure version value."] - pub version: NvU32, - #[doc = "!< [out] Count of active encoder sessions."] - pub sessionsCount: NvU32, - #[doc = "!< [out] Array of session info. Caller should allocate memory for this field before making\n!< the NvAPI_GPU_GetEncoderSessionsInfo() call, memory allocated should be of\n!< size = sizeof(NV_ENCODER_PER_SESSION_INFO_V1) * NV_ENCODER_SESSION_INFO_MAX_ENTRIES_V1."] - pub pSessionInfo: *mut NV_ENCODER_PER_SESSION_INFO_V1, -} -pub type NV_ENCODER_SESSIONS_INFO_V1 = _NV_ENCODER_SESSIONS_INFO_V1; -pub type NV_ENCODER_SESSIONS_INFO = NV_ENCODER_SESSIONS_INFO_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_INFO_V1 { - #[doc = "!< Structure Version."] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, -} -impl _NV_GPU_INFO_V1 { - #[inline] - pub fn bIsExternalGpu(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsExternalGpu(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsExternalGpu_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsExternalGpu_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bIsExternalGpu: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsExternalGpu: u32 = unsafe { ::std::mem::transmute(bIsExternalGpu) }; - bIsExternalGpu as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_GPU_INFO_V1 = _NV_GPU_INFO_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_INFO_V2 { - #[doc = "!< Structure Version."] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Reserved for future use"] - pub reserved1: NvU64, - #[doc = "!< Number of \"Ray Tracing Cores\" supported by the GPU."] - pub rayTracingCores: NvU32, - #[doc = "!< Number of \"Tensor Cores\" supported by the GPU."] - pub tensorCores: NvU32, - #[doc = "!< Reserved for future use."] - pub reserved2: [NvU32; 14usize], -} -impl _NV_GPU_INFO_V2 { - #[inline] - pub fn bIsExternalGpu(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsExternalGpu(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsExternalGpu_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsExternalGpu_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved0(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved0(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved0_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved0_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bIsExternalGpu: NvU32, - reserved0: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsExternalGpu: u32 = unsafe { ::std::mem::transmute(bIsExternalGpu) }; - bIsExternalGpu as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved0: u32 = unsafe { ::std::mem::transmute(reserved0) }; - reserved0 as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_GPU_INFO_V2 = _NV_GPU_INFO_V2; -pub type NV_GPU_INFO = NV_GPU_INFO_V2; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_VR_READY_V1 { - #[doc = "!< Structure Version."] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, -} -impl _NV_GPU_VR_READY_V1 { - #[inline] - pub fn isVRReady(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isVRReady(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isVRReady_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isVRReady_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isVRReady: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isVRReady: u32 = unsafe { ::std::mem::transmute(isVRReady) }; - isVRReady as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_GPU_VR_READY_V1 = _NV_GPU_VR_READY_V1; -pub type NV_GPU_VR_READY = NV_GPU_VR_READY_V1; -pub const _NV_ADAPTER_TYPE_NV_ADAPTER_TYPE_UNKNOWN: _NV_ADAPTER_TYPE = 0; -pub const _NV_ADAPTER_TYPE_NV_ADAPTER_TYPE_WDDM: _NV_ADAPTER_TYPE = 1; -pub const _NV_ADAPTER_TYPE_NV_ADAPTER_TYPE_MCDM: _NV_ADAPTER_TYPE = 2; -pub const _NV_ADAPTER_TYPE_NV_ADAPTER_TYPE_TCC: _NV_ADAPTER_TYPE = 4; -pub const _NV_ADAPTER_TYPE_NV_ADAPTER_TYPE_LAST: _NV_ADAPTER_TYPE = -1; -pub type _NV_ADAPTER_TYPE = ::std::os::raw::c_int; -pub use self::_NV_ADAPTER_TYPE as NV_ADAPTER_TYPE; -#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetGspFeatures()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_GSP_INFO_V1 { - #[doc = "!< [in] Structure version"] - pub version: NvU32, - #[doc = "!< [out] Contains GSP firmware version"] - pub firmwareVersion: [NvU8; 64usize], - #[doc = "!< Reserved for future use"] - pub reserved: NvU32, -} -#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetGspFeatures()."] -pub type NV_GPU_GSP_INFO_V1 = _NV_GPU_GSP_INFO_V1; -#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetGspFeatures()."] -pub type NV_GPU_GSP_INFO = NV_GPU_GSP_INFO_V1; -#[doc = "! \\fn NvAPI_GPU_GetUUID(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_UUID *pGpuUuid)\n! DESCRIPTION: This function returns the GPU UUID for the specified physical GPU handle.\n! The UUID is returned in GUID format (16 bytes).\n!\n! SUPPORTED OS: Windows 10 and higher\n!\n!\n! TCC_SUPPORTED\n!\n! MCDM_SUPPORTED\n!\n! \\since Release: 595\n!\n! \\param [in] hPhysicalGpu Physical GPU handle to get UUID for\n! \\param [in,out] pGpuUuid Pointer to structure that will receive the GPU UUID\n!\n! \\retval NVAPI_OK Request completed successfully\n! \\return This API can return any of the error codes enumerated in #NvAPI_Status.\n!\n! \\ingroup gpu\n\n! Used in NvAPI_GPU_GetUUID()"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_UUID_V1 { - pub version: NvU32, - pub uuid: [NvU8; 16usize], -} -#[doc = "! \\fn NvAPI_GPU_GetUUID(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_UUID *pGpuUuid)\n! DESCRIPTION: This function returns the GPU UUID for the specified physical GPU handle.\n! The UUID is returned in GUID format (16 bytes).\n!\n! SUPPORTED OS: Windows 10 and higher\n!\n!\n! TCC_SUPPORTED\n!\n! MCDM_SUPPORTED\n!\n! \\since Release: 595\n!\n! \\param [in] hPhysicalGpu Physical GPU handle to get UUID for\n! \\param [in,out] pGpuUuid Pointer to structure that will receive the GPU UUID\n!\n! \\retval NVAPI_OK Request completed successfully\n! \\return This API can return any of the error codes enumerated in #NvAPI_Status.\n!\n! \\ingroup gpu\n\n! Used in NvAPI_GPU_GetUUID()"] -pub type NV_GPU_UUID_V1 = _NV_GPU_UUID_V1; -#[doc = "! \\fn NvAPI_GPU_GetUUID(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_UUID *pGpuUuid)\n! DESCRIPTION: This function returns the GPU UUID for the specified physical GPU handle.\n! The UUID is returned in GUID format (16 bytes).\n!\n! SUPPORTED OS: Windows 10 and higher\n!\n!\n! TCC_SUPPORTED\n!\n! MCDM_SUPPORTED\n!\n! \\since Release: 595\n!\n! \\param [in] hPhysicalGpu Physical GPU handle to get UUID for\n! \\param [in,out] pGpuUuid Pointer to structure that will receive the GPU UUID\n!\n! \\retval NVAPI_OK Request completed successfully\n! \\return This API can return any of the error codes enumerated in #NvAPI_Status.\n!\n! \\ingroup gpu\n\n! Used in NvAPI_GPU_GetUUID()"] -pub type NV_GPU_UUID = NV_GPU_UUID_V1; -#[doc = "! \\ingroup gpupstate\n! Used in NvAPI_GPU_GetPstatesInfoEx()"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_PERF_PSTATES_INFO_V1 { - pub version: NvU32, - #[doc = "!< - bit 0 indicates if perfmon is enabled or not\n!< - bit 1 indicates if dynamic Pstate is capable or not\n!< - bit 2 indicates if dynamic Pstate is enable or not\n!< - all other bits must be set to 0"] - pub flags: NvU32, - #[doc = "!< The number of available p-states"] - pub numPstates: NvU32, - #[doc = "!< The number of clock domains supported by each P-State"] - pub numClocks: NvU32, - pub pstates: [NV_GPU_PERF_PSTATES_INFO_V1__bindgen_ty_1; 16usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_PERF_PSTATES_INFO_V1__bindgen_ty_1 { - #[doc = "!< ID of the p-state."] - pub pstateId: NV_GPU_PERF_PSTATE_ID, - #[doc = "!< - bit 0 indicates if the PCIE limit is GEN1 or GEN2\n!< - bit 1 indicates if the Pstate is overclocked or not\n!< - bit 2 indicates if the Pstate is overclockable or not\n!< - all other bits must be set to 0"] - pub flags: NvU32, - pub clocks: [NV_GPU_PERF_PSTATES_INFO_V1__bindgen_ty_1__bindgen_ty_1; 32usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_PERF_PSTATES_INFO_V1__bindgen_ty_1__bindgen_ty_1 { - #[doc = "!< ID of the clock domain"] - pub domainId: NV_GPU_PUBLIC_CLOCK_ID, - #[doc = "!< Reserved. Must be set to 0"] - pub flags: NvU32, - #[doc = "!< Clock frequency in kHz"] - pub freq: NvU32, -} -#[doc = "! \\ingroup gpupstate"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_PERF_PSTATES_INFO_V2 { - pub version: NvU32, - #[doc = "!< - bit 0 indicates if perfmon is enabled or not\n!< - bit 1 indicates if dynamic Pstate is capable or not\n!< - bit 2 indicates if dynamic Pstate is enable or not\n!< - all other bits must be set to 0"] - pub flags: NvU32, - #[doc = "!< The number of available p-states"] - pub numPstates: NvU32, - #[doc = "!< The number of clock domains supported by each P-State"] - pub numClocks: NvU32, - pub numVoltages: NvU32, - #[doc = "!< Valid index range is 0 to numVoltages-1"] - pub pstates: [NV_GPU_PERF_PSTATES_INFO_V2__bindgen_ty_1; 16usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_PERF_PSTATES_INFO_V2__bindgen_ty_1 { - #[doc = "!< ID of the p-state."] - pub pstateId: NV_GPU_PERF_PSTATE_ID, - #[doc = "!< - bit 0 indicates if the PCIE limit is GEN1 or GEN2\n!< - bit 1 indicates if the Pstate is overclocked or not\n!< - bit 2 indicates if the Pstate is overclockable or not\n!< - all other bits must be set to 0"] - pub flags: NvU32, - pub clocks: [NV_GPU_PERF_PSTATES_INFO_V2__bindgen_ty_1__bindgen_ty_1; 32usize], - pub voltages: [NV_GPU_PERF_PSTATES_INFO_V2__bindgen_ty_1__bindgen_ty_2; 16usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_PERF_PSTATES_INFO_V2__bindgen_ty_1__bindgen_ty_1 { - pub domainId: NV_GPU_PUBLIC_CLOCK_ID, - #[doc = "!< bit 0 indicates if this clock is overclockable\n!< all other bits must be set to 0"] - pub flags: NvU32, - pub freq: NvU32, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_PERF_PSTATES_INFO_V2__bindgen_ty_1__bindgen_ty_2 { - #[doc = "!< ID of the voltage domain, containing flags and mvolt info"] - pub domainId: NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID, - #[doc = "!< Reserved for future use. Must be set to 0"] - pub flags: NvU32, - #[doc = "!< Voltage in mV"] - pub mvolt: NvU32, -} -#[doc = "! \\ingroup gpupstate"] -pub type NV_GPU_PERF_PSTATES_INFO = NV_GPU_PERF_PSTATES_INFO_V2; -#[doc = "! \\ingroup gpupstate\n! Used in NvAPI_GPU_GetDynamicPstatesInfoEx()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_DYNAMIC_PSTATES_INFO_EX { - #[doc = "!< Structure version"] - pub version: NvU32, - #[doc = "!< bit 0 indicates if the dynamic Pstate is enabled or not"] - pub flags: NvU32, - pub utilization: [NV_GPU_DYNAMIC_PSTATES_INFO_EX__bindgen_ty_1; 8usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_DYNAMIC_PSTATES_INFO_EX__bindgen_ty_1 { - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, - #[doc = "!< Percentage of time where the domain is considered busy in the last 1 second interval"] - pub percentage: NvU32, -} -impl NV_GPU_DYNAMIC_PSTATES_INFO_EX__bindgen_ty_1 { - #[inline] - pub fn bIsPresent(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsPresent(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsPresent_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsPresent_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1(bIsPresent: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsPresent: u32 = unsafe { ::std::mem::transmute(bIsPresent) }; - bIsPresent as u64 - }); - __bindgen_bitfield_unit - } -} -pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_NONE: NV_THERMAL_TARGET = 0; -#[doc = "!< GPU core temperature requires NvPhysicalGpuHandle"] -pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_GPU: NV_THERMAL_TARGET = 1; -#[doc = "!< GPU memory temperature requires NvPhysicalGpuHandle"] -pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_MEMORY: NV_THERMAL_TARGET = 2; -#[doc = "!< GPU power supply temperature requires NvPhysicalGpuHandle"] -pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_POWER_SUPPLY: NV_THERMAL_TARGET = 4; -#[doc = "!< GPU board ambient temperature requires NvPhysicalGpuHandle"] -pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_BOARD: NV_THERMAL_TARGET = 8; -#[doc = "!< Visual Computing Device Board temperature requires NvVisualComputingDeviceHandle"] -pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_VCD_BOARD: NV_THERMAL_TARGET = 9; -#[doc = "!< Visual Computing Device Inlet temperature requires NvVisualComputingDeviceHandle"] -pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_VCD_INLET: NV_THERMAL_TARGET = 10; -#[doc = "!< Visual Computing Device Outlet temperature requires NvVisualComputingDeviceHandle"] -pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_VCD_OUTLET: NV_THERMAL_TARGET = 11; -pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_ALL: NV_THERMAL_TARGET = 15; -pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_UNKNOWN: NV_THERMAL_TARGET = -1; -#[doc = "! \\ingroup gputhermal\n! Used in NV_GPU_THERMAL_SETTINGS"] -pub type NV_THERMAL_TARGET = ::std::os::raw::c_int; -pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_NONE: NV_THERMAL_CONTROLLER = 0; -pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_GPU_INTERNAL: NV_THERMAL_CONTROLLER = 1; -pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_ADM1032: NV_THERMAL_CONTROLLER = 2; -pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_MAX6649: NV_THERMAL_CONTROLLER = 3; -pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_MAX1617: NV_THERMAL_CONTROLLER = 4; -pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_LM99: NV_THERMAL_CONTROLLER = 5; -pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_LM89: NV_THERMAL_CONTROLLER = 6; -pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_LM64: NV_THERMAL_CONTROLLER = 7; -pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_ADT7473: NV_THERMAL_CONTROLLER = 8; -pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_SBMAX6649: NV_THERMAL_CONTROLLER = 9; -pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_VBIOSEVT: NV_THERMAL_CONTROLLER = 10; -pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_OS: NV_THERMAL_CONTROLLER = 11; -pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_UNKNOWN: NV_THERMAL_CONTROLLER = -1; -#[doc = "! \\ingroup gputhermal\n! Used in NV_GPU_THERMAL_SETTINGS"] -pub type NV_THERMAL_CONTROLLER = ::std::os::raw::c_int; -#[doc = "! \\ingroup gputhermal\n! Used in NvAPI_GPU_GetThermalSettings()"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_THERMAL_SETTINGS_V1 { - #[doc = "!< structure version"] - pub version: NvU32, - #[doc = "!< number of associated thermal sensors"] - pub count: NvU32, - pub sensor: [NV_GPU_THERMAL_SETTINGS_V1__bindgen_ty_1; 3usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_THERMAL_SETTINGS_V1__bindgen_ty_1 { - #[doc = "!< internal, ADM1032, MAX6649..."] - pub controller: NV_THERMAL_CONTROLLER, - #[doc = "!< The min default temperature value of the thermal sensor in degree Celsius"] - pub defaultMinTemp: NvU32, - #[doc = "!< The max default temperature value of the thermal sensor in degree Celsius"] - pub defaultMaxTemp: NvU32, - #[doc = "!< The current temperature value of the thermal sensor in degree Celsius"] - pub currentTemp: NvU32, - #[doc = "!< Thermal sensor targeted @ GPU, memory, chipset, powersupply, Visual Computing Device, etc."] - pub target: NV_THERMAL_TARGET, -} -#[doc = "! \\ingroup gputhermal"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_THERMAL_SETTINGS_V2 { - #[doc = "!< structure version"] - pub version: NvU32, - #[doc = "!< number of associated thermal sensors"] - pub count: NvU32, - pub sensor: [NV_GPU_THERMAL_SETTINGS_V2__bindgen_ty_1; 3usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_THERMAL_SETTINGS_V2__bindgen_ty_1 { - #[doc = "!< internal, ADM1032, MAX6649..."] - pub controller: NV_THERMAL_CONTROLLER, - #[doc = "!< Minimum default temperature value of the thermal sensor in degree Celsius"] - pub defaultMinTemp: NvS32, - #[doc = "!< Maximum default temperature value of the thermal sensor in degree Celsius"] - pub defaultMaxTemp: NvS32, - #[doc = "!< Current temperature value of the thermal sensor in degree Celsius"] - pub currentTemp: NvS32, - #[doc = "!< Thermal sensor targeted - GPU, memory, chipset, powersupply, Visual Computing Device, etc"] - pub target: NV_THERMAL_TARGET, -} -#[doc = "! \\ingroup gputhermal"] -pub type NV_GPU_THERMAL_SETTINGS = NV_GPU_THERMAL_SETTINGS_V2; -#[doc = "! \\ingroup gpuclock\n! Used in NvAPI_GPU_GetAllClockFrequencies()"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_CLOCK_FREQUENCIES_V1 { - #[doc = "!< Structure version"] - pub version: NvU32, - #[doc = "!< These bits are reserved for future use."] - pub reserved: NvU32, - pub domain: [NV_GPU_CLOCK_FREQUENCIES_V1__bindgen_ty_1; 32usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_CLOCK_FREQUENCIES_V1__bindgen_ty_1 { - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Clock frequency (kHz)"] - pub frequency: NvU32, -} -impl NV_GPU_CLOCK_FREQUENCIES_V1__bindgen_ty_1 { - #[inline] - pub fn bIsPresent(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsPresent(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsPresent_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsPresent_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bIsPresent: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsPresent: u32 = unsafe { ::std::mem::transmute(bIsPresent) }; - bIsPresent as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub const NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE_NV_GPU_CLOCK_FREQUENCIES_CURRENT_FREQ: - NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE = 0; -pub const NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE_NV_GPU_CLOCK_FREQUENCIES_BASE_CLOCK: - NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE = 1; -pub const NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE_NV_GPU_CLOCK_FREQUENCIES_BOOST_CLOCK: - NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE = 2; -pub const NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE_NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE_NUM: - NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE = 3; -#[doc = "! \\ingroup gpuclock\n! Used in NvAPI_GPU_GetAllClockFrequencies()"] -pub type NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE = ::std::os::raw::c_int; -#[doc = "! \\ingroup gpuclock\n! Used in NvAPI_GPU_GetAllClockFrequencies()"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_CLOCK_FREQUENCIES_V2 { - #[doc = "!< Structure version"] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - pub domain: [NV_GPU_CLOCK_FREQUENCIES_V2__bindgen_ty_1; 32usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_CLOCK_FREQUENCIES_V2__bindgen_ty_1 { - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Clock frequency (kHz)"] - pub frequency: NvU32, -} -impl NV_GPU_CLOCK_FREQUENCIES_V2__bindgen_ty_1 { - #[inline] - pub fn bIsPresent(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsPresent(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsPresent_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsPresent_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bIsPresent: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsPresent: u32 = unsafe { ::std::mem::transmute(bIsPresent) }; - bIsPresent as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -impl NV_GPU_CLOCK_FREQUENCIES_V2 { - #[inline] - pub fn ClockType(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32) } - } - #[inline] - pub fn set_ClockType(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 4u8, val as u64) - } - } - #[inline] - pub unsafe fn ClockType_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 4u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_ClockType_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 4u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 20u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 20u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 20u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 20u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved1(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u32) } - } - #[inline] - pub fn set_reserved1(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(24usize, 8u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved1_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 24usize, - 8u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved1_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 24usize, - 8u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - ClockType: NvU32, - reserved: NvU32, - reserved1: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 4u8, { - let ClockType: u32 = unsafe { ::std::mem::transmute(ClockType) }; - ClockType as u64 - }); - __bindgen_bitfield_unit.set(4usize, 20u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit.set(24usize, 8u8, { - let reserved1: u32 = unsafe { ::std::mem::transmute(reserved1) }; - reserved1 as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! \\ingroup gpuclock\n! Used in NvAPI_GPU_GetAllClockFrequencies()"] -pub type NV_GPU_CLOCK_FREQUENCIES = NV_GPU_CLOCK_FREQUENCIES_V2; -pub const _NV_GPU_ILLUMINATION_ATTRIB_NV_GPU_IA_LOGO_BRIGHTNESS: _NV_GPU_ILLUMINATION_ATTRIB = 0; -pub const _NV_GPU_ILLUMINATION_ATTRIB_NV_GPU_IA_SLI_BRIGHTNESS: _NV_GPU_ILLUMINATION_ATTRIB = 1; -#[doc = "! \\ingroup gpu"] -pub type _NV_GPU_ILLUMINATION_ATTRIB = ::std::os::raw::c_int; -#[doc = "! \\ingroup gpu"] -pub use self::_NV_GPU_ILLUMINATION_ATTRIB as NV_GPU_ILLUMINATION_ATTRIB; -#[doc = "! \\ingroup gpu"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_QUERY_ILLUMINATION_SUPPORT_PARM_V1 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< The handle of the GPU that you are checking for the specified attribute.\n!< note that this is the GPU that is managing the attribute.\n!< Only a single GPU can manage an given attribute on a given HW element,\n!< regardless of how many are attatched.\n!< I.E. only one GPU will be used to control the brightness of the LED on an SLI bridge,\n!< regardless of how many are physicaly attached.\n!< You enumerate thru the GPUs with this call to determine which GPU is managing the attribute."] - pub hPhysicalGpu: NvPhysicalGpuHandle, - #[doc = "!< An enumeration value specifying the Illumination attribute to be querried.\n!< refer to enum \\ref NV_GPU_ILLUMINATION_ATTRIB."] - pub Attribute: NV_GPU_ILLUMINATION_ATTRIB, - #[doc = "!< A boolean indicating if the attribute is supported."] - pub bSupported: NvU32, -} -#[doc = "! \\ingroup gpu"] -pub type NV_GPU_QUERY_ILLUMINATION_SUPPORT_PARM_V1 = _NV_GPU_QUERY_ILLUMINATION_SUPPORT_PARM_V1; -#[doc = "! \\ingroup gpu"] -pub type NV_GPU_QUERY_ILLUMINATION_SUPPORT_PARM = NV_GPU_QUERY_ILLUMINATION_SUPPORT_PARM_V1; -#[doc = "! \\ingroup gpu"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_GET_ILLUMINATION_PARM_V1 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< The handle of the GPU that you are checking for the specified attribute.\n!< Note that this is the GPU that is managing the attribute.\n!< Only a single GPU can manage an given attribute on a given HW element,\n!< regardless of how many are attatched.\n!< I.E. only one GPU will be used to control the brightness of the LED on an SLI bridge,\n!< regardless of how many are physicaly attached.\n!< You enumerate thru the GPUs with this call to determine which GPU is managing the attribute."] - pub hPhysicalGpu: NvPhysicalGpuHandle, - #[doc = "!< An enumeration value specifying the Illumination attribute to be querried.\n!< refer to enum \\ref NV_GPU_ILLUMINATION_ATTRIB."] - pub Attribute: NV_GPU_ILLUMINATION_ATTRIB, - #[doc = "!< A DWORD that will contain the current value of the specified attribute."] - pub Value: NvU32, -} -#[doc = "! \\ingroup gpu"] -pub type NV_GPU_GET_ILLUMINATION_PARM_V1 = _NV_GPU_GET_ILLUMINATION_PARM_V1; -#[doc = "! \\ingroup gpu"] -pub type NV_GPU_GET_ILLUMINATION_PARM = NV_GPU_GET_ILLUMINATION_PARM_V1; -#[doc = "! \\ingroup gpu"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_SET_ILLUMINATION_PARM_V1 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< The handle of the GPU that you are checking for the specified attribute.\n!< Note that this is the GPU that is managing the attribute.\n!< Only a single GPU can manage an given attribute on a given HW element,\n!< regardless of how many are attatched.\n!< I.E. only one GPU will be used to control the brightness of the LED on an SLI bridge,\n!< regardless of how many are physicaly attached.\n!< You enumerate thru the GPUs with this call to determine which GPU is managing the attribute."] - pub hPhysicalGpu: NvPhysicalGpuHandle, - #[doc = "!< An enumeration value specifying the Illumination attribute to be querried.\n!< refer to enum \\ref NV_GPU_ILLUMINATION_ATTRIB."] - pub Attribute: NV_GPU_ILLUMINATION_ATTRIB, - #[doc = "!< A DWORD containing the new value for the specified attribute.\n!< This should be specified as a percentage of the full range of the attribute\n!< (0-100; 0 = off, 100 = full brightness)\n!< If a value is specified outside this range, NVAPI_INVALID_ARGUMENT will be returned."] - pub Value: NvU32, -} -#[doc = "! \\ingroup gpu"] -pub type NV_GPU_SET_ILLUMINATION_PARM_V1 = _NV_GPU_SET_ILLUMINATION_PARM_V1; -#[doc = "! \\ingroup gpu"] -pub type NV_GPU_SET_ILLUMINATION_PARM = NV_GPU_SET_ILLUMINATION_PARM_V1; -pub const NV_GPU_CLIENT_ILLUM_CTRL_MODE_NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB: - NV_GPU_CLIENT_ILLUM_CTRL_MODE = 0; -pub const NV_GPU_CLIENT_ILLUM_CTRL_MODE_NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB: - NV_GPU_CLIENT_ILLUM_CTRL_MODE = 1; -pub const NV_GPU_CLIENT_ILLUM_CTRL_MODE_NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL: - NV_GPU_CLIENT_ILLUM_CTRL_MODE = 0; -pub const NV_GPU_CLIENT_ILLUM_CTRL_MODE_NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR: - NV_GPU_CLIENT_ILLUM_CTRL_MODE = 1; -pub const NV_GPU_CLIENT_ILLUM_CTRL_MODE_NV_GPU_CLIENT_ILLUM_CTRL_MODE_INVALID: - NV_GPU_CLIENT_ILLUM_CTRL_MODE = 255; -#[doc = " Enumeration of control modes that can be applied to Illumination Zones."] -pub type NV_GPU_CLIENT_ILLUM_CTRL_MODE = ::std::os::raw::c_int; -pub const NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_GPU_TOP_0: - NV_GPU_CLIENT_ILLUM_ZONE_LOCATION = 0; -pub const NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_GPU_FRONT_0: - NV_GPU_CLIENT_ILLUM_ZONE_LOCATION = 8; -pub const NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_GPU_BACK_0: - NV_GPU_CLIENT_ILLUM_ZONE_LOCATION = 12; -pub const NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_SLI_TOP_0: - NV_GPU_CLIENT_ILLUM_ZONE_LOCATION = 32; -pub const NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_INVALID: - NV_GPU_CLIENT_ILLUM_ZONE_LOCATION = -1; -#[doc = " Enumeration of locations where an Illumination Zone might be present.\n Encoding used -\n 1:0 - Number specifier (0)\n 4:2 - Location (TOP)\n 7:5 - Type (GPU/SLI)"] -pub type NV_GPU_CLIENT_ILLUM_ZONE_LOCATION = ::std::os::raw::c_int; -pub const NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_INVALID: - NV_GPU_CLIENT_ILLUM_DEVICE_TYPE = 0; -pub const NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_MCUV10: - NV_GPU_CLIENT_ILLUM_DEVICE_TYPE = 1; -pub const NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_GPIO_PWM_RGBW_V10: - NV_GPU_CLIENT_ILLUM_DEVICE_TYPE = 2; -pub const NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_GPIO_PWM_SINGLE_COLOR_V10 : NV_GPU_CLIENT_ILLUM_DEVICE_TYPE = 3 ; -#[doc = " Enumeration of ILLUM_DEVICEs."] -pub type NV_GPU_CLIENT_ILLUM_DEVICE_TYPE = ::std::os::raw::c_int; -pub const NV_GPU_CLIENT_ILLUM_ZONE_TYPE_NV_GPU_CLIENT_ILLUM_ZONE_TYPE_INVALID: - NV_GPU_CLIENT_ILLUM_ZONE_TYPE = 0; -pub const NV_GPU_CLIENT_ILLUM_ZONE_TYPE_NV_GPU_CLIENT_ILLUM_ZONE_TYPE_RGB: - NV_GPU_CLIENT_ILLUM_ZONE_TYPE = 1; -pub const NV_GPU_CLIENT_ILLUM_ZONE_TYPE_NV_GPU_CLIENT_ILLUM_ZONE_TYPE_COLOR_FIXED: - NV_GPU_CLIENT_ILLUM_ZONE_TYPE = 2; -pub const NV_GPU_CLIENT_ILLUM_ZONE_TYPE_NV_GPU_CLIENT_ILLUM_ZONE_TYPE_RGBW: - NV_GPU_CLIENT_ILLUM_ZONE_TYPE = 3; -pub const NV_GPU_CLIENT_ILLUM_ZONE_TYPE_NV_GPU_CLIENT_ILLUM_ZONE_TYPE_SINGLE_COLOR: - NV_GPU_CLIENT_ILLUM_ZONE_TYPE = 4; -#[doc = " Enumeration of ILLUM_ZONEs."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_TYPE = ::std::os::raw::c_int; -pub const NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE_NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_HALF_HALT : NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE = 0 ; -pub const NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE_NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_FULL_HALT : NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE = 1 ; -pub const NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE_NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_FULL_REPEAT : NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE = 2 ; -pub const NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE_NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_INVALID : NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE = 255 ; -#[doc = " Enumeration of Cycle types for piecewise linear control mode."] -pub type NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE = ::std::os::raw::c_int; -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1\n Describes the static information of illumination device type MCUV10."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_MCUV10 { - #[doc = " I2C Device Index: Pointing to the illumination device in I2C Devices Table."] - pub i2cDevIdx: NvU8, -} -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1\n Describes the static information of illumination device type MCUV10."] -pub type NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_MCUV10 = _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_MCUV10; -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1\n Describes the static information of illum device type GPIO_PWM_RGBW."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_RGBW { - #[doc = " Red drive GPIO pin."] - pub gpioPinRed: NvU8, - #[doc = " Green drive GPIO pin."] - pub gpioPinGreen: NvU8, - #[doc = " Blue drive GPIO pin."] - pub gpioPinBlue: NvU8, - #[doc = " White drive GPIO pin."] - pub gpioPinWhite: NvU8, -} -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1\n Describes the static information of illum device type GPIO_PWM_RGBW."] -pub type NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_RGBW = - _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_RGBW; -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1\n Describes the static information of illum device type GPIO_PWM_SINGLE_COLOR."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_SINGLE_COLOR { - #[doc = " Single Color GPIO pin."] - pub gpioPinSingleColor: NvU8, -} -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1\n Describes the static information of illum device type GPIO_PWM_SINGLE_COLOR."] -pub type NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_SINGLE_COLOR = - _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_SINGLE_COLOR; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1 { - #[doc = " Type of the illumination device."] - pub type_: NV_GPU_CLIENT_ILLUM_DEVICE_TYPE, - #[doc = " Supported control modes for this illumination device."] - pub ctrlModeMask: NvU32, - pub data: _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1__bindgen_ty_1, - #[doc = " Reserved for future."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Union of illumination device info data. Interpreted as per\n @ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1::type"] -#[repr(C)] -#[derive(Copy, Clone)] -pub union _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1__bindgen_ty_1 { - pub mcuv10: NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_MCUV10, - pub gpioPwmRgbwv10: NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_RGBW, - pub gpioPwmSingleColorv10: NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_SINGLE_COLOR, - #[doc = " Reserved bytes for possible future extension of this struct."] - pub rsvd: [NvU8; 64usize], -} -pub type NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1 = _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_PARAMS_V1 { - #[doc = " Version of structure. Must always be first member."] - pub version: NvU32, - #[doc = " Number of illumination devices present."] - pub numIllumDevices: NvU32, - #[doc = " Reserved bytes for possible future extension of this struct."] - pub rsvd: [NvU8; 64usize], - pub devices: [NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1; 32usize], -} -pub type NV_GPU_CLIENT_ILLUM_DEVICE_INFO_PARAMS_V1 = _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_PARAMS_V1; -pub type NV_GPU_CLIENT_ILLUM_DEVICE_INFO_PARAMS = NV_GPU_CLIENT_ILLUM_DEVICE_INFO_PARAMS_V1; -#[doc = " Structure representing the data required for synchronization."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_CLIENT_ILLUM_DEVICE_SYNC_V1 { - #[doc = " Boolean representing the need for synchronization."] - pub bSync: NvBool, - #[doc = " Time stamp value required for synchronization."] - pub timeStampms: NvU64, - #[doc = " Reserved for future."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Structure representing the device control parameters of each ILLUM_DEVICE."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_V1 { - #[doc = " Type of the illum device."] - pub type_: NV_GPU_CLIENT_ILLUM_DEVICE_TYPE, - #[doc = " Structure containing the synchronization data for the illumination device."] - pub syncData: NV_GPU_CLIENT_ILLUM_DEVICE_SYNC_V1, - #[doc = " Reserved for future."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Structure representing the device control parameters of each ILLUM_DEVICE."] -pub type NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL = NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_V1; -#[doc = " Structure representing the control parameters of ILLUM_DEVICE-s."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_PARAMS_V1 { - #[doc = " Version of structure. Must always be first member."] - pub version: NvU32, - #[doc = " Number of illumination devices present."] - pub numIllumDevices: NvU32, - #[doc = " Reserved bytes for possible future extension of this struct."] - pub rsvd: [NvU8; 64usize], - pub devices: [NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_V1; 32usize], -} -#[doc = " Structure representing the control parameters of ILLUM_DEVICE-s."] -pub type NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_PARAMS = NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_PARAMS_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGB { - pub rsvd: NvU8, -} -pub type NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGB = _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGB; -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1\n Describes the static information of illum zone type RGBW."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGBW { - pub rsvd: NvU8, -} -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1\n Describes the static information of illum zone type RGBW."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGBW = _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGBW; -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1\n Describes the static information of illum zone type SINGLE_COLOR."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_SINGLE_COLOR { - pub rsvd: NvU8, -} -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1\n Describes the static information of illum zone type SINGLE_COLOR."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_SINGLE_COLOR = - _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_SINGLE_COLOR; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1 { - pub type_: NV_GPU_CLIENT_ILLUM_ZONE_TYPE, - #[doc = " Index pointing to an Illumination Device that controls this zone."] - pub illumDeviceIdx: NvU8, - #[doc = " Provider index for representing logical to physical zone mapping."] - pub provIdx: NvU8, - #[doc = " Location of the zone on the board."] - pub zoneLocation: NV_GPU_CLIENT_ILLUM_ZONE_LOCATION, - pub data: _NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1__bindgen_ty_1, - pub rsvd: [NvU8; 64usize], -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union _NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1__bindgen_ty_1 { - pub rgb: NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGB, - pub rgbw: NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGBW, - pub singleColor: NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_SINGLE_COLOR, - #[doc = " Reserved bytes for possible future extension of this struct."] - pub rsvd: [NvU8; 64usize], -} -pub type NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1 = _NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_INFO_PARAMS_V1 { - #[doc = " Version of structure. Must always be first member."] - pub version: NvU32, - #[doc = " Number of illumination zones present."] - pub numIllumZones: NvU32, - #[doc = " Reserved bytes for possible future extension of this struct."] - pub rsvd: [NvU8; 64usize], - pub zones: [NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1; 32usize], -} -pub type NV_GPU_CLIENT_ILLUM_ZONE_INFO_PARAMS_V1 = _NV_GPU_CLIENT_ILLUM_ZONE_INFO_PARAMS_V1; -pub type NV_GPU_CLIENT_ILLUM_ZONE_INFO_PARAMS = NV_GPU_CLIENT_ILLUM_ZONE_INFO_PARAMS_V1; -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB\n Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB_PARAMS { - #[doc = " Red compenent of color applied to the zone."] - pub colorR: NvU8, - #[doc = " Green compenent of color applied to the zone."] - pub colorG: NvU8, - #[doc = " Blue compenent of color applied to the zone."] - pub colorB: NvU8, - #[doc = " Brightness perecentage value of the zone."] - pub brightnessPct: NvU8, -} -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB\n Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB_PARAMS = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB_PARAMS; -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB { - #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] - pub rgbParams: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB_PARAMS, -} -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB; -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR { - #[doc = " Type of cycle effect to apply."] - pub cycleType: NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE, - #[doc = " Number of times to repeat function within group period."] - pub grpCount: NvU8, - #[doc = " Time in ms to transition from color A to color B."] - pub riseTimems: NvU16, - #[doc = " Time in ms to transition from color B to color A."] - pub fallTimems: NvU16, - #[doc = " Time in ms to remain at color A before color A to color B transition."] - pub ATimems: NvU16, - #[doc = " Time in ms to remain at color B before color B to color A transition."] - pub BTimems: NvU16, - #[doc = " Time in ms to remain idle before next group of repeated function cycles."] - pub grpIdleTimems: NvU16, - #[doc = " Time in ms to offset the cycle relative to other zones."] - pub phaseOffsetms: NvU16, -} -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR; -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB { - #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] - pub rgbParams: [NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB_PARAMS; 2usize], - pub piecewiseLinearData: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR, -} -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB; -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illumination zone of type\n \\ref NV_GPU_CLIENT_ILLUM_ZONE_TYPE_RGB."] -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB { - pub data: _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB__bindgen_ty_1, - #[doc = " Reserved for future."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Union of illumination zone control data for zone of type NV_GPU_CLIENT_ILLUM_ZONE_TYPE_RGB.\n Interpreted as per ctrlMode."] -#[repr(C)] -#[derive(Copy, Clone)] -pub union _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB__bindgen_ty_1 { - pub manualRGB: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB, - pub piecewiseLinearRGB: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB, - #[doc = " Reserved bytes for possible future extension of this struct."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illumination zone of type\n \\ref NV_GPU_CLIENT_ILLUM_ZONE_TYPE_RGB."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB = _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB; -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED\n Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_RGB."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED_PARAMS { - #[doc = " Brightness percentage value of the zone."] - pub brightnessPct: NvU8, -} -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED\n Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_RGB."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED_PARAMS = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED_PARAMS; -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED { - #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] - pub colorFixedParams: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED_PARAMS, -} -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED; -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_COLOR_FIXED { - #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] - pub colorFixedParams: [NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED_PARAMS; 2usize], - pub piecewiseLinearData: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR, -} -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_COLOR_FIXED = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_COLOR_FIXED; -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illum zone of type\n \\ref NV_GPU_CLIENT_ILLUM_ZONE_TYPE_COLOR_FIXED."] -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED { - pub data: _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED__bindgen_ty_1, - #[doc = " Reserved for future."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Union of illum zone control data for zone of type NV_GPU_CLIENT_ILLUM_ZONE_TYPE_COLOR_FIXED.\n Interpreted as per ctrlMode."] -#[repr(C)] -#[derive(Copy, Clone)] -pub union _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED__bindgen_ty_1 { - pub manualColorFixed: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED, - pub piecewiseLinearColorFixed: - NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_COLOR_FIXED, - #[doc = " Reserved bytes for possible future extension of this struct."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illum zone of type\n \\ref NV_GPU_CLIENT_ILLUM_ZONE_TYPE_COLOR_FIXED."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED; -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW\n Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGBW."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW_PARAMS { - #[doc = " Red component of color applied to the zone."] - pub colorR: NvU8, - #[doc = " Green component of color applied to the zone."] - pub colorG: NvU8, - #[doc = " Blue component of color applied to the zone."] - pub colorB: NvU8, - #[doc = " White component of color applied to the zone."] - pub colorW: NvU8, - #[doc = " Brightness percentage value of the zone."] - pub brightnessPct: NvU8, -} -#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW\n Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGBW."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW_PARAMS = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW_PARAMS; -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_RGBW\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_RGBW."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW { - #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_RGBW."] - pub rgbwParams: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW_PARAMS, -} -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_RGBW\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_RGBW."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW; -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_RGBW\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGBW."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGBW { - #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGBW."] - pub rgbwParams: [NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW_PARAMS; 2usize], - pub piecewiseLinearData: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR, -} -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_RGBW\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGBW."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGBW = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGBW; -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illum zone of type\n \\ref NV_GPU_ILLUM_ZONE_TYPE_RGBW."] -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW { - pub data: _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW__bindgen_ty_1, - #[doc = " Reserved for future."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Union of illum zone control data for zone of type NV_GPU_ILLUM_ZONE_TYPE_RGBW.\n Interpreted as per ctrlMode."] -#[repr(C)] -#[derive(Copy, Clone)] -pub union _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW__bindgen_ty_1 { - pub manualRGBW: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW, - pub piecewiseLinearRGBW: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGBW, - #[doc = " Reserved bytes for possible future extension of this struct."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illum zone of type\n \\ref NV_GPU_ILLUM_ZONE_TYPE_RGBW."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW = _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW; -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR\n Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_SINGLE_COLOR."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR_PARAMS { - #[doc = " Brightness percentage value of the zone."] - pub brightnessPct: NvU8, -} -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR\n Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_SINGLE_COLOR."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR_PARAMS = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR_PARAMS; -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_SINGLE_COLOR."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR { - #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_SINGLE_COLOR."] - pub singleColorParams: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR_PARAMS, -} -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_SINGLE_COLOR."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR; -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_SINGLE_COLOR."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_SINGLE_COLOR { - #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_SINGLE_COLOR."] - pub singleColorParams: - [NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR_PARAMS; 2usize], - pub piecewiseLinearData: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR, -} -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_SINGLE_COLOR."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_SINGLE_COLOR = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_SINGLE_COLOR; -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illum zone of type\n \\ref NV_GPU_ILLUM_ZONE_TYPE_SINGLE_COLOR."] -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR { - pub data: _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR__bindgen_ty_1, - #[doc = " Reserved for future."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Union of illum zone control data for zone of type NV_GPU_ILLUM_ZONE_TYPE_SINGLE_COLOR.\n Interpreted as per ctrlMode."] -#[repr(C)] -#[derive(Copy, Clone)] -pub union _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR__bindgen_ty_1 { - pub manualSingleColor: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR, - pub piecewiseLinearSingleColor: - NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_SINGLE_COLOR, - #[doc = " Reserved bytes for possible future extension of this struct."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illum zone of type\n \\ref NV_GPU_ILLUM_ZONE_TYPE_SINGLE_COLOR."] -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR = - _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1 { - pub type_: NV_GPU_CLIENT_ILLUM_ZONE_TYPE, - pub ctrlMode: NV_GPU_CLIENT_ILLUM_CTRL_MODE, - pub data: _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1__bindgen_ty_1, - pub rsvd: [NvU8; 64usize], -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1__bindgen_ty_1 { - pub rgb: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB, - pub colorFixed: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED, - pub rgbw: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW, - pub singleColor: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR, - pub rsvd: [NvU8; 64usize], -} -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1 = _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS_V1 { - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = " Number of illumination zones present."] - pub numIllumZonesControl: NvU32, - #[doc = " Reserved bytes for possible future extension of this struct."] - pub rsvd: [NvU8; 64usize], - pub zones: [NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1; 32usize], -} -impl _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS_V1 { - #[inline] - pub fn bDefault(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bDefault(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bDefault_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bDefault_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn rsvdField(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_rsvdField(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn rsvdField_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_rsvdField_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bDefault: NvU32, - rsvdField: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bDefault: u32 = unsafe { ::std::mem::transmute(bDefault) }; - bDefault as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let rsvdField: u32 = unsafe { ::std::mem::transmute(rsvdField) }; - rsvdField as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS_V1 = _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS_V1; -pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS = NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS_V1; -#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_GetDisplayPortInfo()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_DISPLAY_PORT_INFO_V1 { - #[doc = "!< Structure version"] - pub version: NvU32, - #[doc = "!< DPCD version of the monitor"] - pub dpcd_ver: NvU32, - #[doc = "!< Maximum supported link rate"] - pub maxLinkRate: NV_DP_LINK_RATE, - #[doc = "!< Maximum supported lane count"] - pub maxLaneCount: NV_DP_LANE_COUNT, - #[doc = "!< Current link rate"] - pub curLinkRate: NV_DP_LINK_RATE, - #[doc = "!< Current lane count"] - pub curLaneCount: NV_DP_LANE_COUNT, - #[doc = "!< Current color format"] - pub colorFormat: NV_DP_COLOR_FORMAT, - #[doc = "!< Dynamic range"] - pub dynamicRange: NV_DP_DYNAMIC_RANGE, - #[doc = "!< Ignored in RGB space"] - pub colorimetry: NV_DP_COLORIMETRY, - #[doc = "!< Current bit-per-component"] - pub bpc: NV_DP_BPC, - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, -} -impl _NV_DISPLAY_PORT_INFO_V1 { - #[inline] - pub fn isDp(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isDp(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isDp_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isDp_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isInternalDp(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_isInternalDp(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isInternalDp_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isInternalDp_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isColorCtrlSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_isColorCtrlSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isColorCtrlSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isColorCtrlSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn is6BPCSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_is6BPCSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn is6BPCSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_is6BPCSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn is8BPCSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } - } - #[inline] - pub fn set_is8BPCSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn is8BPCSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_is8BPCSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn is10BPCSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } - } - #[inline] - pub fn set_is10BPCSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn is10BPCSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_is10BPCSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn is12BPCSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } - } - #[inline] - pub fn set_is12BPCSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(6usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn is12BPCSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 6usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_is12BPCSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 6usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn is16BPCSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } - } - #[inline] - pub fn set_is16BPCSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(7usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn is16BPCSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 7usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_is16BPCSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 7usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isYCrCb420Supported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) } - } - #[inline] - pub fn set_isYCrCb420Supported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(8usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isYCrCb420Supported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 8usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isYCrCb420Supported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 8usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isYCrCb422Supported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) } - } - #[inline] - pub fn set_isYCrCb422Supported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(9usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isYCrCb422Supported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 9usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isYCrCb422Supported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 9usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isYCrCb444Supported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) } - } - #[inline] - pub fn set_isYCrCb444Supported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(10usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isYCrCb444Supported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 10usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isYCrCb444Supported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 10usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isRgb444SupportedOnCurrentMode(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) } - } - #[inline] - pub fn set_isRgb444SupportedOnCurrentMode(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(11usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isRgb444SupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 11usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isRgb444SupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 11usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isYCbCr444SupportedOnCurrentMode(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) } - } - #[inline] - pub fn set_isYCbCr444SupportedOnCurrentMode(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(12usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isYCbCr444SupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 12usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isYCbCr444SupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 12usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isYCbCr422SupportedOnCurrentMode(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) } - } - #[inline] - pub fn set_isYCbCr422SupportedOnCurrentMode(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(13usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isYCbCr422SupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 13usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isYCbCr422SupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 13usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isYCbCr420SupportedOnCurrentMode(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) } - } - #[inline] - pub fn set_isYCbCr420SupportedOnCurrentMode(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(14usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isYCbCr420SupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 14usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isYCbCr420SupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 14usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn is6BPCSupportedOnCurrentMode(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) } - } - #[inline] - pub fn set_is6BPCSupportedOnCurrentMode(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(15usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn is6BPCSupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 15usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_is6BPCSupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 15usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn is8BPCSupportedOnCurrentMode(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) } - } - #[inline] - pub fn set_is8BPCSupportedOnCurrentMode(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(16usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn is8BPCSupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 16usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_is8BPCSupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 16usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn is10BPCSupportedOnCurrentMode(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) } - } - #[inline] - pub fn set_is10BPCSupportedOnCurrentMode(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(17usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn is10BPCSupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 17usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_is10BPCSupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 17usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn is12BPCSupportedOnCurrentMode(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) } - } - #[inline] - pub fn set_is12BPCSupportedOnCurrentMode(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(18usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn is12BPCSupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 18usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_is12BPCSupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 18usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn is16BPCSupportedOnCurrentMode(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u32) } - } - #[inline] - pub fn set_is16BPCSupportedOnCurrentMode(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(19usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn is16BPCSupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 19usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_is16BPCSupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 19usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonxvYCC601Capable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonxvYCC601Capable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(20usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonxvYCC601Capable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 20usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonxvYCC601Capable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 20usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonxvYCC709Capable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonxvYCC709Capable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(21usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonxvYCC709Capable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 21usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonxvYCC709Capable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 21usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonsYCC601Capable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonsYCC601Capable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(22usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonsYCC601Capable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 22usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonsYCC601Capable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 22usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonAdobeYCC601Capable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonAdobeYCC601Capable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(23usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonAdobeYCC601Capable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 23usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonAdobeYCC601Capable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 23usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonAdobeRGBCapable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonAdobeRGBCapable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(24usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonAdobeRGBCapable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 24usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonAdobeRGBCapable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 24usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonBT2020RGBCapable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonBT2020RGBCapable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(25usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonBT2020RGBCapable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 25usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonBT2020RGBCapable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 25usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonBT2020YCCCapable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonBT2020YCCCapable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(26usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonBT2020YCCCapable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 26usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonBT2020YCCCapable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 26usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonBT2020cYCCCapable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonBT2020cYCCCapable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(27usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonBT2020cYCCCapable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 27usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonBT2020cYCCCapable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 27usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 4u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(28usize, 4u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 28usize, - 4u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 28usize, - 4u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isDp: NvU32, - isInternalDp: NvU32, - isColorCtrlSupported: NvU32, - is6BPCSupported: NvU32, - is8BPCSupported: NvU32, - is10BPCSupported: NvU32, - is12BPCSupported: NvU32, - is16BPCSupported: NvU32, - isYCrCb420Supported: NvU32, - isYCrCb422Supported: NvU32, - isYCrCb444Supported: NvU32, - isRgb444SupportedOnCurrentMode: NvU32, - isYCbCr444SupportedOnCurrentMode: NvU32, - isYCbCr422SupportedOnCurrentMode: NvU32, - isYCbCr420SupportedOnCurrentMode: NvU32, - is6BPCSupportedOnCurrentMode: NvU32, - is8BPCSupportedOnCurrentMode: NvU32, - is10BPCSupportedOnCurrentMode: NvU32, - is12BPCSupportedOnCurrentMode: NvU32, - is16BPCSupportedOnCurrentMode: NvU32, - isMonxvYCC601Capable: NvU32, - isMonxvYCC709Capable: NvU32, - isMonsYCC601Capable: NvU32, - isMonAdobeYCC601Capable: NvU32, - isMonAdobeRGBCapable: NvU32, - isMonBT2020RGBCapable: NvU32, - isMonBT2020YCCCapable: NvU32, - isMonBT2020cYCCCapable: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isDp: u32 = unsafe { ::std::mem::transmute(isDp) }; - isDp as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let isInternalDp: u32 = unsafe { ::std::mem::transmute(isInternalDp) }; - isInternalDp as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let isColorCtrlSupported: u32 = unsafe { ::std::mem::transmute(isColorCtrlSupported) }; - isColorCtrlSupported as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let is6BPCSupported: u32 = unsafe { ::std::mem::transmute(is6BPCSupported) }; - is6BPCSupported as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let is8BPCSupported: u32 = unsafe { ::std::mem::transmute(is8BPCSupported) }; - is8BPCSupported as u64 - }); - __bindgen_bitfield_unit.set(5usize, 1u8, { - let is10BPCSupported: u32 = unsafe { ::std::mem::transmute(is10BPCSupported) }; - is10BPCSupported as u64 - }); - __bindgen_bitfield_unit.set(6usize, 1u8, { - let is12BPCSupported: u32 = unsafe { ::std::mem::transmute(is12BPCSupported) }; - is12BPCSupported as u64 - }); - __bindgen_bitfield_unit.set(7usize, 1u8, { - let is16BPCSupported: u32 = unsafe { ::std::mem::transmute(is16BPCSupported) }; - is16BPCSupported as u64 - }); - __bindgen_bitfield_unit.set(8usize, 1u8, { - let isYCrCb420Supported: u32 = unsafe { ::std::mem::transmute(isYCrCb420Supported) }; - isYCrCb420Supported as u64 - }); - __bindgen_bitfield_unit.set(9usize, 1u8, { - let isYCrCb422Supported: u32 = unsafe { ::std::mem::transmute(isYCrCb422Supported) }; - isYCrCb422Supported as u64 - }); - __bindgen_bitfield_unit.set(10usize, 1u8, { - let isYCrCb444Supported: u32 = unsafe { ::std::mem::transmute(isYCrCb444Supported) }; - isYCrCb444Supported as u64 - }); - __bindgen_bitfield_unit.set(11usize, 1u8, { - let isRgb444SupportedOnCurrentMode: u32 = - unsafe { ::std::mem::transmute(isRgb444SupportedOnCurrentMode) }; - isRgb444SupportedOnCurrentMode as u64 - }); - __bindgen_bitfield_unit.set(12usize, 1u8, { - let isYCbCr444SupportedOnCurrentMode: u32 = - unsafe { ::std::mem::transmute(isYCbCr444SupportedOnCurrentMode) }; - isYCbCr444SupportedOnCurrentMode as u64 - }); - __bindgen_bitfield_unit.set(13usize, 1u8, { - let isYCbCr422SupportedOnCurrentMode: u32 = - unsafe { ::std::mem::transmute(isYCbCr422SupportedOnCurrentMode) }; - isYCbCr422SupportedOnCurrentMode as u64 - }); - __bindgen_bitfield_unit.set(14usize, 1u8, { - let isYCbCr420SupportedOnCurrentMode: u32 = - unsafe { ::std::mem::transmute(isYCbCr420SupportedOnCurrentMode) }; - isYCbCr420SupportedOnCurrentMode as u64 - }); - __bindgen_bitfield_unit.set(15usize, 1u8, { - let is6BPCSupportedOnCurrentMode: u32 = - unsafe { ::std::mem::transmute(is6BPCSupportedOnCurrentMode) }; - is6BPCSupportedOnCurrentMode as u64 - }); - __bindgen_bitfield_unit.set(16usize, 1u8, { - let is8BPCSupportedOnCurrentMode: u32 = - unsafe { ::std::mem::transmute(is8BPCSupportedOnCurrentMode) }; - is8BPCSupportedOnCurrentMode as u64 - }); - __bindgen_bitfield_unit.set(17usize, 1u8, { - let is10BPCSupportedOnCurrentMode: u32 = - unsafe { ::std::mem::transmute(is10BPCSupportedOnCurrentMode) }; - is10BPCSupportedOnCurrentMode as u64 - }); - __bindgen_bitfield_unit.set(18usize, 1u8, { - let is12BPCSupportedOnCurrentMode: u32 = - unsafe { ::std::mem::transmute(is12BPCSupportedOnCurrentMode) }; - is12BPCSupportedOnCurrentMode as u64 - }); - __bindgen_bitfield_unit.set(19usize, 1u8, { - let is16BPCSupportedOnCurrentMode: u32 = - unsafe { ::std::mem::transmute(is16BPCSupportedOnCurrentMode) }; - is16BPCSupportedOnCurrentMode as u64 - }); - __bindgen_bitfield_unit.set(20usize, 1u8, { - let isMonxvYCC601Capable: u32 = unsafe { ::std::mem::transmute(isMonxvYCC601Capable) }; - isMonxvYCC601Capable as u64 - }); - __bindgen_bitfield_unit.set(21usize, 1u8, { - let isMonxvYCC709Capable: u32 = unsafe { ::std::mem::transmute(isMonxvYCC709Capable) }; - isMonxvYCC709Capable as u64 - }); - __bindgen_bitfield_unit.set(22usize, 1u8, { - let isMonsYCC601Capable: u32 = unsafe { ::std::mem::transmute(isMonsYCC601Capable) }; - isMonsYCC601Capable as u64 - }); - __bindgen_bitfield_unit.set(23usize, 1u8, { - let isMonAdobeYCC601Capable: u32 = - unsafe { ::std::mem::transmute(isMonAdobeYCC601Capable) }; - isMonAdobeYCC601Capable as u64 - }); - __bindgen_bitfield_unit.set(24usize, 1u8, { - let isMonAdobeRGBCapable: u32 = unsafe { ::std::mem::transmute(isMonAdobeRGBCapable) }; - isMonAdobeRGBCapable as u64 - }); - __bindgen_bitfield_unit.set(25usize, 1u8, { - let isMonBT2020RGBCapable: u32 = - unsafe { ::std::mem::transmute(isMonBT2020RGBCapable) }; - isMonBT2020RGBCapable as u64 - }); - __bindgen_bitfield_unit.set(26usize, 1u8, { - let isMonBT2020YCCCapable: u32 = - unsafe { ::std::mem::transmute(isMonBT2020YCCCapable) }; - isMonBT2020YCCCapable as u64 - }); - __bindgen_bitfield_unit.set(27usize, 1u8, { - let isMonBT2020cYCCCapable: u32 = - unsafe { ::std::mem::transmute(isMonBT2020cYCCCapable) }; - isMonBT2020cYCCCapable as u64 - }); - __bindgen_bitfield_unit.set(28usize, 4u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_GetDisplayPortInfo()."] -pub type NV_DISPLAY_PORT_INFO_V1 = _NV_DISPLAY_PORT_INFO_V1; -#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_GetDisplayPortInfo()."] -pub type NV_DISPLAY_PORT_INFO = NV_DISPLAY_PORT_INFO_V1; -#[doc = "! \\ingroup dispcontrol\n! DisplayPort configuration settings - used in NvAPI_SetDisplayPort()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_DISPLAY_PORT_CONFIG { - #[doc = "!< Structure version - 2 is the latest"] - pub version: NvU32, - #[doc = "!< Link rate"] - pub linkRate: NV_DP_LINK_RATE, - #[doc = "!< Lane count"] - pub laneCount: NV_DP_LANE_COUNT, - #[doc = "!< Color format to set"] - pub colorFormat: NV_DP_COLOR_FORMAT, - #[doc = "!< Dynamic range"] - pub dynamicRange: NV_DP_DYNAMIC_RANGE, - #[doc = "!< Ignored in RGB space"] - pub colorimetry: NV_DP_COLORIMETRY, - #[doc = "!< Bit-per-component"] - pub bpc: NV_DP_BPC, - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, - pub __bindgen_padding_0: [u8; 3usize], -} -impl NV_DISPLAY_PORT_CONFIG { - #[inline] - pub fn isHPD(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isHPD(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isHPD_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isHPD_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isSetDeferred(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_isSetDeferred(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isSetDeferred_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isSetDeferred_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isChromaLpfOff(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_isChromaLpfOff(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isChromaLpfOff_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isChromaLpfOff_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isDitherOff(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_isDitherOff(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isDitherOff_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isDitherOff_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn testLinkTrain(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } - } - #[inline] - pub fn set_testLinkTrain(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn testLinkTrain_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_testLinkTrain_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn testColorChange(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } - } - #[inline] - pub fn set_testColorChange(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn testColorChange_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_testColorChange_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isHPD: NvU32, - isSetDeferred: NvU32, - isChromaLpfOff: NvU32, - isDitherOff: NvU32, - testLinkTrain: NvU32, - testColorChange: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isHPD: u32 = unsafe { ::std::mem::transmute(isHPD) }; - isHPD as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let isSetDeferred: u32 = unsafe { ::std::mem::transmute(isSetDeferred) }; - isSetDeferred as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let isChromaLpfOff: u32 = unsafe { ::std::mem::transmute(isChromaLpfOff) }; - isChromaLpfOff as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let isDitherOff: u32 = unsafe { ::std::mem::transmute(isDitherOff) }; - isDitherOff as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let testLinkTrain: u32 = unsafe { ::std::mem::transmute(testLinkTrain) }; - testLinkTrain as u64 - }); - __bindgen_bitfield_unit.set(5usize, 1u8, { - let testColorChange: u32 = unsafe { ::std::mem::transmute(testColorChange) }; - testColorChange as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_GetHDMISupportInfo()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDMI_SUPPORT_INFO_V1 { - #[doc = "!< Structure version"] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Revision number of the EDID 861 extension"] - pub EDID861ExtRev: NvU32, -} -impl _NV_HDMI_SUPPORT_INFO_V1 { - #[inline] - pub fn isGpuHDMICapable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isGpuHDMICapable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isGpuHDMICapable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isGpuHDMICapable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonUnderscanCapable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonUnderscanCapable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonUnderscanCapable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonUnderscanCapable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonBasicAudioCapable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonBasicAudioCapable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonBasicAudioCapable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonBasicAudioCapable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonYCbCr444Capable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonYCbCr444Capable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonYCbCr444Capable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonYCbCr444Capable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonYCbCr422Capable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonYCbCr422Capable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonYCbCr422Capable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonYCbCr422Capable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonxvYCC601Capable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonxvYCC601Capable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonxvYCC601Capable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonxvYCC601Capable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonxvYCC709Capable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonxvYCC709Capable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(6usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonxvYCC709Capable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 6usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonxvYCC709Capable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 6usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonHDMI(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonHDMI(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(7usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonHDMI_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 7usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonHDMI_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 7usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 24u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(8usize, 24u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 8usize, - 24u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 8usize, - 24u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isGpuHDMICapable: NvU32, - isMonUnderscanCapable: NvU32, - isMonBasicAudioCapable: NvU32, - isMonYCbCr444Capable: NvU32, - isMonYCbCr422Capable: NvU32, - isMonxvYCC601Capable: NvU32, - isMonxvYCC709Capable: NvU32, - isMonHDMI: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isGpuHDMICapable: u32 = unsafe { ::std::mem::transmute(isGpuHDMICapable) }; - isGpuHDMICapable as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let isMonUnderscanCapable: u32 = - unsafe { ::std::mem::transmute(isMonUnderscanCapable) }; - isMonUnderscanCapable as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let isMonBasicAudioCapable: u32 = - unsafe { ::std::mem::transmute(isMonBasicAudioCapable) }; - isMonBasicAudioCapable as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let isMonYCbCr444Capable: u32 = unsafe { ::std::mem::transmute(isMonYCbCr444Capable) }; - isMonYCbCr444Capable as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let isMonYCbCr422Capable: u32 = unsafe { ::std::mem::transmute(isMonYCbCr422Capable) }; - isMonYCbCr422Capable as u64 - }); - __bindgen_bitfield_unit.set(5usize, 1u8, { - let isMonxvYCC601Capable: u32 = unsafe { ::std::mem::transmute(isMonxvYCC601Capable) }; - isMonxvYCC601Capable as u64 - }); - __bindgen_bitfield_unit.set(6usize, 1u8, { - let isMonxvYCC709Capable: u32 = unsafe { ::std::mem::transmute(isMonxvYCC709Capable) }; - isMonxvYCC709Capable as u64 - }); - __bindgen_bitfield_unit.set(7usize, 1u8, { - let isMonHDMI: u32 = unsafe { ::std::mem::transmute(isMonHDMI) }; - isMonHDMI as u64 - }); - __bindgen_bitfield_unit.set(8usize, 24u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_GetHDMISupportInfo()."] -pub type NV_HDMI_SUPPORT_INFO_V1 = _NV_HDMI_SUPPORT_INFO_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDMI_SUPPORT_INFO_V2 { - #[doc = "!< Structure version"] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Revision number of the EDID 861 extension"] - pub EDID861ExtRev: NvU32, -} -impl _NV_HDMI_SUPPORT_INFO_V2 { - #[inline] - pub fn isGpuHDMICapable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isGpuHDMICapable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isGpuHDMICapable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isGpuHDMICapable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonUnderscanCapable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonUnderscanCapable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonUnderscanCapable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonUnderscanCapable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonBasicAudioCapable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonBasicAudioCapable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonBasicAudioCapable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonBasicAudioCapable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonYCbCr444Capable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonYCbCr444Capable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonYCbCr444Capable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonYCbCr444Capable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonYCbCr422Capable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonYCbCr422Capable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonYCbCr422Capable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonYCbCr422Capable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonxvYCC601Capable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonxvYCC601Capable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonxvYCC601Capable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonxvYCC601Capable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonxvYCC709Capable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonxvYCC709Capable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(6usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonxvYCC709Capable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 6usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonxvYCC709Capable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 6usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonHDMI(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonHDMI(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(7usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonHDMI_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 7usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonHDMI_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 7usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonsYCC601Capable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonsYCC601Capable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(8usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonsYCC601Capable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 8usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonsYCC601Capable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 8usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonAdobeYCC601Capable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonAdobeYCC601Capable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(9usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonAdobeYCC601Capable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 9usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonAdobeYCC601Capable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 9usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isMonAdobeRGBCapable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMonAdobeRGBCapable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(10usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMonAdobeRGBCapable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 10usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMonAdobeRGBCapable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 10usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 21u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(11usize, 21u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 11usize, - 21u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 11usize, - 21u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isGpuHDMICapable: NvU32, - isMonUnderscanCapable: NvU32, - isMonBasicAudioCapable: NvU32, - isMonYCbCr444Capable: NvU32, - isMonYCbCr422Capable: NvU32, - isMonxvYCC601Capable: NvU32, - isMonxvYCC709Capable: NvU32, - isMonHDMI: NvU32, - isMonsYCC601Capable: NvU32, - isMonAdobeYCC601Capable: NvU32, - isMonAdobeRGBCapable: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isGpuHDMICapable: u32 = unsafe { ::std::mem::transmute(isGpuHDMICapable) }; - isGpuHDMICapable as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let isMonUnderscanCapable: u32 = - unsafe { ::std::mem::transmute(isMonUnderscanCapable) }; - isMonUnderscanCapable as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let isMonBasicAudioCapable: u32 = - unsafe { ::std::mem::transmute(isMonBasicAudioCapable) }; - isMonBasicAudioCapable as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let isMonYCbCr444Capable: u32 = unsafe { ::std::mem::transmute(isMonYCbCr444Capable) }; - isMonYCbCr444Capable as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let isMonYCbCr422Capable: u32 = unsafe { ::std::mem::transmute(isMonYCbCr422Capable) }; - isMonYCbCr422Capable as u64 - }); - __bindgen_bitfield_unit.set(5usize, 1u8, { - let isMonxvYCC601Capable: u32 = unsafe { ::std::mem::transmute(isMonxvYCC601Capable) }; - isMonxvYCC601Capable as u64 - }); - __bindgen_bitfield_unit.set(6usize, 1u8, { - let isMonxvYCC709Capable: u32 = unsafe { ::std::mem::transmute(isMonxvYCC709Capable) }; - isMonxvYCC709Capable as u64 - }); - __bindgen_bitfield_unit.set(7usize, 1u8, { - let isMonHDMI: u32 = unsafe { ::std::mem::transmute(isMonHDMI) }; - isMonHDMI as u64 - }); - __bindgen_bitfield_unit.set(8usize, 1u8, { - let isMonsYCC601Capable: u32 = unsafe { ::std::mem::transmute(isMonsYCC601Capable) }; - isMonsYCC601Capable as u64 - }); - __bindgen_bitfield_unit.set(9usize, 1u8, { - let isMonAdobeYCC601Capable: u32 = - unsafe { ::std::mem::transmute(isMonAdobeYCC601Capable) }; - isMonAdobeYCC601Capable as u64 - }); - __bindgen_bitfield_unit.set(10usize, 1u8, { - let isMonAdobeRGBCapable: u32 = unsafe { ::std::mem::transmute(isMonAdobeRGBCapable) }; - isMonAdobeRGBCapable as u64 - }); - __bindgen_bitfield_unit.set(11usize, 21u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_HDMI_SUPPORT_INFO_V2 = _NV_HDMI_SUPPORT_INFO_V2; -pub type NV_HDMI_SUPPORT_INFO = NV_HDMI_SUPPORT_INFO_V2; -#[doc = "!< Returns the fields in the infoframe with values set by the manufacturer - NVIDIA/OEM."] -pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_GET_DEFAULT: NV_INFOFRAME_CMD = 0; -#[doc = "!< Sets the fields in the infoframe to auto, and infoframe to the default infoframe for use in a set."] -pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_RESET: NV_INFOFRAME_CMD = 1; -#[doc = "!< Get the current infoframe state."] -pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_GET: NV_INFOFRAME_CMD = 2; -#[doc = "!< Set the current infoframe state (flushed to the monitor), the values are one time and do not persist."] -pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_SET: NV_INFOFRAME_CMD = 3; -#[doc = "!< Get the override infoframe state, non-override fields will be set to value = AUTO, overridden fields will have the current override values."] -pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_GET_OVERRIDE: NV_INFOFRAME_CMD = 4; -#[doc = "!< Set the override infoframe state, non-override fields will be set to value = AUTO, other values indicate override; persist across modeset/reboot"] -pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_SET_OVERRIDE: NV_INFOFRAME_CMD = 5; -#[doc = "!< get properties associated with infoframe (each of the infoframe type will have properties)"] -pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_GET_PROPERTY: NV_INFOFRAME_CMD = 6; -#[doc = "!< set properties associated with infoframe"] -pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_SET_PROPERTY: NV_INFOFRAME_CMD = 7; -#[doc = "! \\ingroup dispcontrol"] -pub type NV_INFOFRAME_CMD = ::std::os::raw::c_int; -#[doc = "!< Driver determines whether to send infoframes."] -pub const NV_INFOFRAME_PROPERTY_MODE_NV_INFOFRAME_PROPERTY_MODE_AUTO: NV_INFOFRAME_PROPERTY_MODE = - 0; -#[doc = "!< Driver always sends infoframe."] -pub const NV_INFOFRAME_PROPERTY_MODE_NV_INFOFRAME_PROPERTY_MODE_ENABLE: NV_INFOFRAME_PROPERTY_MODE = - 1; -#[doc = "!< Driver never sends infoframe."] -pub const NV_INFOFRAME_PROPERTY_MODE_NV_INFOFRAME_PROPERTY_MODE_DISABLE: - NV_INFOFRAME_PROPERTY_MODE = 2; -#[doc = "!< Driver only sends infoframe when client requests it via infoframe escape call."] -pub const NV_INFOFRAME_PROPERTY_MODE_NV_INFOFRAME_PROPERTY_MODE_ALLOW_OVERRIDE: - NV_INFOFRAME_PROPERTY_MODE = 3; -pub type NV_INFOFRAME_PROPERTY_MODE = ::std::os::raw::c_int; -pub const NV_INFOFRAME_PROPERTY_BLACKLIST_NV_INFOFRAME_PROPERTY_BLACKLIST_FALSE: - NV_INFOFRAME_PROPERTY_BLACKLIST = 0; -pub const NV_INFOFRAME_PROPERTY_BLACKLIST_NV_INFOFRAME_PROPERTY_BLACKLIST_TRUE: - NV_INFOFRAME_PROPERTY_BLACKLIST = 1; -#[doc = "! Returns whether the current monitor is in blacklist or force this monitor to be in blacklist."] -pub type NV_INFOFRAME_PROPERTY_BLACKLIST = ::std::os::raw::c_int; -#[repr(C)] -#[repr(align(4))] -#[derive(Debug, Copy, Clone)] -pub struct NV_INFOFRAME_PROPERTY { - pub _bitfield_align_1: [u16; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, -} -impl NV_INFOFRAME_PROPERTY { - #[inline] - pub fn mode(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32) } - } - #[inline] - pub fn set_mode(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 4u8, val as u64) - } - } - #[inline] - pub unsafe fn mode_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 4u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_mode_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 4u8, - val as u64, - ) - } - } - #[inline] - pub fn blackList(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 2u8) as u32) } - } - #[inline] - pub fn set_blackList(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn blackList_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_blackList_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 10u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(6usize, 10u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 6usize, - 10u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 6usize, - 10u8, - val as u64, - ) - } - } - #[inline] - pub fn version(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 8u8) as u32) } - } - #[inline] - pub fn set_version(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(16usize, 8u8, val as u64) - } - } - #[inline] - pub unsafe fn version_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 16usize, - 8u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_version_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 16usize, - 8u8, - val as u64, - ) - } - } - #[inline] - pub fn length(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u32) } - } - #[inline] - pub fn set_length(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(24usize, 8u8, val as u64) - } - } - #[inline] - pub unsafe fn length_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 24usize, - 8u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_length_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 24usize, - 8u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - mode: NvU32, - blackList: NvU32, - reserved: NvU32, - version: NvU32, - length: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 4u8, { - let mode: u32 = unsafe { ::std::mem::transmute(mode) }; - mode as u64 - }); - __bindgen_bitfield_unit.set(4usize, 2u8, { - let blackList: u32 = unsafe { ::std::mem::transmute(blackList) }; - blackList as u64 - }); - __bindgen_bitfield_unit.set(6usize, 10u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit.set(16usize, 8u8, { - let version: u32 = unsafe { ::std::mem::transmute(version) }; - version as u64 - }); - __bindgen_bitfield_unit.set(24usize, 8u8, { - let length: u32 = unsafe { ::std::mem::transmute(length) }; - length as u64 - }); - __bindgen_bitfield_unit - } -} -pub const NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_NODATA: - NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO = 0; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_OVERSCAN: - NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO = 1; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_UNDERSCAN: - NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO = 2; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_FUTURE: - NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO = 3; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_AUTO: - NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO = 7; -#[doc = "! Byte1 related"] -pub type NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_NOT_PRESENT: - NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA = 0; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_VERTICAL_PRESENT : NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_HORIZONTAL_PRESENT : NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_BOTH_PRESENT: - NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA = 3; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_AUTO: - NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA = 7; -pub type NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO_NV_INFOFRAME_FIELD_VALUE_AVI_AFI_ABSENT: - NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO = 0; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO_NV_INFOFRAME_FIELD_VALUE_AVI_AFI_PRESENT: - NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO = 1; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO_NV_INFOFRAME_FIELD_VALUE_AVI_AFI_AUTO: - NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO = 3; -pub type NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_RGB: - NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT = 0; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_YCbCr422 : NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_YCbCr444 : NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_FUTURE : NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_AUTO: - NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT = 7; -pub type NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_F17_NV_INFOFRAME_FIELD_VALUE_AVI_F17_FALSE: - NV_INFOFRAME_FIELD_VALUE_AVI_F17 = 0; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_F17_NV_INFOFRAME_FIELD_VALUE_AVI_F17_TRUE: - NV_INFOFRAME_FIELD_VALUE_AVI_F17 = 1; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_F17_NV_INFOFRAME_FIELD_VALUE_AVI_F17_AUTO: - NV_INFOFRAME_FIELD_VALUE_AVI_F17 = 3; -pub type NV_INFOFRAME_FIELD_VALUE_AVI_F17 = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NO_AFD : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE01 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE02 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE03 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_LETTERBOX_GT16x9 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 4 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE05 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 5 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE06 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 6 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE07 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 7 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_EQUAL_CODEDFRAME : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 8 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_CENTER_4x3 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 9 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_CENTER_16x9 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 10 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_CENTER_14x9 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 11 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE12 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 12 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_4x3_ON_14x9 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 13 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_16x9_ON_14x9 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 14 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_16x9_ON_4x3 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 15 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 31 ; -#[doc = "! Byte2 related"] -pub type NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_NO_DATA : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_4x3 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_16x9 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_FUTURE : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME = 7 ; -pub type NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_NO_DATA : NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_SMPTE_170M : NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_ITUR_BT709 : NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_USE_EXTENDED_COLORIMETRY : NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_AUTO: - NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY = 7; -pub type NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_NO_DATA : NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_HORIZONTAL : NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_VERTICAL : NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_BOTH : NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING = 7 ; -#[doc = "! Byte 3 related"] -pub type NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_DEFAULT : NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_LIMITED_RANGE : NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_FULL_RANGE : NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_RESERVED : NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION = 7 ; -pub type NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_XVYCC601 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_XVYCC709 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_SYCC601 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_ADOBEYCC601 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_ADOBERGB : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 4 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_RESERVED05 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 5 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_RESERVED06 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 6 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_RESERVED07 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 7 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 15 ; -pub type NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ITC_NV_INFOFRAME_FIELD_VALUE_AVI_ITC_VIDEO_CONTENT: - NV_INFOFRAME_FIELD_VALUE_AVI_ITC = 0; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ITC_NV_INFOFRAME_FIELD_VALUE_AVI_ITC_ITCONTENT: - NV_INFOFRAME_FIELD_VALUE_AVI_ITC = 1; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_ITC_NV_INFOFRAME_FIELD_VALUE_AVI_ITC_AUTO: - NV_INFOFRAME_FIELD_VALUE_AVI_ITC = 3; -pub type NV_INFOFRAME_FIELD_VALUE_AVI_ITC = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NONE : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X02 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X03 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X04 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X05 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 4 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X06 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 5 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X07 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 6 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X08 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 7 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X09 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 8 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X10 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 9 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED10 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 10 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED11 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 11 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED12 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 12 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED13 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 13 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED14 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 14 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED15 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 15 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 31 ; -#[doc = "! Byte 4 related"] -pub type NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_GRAPHICS : NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_PHOTO : NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_CINEMA : NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_GAME: - NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE = 3; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_AUTO: - NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE = 7; -pub type NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_LIMITED_RANGE : NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_FULL_RANGE : NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_RESERVED02 : NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_RESERVED03 : NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION = 7 ; -pub type NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION = ::std::os::raw::c_int; -#[doc = "! Adding an Auto bit to each field"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_INFOFRAME_VIDEO { - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 23usize]>, -} -impl NV_INFOFRAME_VIDEO { - #[inline] - pub fn vic(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) } - } - #[inline] - pub fn set_vic(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 8u8, val as u64) - } - } - #[inline] - pub unsafe fn vic_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 8u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_vic_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 8u8, - val as u64, - ) - } - } - #[inline] - pub fn pixelRepeat(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 5u8) as u32) } - } - #[inline] - pub fn set_pixelRepeat(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(8usize, 5u8, val as u64) - } - } - #[inline] - pub unsafe fn pixelRepeat_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 8usize, - 5u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_pixelRepeat_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 8usize, - 5u8, - val as u64, - ) - } - } - #[inline] - pub fn colorSpace(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 3u8) as u32) } - } - #[inline] - pub fn set_colorSpace(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(13usize, 3u8, val as u64) - } - } - #[inline] - pub unsafe fn colorSpace_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 13usize, - 3u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_colorSpace_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 13usize, - 3u8, - val as u64, - ) - } - } - #[inline] - pub fn colorimetry(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 3u8) as u32) } - } - #[inline] - pub fn set_colorimetry(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(16usize, 3u8, val as u64) - } - } - #[inline] - pub unsafe fn colorimetry_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 16usize, - 3u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_colorimetry_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 16usize, - 3u8, - val as u64, - ) - } - } - #[inline] - pub fn extendedColorimetry(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 4u8) as u32) } - } - #[inline] - pub fn set_extendedColorimetry(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(19usize, 4u8, val as u64) - } - } - #[inline] - pub unsafe fn extendedColorimetry_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 19usize, - 4u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_extendedColorimetry_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 19usize, - 4u8, - val as u64, - ) - } - } - #[inline] - pub fn rgbQuantizationRange(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 3u8) as u32) } - } - #[inline] - pub fn set_rgbQuantizationRange(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(23usize, 3u8, val as u64) - } - } - #[inline] - pub unsafe fn rgbQuantizationRange_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 23usize, - 3u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_rgbQuantizationRange_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 23usize, - 3u8, - val as u64, - ) - } - } - #[inline] - pub fn yccQuantizationRange(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 3u8) as u32) } - } - #[inline] - pub fn set_yccQuantizationRange(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(26usize, 3u8, val as u64) - } - } - #[inline] - pub unsafe fn yccQuantizationRange_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 26usize, - 3u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_yccQuantizationRange_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 26usize, - 3u8, - val as u64, - ) - } - } - #[inline] - pub fn itContent(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 2u8) as u32) } - } - #[inline] - pub fn set_itContent(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(29usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn itContent_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 29usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_itContent_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 29usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn contentTypes(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 3u8) as u32) } - } - #[inline] - pub fn set_contentTypes(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(32usize, 3u8, val as u64) - } - } - #[inline] - pub unsafe fn contentTypes_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 32usize, - 3u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_contentTypes_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 32usize, - 3u8, - val as u64, - ) - } - } - #[inline] - pub fn scanInfo(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(35usize, 3u8) as u32) } - } - #[inline] - pub fn set_scanInfo(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(35usize, 3u8, val as u64) - } - } - #[inline] - pub unsafe fn scanInfo_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 35usize, - 3u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_scanInfo_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 35usize, - 3u8, - val as u64, - ) - } - } - #[inline] - pub fn activeFormatInfoPresent(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(38usize, 2u8) as u32) } - } - #[inline] - pub fn set_activeFormatInfoPresent(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(38usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn activeFormatInfoPresent_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 38usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_activeFormatInfoPresent_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 38usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn activeFormatAspectRatio(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(40usize, 5u8) as u32) } - } - #[inline] - pub fn set_activeFormatAspectRatio(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(40usize, 5u8, val as u64) - } - } - #[inline] - pub unsafe fn activeFormatAspectRatio_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 40usize, - 5u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_activeFormatAspectRatio_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 40usize, - 5u8, - val as u64, - ) - } - } - #[inline] - pub fn picAspectRatio(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(45usize, 3u8) as u32) } - } - #[inline] - pub fn set_picAspectRatio(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(45usize, 3u8, val as u64) - } - } - #[inline] - pub unsafe fn picAspectRatio_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 45usize, - 3u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_picAspectRatio_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 45usize, - 3u8, - val as u64, - ) - } - } - #[inline] - pub fn nonuniformScaling(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 3u8) as u32) } - } - #[inline] - pub fn set_nonuniformScaling(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(48usize, 3u8, val as u64) - } - } - #[inline] - pub unsafe fn nonuniformScaling_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 48usize, - 3u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_nonuniformScaling_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 48usize, - 3u8, - val as u64, - ) - } - } - #[inline] - pub fn barInfo(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(51usize, 3u8) as u32) } - } - #[inline] - pub fn set_barInfo(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(51usize, 3u8, val as u64) - } - } - #[inline] - pub unsafe fn barInfo_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 51usize, - 3u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_barInfo_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 51usize, - 3u8, - val as u64, - ) - } - } - #[inline] - pub fn top_bar(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(64usize, 17u8) as u32) } - } - #[inline] - pub fn set_top_bar(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(64usize, 17u8, val as u64) - } - } - #[inline] - pub unsafe fn top_bar_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 64usize, - 17u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_top_bar_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 64usize, - 17u8, - val as u64, - ) - } - } - #[inline] - pub fn bottom_bar(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(96usize, 17u8) as u32) } - } - #[inline] - pub fn set_bottom_bar(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(96usize, 17u8, val as u64) - } - } - #[inline] - pub unsafe fn bottom_bar_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 96usize, - 17u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bottom_bar_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 96usize, - 17u8, - val as u64, - ) - } - } - #[inline] - pub fn left_bar(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(128usize, 17u8) as u32) } - } - #[inline] - pub fn set_left_bar(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(128usize, 17u8, val as u64) - } - } - #[inline] - pub unsafe fn left_bar_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 128usize, - 17u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_left_bar_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 128usize, - 17u8, - val as u64, - ) - } - } - #[inline] - pub fn right_bar(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(160usize, 17u8) as u32) } - } - #[inline] - pub fn set_right_bar(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(160usize, 17u8, val as u64) - } - } - #[inline] - pub unsafe fn right_bar_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 160usize, - 17u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_right_bar_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 160usize, - 17u8, - val as u64, - ) - } - } - #[inline] - pub fn Future17(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(177usize, 2u8) as u32) } - } - #[inline] - pub fn set_Future17(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(177usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn Future17_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 177usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_Future17_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 177usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn Future47(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(179usize, 2u8) as u32) } - } - #[inline] - pub fn set_Future47(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(179usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn Future47_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 179usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_Future47_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 179usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - vic: NvU32, - pixelRepeat: NvU32, - colorSpace: NvU32, - colorimetry: NvU32, - extendedColorimetry: NvU32, - rgbQuantizationRange: NvU32, - yccQuantizationRange: NvU32, - itContent: NvU32, - contentTypes: NvU32, - scanInfo: NvU32, - activeFormatInfoPresent: NvU32, - activeFormatAspectRatio: NvU32, - picAspectRatio: NvU32, - nonuniformScaling: NvU32, - barInfo: NvU32, - top_bar: NvU32, - bottom_bar: NvU32, - left_bar: NvU32, - right_bar: NvU32, - Future17: NvU32, - Future47: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 23usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 23usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 8u8, { - let vic: u32 = unsafe { ::std::mem::transmute(vic) }; - vic as u64 - }); - __bindgen_bitfield_unit.set(8usize, 5u8, { - let pixelRepeat: u32 = unsafe { ::std::mem::transmute(pixelRepeat) }; - pixelRepeat as u64 - }); - __bindgen_bitfield_unit.set(13usize, 3u8, { - let colorSpace: u32 = unsafe { ::std::mem::transmute(colorSpace) }; - colorSpace as u64 - }); - __bindgen_bitfield_unit.set(16usize, 3u8, { - let colorimetry: u32 = unsafe { ::std::mem::transmute(colorimetry) }; - colorimetry as u64 - }); - __bindgen_bitfield_unit.set(19usize, 4u8, { - let extendedColorimetry: u32 = unsafe { ::std::mem::transmute(extendedColorimetry) }; - extendedColorimetry as u64 - }); - __bindgen_bitfield_unit.set(23usize, 3u8, { - let rgbQuantizationRange: u32 = unsafe { ::std::mem::transmute(rgbQuantizationRange) }; - rgbQuantizationRange as u64 - }); - __bindgen_bitfield_unit.set(26usize, 3u8, { - let yccQuantizationRange: u32 = unsafe { ::std::mem::transmute(yccQuantizationRange) }; - yccQuantizationRange as u64 - }); - __bindgen_bitfield_unit.set(29usize, 2u8, { - let itContent: u32 = unsafe { ::std::mem::transmute(itContent) }; - itContent as u64 - }); - __bindgen_bitfield_unit.set(32usize, 3u8, { - let contentTypes: u32 = unsafe { ::std::mem::transmute(contentTypes) }; - contentTypes as u64 - }); - __bindgen_bitfield_unit.set(35usize, 3u8, { - let scanInfo: u32 = unsafe { ::std::mem::transmute(scanInfo) }; - scanInfo as u64 - }); - __bindgen_bitfield_unit.set(38usize, 2u8, { - let activeFormatInfoPresent: u32 = - unsafe { ::std::mem::transmute(activeFormatInfoPresent) }; - activeFormatInfoPresent as u64 - }); - __bindgen_bitfield_unit.set(40usize, 5u8, { - let activeFormatAspectRatio: u32 = - unsafe { ::std::mem::transmute(activeFormatAspectRatio) }; - activeFormatAspectRatio as u64 - }); - __bindgen_bitfield_unit.set(45usize, 3u8, { - let picAspectRatio: u32 = unsafe { ::std::mem::transmute(picAspectRatio) }; - picAspectRatio as u64 - }); - __bindgen_bitfield_unit.set(48usize, 3u8, { - let nonuniformScaling: u32 = unsafe { ::std::mem::transmute(nonuniformScaling) }; - nonuniformScaling as u64 - }); - __bindgen_bitfield_unit.set(51usize, 3u8, { - let barInfo: u32 = unsafe { ::std::mem::transmute(barInfo) }; - barInfo as u64 - }); - __bindgen_bitfield_unit.set(64usize, 17u8, { - let top_bar: u32 = unsafe { ::std::mem::transmute(top_bar) }; - top_bar as u64 - }); - __bindgen_bitfield_unit.set(96usize, 17u8, { - let bottom_bar: u32 = unsafe { ::std::mem::transmute(bottom_bar) }; - bottom_bar as u64 - }); - __bindgen_bitfield_unit.set(128usize, 17u8, { - let left_bar: u32 = unsafe { ::std::mem::transmute(left_bar) }; - left_bar as u64 - }); - __bindgen_bitfield_unit.set(160usize, 17u8, { - let right_bar: u32 = unsafe { ::std::mem::transmute(right_bar) }; - right_bar as u64 - }); - __bindgen_bitfield_unit.set(177usize, 2u8, { - let Future17: u32 = unsafe { ::std::mem::transmute(Future17) }; - Future17 as u64 - }); - __bindgen_bitfield_unit.set(179usize, 2u8, { - let Future47: u32 = unsafe { ::std::mem::transmute(Future47) }; - Future47 as u64 - }); - __bindgen_bitfield_unit - } -} -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_IN_HEADER : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_2 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_3 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_4 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_5 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 4 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_6 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 5 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_7 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 6 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_8 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 7 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 15 ; -#[doc = "! Byte 1 related"] -pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_IN_HEADER : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_PCM : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_AC3 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_MPEG1 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_MP3 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 4 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_MPEG2 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 5 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_AACLC : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 6 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_DTS : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 7 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_ATRAC : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 8 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_DSD : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 9 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_EAC3 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 10 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_DTSHD : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 11 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_MLP : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 12 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_DST : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 13 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_WMAPRO : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 14 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_USE_CODING_EXTENSION_TYPE : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 15 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 31 ; -pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_IN_HEADER : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_16BITS : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_20BITS : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_24BITS : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE = 7 ; -#[doc = "! Byte 2 related"] -pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_IN_HEADER : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_32000HZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_44100HZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_48000HZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_88200KHZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 4 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_96000KHZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 5 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_176400KHZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 6 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_192000KHZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 7 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 15 ; -pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_USE_CODING_TYPE : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_HEAAC : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_HEAACV2 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_MPEGSURROUND : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE04 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 4 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE05 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 5 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE06 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 6 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE07 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 7 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE08 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 8 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE09 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 9 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE10 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 10 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE11 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 11 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE12 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 12 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE13 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 13 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE14 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 14 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE15 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 15 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE16 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 16 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE17 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 17 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE18 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 18 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE19 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 19 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE20 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 20 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE21 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 21 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE22 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 22 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE23 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 23 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE24 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 24 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE25 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 25 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE26 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 26 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE27 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 27 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE28 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 28 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE29 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 29 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE30 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 30 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE31 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 31 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 63 ; -#[doc = "! Byte 3 related"] -pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_X_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_X_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_X_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_X_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_RC_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 4 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_RC_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 5 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_RC_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 6 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_RC_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 7 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_RR_RL_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 8 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_RR_RL_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 9 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 10 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 11 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_RC_RR_RL_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 12 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_RC_RR_RL_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 13 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_RC_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 14 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_RC_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 15 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_RRC_RLC_RR_RL_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 16 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_RRC_RLC_RR_RL_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 17 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_RRC_RLC_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 18 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_RRC_RLC_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 19 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_X_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 20 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_X_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 21 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_X_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 22 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_X_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 23 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_RC_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 24 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_RC_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 25 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_RC_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 26 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_RC_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 27 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_RR_RL_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 28 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_RR_RL_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 29 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 30 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 31 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_FCH_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 32 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_FCH_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 33 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_X_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 34 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_X_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 35 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRH_FLH_RR_RL_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 36 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRH_FLH_RR_RL_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 37 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRW_FLW_RR_RL_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 38 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRW_FLW_RR_RL_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 39 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_RC_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 40 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_RC_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 41 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FCH_RC_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 42 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FCH_RC_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 43 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_FCH_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 44 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_FCH_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 45 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRH_FLH_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 46 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRH_FLH_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 47 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRW_FLW_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 48 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRW_FLW_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 49 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 511 ; -#[doc = "! Byte 4 related"] -pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_NO_DATA : NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_0DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_PLUS10DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_RESERVED03 : NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL = 7 ; -#[doc = "! Byte 5 related"] -pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_0DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_1DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_2DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 2 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_3DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 3 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_4DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 4 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_5DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 5 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_6DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 6 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_7DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 7 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_8DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 8 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_9DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 9 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_10DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 10 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_11DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 11 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_12DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 12 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_13DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 13 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_14DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 14 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_15DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 15 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 31 ; -pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = ::std::os::raw::c_int; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_PERMITTED : NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX = 0 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_PROHIBITED : NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX = 1 ; -pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_AUTO: - NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX = 3; -pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX = ::std::os::raw::c_int; -#[repr(C)] -#[repr(align(4))] -#[derive(Debug, Copy, Clone)] -pub struct NV_INFOFRAME_AUDIO { - pub _bitfield_align_1: [u16; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 14usize]>, - pub __bindgen_padding_0: u16, -} -impl NV_INFOFRAME_AUDIO { - #[inline] - pub fn codingType(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 5u8) as u32) } - } - #[inline] - pub fn set_codingType(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 5u8, val as u64) - } - } - #[inline] - pub unsafe fn codingType_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 5u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_codingType_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 5u8, - val as u64, - ) - } - } - #[inline] - pub fn codingExtensionType(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 6u8) as u32) } - } - #[inline] - pub fn set_codingExtensionType(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 6u8, val as u64) - } - } - #[inline] - pub unsafe fn codingExtensionType_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 6u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_codingExtensionType_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 6u8, - val as u64, - ) - } - } - #[inline] - pub fn sampleSize(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 3u8) as u32) } - } - #[inline] - pub fn set_sampleSize(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(11usize, 3u8, val as u64) - } - } - #[inline] - pub unsafe fn sampleSize_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 11usize, - 3u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_sampleSize_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 11usize, - 3u8, - val as u64, - ) - } - } - #[inline] - pub fn sampleRate(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 4u8) as u32) } - } - #[inline] - pub fn set_sampleRate(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(14usize, 4u8, val as u64) - } - } - #[inline] - pub unsafe fn sampleRate_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 14usize, - 4u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_sampleRate_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 14usize, - 4u8, - val as u64, - ) - } - } - #[inline] - pub fn channelCount(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 4u8) as u32) } - } - #[inline] - pub fn set_channelCount(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(18usize, 4u8, val as u64) - } - } - #[inline] - pub unsafe fn channelCount_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 18usize, - 4u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_channelCount_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 18usize, - 4u8, - val as u64, - ) - } - } - #[inline] - pub fn speakerPlacement(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 9u8) as u32) } - } - #[inline] - pub fn set_speakerPlacement(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(22usize, 9u8, val as u64) - } - } - #[inline] - pub unsafe fn speakerPlacement_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 22usize, - 9u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_speakerPlacement_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 22usize, - 9u8, - val as u64, - ) - } - } - #[inline] - pub fn downmixInhibit(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 2u8) as u32) } - } - #[inline] - pub fn set_downmixInhibit(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(32usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn downmixInhibit_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 32usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_downmixInhibit_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 32usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn lfePlaybackLevel(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(34usize, 3u8) as u32) } - } - #[inline] - pub fn set_lfePlaybackLevel(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(34usize, 3u8, val as u64) - } - } - #[inline] - pub unsafe fn lfePlaybackLevel_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 34usize, - 3u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_lfePlaybackLevel_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 34usize, - 3u8, - val as u64, - ) - } - } - #[inline] - pub fn levelShift(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(37usize, 5u8) as u32) } - } - #[inline] - pub fn set_levelShift(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(37usize, 5u8, val as u64) - } - } - #[inline] - pub unsafe fn levelShift_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 37usize, - 5u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_levelShift_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 37usize, - 5u8, - val as u64, - ) - } - } - #[inline] - pub fn Future12(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(42usize, 2u8) as u32) } - } - #[inline] - pub fn set_Future12(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(42usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn Future12_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 42usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_Future12_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 42usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn Future2x(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(44usize, 4u8) as u32) } - } - #[inline] - pub fn set_Future2x(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(44usize, 4u8, val as u64) - } - } - #[inline] - pub unsafe fn Future2x_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 44usize, - 4u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_Future2x_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 44usize, - 4u8, - val as u64, - ) - } - } - #[inline] - pub fn Future3x(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 4u8) as u32) } - } - #[inline] - pub fn set_Future3x(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(48usize, 4u8, val as u64) - } - } - #[inline] - pub unsafe fn Future3x_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 48usize, - 4u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_Future3x_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 48usize, - 4u8, - val as u64, - ) - } - } - #[inline] - pub fn Future52(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(52usize, 2u8) as u32) } - } - #[inline] - pub fn set_Future52(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(52usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn Future52_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 52usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_Future52_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 52usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn Future6(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(54usize, 9u8) as u32) } - } - #[inline] - pub fn set_Future6(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(54usize, 9u8, val as u64) - } - } - #[inline] - pub unsafe fn Future6_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 54usize, - 9u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_Future6_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 54usize, - 9u8, - val as u64, - ) - } - } - #[inline] - pub fn Future7(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(64usize, 9u8) as u32) } - } - #[inline] - pub fn set_Future7(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(64usize, 9u8, val as u64) - } - } - #[inline] - pub unsafe fn Future7_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 64usize, - 9u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_Future7_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 64usize, - 9u8, - val as u64, - ) - } - } - #[inline] - pub fn Future8(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(73usize, 9u8) as u32) } - } - #[inline] - pub fn set_Future8(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(73usize, 9u8, val as u64) - } - } - #[inline] - pub unsafe fn Future8_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 73usize, - 9u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_Future8_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 73usize, - 9u8, - val as u64, - ) - } - } - #[inline] - pub fn Future9(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(82usize, 9u8) as u32) } - } - #[inline] - pub fn set_Future9(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(82usize, 9u8, val as u64) - } - } - #[inline] - pub unsafe fn Future9_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 82usize, - 9u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_Future9_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 82usize, - 9u8, - val as u64, - ) - } - } - #[inline] - pub fn Future10(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(96usize, 9u8) as u32) } - } - #[inline] - pub fn set_Future10(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(96usize, 9u8, val as u64) - } - } - #[inline] - pub unsafe fn Future10_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 96usize, - 9u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_Future10_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 96usize, - 9u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - codingType: NvU32, - codingExtensionType: NvU32, - sampleSize: NvU32, - sampleRate: NvU32, - channelCount: NvU32, - speakerPlacement: NvU32, - downmixInhibit: NvU32, - lfePlaybackLevel: NvU32, - levelShift: NvU32, - Future12: NvU32, - Future2x: NvU32, - Future3x: NvU32, - Future52: NvU32, - Future6: NvU32, - Future7: NvU32, - Future8: NvU32, - Future9: NvU32, - Future10: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 14usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 14usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 5u8, { - let codingType: u32 = unsafe { ::std::mem::transmute(codingType) }; - codingType as u64 - }); - __bindgen_bitfield_unit.set(5usize, 6u8, { - let codingExtensionType: u32 = unsafe { ::std::mem::transmute(codingExtensionType) }; - codingExtensionType as u64 - }); - __bindgen_bitfield_unit.set(11usize, 3u8, { - let sampleSize: u32 = unsafe { ::std::mem::transmute(sampleSize) }; - sampleSize as u64 - }); - __bindgen_bitfield_unit.set(14usize, 4u8, { - let sampleRate: u32 = unsafe { ::std::mem::transmute(sampleRate) }; - sampleRate as u64 - }); - __bindgen_bitfield_unit.set(18usize, 4u8, { - let channelCount: u32 = unsafe { ::std::mem::transmute(channelCount) }; - channelCount as u64 - }); - __bindgen_bitfield_unit.set(22usize, 9u8, { - let speakerPlacement: u32 = unsafe { ::std::mem::transmute(speakerPlacement) }; - speakerPlacement as u64 - }); - __bindgen_bitfield_unit.set(32usize, 2u8, { - let downmixInhibit: u32 = unsafe { ::std::mem::transmute(downmixInhibit) }; - downmixInhibit as u64 - }); - __bindgen_bitfield_unit.set(34usize, 3u8, { - let lfePlaybackLevel: u32 = unsafe { ::std::mem::transmute(lfePlaybackLevel) }; - lfePlaybackLevel as u64 - }); - __bindgen_bitfield_unit.set(37usize, 5u8, { - let levelShift: u32 = unsafe { ::std::mem::transmute(levelShift) }; - levelShift as u64 - }); - __bindgen_bitfield_unit.set(42usize, 2u8, { - let Future12: u32 = unsafe { ::std::mem::transmute(Future12) }; - Future12 as u64 - }); - __bindgen_bitfield_unit.set(44usize, 4u8, { - let Future2x: u32 = unsafe { ::std::mem::transmute(Future2x) }; - Future2x as u64 - }); - __bindgen_bitfield_unit.set(48usize, 4u8, { - let Future3x: u32 = unsafe { ::std::mem::transmute(Future3x) }; - Future3x as u64 - }); - __bindgen_bitfield_unit.set(52usize, 2u8, { - let Future52: u32 = unsafe { ::std::mem::transmute(Future52) }; - Future52 as u64 - }); - __bindgen_bitfield_unit.set(54usize, 9u8, { - let Future6: u32 = unsafe { ::std::mem::transmute(Future6) }; - Future6 as u64 - }); - __bindgen_bitfield_unit.set(64usize, 9u8, { - let Future7: u32 = unsafe { ::std::mem::transmute(Future7) }; - Future7 as u64 - }); - __bindgen_bitfield_unit.set(73usize, 9u8, { - let Future8: u32 = unsafe { ::std::mem::transmute(Future8) }; - Future8 as u64 - }); - __bindgen_bitfield_unit.set(82usize, 9u8, { - let Future9: u32 = unsafe { ::std::mem::transmute(Future9) }; - Future9 as u64 - }); - __bindgen_bitfield_unit.set(96usize, 9u8, { - let Future10: u32 = unsafe { ::std::mem::transmute(Future10) }; - Future10 as u64 - }); - __bindgen_bitfield_unit - } -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct NV_INFOFRAME_DATA { - #[doc = "!< version of this structure"] - pub version: NvU32, - #[doc = "!< size of this structure"] - pub size: NvU16, - #[doc = "!< The actions to perform from NV_INFOFRAME_CMD"] - pub cmd: NvU8, - #[doc = "!< type of infoframe"] - pub type_: NvU8, - pub infoframe: NV_INFOFRAME_DATA__bindgen_ty_1, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union NV_INFOFRAME_DATA__bindgen_ty_1 { - #[doc = "!< This is NVIDIA-specific and corresponds to the property cmds and associated infoframe."] - pub property: NV_INFOFRAME_PROPERTY, - pub audio: NV_INFOFRAME_AUDIO, - pub video: NV_INFOFRAME_VIDEO, -} -pub const NV_COLOR_CMD_NV_COLOR_CMD_GET: NV_COLOR_CMD = 1; -pub const NV_COLOR_CMD_NV_COLOR_CMD_SET: NV_COLOR_CMD = 2; -pub const NV_COLOR_CMD_NV_COLOR_CMD_IS_SUPPORTED_COLOR: NV_COLOR_CMD = 3; -pub const NV_COLOR_CMD_NV_COLOR_CMD_GET_DEFAULT: NV_COLOR_CMD = 4; -pub type NV_COLOR_CMD = ::std::os::raw::c_int; -pub const NV_COLOR_FORMAT_NV_COLOR_FORMAT_RGB: NV_COLOR_FORMAT = 0; -pub const NV_COLOR_FORMAT_NV_COLOR_FORMAT_YUV422: NV_COLOR_FORMAT = 1; -pub const NV_COLOR_FORMAT_NV_COLOR_FORMAT_YUV444: NV_COLOR_FORMAT = 2; -pub const NV_COLOR_FORMAT_NV_COLOR_FORMAT_YUV420: NV_COLOR_FORMAT = 3; -pub const NV_COLOR_FORMAT_NV_COLOR_FORMAT_DEFAULT: NV_COLOR_FORMAT = 254; -pub const NV_COLOR_FORMAT_NV_COLOR_FORMAT_AUTO: NV_COLOR_FORMAT = 255; -#[doc = "! See Table 14 of CEA-861E. Not all of this is supported by the GPU."] -pub type NV_COLOR_FORMAT = ::std::os::raw::c_int; -pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_RGB: NV_COLOR_COLORIMETRY = 0; -pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_YCC601: NV_COLOR_COLORIMETRY = 1; -pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_YCC709: NV_COLOR_COLORIMETRY = 2; -pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_XVYCC601: NV_COLOR_COLORIMETRY = 3; -pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_XVYCC709: NV_COLOR_COLORIMETRY = 4; -pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_SYCC601: NV_COLOR_COLORIMETRY = 5; -pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_ADOBEYCC601: NV_COLOR_COLORIMETRY = 6; -pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_ADOBERGB: NV_COLOR_COLORIMETRY = 7; -pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_BT2020RGB: NV_COLOR_COLORIMETRY = 8; -pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_BT2020YCC: NV_COLOR_COLORIMETRY = 9; -pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_BT2020cYCC: NV_COLOR_COLORIMETRY = 10; -pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_DEFAULT: NV_COLOR_COLORIMETRY = 254; -pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_AUTO: NV_COLOR_COLORIMETRY = 255; -pub type NV_COLOR_COLORIMETRY = ::std::os::raw::c_int; -pub const _NV_DYNAMIC_RANGE_NV_DYNAMIC_RANGE_VESA: _NV_DYNAMIC_RANGE = 0; -pub const _NV_DYNAMIC_RANGE_NV_DYNAMIC_RANGE_CEA: _NV_DYNAMIC_RANGE = 1; -pub const _NV_DYNAMIC_RANGE_NV_DYNAMIC_RANGE_AUTO: _NV_DYNAMIC_RANGE = 255; -pub type _NV_DYNAMIC_RANGE = ::std::os::raw::c_int; -pub use self::_NV_DYNAMIC_RANGE as NV_DYNAMIC_RANGE; -pub const _NV_BPC_NV_BPC_DEFAULT: _NV_BPC = 0; -pub const _NV_BPC_NV_BPC_6: _NV_BPC = 1; -pub const _NV_BPC_NV_BPC_8: _NV_BPC = 2; -pub const _NV_BPC_NV_BPC_10: _NV_BPC = 3; -pub const _NV_BPC_NV_BPC_12: _NV_BPC = 4; -pub const _NV_BPC_NV_BPC_16: _NV_BPC = 5; -pub type _NV_BPC = ::std::os::raw::c_int; -pub use self::_NV_BPC as NV_BPC; -#[doc = "!< app/nvcpl make decision to select the desire color format"] -pub const _NV_COLOR_SELECTION_POLICY_NV_COLOR_SELECTION_POLICY_USER: _NV_COLOR_SELECTION_POLICY = 0; -#[doc = "!< driver/ OS make decision to select the best color format"] -pub const _NV_COLOR_SELECTION_POLICY_NV_COLOR_SELECTION_POLICY_BEST_QUALITY: - _NV_COLOR_SELECTION_POLICY = 1; -pub const _NV_COLOR_SELECTION_POLICY_NV_COLOR_SELECTION_POLICY_DEFAULT: _NV_COLOR_SELECTION_POLICY = - 1; -pub const _NV_COLOR_SELECTION_POLICY_NV_COLOR_SELECTION_POLICY_UNKNOWN: _NV_COLOR_SELECTION_POLICY = - 255; -pub type _NV_COLOR_SELECTION_POLICY = ::std::os::raw::c_int; -pub use self::_NV_COLOR_SELECTION_POLICY as NV_COLOR_SELECTION_POLICY; -pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_DEFAULT: _NV_DESKTOP_COLOR_DEPTH = 0; -pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_8BPC: _NV_DESKTOP_COLOR_DEPTH = 1; -pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_10BPC: _NV_DESKTOP_COLOR_DEPTH = 2; -pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_16BPC_FLOAT: _NV_DESKTOP_COLOR_DEPTH = 3; -pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_16BPC_FLOAT_WCG: _NV_DESKTOP_COLOR_DEPTH = - 4; -pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_16BPC_FLOAT_HDR: _NV_DESKTOP_COLOR_DEPTH = - 5; -pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_MAX_VALUE: _NV_DESKTOP_COLOR_DEPTH = 5; -pub type _NV_DESKTOP_COLOR_DEPTH = ::std::os::raw::c_int; -pub use self::_NV_DESKTOP_COLOR_DEPTH as NV_DESKTOP_COLOR_DEPTH; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_COLOR_DATA_V1 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< Size of this structure"] - pub size: NvU16, - pub cmd: NvU8, - pub data: _NV_COLOR_DATA_V1__bindgen_ty_1, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_COLOR_DATA_V1__bindgen_ty_1 { - #[doc = "!< One of NV_COLOR_FORMAT enum values."] - pub colorFormat: NvU8, - #[doc = "!< One of NV_COLOR_COLORIMETRY enum values."] - pub colorimetry: NvU8, -} -pub type NV_COLOR_DATA_V1 = _NV_COLOR_DATA_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_COLOR_DATA_V2 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< Size of this structure"] - pub size: NvU16, - pub cmd: NvU8, - pub data: _NV_COLOR_DATA_V2__bindgen_ty_1, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_COLOR_DATA_V2__bindgen_ty_1 { - #[doc = "!< One of NV_COLOR_FORMAT enum values."] - pub colorFormat: NvU8, - #[doc = "!< One of NV_COLOR_COLORIMETRY enum values."] - pub colorimetry: NvU8, - #[doc = "!< One of NV_DYNAMIC_RANGE enum values."] - pub dynamicRange: NvU8, -} -pub type NV_COLOR_DATA_V2 = _NV_COLOR_DATA_V2; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_COLOR_DATA_V3 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< Size of this structure"] - pub size: NvU16, - pub cmd: NvU8, - pub data: _NV_COLOR_DATA_V3__bindgen_ty_1, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_COLOR_DATA_V3__bindgen_ty_1 { - #[doc = "!< One of NV_COLOR_FORMAT enum values."] - pub colorFormat: NvU8, - #[doc = "!< One of NV_COLOR_COLORIMETRY enum values."] - pub colorimetry: NvU8, - #[doc = "!< One of NV_DYNAMIC_RANGE enum values."] - pub dynamicRange: NvU8, - #[doc = "!< One of NV_BPC enum values."] - pub bpc: NV_BPC, -} -pub type NV_COLOR_DATA_V3 = _NV_COLOR_DATA_V3; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_COLOR_DATA_V4 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< Size of this structure"] - pub size: NvU16, - pub cmd: NvU8, - pub data: _NV_COLOR_DATA_V4__bindgen_ty_1, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_COLOR_DATA_V4__bindgen_ty_1 { - #[doc = "!< One of NV_COLOR_FORMAT enum values."] - pub colorFormat: NvU8, - #[doc = "!< One of NV_COLOR_COLORIMETRY enum values."] - pub colorimetry: NvU8, - #[doc = "!< One of NV_DYNAMIC_RANGE enum values."] - pub dynamicRange: NvU8, - #[doc = "!< One of NV_BPC enum values."] - pub bpc: NV_BPC, - #[doc = "!< One of the color selection policy"] - pub colorSelectionPolicy: NV_COLOR_SELECTION_POLICY, -} -pub type NV_COLOR_DATA_V4 = _NV_COLOR_DATA_V4; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_COLOR_DATA_V5 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< Size of this structure"] - pub size: NvU16, - pub cmd: NvU8, - pub data: _NV_COLOR_DATA_V5__bindgen_ty_1, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_COLOR_DATA_V5__bindgen_ty_1 { - #[doc = "!< One of NV_COLOR_FORMAT enum values."] - pub colorFormat: NvU8, - #[doc = "!< One of NV_COLOR_COLORIMETRY enum values."] - pub colorimetry: NvU8, - #[doc = "!< One of NV_DYNAMIC_RANGE enum values."] - pub dynamicRange: NvU8, - #[doc = "!< One of NV_BPC enum values."] - pub bpc: NV_BPC, - #[doc = "!< One of the color selection policy"] - pub colorSelectionPolicy: NV_COLOR_SELECTION_POLICY, - #[doc = "!< One of NV_DESKTOP_COLOR_DEPTH enum values."] - pub depth: NV_DESKTOP_COLOR_DEPTH, -} -pub type NV_COLOR_DATA_V5 = _NV_COLOR_DATA_V5; -pub type NV_COLOR_DATA = NV_COLOR_DATA_V5; -#[doc = "!< Tells the type of structure used to define the Static Metadata Descriptor block."] -pub const NV_STATIC_METADATA_DESCRIPTOR_ID_NV_STATIC_METADATA_TYPE_1: - NV_STATIC_METADATA_DESCRIPTOR_ID = 0; -#[doc = "! @}"] -pub type NV_STATIC_METADATA_DESCRIPTOR_ID = ::std::os::raw::c_int; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDR_CAPABILITIES_V1 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Static Metadata Descriptor Id (0 for static metadata type 1)"] - pub static_metadata_descriptor_id: NV_STATIC_METADATA_DESCRIPTOR_ID, - pub display_data: _NV_HDR_CAPABILITIES_V1__bindgen_ty_1, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDR_CAPABILITIES_V1__bindgen_ty_1 { - #[doc = "!< x coordinate of color primary 0 (e.g. Red) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x0: NvU16, - #[doc = "!< y coordinate of color primary 0 (e.g. Red) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y0: NvU16, - #[doc = "!< x coordinate of color primary 1 (e.g. Green) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x1: NvU16, - #[doc = "!< y coordinate of color primary 1 (e.g. Green) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y1: NvU16, - #[doc = "!< x coordinate of color primary 2 (e.g. Blue) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x2: NvU16, - #[doc = "!< y coordinate of color primary 2 (e.g. Blue) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y2: NvU16, - #[doc = "!< x coordinate of white point of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayWhitePoint_x: NvU16, - #[doc = "!< y coordinate of white point of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayWhitePoint_y: NvU16, - #[doc = "!< Maximum display luminance = desired max luminance of HDR content ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] - pub desired_content_max_luminance: NvU16, - #[doc = "!< Minimum display luminance = desired min luminance of HDR content ([0x0001-0xFFFF] = [1.0 - 6.55350] cd/m^2)"] - pub desired_content_min_luminance: NvU16, - #[doc = "!< Desired maximum Frame-Average Light Level (MaxFALL) of HDR content ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] - pub desired_content_max_frame_average_luminance: NvU16, -} -impl _NV_HDR_CAPABILITIES_V1 { - #[inline] - pub fn isST2084EotfSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isST2084EotfSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isST2084EotfSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isST2084EotfSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isTraditionalHdrGammaSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_isTraditionalHdrGammaSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isTraditionalHdrGammaSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isTraditionalHdrGammaSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isEdrSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_isEdrSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isEdrSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isEdrSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn driverExpandDefaultHdrParameters(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_driverExpandDefaultHdrParameters(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn driverExpandDefaultHdrParameters_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_driverExpandDefaultHdrParameters_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isTraditionalSdrGammaSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } - } - #[inline] - pub fn set_isTraditionalSdrGammaSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isTraditionalSdrGammaSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isTraditionalSdrGammaSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 27u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 27u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 27u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isST2084EotfSupported: NvU32, - isTraditionalHdrGammaSupported: NvU32, - isEdrSupported: NvU32, - driverExpandDefaultHdrParameters: NvU32, - isTraditionalSdrGammaSupported: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isST2084EotfSupported: u32 = - unsafe { ::std::mem::transmute(isST2084EotfSupported) }; - isST2084EotfSupported as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let isTraditionalHdrGammaSupported: u32 = - unsafe { ::std::mem::transmute(isTraditionalHdrGammaSupported) }; - isTraditionalHdrGammaSupported as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let isEdrSupported: u32 = unsafe { ::std::mem::transmute(isEdrSupported) }; - isEdrSupported as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let driverExpandDefaultHdrParameters: u32 = - unsafe { ::std::mem::transmute(driverExpandDefaultHdrParameters) }; - driverExpandDefaultHdrParameters as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let isTraditionalSdrGammaSupported: u32 = - unsafe { ::std::mem::transmute(isTraditionalSdrGammaSupported) }; - isTraditionalSdrGammaSupported as u64 - }); - __bindgen_bitfield_unit.set(5usize, 27u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_HDR_CAPABILITIES_V1 = _NV_HDR_CAPABILITIES_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDR_CAPABILITIES_V2 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Static Metadata Descriptor Id (0 for static metadata type 1)"] - pub static_metadata_descriptor_id: NV_STATIC_METADATA_DESCRIPTOR_ID, - pub display_data: _NV_HDR_CAPABILITIES_V2__bindgen_ty_1, - pub dv_static_metadata: _NV_HDR_CAPABILITIES_V2__bindgen_ty_2, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDR_CAPABILITIES_V2__bindgen_ty_1 { - #[doc = "!< x coordinate of color primary 0 (e.g. Red) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x0: NvU16, - #[doc = "!< y coordinate of color primary 0 (e.g. Red) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y0: NvU16, - #[doc = "!< x coordinate of color primary 1 (e.g. Green) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x1: NvU16, - #[doc = "!< y coordinate of color primary 1 (e.g. Green) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y1: NvU16, - #[doc = "!< x coordinate of color primary 2 (e.g. Blue) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x2: NvU16, - #[doc = "!< y coordinate of color primary 2 (e.g. Blue) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y2: NvU16, - #[doc = "!< x coordinate of white point of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayWhitePoint_x: NvU16, - #[doc = "!< y coordinate of white point of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayWhitePoint_y: NvU16, - #[doc = "!< Maximum display luminance = desired max luminance of HDR content ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] - pub desired_content_max_luminance: NvU16, - #[doc = "!< Minimum display luminance = desired min luminance of HDR content ([0x0001-0xFFFF] = [1.0 - 6.55350] cd/m^2)"] - pub desired_content_min_luminance: NvU16, - #[doc = "!< Desired maximum Frame-Average Light Level (MaxFALL) of HDR content ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] - pub desired_content_max_frame_average_luminance: NvU16, -} -#[repr(C)] -#[repr(align(4))] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDR_CAPABILITIES_V2__bindgen_ty_2 { - pub _bitfield_align_1: [u16; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Represents min luminance level of Sink"] - pub target_min_luminance: NvU16, - #[doc = "!< Represents max luminance level of sink"] - pub target_max_luminance: NvU16, - #[doc = "!< Red primary chromaticity coordinate x"] - pub cc_red_x: NvU16, - #[doc = "!< Red primary chromaticity coordinate y"] - pub cc_red_y: NvU16, - #[doc = "!< Green primary chromaticity coordinate x"] - pub cc_green_x: NvU16, - #[doc = "!< Green primary chromaticity coordinate Y"] - pub cc_green_y: NvU16, - #[doc = "!< Blue primary chromaticity coordinate x"] - pub cc_blue_x: NvU16, - #[doc = "!< Blue primary chromaticity coordinate y"] - pub cc_blue_y: NvU16, - #[doc = "!< White primary chromaticity coordinate x"] - pub cc_white_x: NvU16, - #[doc = "!< White primary chromaticity coordinate y"] - pub cc_white_y: NvU16, -} -impl _NV_HDR_CAPABILITIES_V2__bindgen_ty_2 { - #[inline] - pub fn VSVDB_version(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 3u8) as u32) } - } - #[inline] - pub fn set_VSVDB_version(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 3u8, val as u64) - } - } - #[inline] - pub unsafe fn VSVDB_version_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 3u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_VSVDB_version_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 3u8, - val as u64, - ) - } - } - #[inline] - pub fn dm_version(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 8u8) as u32) } - } - #[inline] - pub fn set_dm_version(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 8u8, val as u64) - } - } - #[inline] - pub unsafe fn dm_version_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 8u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_dm_version_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 8u8, - val as u64, - ) - } - } - #[inline] - pub fn supports_2160p60hz(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) } - } - #[inline] - pub fn set_supports_2160p60hz(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(11usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supports_2160p60hz_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 11usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_supports_2160p60hz_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 11usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn supports_YUV422_12bit(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) } - } - #[inline] - pub fn set_supports_YUV422_12bit(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(12usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supports_YUV422_12bit_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 12usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_supports_YUV422_12bit_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 12usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn supports_global_dimming(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) } - } - #[inline] - pub fn set_supports_global_dimming(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(13usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supports_global_dimming_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 13usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_supports_global_dimming_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 13usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn colorimetry(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) } - } - #[inline] - pub fn set_colorimetry(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(14usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn colorimetry_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 14usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_colorimetry_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 14usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn supports_backlight_control(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 2u8) as u32) } - } - #[inline] - pub fn set_supports_backlight_control(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(15usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn supports_backlight_control_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 15usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_supports_backlight_control_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 15usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn backlt_min_luma(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 2u8) as u32) } - } - #[inline] - pub fn set_backlt_min_luma(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(17usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn backlt_min_luma_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 17usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_backlt_min_luma_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 17usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn interface_supported_by_sink(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 2u8) as u32) } - } - #[inline] - pub fn set_interface_supported_by_sink(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(19usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn interface_supported_by_sink_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 19usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_interface_supported_by_sink_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 19usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn supports_10b_12b_444(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 2u8) as u32) } - } - #[inline] - pub fn set_supports_10b_12b_444(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(21usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn supports_10b_12b_444_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 21usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_supports_10b_12b_444_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 21usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 9u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(23usize, 9u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 23usize, - 9u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 23usize, - 9u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - VSVDB_version: NvU32, - dm_version: NvU32, - supports_2160p60hz: NvU32, - supports_YUV422_12bit: NvU32, - supports_global_dimming: NvU32, - colorimetry: NvU32, - supports_backlight_control: NvU32, - backlt_min_luma: NvU32, - interface_supported_by_sink: NvU32, - supports_10b_12b_444: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 3u8, { - let VSVDB_version: u32 = unsafe { ::std::mem::transmute(VSVDB_version) }; - VSVDB_version as u64 - }); - __bindgen_bitfield_unit.set(3usize, 8u8, { - let dm_version: u32 = unsafe { ::std::mem::transmute(dm_version) }; - dm_version as u64 - }); - __bindgen_bitfield_unit.set(11usize, 1u8, { - let supports_2160p60hz: u32 = unsafe { ::std::mem::transmute(supports_2160p60hz) }; - supports_2160p60hz as u64 - }); - __bindgen_bitfield_unit.set(12usize, 1u8, { - let supports_YUV422_12bit: u32 = - unsafe { ::std::mem::transmute(supports_YUV422_12bit) }; - supports_YUV422_12bit as u64 - }); - __bindgen_bitfield_unit.set(13usize, 1u8, { - let supports_global_dimming: u32 = - unsafe { ::std::mem::transmute(supports_global_dimming) }; - supports_global_dimming as u64 - }); - __bindgen_bitfield_unit.set(14usize, 1u8, { - let colorimetry: u32 = unsafe { ::std::mem::transmute(colorimetry) }; - colorimetry as u64 - }); - __bindgen_bitfield_unit.set(15usize, 2u8, { - let supports_backlight_control: u32 = - unsafe { ::std::mem::transmute(supports_backlight_control) }; - supports_backlight_control as u64 - }); - __bindgen_bitfield_unit.set(17usize, 2u8, { - let backlt_min_luma: u32 = unsafe { ::std::mem::transmute(backlt_min_luma) }; - backlt_min_luma as u64 - }); - __bindgen_bitfield_unit.set(19usize, 2u8, { - let interface_supported_by_sink: u32 = - unsafe { ::std::mem::transmute(interface_supported_by_sink) }; - interface_supported_by_sink as u64 - }); - __bindgen_bitfield_unit.set(21usize, 2u8, { - let supports_10b_12b_444: u32 = unsafe { ::std::mem::transmute(supports_10b_12b_444) }; - supports_10b_12b_444 as u64 - }); - __bindgen_bitfield_unit.set(23usize, 9u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -impl _NV_HDR_CAPABILITIES_V2 { - #[inline] - pub fn isST2084EotfSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isST2084EotfSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isST2084EotfSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isST2084EotfSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isTraditionalHdrGammaSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_isTraditionalHdrGammaSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isTraditionalHdrGammaSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isTraditionalHdrGammaSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isEdrSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_isEdrSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isEdrSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isEdrSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn driverExpandDefaultHdrParameters(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_driverExpandDefaultHdrParameters(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn driverExpandDefaultHdrParameters_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_driverExpandDefaultHdrParameters_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isTraditionalSdrGammaSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } - } - #[inline] - pub fn set_isTraditionalSdrGammaSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isTraditionalSdrGammaSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isTraditionalSdrGammaSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isDolbyVisionSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } - } - #[inline] - pub fn set_isDolbyVisionSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isDolbyVisionSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isDolbyVisionSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 26u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(6usize, 26u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 6usize, - 26u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 6usize, - 26u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isST2084EotfSupported: NvU32, - isTraditionalHdrGammaSupported: NvU32, - isEdrSupported: NvU32, - driverExpandDefaultHdrParameters: NvU32, - isTraditionalSdrGammaSupported: NvU32, - isDolbyVisionSupported: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isST2084EotfSupported: u32 = - unsafe { ::std::mem::transmute(isST2084EotfSupported) }; - isST2084EotfSupported as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let isTraditionalHdrGammaSupported: u32 = - unsafe { ::std::mem::transmute(isTraditionalHdrGammaSupported) }; - isTraditionalHdrGammaSupported as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let isEdrSupported: u32 = unsafe { ::std::mem::transmute(isEdrSupported) }; - isEdrSupported as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let driverExpandDefaultHdrParameters: u32 = - unsafe { ::std::mem::transmute(driverExpandDefaultHdrParameters) }; - driverExpandDefaultHdrParameters as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let isTraditionalSdrGammaSupported: u32 = - unsafe { ::std::mem::transmute(isTraditionalSdrGammaSupported) }; - isTraditionalSdrGammaSupported as u64 - }); - __bindgen_bitfield_unit.set(5usize, 1u8, { - let isDolbyVisionSupported: u32 = - unsafe { ::std::mem::transmute(isDolbyVisionSupported) }; - isDolbyVisionSupported as u64 - }); - __bindgen_bitfield_unit.set(6usize, 26u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_HDR_CAPABILITIES_V2 = _NV_HDR_CAPABILITIES_V2; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDR_CAPABILITIES_V3 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Static Metadata Descriptor Id (0 for static metadata type 1)"] - pub static_metadata_descriptor_id: NV_STATIC_METADATA_DESCRIPTOR_ID, - pub display_data: _NV_HDR_CAPABILITIES_V3__bindgen_ty_1, - pub dv_static_metadata: _NV_HDR_CAPABILITIES_V3__bindgen_ty_2, - pub hdr10plus_vsvdb: _NV_HDR_CAPABILITIES_V3__bindgen_ty_3, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDR_CAPABILITIES_V3__bindgen_ty_1 { - #[doc = "!< x coordinate of color primary 0 (e.g. Red) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x0: NvU16, - #[doc = "!< y coordinate of color primary 0 (e.g. Red) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y0: NvU16, - #[doc = "!< x coordinate of color primary 1 (e.g. Green) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x1: NvU16, - #[doc = "!< y coordinate of color primary 1 (e.g. Green) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y1: NvU16, - #[doc = "!< x coordinate of color primary 2 (e.g. Blue) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x2: NvU16, - #[doc = "!< y coordinate of color primary 2 (e.g. Blue) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y2: NvU16, - #[doc = "!< x coordinate of white point of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayWhitePoint_x: NvU16, - #[doc = "!< y coordinate of white point of the display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayWhitePoint_y: NvU16, - #[doc = "!< Maximum display luminance = desired max luminance of HDR content ([0x0000-0xFFFF] = [0.0 - 65535.0] cd/m^2, in units of 1 cd/m^2)"] - pub desired_content_max_luminance: NvU16, - #[doc = "!< Minimum display luminance = desired min luminance of HDR content ([0x0000-0xFFFF] = [0.0 - 6.55350] cd/m^2, in units of 0.0001 cd/m^2)"] - pub desired_content_min_luminance: NvU16, - #[doc = "!< Desired maximum Frame-Average Light Level (MaxFALL) of HDR content ([0x0000-0xFFFF] = [0.0 - 65535.0] cd/m^2, in units of 1 cd/m^2)"] - pub desired_content_max_frame_average_luminance: NvU16, -} -#[repr(C)] -#[repr(align(4))] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDR_CAPABILITIES_V3__bindgen_ty_2 { - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Represents min luminance level of Sink"] - pub target_min_luminance: NvU16, - #[doc = "!< Represents max luminance level of sink"] - pub target_max_luminance: NvU16, - #[doc = "!< Red primary chromaticity coordinate x"] - pub cc_red_x: NvU16, - #[doc = "!< Red primary chromaticity coordinate y"] - pub cc_red_y: NvU16, - #[doc = "!< Green primary chromaticity coordinate x"] - pub cc_green_x: NvU16, - #[doc = "!< Green primary chromaticity coordinate Y"] - pub cc_green_y: NvU16, - #[doc = "!< Blue primary chromaticity coordinate x"] - pub cc_blue_x: NvU16, - #[doc = "!< Blue primary chromaticity coordinate y"] - pub cc_blue_y: NvU16, - #[doc = "!< White primary chromaticity coordinate x"] - pub cc_white_x: NvU16, - #[doc = "!< White primary chromaticity coordinate y"] - pub cc_white_y: NvU16, -} -impl _NV_HDR_CAPABILITIES_V3__bindgen_ty_2 { - #[inline] - pub fn VSVDB_version(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 3u8) as u32) } - } - #[inline] - pub fn set_VSVDB_version(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 3u8, val as u64) - } - } - #[inline] - pub unsafe fn VSVDB_version_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 3u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_VSVDB_version_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 3u8, - val as u64, - ) - } - } - #[inline] - pub fn dm_version(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 8u8) as u32) } - } - #[inline] - pub fn set_dm_version(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 8u8, val as u64) - } - } - #[inline] - pub unsafe fn dm_version_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 8u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_dm_version_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 8u8, - val as u64, - ) - } - } - #[inline] - pub fn supports_2160p60hz(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) } - } - #[inline] - pub fn set_supports_2160p60hz(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(11usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supports_2160p60hz_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 11usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_supports_2160p60hz_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 11usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn supports_YUV422_12bit(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) } - } - #[inline] - pub fn set_supports_YUV422_12bit(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(12usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supports_YUV422_12bit_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 12usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_supports_YUV422_12bit_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 12usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn supports_global_dimming(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) } - } - #[inline] - pub fn set_supports_global_dimming(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(13usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supports_global_dimming_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 13usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_supports_global_dimming_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 13usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn colorimetry(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) } - } - #[inline] - pub fn set_colorimetry(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(14usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn colorimetry_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 14usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_colorimetry_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 14usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn supports_backlight_control(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 2u8) as u32) } - } - #[inline] - pub fn set_supports_backlight_control(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(15usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn supports_backlight_control_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 15usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_supports_backlight_control_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 15usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn backlt_min_luma(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 2u8) as u32) } - } - #[inline] - pub fn set_backlt_min_luma(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(17usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn backlt_min_luma_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 17usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_backlt_min_luma_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 17usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn interface_supported_by_sink(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 2u8) as u32) } - } - #[inline] - pub fn set_interface_supported_by_sink(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(19usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn interface_supported_by_sink_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 19usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_interface_supported_by_sink_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 19usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn supports_10b_12b_444(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 2u8) as u32) } - } - #[inline] - pub fn set_supports_10b_12b_444(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(21usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn supports_10b_12b_444_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 21usize, - 2u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_supports_10b_12b_444_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 21usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn parity(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u32) } - } - #[inline] - pub fn set_parity(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(23usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn parity_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 23usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_parity_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 23usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(24usize, 8u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 24usize, - 8u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 24usize, - 8u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - VSVDB_version: NvU32, - dm_version: NvU32, - supports_2160p60hz: NvU32, - supports_YUV422_12bit: NvU32, - supports_global_dimming: NvU32, - colorimetry: NvU32, - supports_backlight_control: NvU32, - backlt_min_luma: NvU32, - interface_supported_by_sink: NvU32, - supports_10b_12b_444: NvU32, - parity: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 3u8, { - let VSVDB_version: u32 = unsafe { ::std::mem::transmute(VSVDB_version) }; - VSVDB_version as u64 - }); - __bindgen_bitfield_unit.set(3usize, 8u8, { - let dm_version: u32 = unsafe { ::std::mem::transmute(dm_version) }; - dm_version as u64 - }); - __bindgen_bitfield_unit.set(11usize, 1u8, { - let supports_2160p60hz: u32 = unsafe { ::std::mem::transmute(supports_2160p60hz) }; - supports_2160p60hz as u64 - }); - __bindgen_bitfield_unit.set(12usize, 1u8, { - let supports_YUV422_12bit: u32 = - unsafe { ::std::mem::transmute(supports_YUV422_12bit) }; - supports_YUV422_12bit as u64 - }); - __bindgen_bitfield_unit.set(13usize, 1u8, { - let supports_global_dimming: u32 = - unsafe { ::std::mem::transmute(supports_global_dimming) }; - supports_global_dimming as u64 - }); - __bindgen_bitfield_unit.set(14usize, 1u8, { - let colorimetry: u32 = unsafe { ::std::mem::transmute(colorimetry) }; - colorimetry as u64 - }); - __bindgen_bitfield_unit.set(15usize, 2u8, { - let supports_backlight_control: u32 = - unsafe { ::std::mem::transmute(supports_backlight_control) }; - supports_backlight_control as u64 - }); - __bindgen_bitfield_unit.set(17usize, 2u8, { - let backlt_min_luma: u32 = unsafe { ::std::mem::transmute(backlt_min_luma) }; - backlt_min_luma as u64 - }); - __bindgen_bitfield_unit.set(19usize, 2u8, { - let interface_supported_by_sink: u32 = - unsafe { ::std::mem::transmute(interface_supported_by_sink) }; - interface_supported_by_sink as u64 - }); - __bindgen_bitfield_unit.set(21usize, 2u8, { - let supports_10b_12b_444: u32 = unsafe { ::std::mem::transmute(supports_10b_12b_444) }; - supports_10b_12b_444 as u64 - }); - __bindgen_bitfield_unit.set(23usize, 1u8, { - let parity: u32 = unsafe { ::std::mem::transmute(parity) }; - parity as u64 - }); - __bindgen_bitfield_unit.set(24usize, 8u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[repr(C)] -#[repr(align(2))] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDR_CAPABILITIES_V3__bindgen_ty_3 { - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>, -} -impl _NV_HDR_CAPABILITIES_V3__bindgen_ty_3 { - #[inline] - pub fn application_version(&self) -> NvU16 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u16) } - } - #[inline] - pub fn set_application_version(&mut self, val: NvU16) { - unsafe { - let val: u16 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn application_version_raw(this: *const Self) -> NvU16 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 2u8, - ) as u16) - } - } - #[inline] - pub unsafe fn set_application_version_raw(this: *mut Self, val: NvU16) { - unsafe { - let val: u16 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn full_frame_peak_luminance_index(&self) -> NvU16 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 2u8) as u16) } - } - #[inline] - pub fn set_full_frame_peak_luminance_index(&mut self, val: NvU16) { - unsafe { - let val: u16 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn full_frame_peak_luminance_index_raw(this: *const Self) -> NvU16 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 2u8, - ) as u16) - } - } - #[inline] - pub unsafe fn set_full_frame_peak_luminance_index_raw(this: *mut Self, val: NvU16) { - unsafe { - let val: u16 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn peak_luminance_index(&self) -> NvU16 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u16) } - } - #[inline] - pub fn set_peak_luminance_index(&mut self, val: NvU16) { - unsafe { - let val: u16 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 4u8, val as u64) - } - } - #[inline] - pub unsafe fn peak_luminance_index_raw(this: *const Self) -> NvU16 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 4u8, - ) as u16) - } - } - #[inline] - pub unsafe fn set_peak_luminance_index_raw(this: *mut Self, val: NvU16) { - unsafe { - let val: u16 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 4u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU16 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 8u8) as u16) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU16) { - unsafe { - let val: u16 = ::std::mem::transmute(val); - self._bitfield_1.set(8usize, 8u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU16 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 8usize, - 8u8, - ) as u16) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU16) { - unsafe { - let val: u16 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 8usize, - 8u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - application_version: NvU16, - full_frame_peak_luminance_index: NvU16, - peak_luminance_index: NvU16, - reserved: NvU16, - ) -> __BindgenBitfieldUnit<[u8; 2usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 2u8, { - let application_version: u16 = unsafe { ::std::mem::transmute(application_version) }; - application_version as u64 - }); - __bindgen_bitfield_unit.set(2usize, 2u8, { - let full_frame_peak_luminance_index: u16 = - unsafe { ::std::mem::transmute(full_frame_peak_luminance_index) }; - full_frame_peak_luminance_index as u64 - }); - __bindgen_bitfield_unit.set(4usize, 4u8, { - let peak_luminance_index: u16 = unsafe { ::std::mem::transmute(peak_luminance_index) }; - peak_luminance_index as u64 - }); - __bindgen_bitfield_unit.set(8usize, 8u8, { - let reserved: u16 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -impl _NV_HDR_CAPABILITIES_V3 { - #[inline] - pub fn isST2084EotfSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isST2084EotfSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isST2084EotfSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isST2084EotfSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isTraditionalHdrGammaSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_isTraditionalHdrGammaSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isTraditionalHdrGammaSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isTraditionalHdrGammaSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isEdrSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_isEdrSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isEdrSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isEdrSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn driverExpandDefaultHdrParameters(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_driverExpandDefaultHdrParameters(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn driverExpandDefaultHdrParameters_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_driverExpandDefaultHdrParameters_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isTraditionalSdrGammaSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } - } - #[inline] - pub fn set_isTraditionalSdrGammaSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isTraditionalSdrGammaSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isTraditionalSdrGammaSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isDolbyVisionSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } - } - #[inline] - pub fn set_isDolbyVisionSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isDolbyVisionSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isDolbyVisionSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isHdr10PlusSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } - } - #[inline] - pub fn set_isHdr10PlusSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(6usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isHdr10PlusSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 6usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isHdr10PlusSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 6usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isHdr10PlusGamingSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } - } - #[inline] - pub fn set_isHdr10PlusGamingSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(7usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isHdr10PlusGamingSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 7usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isHdr10PlusGamingSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 7usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isNvidiaCertifiedDisplay(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) } - } - #[inline] - pub fn set_isNvidiaCertifiedDisplay(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(8usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isNvidiaCertifiedDisplay_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 8usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isNvidiaCertifiedDisplay_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 8usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 23u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(9usize, 23u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 9usize, - 23u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 9usize, - 23u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isST2084EotfSupported: NvU32, - isTraditionalHdrGammaSupported: NvU32, - isEdrSupported: NvU32, - driverExpandDefaultHdrParameters: NvU32, - isTraditionalSdrGammaSupported: NvU32, - isDolbyVisionSupported: NvU32, - isHdr10PlusSupported: NvU32, - isHdr10PlusGamingSupported: NvU32, - isNvidiaCertifiedDisplay: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isST2084EotfSupported: u32 = - unsafe { ::std::mem::transmute(isST2084EotfSupported) }; - isST2084EotfSupported as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let isTraditionalHdrGammaSupported: u32 = - unsafe { ::std::mem::transmute(isTraditionalHdrGammaSupported) }; - isTraditionalHdrGammaSupported as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let isEdrSupported: u32 = unsafe { ::std::mem::transmute(isEdrSupported) }; - isEdrSupported as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let driverExpandDefaultHdrParameters: u32 = - unsafe { ::std::mem::transmute(driverExpandDefaultHdrParameters) }; - driverExpandDefaultHdrParameters as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let isTraditionalSdrGammaSupported: u32 = - unsafe { ::std::mem::transmute(isTraditionalSdrGammaSupported) }; - isTraditionalSdrGammaSupported as u64 - }); - __bindgen_bitfield_unit.set(5usize, 1u8, { - let isDolbyVisionSupported: u32 = - unsafe { ::std::mem::transmute(isDolbyVisionSupported) }; - isDolbyVisionSupported as u64 - }); - __bindgen_bitfield_unit.set(6usize, 1u8, { - let isHdr10PlusSupported: u32 = unsafe { ::std::mem::transmute(isHdr10PlusSupported) }; - isHdr10PlusSupported as u64 - }); - __bindgen_bitfield_unit.set(7usize, 1u8, { - let isHdr10PlusGamingSupported: u32 = - unsafe { ::std::mem::transmute(isHdr10PlusGamingSupported) }; - isHdr10PlusGamingSupported as u64 - }); - __bindgen_bitfield_unit.set(8usize, 1u8, { - let isNvidiaCertifiedDisplay: u32 = - unsafe { ::std::mem::transmute(isNvidiaCertifiedDisplay) }; - isNvidiaCertifiedDisplay as u64 - }); - __bindgen_bitfield_unit.set(9usize, 23u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_HDR_CAPABILITIES_V3 = _NV_HDR_CAPABILITIES_V3; -pub type NV_HDR_CAPABILITIES = NV_HDR_CAPABILITIES_V3; -#[doc = "!< Get current HDR output configuration"] -pub const NV_HDR_CMD_NV_HDR_CMD_GET: NV_HDR_CMD = 0; -#[doc = "!< Set HDR output configuration"] -pub const NV_HDR_CMD_NV_HDR_CMD_SET: NV_HDR_CMD = 1; -#[doc = "! @}"] -pub type NV_HDR_CMD = ::std::os::raw::c_int; -#[doc = "!< Turn off HDR"] -pub const NV_HDR_MODE_NV_HDR_MODE_OFF: NV_HDR_MODE = 0; -#[doc = "!< Source: CCCS [a.k.a FP16 scRGB, linear, sRGB primaries, [-65504,0, 65504] range, RGB(1,1,1) = 80nits] Output : UHDA HDR [a.k.a HDR10, RGB/YCC 10/12bpc ST2084(PQ) EOTF RGB(1,1,1) = 10000 nits, Rec2020 color primaries, ST2086 static HDR metadata]. This is the only supported production HDR mode."] -pub const NV_HDR_MODE_NV_HDR_MODE_UHDA: NV_HDR_MODE = 2; -#[doc = "!< Experimental mode only, not for production! Source: HDR10 RGB 10bpc Output: HDR10 RGB 10 bpc - signal UHDA HDR mode (PQ + Rec2020) to the sink but send source pixel values unmodified (no PQ or Rec2020 conversions) - assumes source is already in HDR10 format."] -pub const NV_HDR_MODE_NV_HDR_MODE_UHDA_PASSTHROUGH: NV_HDR_MODE = 5; -#[doc = "!< Experimental mode only, not for production! Source: RGB8 Dolby Vision encoded (12 bpc YCbCr422 packed into RGB8) Output: Dolby Vision encoded : Application is to encoded frames in DV format and embed DV dynamic metadata as described in Dolby Vision specification."] -pub const NV_HDR_MODE_NV_HDR_MODE_DOLBY_VISION: NV_HDR_MODE = 7; -#[doc = "!< Do not use! Internal test mode only, to be removed. Source: CCCS (a.k.a FP16 scRGB) Output : EDR (Extended Dynamic Range) - HDR content is tonemapped and gamut mapped to output on regular SDR display set to max luminance ( ~300 nits )."] -pub const NV_HDR_MODE_NV_HDR_MODE_EDR: NV_HDR_MODE = 3; -#[doc = "!< Do not use! Internal test mode only, to be removed. Source: any Output: SDR (Standard Dynamic Range), we continuously send SDR EOTF InfoFrame signaling, HDMI compliance testing."] -pub const NV_HDR_MODE_NV_HDR_MODE_SDR: NV_HDR_MODE = 4; -#[doc = "!< Do not use! Internal test mode only, to be removed. Source: CCCS (a.k.a FP16 scRGB) Output : notebook HDR"] -pub const NV_HDR_MODE_NV_HDR_MODE_UHDA_NB: NV_HDR_MODE = 6; -#[doc = "!< Do not use! Obsolete, to be removed. NV_HDR_MODE_UHDBD == NV_HDR_MODE_UHDA, reflects obsolete pre-UHDA naming convention."] -pub const NV_HDR_MODE_NV_HDR_MODE_UHDBD: NV_HDR_MODE = 2; -pub type NV_HDR_MODE = ::std::os::raw::c_int; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDR_COLOR_DATA_V1 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< Command get/set"] - pub cmd: NV_HDR_CMD, - #[doc = "!< HDR mode"] - pub hdrMode: NV_HDR_MODE, - #[doc = "!< Static Metadata Descriptor Id (0 for static metadata type 1)"] - pub static_metadata_descriptor_id: NV_STATIC_METADATA_DESCRIPTOR_ID, - pub mastering_display_data: _NV_HDR_COLOR_DATA_V1__bindgen_ty_1, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDR_COLOR_DATA_V1__bindgen_ty_1 { - #[doc = "!< x coordinate of color primary 0 (e.g. Red) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x0: NvU16, - #[doc = "!< y coordinate of color primary 0 (e.g. Red) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y0: NvU16, - #[doc = "!< x coordinate of color primary 1 (e.g. Green) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x1: NvU16, - #[doc = "!< y coordinate of color primary 1 (e.g. Green) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y1: NvU16, - #[doc = "!< x coordinate of color primary 2 (e.g. Blue) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x2: NvU16, - #[doc = "!< y coordinate of color primary 2 (e.g. Blue) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y2: NvU16, - #[doc = "!< x coordinate of white point of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayWhitePoint_x: NvU16, - #[doc = "!< y coordinate of white point of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayWhitePoint_y: NvU16, - #[doc = "!< Maximum display mastering luminance ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] - pub max_display_mastering_luminance: NvU16, - #[doc = "!< Minimum display mastering luminance ([0x0001-0xFFFF] = [1.0 - 6.55350] cd/m^2)"] - pub min_display_mastering_luminance: NvU16, - #[doc = "!< Maximum Content Light level (MaxCLL) ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] - pub max_content_light_level: NvU16, - #[doc = "!< Maximum Frame-Average Light Level (MaxFALL) ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] - pub max_frame_average_light_level: NvU16, -} -pub type NV_HDR_COLOR_DATA_V1 = _NV_HDR_COLOR_DATA_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDR_COLOR_DATA_V2 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< Command get/set"] - pub cmd: NV_HDR_CMD, - #[doc = "!< HDR mode"] - pub hdrMode: NV_HDR_MODE, - #[doc = "!< Static Metadata Descriptor Id (0 for static metadata type 1)"] - pub static_metadata_descriptor_id: NV_STATIC_METADATA_DESCRIPTOR_ID, - pub mastering_display_data: _NV_HDR_COLOR_DATA_V2__bindgen_ty_1, - #[doc = "!< Optional, One of NV_COLOR_FORMAT enum values, if set it will apply requested color format for HDR session"] - pub hdrColorFormat: NV_COLOR_FORMAT, - #[doc = "!< Optional, One of NV_DYNAMIC_RANGE enum values, if set it will apply requested dynamic range for HDR session"] - pub hdrDynamicRange: NV_DYNAMIC_RANGE, - #[doc = "!< Optional, One of NV_BPC enum values, if set it will apply requested color depth\n!< Dolby Vision mode: DV supports specific combinations of colorformat, dynamic range and bpc. Please refer Dolby Vision specification.\n!< If invalid or no combination is passed driver will force default combination of RGB format + full range + 8bpc.\n!< HDR mode: These fields are ignored in hdr mode"] - pub hdrBpc: NV_BPC, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDR_COLOR_DATA_V2__bindgen_ty_1 { - #[doc = "!< x coordinate of color primary 0 (e.g. Red) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x0: NvU16, - #[doc = "!< y coordinate of color primary 0 (e.g. Red) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y0: NvU16, - #[doc = "!< x coordinate of color primary 1 (e.g. Green) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x1: NvU16, - #[doc = "!< y coordinate of color primary 1 (e.g. Green) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y1: NvU16, - #[doc = "!< x coordinate of color primary 2 (e.g. Blue) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x2: NvU16, - #[doc = "!< y coordinate of color primary 2 (e.g. Blue) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y2: NvU16, - #[doc = "!< x coordinate of white point of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayWhitePoint_x: NvU16, - #[doc = "!< y coordinate of white point of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayWhitePoint_y: NvU16, - #[doc = "!< Maximum display mastering luminance ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] - pub max_display_mastering_luminance: NvU16, - #[doc = "!< Minimum display mastering luminance ([0x0001-0xFFFF] = [1.0 - 6.55350] cd/m^2)"] - pub min_display_mastering_luminance: NvU16, - #[doc = "!< Maximum Content Light level (MaxCLL) ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] - pub max_content_light_level: NvU16, - #[doc = "!< Maximum Frame-Average Light Level (MaxFALL) ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] - pub max_frame_average_light_level: NvU16, -} -pub type NV_HDR_COLOR_DATA_V2 = _NV_HDR_COLOR_DATA_V2; -pub type NV_HDR_COLOR_DATA = NV_HDR_COLOR_DATA_V2; -#[doc = "!< sRGB IEC 61966-2-1:1999 == DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709"] -pub const _NV_COLORSPACE_TYPE_NV_COLORSPACE_sRGB: _NV_COLORSPACE_TYPE = 0; -#[doc = "!< FP16 linear with sRGB color primaries == DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709"] -pub const _NV_COLORSPACE_TYPE_NV_COLORSPACE_xRGB: _NV_COLORSPACE_TYPE = 1; -#[doc = "!< ITU-R Rec BT.2100 (HDR10) == DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020"] -pub const _NV_COLORSPACE_TYPE_NV_COLORSPACE_REC2100: _NV_COLORSPACE_TYPE = 12; -pub type _NV_COLORSPACE_TYPE = ::std::os::raw::c_int; -pub use self::_NV_COLORSPACE_TYPE as NV_COLORSPACE_TYPE; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_HDR_METADATA_V1 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< x coordinate of color primary 0 (e.g. Red) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x0: NvU16, - #[doc = "!< y coordinate of color primary 0 (e.g. Red) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y0: NvU16, - #[doc = "!< x coordinate of color primary 1 (e.g. Green) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x1: NvU16, - #[doc = "!< y coordinate of color primary 1 (e.g. Green) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y1: NvU16, - #[doc = "!< x coordinate of color primary 2 (e.g. Blue) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_x2: NvU16, - #[doc = "!< y coordinate of color primary 2 (e.g. Blue) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayPrimary_y2: NvU16, - #[doc = "!< x coordinate of white point of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayWhitePoint_x: NvU16, - #[doc = "!< y coordinate of white point of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] - pub displayWhitePoint_y: NvU16, - #[doc = "!< Maximum display mastering luminance ([0x0000-0xFFFF] = [0.0 - 65535.0] cd/m^2, in units of 1 cd/m^2)"] - pub max_display_mastering_luminance: NvU16, - #[doc = "!< Minimum display mastering luminance ([0x0000-0xFFFF] = [0.0 - 6.55350] cd/m^2, in units of 0.0001 cd/m^2)"] - pub min_display_mastering_luminance: NvU16, - #[doc = "!< Maximum Content Light level (MaxCLL) ([0x0000-0xFFFF] = [0.0 - 65535.0] cd/m^2, in units of 1 cd/m^2)"] - pub max_content_light_level: NvU16, - #[doc = "!< Maximum Frame-Average Light Level (MaxFALL) ([0x0000-0xFFFF] = [0.0 - 65535.0] cd/m^2, in units of 1 cd/m^2)"] - pub max_frame_average_light_level: NvU16, -} -pub type NV_HDR_METADATA_V1 = _NV_HDR_METADATA_V1; -pub type NV_HDR_METADATA = NV_HDR_METADATA_V1; -pub const _NV_DISPLAY_OUTPUT_MODE_NV_DISPLAY_OUTPUT_MODE_SDR: _NV_DISPLAY_OUTPUT_MODE = 0; -pub const _NV_DISPLAY_OUTPUT_MODE_NV_DISPLAY_OUTPUT_MODE_HDR10: _NV_DISPLAY_OUTPUT_MODE = 1; -pub const _NV_DISPLAY_OUTPUT_MODE_NV_DISPLAY_OUTPUT_MODE_HDR10PLUS_GAMING: _NV_DISPLAY_OUTPUT_MODE = - 2; -pub type _NV_DISPLAY_OUTPUT_MODE = ::std::os::raw::c_int; -pub use self::_NV_DISPLAY_OUTPUT_MODE as NV_DISPLAY_OUTPUT_MODE; -pub const _NV_HDR_TONEMAPPING_METHOD_NV_HDR_TONEMAPPING_APP: _NV_HDR_TONEMAPPING_METHOD = 0; -pub const _NV_HDR_TONEMAPPING_METHOD_NV_HDR_TONEMAPPING_GPU: _NV_HDR_TONEMAPPING_METHOD = 1; -pub type _NV_HDR_TONEMAPPING_METHOD = ::std::os::raw::c_int; -pub use self::_NV_HDR_TONEMAPPING_METHOD as NV_HDR_TONEMAPPING_METHOD; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_DISPLAY_COLORIMETRY_V1 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< min luminance, cd/m^2"] - pub min_luminance: f32, - #[doc = "!< max 100% frame luminance, cd/m^2"] - pub max_full_frame_luminance: f32, - #[doc = "!< max 10% frame luminance, cd/m^2"] - pub max_luminance: f32, - #[doc = "!< HDR brightness luminance scaling factor applied by GPU on output pixels"] - pub hdrBrightnessLuminanceScalingFactor: f32, - #[doc = "!< red primary chromaticity coordinate x"] - pub red_primary_x: f32, - #[doc = "!< red primary chromaticity coordinate y"] - pub red_primary_y: f32, - #[doc = "!< green primary chromaticity coordinate x"] - pub green_primary_x: f32, - #[doc = "!< green primary chromaticity coordinate y"] - pub green_primary_y: f32, - #[doc = "!< blue primary chromaticity coordinate x"] - pub blue_primary_x: f32, - #[doc = "!< blue primary chromaticity coordinate y"] - pub blue_primary_y: f32, - #[doc = "!< white point chromaticity coordinate x"] - pub white_point_x: f32, - #[doc = "!< white point chromaticity coordinate y"] - pub white_point_y: f32, -} -pub type NV_DISPLAY_COLORIMETRY_V1 = _NV_DISPLAY_COLORIMETRY_V1; -pub type NV_DISPLAY_COLORIMETRY = NV_DISPLAY_COLORIMETRY_V1; -#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_DISP_GetTiming()."] -#[repr(C)] -#[repr(align(4))] -#[derive(Copy, Clone)] -pub struct NV_TIMING_FLAG { - pub _bitfield_align_1: [u16; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>, - pub __bindgen_anon_1: NV_TIMING_FLAG__bindgen_ty_1, - pub _bitfield_align_2: [u8; 0], - pub _bitfield_2: __BindgenBitfieldUnit<[u8; 1usize]>, - pub __bindgen_padding_0: [u8; 5usize], -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union NV_TIMING_FLAG__bindgen_ty_1 { - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>, -} -impl NV_TIMING_FLAG__bindgen_ty_1 { - #[inline] - pub fn tvFormat(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) } - } - #[inline] - pub fn set_tvFormat(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 8u8, val as u64) - } - } - #[inline] - pub unsafe fn tvFormat_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 8u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_tvFormat_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 8u8, - val as u64, - ) - } - } - #[inline] - pub fn ceaId(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 8u8) as u32) } - } - #[inline] - pub fn set_ceaId(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(8usize, 8u8, val as u64) - } - } - #[inline] - pub unsafe fn ceaId_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 8usize, - 8u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_ceaId_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 8usize, - 8u8, - val as u64, - ) - } - } - #[inline] - pub fn nvPsfId(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 8u8) as u32) } - } - #[inline] - pub fn set_nvPsfId(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(16usize, 8u8, val as u64) - } - } - #[inline] - pub unsafe fn nvPsfId_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 16usize, - 8u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_nvPsfId_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 16usize, - 8u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - tvFormat: NvU32, - ceaId: NvU32, - nvPsfId: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 3usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 8u8, { - let tvFormat: u32 = unsafe { ::std::mem::transmute(tvFormat) }; - tvFormat as u64 - }); - __bindgen_bitfield_unit.set(8usize, 8u8, { - let ceaId: u32 = unsafe { ::std::mem::transmute(ceaId) }; - ceaId as u64 - }); - __bindgen_bitfield_unit.set(16usize, 8u8, { - let nvPsfId: u32 = unsafe { ::std::mem::transmute(nvPsfId) }; - nvPsfId as u64 - }); - __bindgen_bitfield_unit - } -} -impl NV_TIMING_FLAG { - #[inline] - pub fn isInterlaced(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32) } - } - #[inline] - pub fn set_isInterlaced(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 4u8, val as u64) - } - } - #[inline] - pub unsafe fn isInterlaced_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 4u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isInterlaced_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 4u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved0(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 12u8) as u32) } - } - #[inline] - pub fn set_reserved0(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 12u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved0_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 12u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved0_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 12u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isInterlaced: NvU32, - reserved0: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 2usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 4u8, { - let isInterlaced: u32 = unsafe { ::std::mem::transmute(isInterlaced) }; - isInterlaced as u64 - }); - __bindgen_bitfield_unit.set(4usize, 12u8, { - let reserved0: u32 = unsafe { ::std::mem::transmute(reserved0) }; - reserved0 as u64 - }); - __bindgen_bitfield_unit - } - #[inline] - pub fn scaling(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 8u8) as u32) } - } - #[inline] - pub fn set_scaling(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_2.set(0usize, 8u8, val as u64) - } - } - #[inline] - pub unsafe fn scaling_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_2), - 0usize, - 8u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_scaling_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_2), - 0usize, - 8u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_2(scaling: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 8u8, { - let scaling: u32 = unsafe { ::std::mem::transmute(scaling) }; - scaling as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_DISP_GetTiming()."] -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_TIMING_INPUT { - #[doc = "!< (IN) structure version"] - pub version: NvU32, - #[doc = "!< Visible horizontal size"] - pub width: NvU32, - #[doc = "!< Visible vertical size"] - pub height: NvU32, - #[doc = "!< Timing refresh rate"] - pub rr: f32, - #[doc = "!< Flag containing additional info for timing calculation."] - pub flag: NV_TIMING_FLAG, - #[doc = "!< Timing type(formula) to use for calculating the timing"] - pub type_: NV_TIMING_OVERRIDE, -} -#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_DISP_GetTiming()."] -pub type NV_TIMING_INPUT = _NV_TIMING_INPUT; -pub const NV_MONITOR_CAPS_TYPE_NV_MONITOR_CAPS_TYPE_HDMI_VSDB: NV_MONITOR_CAPS_TYPE = 4096; -pub const NV_MONITOR_CAPS_TYPE_NV_MONITOR_CAPS_TYPE_HDMI_VCDB: NV_MONITOR_CAPS_TYPE = 4097; -pub const NV_MONITOR_CAPS_TYPE_NV_MONITOR_CAPS_TYPE_GENERIC: NV_MONITOR_CAPS_TYPE = 4098; -#[doc = "! HDMI-related and extended CAPs"] -pub type NV_MONITOR_CAPS_TYPE = ::std::os::raw::c_int; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MONITOR_CAPS_VCDB { - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, -} -impl _NV_MONITOR_CAPS_VCDB { - #[inline] - pub fn quantizationRangeYcc(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) } - } - #[inline] - pub fn set_quantizationRangeYcc(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn quantizationRangeYcc_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_quantizationRangeYcc_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn quantizationRangeRgb(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) } - } - #[inline] - pub fn set_quantizationRangeRgb(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn quantizationRangeRgb_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_quantizationRangeRgb_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn scanInfoPreferredVideoFormat(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 2u8) as u8) } - } - #[inline] - pub fn set_scanInfoPreferredVideoFormat(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn scanInfoPreferredVideoFormat_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 2u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_scanInfoPreferredVideoFormat_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn scanInfoITVideoFormats(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 2u8) as u8) } - } - #[inline] - pub fn set_scanInfoITVideoFormats(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn scanInfoITVideoFormats_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 2u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_scanInfoITVideoFormats_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn scanInfoCEVideoFormats(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 2u8) as u8) } - } - #[inline] - pub fn set_scanInfoCEVideoFormats(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(6usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn scanInfoCEVideoFormats_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 6usize, - 2u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_scanInfoCEVideoFormats_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 6usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - quantizationRangeYcc: NvU8, - quantizationRangeRgb: NvU8, - scanInfoPreferredVideoFormat: NvU8, - scanInfoITVideoFormats: NvU8, - scanInfoCEVideoFormats: NvU8, - ) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let quantizationRangeYcc: u8 = unsafe { ::std::mem::transmute(quantizationRangeYcc) }; - quantizationRangeYcc as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let quantizationRangeRgb: u8 = unsafe { ::std::mem::transmute(quantizationRangeRgb) }; - quantizationRangeRgb as u64 - }); - __bindgen_bitfield_unit.set(2usize, 2u8, { - let scanInfoPreferredVideoFormat: u8 = - unsafe { ::std::mem::transmute(scanInfoPreferredVideoFormat) }; - scanInfoPreferredVideoFormat as u64 - }); - __bindgen_bitfield_unit.set(4usize, 2u8, { - let scanInfoITVideoFormats: u8 = - unsafe { ::std::mem::transmute(scanInfoITVideoFormats) }; - scanInfoITVideoFormats as u64 - }); - __bindgen_bitfield_unit.set(6usize, 2u8, { - let scanInfoCEVideoFormats: u8 = - unsafe { ::std::mem::transmute(scanInfoCEVideoFormats) }; - scanInfoCEVideoFormats as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_MONITOR_CAPS_VCDB = _NV_MONITOR_CAPS_VCDB; -#[doc = "! See NvAPI_DISP_GetMonitorCapabilities()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MONITOR_CAPS_VSDB { - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>, - #[doc = "!< Bye 4"] - pub maxTmdsClock: NvU8, - pub _bitfield_align_2: [u8; 0], - pub _bitfield_2: __BindgenBitfieldUnit<[u8; 1usize]>, - #[doc = "!< Byte 6"] - pub videoLatency: NvU8, - #[doc = "!< Byte 7"] - pub audioLatency: NvU8, - #[doc = "!< Byte 8"] - pub interlacedVideoLatency: NvU8, - #[doc = "!< Byte 9"] - pub interlacedAudioLatency: NvU8, - pub _bitfield_align_3: [u8; 0], - pub _bitfield_3: __BindgenBitfieldUnit<[u8; 2usize]>, - #[doc = "!< Keeping maximum length for 3 bits"] - pub hdmi_vic: [NvU8; 7usize], - #[doc = "!< Keeping maximum length for 5 bits"] - pub hdmi_3d: [NvU8; 31usize], -} -impl _NV_MONITOR_CAPS_VSDB { - #[inline] - pub fn sourcePhysicalAddressB(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u8) } - } - #[inline] - pub fn set_sourcePhysicalAddressB(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 4u8, val as u64) - } - } - #[inline] - pub unsafe fn sourcePhysicalAddressB_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 4u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_sourcePhysicalAddressB_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 4u8, - val as u64, - ) - } - } - #[inline] - pub fn sourcePhysicalAddressA(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u8) } - } - #[inline] - pub fn set_sourcePhysicalAddressA(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 4u8, val as u64) - } - } - #[inline] - pub unsafe fn sourcePhysicalAddressA_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 4u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_sourcePhysicalAddressA_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 4u8, - val as u64, - ) - } - } - #[inline] - pub fn sourcePhysicalAddressD(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 4u8) as u8) } - } - #[inline] - pub fn set_sourcePhysicalAddressD(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(8usize, 4u8, val as u64) - } - } - #[inline] - pub unsafe fn sourcePhysicalAddressD_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 8usize, - 4u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_sourcePhysicalAddressD_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 8usize, - 4u8, - val as u64, - ) - } - } - #[inline] - pub fn sourcePhysicalAddressC(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 4u8) as u8) } - } - #[inline] - pub fn set_sourcePhysicalAddressC(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(12usize, 4u8, val as u64) - } - } - #[inline] - pub unsafe fn sourcePhysicalAddressC_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 12usize, - 4u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_sourcePhysicalAddressC_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 12usize, - 4u8, - val as u64, - ) - } - } - #[inline] - pub fn supportDualDviOperation(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u8) } - } - #[inline] - pub fn set_supportDualDviOperation(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(16usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supportDualDviOperation_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 16usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_supportDualDviOperation_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 16usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved6(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 2u8) as u8) } - } - #[inline] - pub fn set_reserved6(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(17usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved6_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 17usize, - 2u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_reserved6_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 17usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn supportDeepColorYCbCr444(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u8) } - } - #[inline] - pub fn set_supportDeepColorYCbCr444(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(19usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supportDeepColorYCbCr444_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 19usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_supportDeepColorYCbCr444_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 19usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn supportDeepColor30bits(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u8) } - } - #[inline] - pub fn set_supportDeepColor30bits(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(20usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supportDeepColor30bits_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 20usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_supportDeepColor30bits_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 20usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn supportDeepColor36bits(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u8) } - } - #[inline] - pub fn set_supportDeepColor36bits(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(21usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supportDeepColor36bits_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 21usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_supportDeepColor36bits_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 21usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn supportDeepColor48bits(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u8) } - } - #[inline] - pub fn set_supportDeepColor48bits(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(22usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supportDeepColor48bits_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 22usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_supportDeepColor48bits_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 22usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn supportAI(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u8) } - } - #[inline] - pub fn set_supportAI(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(23usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supportAI_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 23usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_supportAI_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 23usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - sourcePhysicalAddressB: NvU8, - sourcePhysicalAddressA: NvU8, - sourcePhysicalAddressD: NvU8, - sourcePhysicalAddressC: NvU8, - supportDualDviOperation: NvU8, - reserved6: NvU8, - supportDeepColorYCbCr444: NvU8, - supportDeepColor30bits: NvU8, - supportDeepColor36bits: NvU8, - supportDeepColor48bits: NvU8, - supportAI: NvU8, - ) -> __BindgenBitfieldUnit<[u8; 3usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 4u8, { - let sourcePhysicalAddressB: u8 = - unsafe { ::std::mem::transmute(sourcePhysicalAddressB) }; - sourcePhysicalAddressB as u64 - }); - __bindgen_bitfield_unit.set(4usize, 4u8, { - let sourcePhysicalAddressA: u8 = - unsafe { ::std::mem::transmute(sourcePhysicalAddressA) }; - sourcePhysicalAddressA as u64 - }); - __bindgen_bitfield_unit.set(8usize, 4u8, { - let sourcePhysicalAddressD: u8 = - unsafe { ::std::mem::transmute(sourcePhysicalAddressD) }; - sourcePhysicalAddressD as u64 - }); - __bindgen_bitfield_unit.set(12usize, 4u8, { - let sourcePhysicalAddressC: u8 = - unsafe { ::std::mem::transmute(sourcePhysicalAddressC) }; - sourcePhysicalAddressC as u64 - }); - __bindgen_bitfield_unit.set(16usize, 1u8, { - let supportDualDviOperation: u8 = - unsafe { ::std::mem::transmute(supportDualDviOperation) }; - supportDualDviOperation as u64 - }); - __bindgen_bitfield_unit.set(17usize, 2u8, { - let reserved6: u8 = unsafe { ::std::mem::transmute(reserved6) }; - reserved6 as u64 - }); - __bindgen_bitfield_unit.set(19usize, 1u8, { - let supportDeepColorYCbCr444: u8 = - unsafe { ::std::mem::transmute(supportDeepColorYCbCr444) }; - supportDeepColorYCbCr444 as u64 - }); - __bindgen_bitfield_unit.set(20usize, 1u8, { - let supportDeepColor30bits: u8 = - unsafe { ::std::mem::transmute(supportDeepColor30bits) }; - supportDeepColor30bits as u64 - }); - __bindgen_bitfield_unit.set(21usize, 1u8, { - let supportDeepColor36bits: u8 = - unsafe { ::std::mem::transmute(supportDeepColor36bits) }; - supportDeepColor36bits as u64 - }); - __bindgen_bitfield_unit.set(22usize, 1u8, { - let supportDeepColor48bits: u8 = - unsafe { ::std::mem::transmute(supportDeepColor48bits) }; - supportDeepColor48bits as u64 - }); - __bindgen_bitfield_unit.set(23usize, 1u8, { - let supportAI: u8 = unsafe { ::std::mem::transmute(supportAI) }; - supportAI as u64 - }); - __bindgen_bitfield_unit - } - #[inline] - pub fn cnc0SupportGraphicsTextContent(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 1u8) as u8) } - } - #[inline] - pub fn set_cnc0SupportGraphicsTextContent(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_2.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn cnc0SupportGraphicsTextContent_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_2), - 0usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_cnc0SupportGraphicsTextContent_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_2), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn cnc1SupportPhotoContent(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_2.get(1usize, 1u8) as u8) } - } - #[inline] - pub fn set_cnc1SupportPhotoContent(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_2.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn cnc1SupportPhotoContent_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_2), - 1usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_cnc1SupportPhotoContent_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_2), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn cnc2SupportCinemaContent(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_2.get(2usize, 1u8) as u8) } - } - #[inline] - pub fn set_cnc2SupportCinemaContent(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_2.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn cnc2SupportCinemaContent_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_2), - 2usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_cnc2SupportCinemaContent_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_2), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn cnc3SupportGameContent(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_2.get(3usize, 1u8) as u8) } - } - #[inline] - pub fn set_cnc3SupportGameContent(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_2.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn cnc3SupportGameContent_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_2), - 3usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_cnc3SupportGameContent_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_2), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved8(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_2.get(4usize, 1u8) as u8) } - } - #[inline] - pub fn set_reserved8(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_2.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved8_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_2), - 4usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_reserved8_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_2), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn hasVicEntries(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_2.get(5usize, 1u8) as u8) } - } - #[inline] - pub fn set_hasVicEntries(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_2.set(5usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn hasVicEntries_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_2), - 5usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_hasVicEntries_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_2), - 5usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn hasInterlacedLatencyField(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_2.get(6usize, 1u8) as u8) } - } - #[inline] - pub fn set_hasInterlacedLatencyField(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_2.set(6usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn hasInterlacedLatencyField_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_2), - 6usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_hasInterlacedLatencyField_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_2), - 6usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn hasLatencyField(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_2.get(7usize, 1u8) as u8) } - } - #[inline] - pub fn set_hasLatencyField(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_2.set(7usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn hasLatencyField_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_2), - 7usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_hasLatencyField_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_2), - 7usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_2( - cnc0SupportGraphicsTextContent: NvU8, - cnc1SupportPhotoContent: NvU8, - cnc2SupportCinemaContent: NvU8, - cnc3SupportGameContent: NvU8, - reserved8: NvU8, - hasVicEntries: NvU8, - hasInterlacedLatencyField: NvU8, - hasLatencyField: NvU8, - ) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let cnc0SupportGraphicsTextContent: u8 = - unsafe { ::std::mem::transmute(cnc0SupportGraphicsTextContent) }; - cnc0SupportGraphicsTextContent as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let cnc1SupportPhotoContent: u8 = - unsafe { ::std::mem::transmute(cnc1SupportPhotoContent) }; - cnc1SupportPhotoContent as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let cnc2SupportCinemaContent: u8 = - unsafe { ::std::mem::transmute(cnc2SupportCinemaContent) }; - cnc2SupportCinemaContent as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let cnc3SupportGameContent: u8 = - unsafe { ::std::mem::transmute(cnc3SupportGameContent) }; - cnc3SupportGameContent as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let reserved8: u8 = unsafe { ::std::mem::transmute(reserved8) }; - reserved8 as u64 - }); - __bindgen_bitfield_unit.set(5usize, 1u8, { - let hasVicEntries: u8 = unsafe { ::std::mem::transmute(hasVicEntries) }; - hasVicEntries as u64 - }); - __bindgen_bitfield_unit.set(6usize, 1u8, { - let hasInterlacedLatencyField: u8 = - unsafe { ::std::mem::transmute(hasInterlacedLatencyField) }; - hasInterlacedLatencyField as u64 - }); - __bindgen_bitfield_unit.set(7usize, 1u8, { - let hasLatencyField: u8 = unsafe { ::std::mem::transmute(hasLatencyField) }; - hasLatencyField as u64 - }); - __bindgen_bitfield_unit - } - #[inline] - pub fn reserved13(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_3.get(0usize, 7u8) as u8) } - } - #[inline] - pub fn set_reserved13(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_3.set(0usize, 7u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved13_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_3), - 0usize, - 7u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_reserved13_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_3), - 0usize, - 7u8, - val as u64, - ) - } - } - #[inline] - pub fn has3dEntries(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_3.get(7usize, 1u8) as u8) } - } - #[inline] - pub fn set_has3dEntries(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_3.set(7usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn has3dEntries_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_3), - 7usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_has3dEntries_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_3), - 7usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn hdmi3dLength(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_3.get(8usize, 5u8) as u8) } - } - #[inline] - pub fn set_hdmi3dLength(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_3.set(8usize, 5u8, val as u64) - } - } - #[inline] - pub unsafe fn hdmi3dLength_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_3), - 8usize, - 5u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_hdmi3dLength_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_3), - 8usize, - 5u8, - val as u64, - ) - } - } - #[inline] - pub fn hdmiVicLength(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_3.get(13usize, 3u8) as u8) } - } - #[inline] - pub fn set_hdmiVicLength(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_3.set(13usize, 3u8, val as u64) - } - } - #[inline] - pub unsafe fn hdmiVicLength_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_3), - 13usize, - 3u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_hdmiVicLength_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_3), - 13usize, - 3u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_3( - reserved13: NvU8, - has3dEntries: NvU8, - hdmi3dLength: NvU8, - hdmiVicLength: NvU8, - ) -> __BindgenBitfieldUnit<[u8; 2usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 7u8, { - let reserved13: u8 = unsafe { ::std::mem::transmute(reserved13) }; - reserved13 as u64 - }); - __bindgen_bitfield_unit.set(7usize, 1u8, { - let has3dEntries: u8 = unsafe { ::std::mem::transmute(has3dEntries) }; - has3dEntries as u64 - }); - __bindgen_bitfield_unit.set(8usize, 5u8, { - let hdmi3dLength: u8 = unsafe { ::std::mem::transmute(hdmi3dLength) }; - hdmi3dLength as u64 - }); - __bindgen_bitfield_unit.set(13usize, 3u8, { - let hdmiVicLength: u8 = unsafe { ::std::mem::transmute(hdmiVicLength) }; - hdmiVicLength as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! See NvAPI_DISP_GetMonitorCapabilities()."] -pub type NV_MONITOR_CAPS_VSDB = _NV_MONITOR_CAPS_VSDB; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MONITOR_CAPS_GENERIC { - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, -} -impl _NV_MONITOR_CAPS_GENERIC { - #[inline] - pub fn supportVRR(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) } - } - #[inline] - pub fn set_supportVRR(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supportVRR_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_supportVRR_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn supportULMB(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) } - } - #[inline] - pub fn set_supportULMB(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supportULMB_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_supportULMB_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isTrueGsync(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) } - } - #[inline] - pub fn set_isTrueGsync(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isTrueGsync_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_isTrueGsync_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isRLACapable(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) } - } - #[inline] - pub fn set_isRLACapable(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isRLACapable_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_isRLACapable_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn currentlyCapableOfVRR(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) } - } - #[inline] - pub fn set_currentlyCapableOfVRR(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn currentlyCapableOfVRR_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_currentlyCapableOfVRR_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn isBasicVRR(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) } - } - #[inline] - pub fn set_isBasicVRR(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isBasicVRR_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_isBasicVRR_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 2u8) as u8) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(6usize, 2u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 6usize, - 2u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 6usize, - 2u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - supportVRR: NvU8, - supportULMB: NvU8, - isTrueGsync: NvU8, - isRLACapable: NvU8, - currentlyCapableOfVRR: NvU8, - isBasicVRR: NvU8, - reserved: NvU8, - ) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let supportVRR: u8 = unsafe { ::std::mem::transmute(supportVRR) }; - supportVRR as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let supportULMB: u8 = unsafe { ::std::mem::transmute(supportULMB) }; - supportULMB as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let isTrueGsync: u8 = unsafe { ::std::mem::transmute(isTrueGsync) }; - isTrueGsync as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let isRLACapable: u8 = unsafe { ::std::mem::transmute(isRLACapable) }; - isRLACapable as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let currentlyCapableOfVRR: u8 = unsafe { ::std::mem::transmute(currentlyCapableOfVRR) }; - currentlyCapableOfVRR as u64 - }); - __bindgen_bitfield_unit.set(5usize, 1u8, { - let isBasicVRR: u8 = unsafe { ::std::mem::transmute(isBasicVRR) }; - isBasicVRR as u64 - }); - __bindgen_bitfield_unit.set(6usize, 2u8, { - let reserved: u8 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_MONITOR_CAPS_GENERIC = _NV_MONITOR_CAPS_GENERIC; -#[doc = "! See NvAPI_DISP_GetMonitorCapabilities()."] -#[repr(C)] -#[derive(Copy, Clone)] -pub struct _NV_MONITOR_CAPABILITIES_V1 { - pub version: NvU32, - pub size: NvU16, - pub infoType: NvU32, - #[doc = "!< Out: VGA, TV, DVI, HDMI, DP"] - pub connectorType: NvU32, - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, - pub data: _NV_MONITOR_CAPABILITIES_V1__bindgen_ty_1, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union _NV_MONITOR_CAPABILITIES_V1__bindgen_ty_1 { - pub vsdb: NV_MONITOR_CAPS_VSDB, - pub vcdb: NV_MONITOR_CAPS_VCDB, - pub caps: NV_MONITOR_CAPS_GENERIC, -} -impl _NV_MONITOR_CAPABILITIES_V1 { - #[inline] - pub fn bIsValidInfo(&self) -> NvU8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) } - } - #[inline] - pub fn set_bIsValidInfo(&mut self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsValidInfo_raw(this: *const Self) -> NvU8 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u8) - } - } - #[inline] - pub unsafe fn set_bIsValidInfo_raw(this: *mut Self, val: NvU8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1(bIsValidInfo: NvU8) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsValidInfo: u8 = unsafe { ::std::mem::transmute(bIsValidInfo) }; - bIsValidInfo as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! See NvAPI_DISP_GetMonitorCapabilities()."] -pub type NV_MONITOR_CAPABILITIES_V1 = _NV_MONITOR_CAPABILITIES_V1; -#[doc = "! See NvAPI_DISP_GetMonitorCapabilities()."] -pub type NV_MONITOR_CAPABILITIES = NV_MONITOR_CAPABILITIES_V1; -#[doc = "! \\ingroup dispcontrol"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MONITOR_COLOR_DATA { - pub version: NvU32, - #[doc = "!< One of the supported color formats"] - pub colorFormat: NV_DP_COLOR_FORMAT, - #[doc = "!< One of the supported bit depths"] - pub backendBitDepths: NV_DP_BPC, -} -#[doc = "! \\ingroup dispcontrol"] -pub type NV_MONITOR_COLOR_CAPS_V1 = _NV_MONITOR_COLOR_DATA; -#[doc = "! \\ingroup dispcontrol"] -pub type NV_MONITOR_COLOR_CAPS = NV_MONITOR_COLOR_CAPS_V1; -#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_DISP_EnumCustomDisplay() and NvAPI_DISP_TryCustomDisplay()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_CUSTOM_DISPLAY { - pub version: NvU32, - #[doc = "!< Source surface(source mode) width"] - pub width: NvU32, - #[doc = "!< Source surface(source mode) height"] - pub height: NvU32, - #[doc = "!< Source surface color depth.\"0\" means all 8/16/32bpp"] - pub depth: NvU32, - #[doc = "!< Color format (optional)"] - pub colorFormat: NV_FORMAT, - #[doc = "!< For multimon support, should be set to (0,0,1.0,1.0) for now."] - pub srcPartition: NV_VIEWPORTF, - #[doc = "!< Horizontal scaling ratio"] - pub xRatio: f32, - #[doc = "!< Vertical scaling ratio"] - pub yRatio: f32, - #[doc = "!< Timing used to program TMDS/DAC/LVDS/HDMI/TVEncoder, etc."] - pub timing: NV_TIMING, - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, - pub __bindgen_padding_0: [u8; 3usize], -} -impl NV_CUSTOM_DISPLAY { - #[inline] - pub fn hwModeSetOnly(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_hwModeSetOnly(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn hwModeSetOnly_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_hwModeSetOnly_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1(hwModeSetOnly: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let hwModeSetOnly: u32 = unsafe { ::std::mem::transmute(hwModeSetOnly) }; - hwModeSetOnly as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! \\ingroup dispcontrol\n! @{"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_EDID_DATA_V1 { - #[doc = "!< Structure version."] - pub version: NvU32, - #[doc = "!< Pointer to EDID data."] - pub pEDID: *mut NvU8, - #[doc = "!< Size of EDID data."] - pub sizeOfEDID: NvU32, -} -#[doc = "! \\ingroup dispcontrol\n! @{"] -pub type NV_EDID_DATA_V1 = _NV_EDID_DATA_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_EDID_DATA_V2 { - #[doc = "!< Structure version."] - pub version: NvU32, - #[doc = "!< Pointer to EDID data."] - pub pEDID: *mut NvU8, - #[doc = "!< Size of EDID data."] - pub sizeOfEDID: NvU32, - #[doc = "!< Reserved for future use."] - pub reserved: [NvU32; 8usize], -} -pub type NV_EDID_DATA_V2 = _NV_EDID_DATA_V2; -pub type NV_EDID_DATA = NV_EDID_DATA_V2; -#[doc = "! @}"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GET_ADAPTIVE_SYNC_DATA_V1 { - #[doc = "!< [in] structure version"] - pub version: NvU32, - #[doc = "!< [out] maximum frame interval in micro seconds as set previously using NvAPI_DISP_SetAdaptiveSyncData function."] - pub maxFrameInterval: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< [out] Number of times the last flip was shown on the screen"] - pub lastFlipRefreshCount: NvU32, - #[doc = "!< [out] Timestamp for the lastest flip on the screen"] - pub lastFlipTimeStamp: NvU64, - #[doc = "!< reserved for future use."] - pub reservedEx: [NvU32; 4usize], -} -impl _NV_GET_ADAPTIVE_SYNC_DATA_V1 { - #[inline] - pub fn bDisableAdaptiveSync(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bDisableAdaptiveSync(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bDisableAdaptiveSync_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bDisableAdaptiveSync_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bDisableFrameSplitting(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_bDisableFrameSplitting(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bDisableFrameSplitting_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bDisableFrameSplitting_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 30u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 30u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 30u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bDisableAdaptiveSync: NvU32, - bDisableFrameSplitting: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bDisableAdaptiveSync: u32 = unsafe { ::std::mem::transmute(bDisableAdaptiveSync) }; - bDisableAdaptiveSync as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let bDisableFrameSplitting: u32 = - unsafe { ::std::mem::transmute(bDisableFrameSplitting) }; - bDisableFrameSplitting as u64 - }); - __bindgen_bitfield_unit.set(2usize, 30u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! @}"] -pub type NV_GET_ADAPTIVE_SYNC_DATA_V1 = _NV_GET_ADAPTIVE_SYNC_DATA_V1; -#[doc = "! @}"] -pub type NV_GET_ADAPTIVE_SYNC_DATA = NV_GET_ADAPTIVE_SYNC_DATA_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_SET_ADAPTIVE_SYNC_DATA_V1 { - #[doc = "!< [in] structure version"] - pub version: NvU32, - #[doc = "!< [in] deprecated, please use maxFrameIntervalNs instead\n!< If maxFrameInterval is sent as 0, default values from EDID will be used."] - pub maxFrameInterval: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Ensure the alignment is 8 bytes and reserve it for future use."] - pub reserved1: NvU32, - #[doc = "!< [in] maximum frame interval in nano seconds.\n!< If maxFrameIntervalNs is sent as 0, default values from EDID will be used."] - pub maxFrameIntervalNs: NvU64, - #[doc = "!< reserved for future use."] - pub reservedEx: [NvU32; 4usize], -} -impl _NV_SET_ADAPTIVE_SYNC_DATA_V1 { - #[inline] - pub fn bDisableAdaptiveSync(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bDisableAdaptiveSync(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bDisableAdaptiveSync_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bDisableAdaptiveSync_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bDisableFrameSplitting(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_bDisableFrameSplitting(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bDisableFrameSplitting_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bDisableFrameSplitting_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 30u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 30u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 30u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bDisableAdaptiveSync: NvU32, - bDisableFrameSplitting: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bDisableAdaptiveSync: u32 = unsafe { ::std::mem::transmute(bDisableAdaptiveSync) }; - bDisableAdaptiveSync as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let bDisableFrameSplitting: u32 = - unsafe { ::std::mem::transmute(bDisableFrameSplitting) }; - bDisableFrameSplitting as u64 - }); - __bindgen_bitfield_unit.set(2usize, 30u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_SET_ADAPTIVE_SYNC_DATA_V1 = _NV_SET_ADAPTIVE_SYNC_DATA_V1; -pub type NV_SET_ADAPTIVE_SYNC_DATA = NV_SET_ADAPTIVE_SYNC_DATA_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GET_VIRTUAL_REFRESH_RATE_DATA_V1 { - #[doc = "!< [in] structure version"] - pub version: NvU32, - #[doc = "!< [out] frame interval in micro seconds if Virtual RR is currently applied"] - pub frameIntervalUs: NvU32, - #[doc = "!< [out] Refresh Rate * 1000"] - pub rrx1k: NvU32, - #[doc = "!< [out] If the content is Gaming"] - pub bIsGamingVrr: NvU32, - #[doc = "!< reserved for future use."] - pub reservedEx: [NvU32; 6usize], -} -pub type NV_GET_VIRTUAL_REFRESH_RATE_DATA_V1 = _NV_GET_VIRTUAL_REFRESH_RATE_DATA_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GET_VIRTUAL_REFRESH_RATE_DATA_V2 { - #[doc = "!< [in] structure version"] - pub version: NvU32, - #[doc = "!< [out] frame interval in micro seconds if Virtual RR is currently applied. This variable is deprecated in V2 and should not be used."] - pub frameIntervalUs: NvU32, - #[doc = "!< [out] Refresh Rate * 1000"] - pub rrx1k: NvU32, - #[doc = "!< [out] If the content is Gaming"] - pub bIsGamingVrr: NvU32, - #[doc = "!< [out] frame interval in nano seconds if Virtual RR is currently applied"] - pub frameIntervalNs: NvU64, - #[doc = "!< reserved for future use."] - pub reservedEx: [NvU32; 4usize], -} -pub type NV_GET_VIRTUAL_REFRESH_RATE_DATA_V2 = _NV_GET_VIRTUAL_REFRESH_RATE_DATA_V2; -pub type NV_GET_VIRTUAL_REFRESH_RATE_DATA = NV_GET_VIRTUAL_REFRESH_RATE_DATA_V2; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_SET_VIRTUAL_REFRESH_RATE_DATA_V1 { - #[doc = "!< [in] structure version"] - pub version: NvU32, - #[doc = "!< [in] frame interval in micro seconds if Virtual RR is currently applied"] - pub frameIntervalUs: NvU32, - #[doc = "!< [in] Refresh Rate * 1000"] - pub rrx1k: NvU32, - #[doc = "!< [in] If the content is Gaming"] - pub bIsGamingVrr: NvU32, - #[doc = "!< reserved for future use."] - pub reservedEx: [NvU32; 6usize], -} -pub type NV_SET_VIRTUAL_REFRESH_RATE_DATA_V1 = _NV_SET_VIRTUAL_REFRESH_RATE_DATA_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_SET_VIRTUAL_REFRESH_RATE_DATA_V2 { - #[doc = "!< [in] structure version"] - pub version: NvU32, - #[doc = "!< [in] frame interval in micro seconds if Virtual RR is currently applied. This variable is deprecated in V2 and should not be used."] - pub frameIntervalUs: NvU32, - #[doc = "!< [in] Refresh Rate * 1000"] - pub rrx1k: NvU32, - #[doc = "!< [in] If the content is Gaming"] - pub bIsGamingVrr: NvU32, - #[doc = "!< [in] frame interval in nano seconds if Virtual RR is currently applied"] - pub frameIntervalNs: NvU64, - #[doc = "!< reserved for future use."] - pub reservedEx: [NvU32; 4usize], -} -pub type NV_SET_VIRTUAL_REFRESH_RATE_DATA_V2 = _NV_SET_VIRTUAL_REFRESH_RATE_DATA_V2; -pub type NV_SET_VIRTUAL_REFRESH_RATE_DATA = NV_SET_VIRTUAL_REFRESH_RATE_DATA_V2; -#[doc = "! \\ingroup dispcontrol"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_SET_PREFERRED_STEREO_DISPLAY_V1 { - #[doc = "!< [in] Structure version"] - pub version: NvU32, - #[doc = "!< [in] Monitor Identifier to be set"] - pub displayId: NvU32, - #[doc = "!< Reserved for future use without adding versioning"] - pub reserved: NvU32, -} -#[doc = "! \\ingroup dispcontrol"] -pub type NV_SET_PREFERRED_STEREO_DISPLAY = NV_SET_PREFERRED_STEREO_DISPLAY_V1; -#[doc = "! \\ingroup dispcontrol"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_GET_PREFERRED_STEREO_DISPLAY_V1 { - #[doc = "!< [in] Structure version"] - pub version: NvU32, - #[doc = "!< [out] The queried stereo display"] - pub displayId: NvU32, - #[doc = "!< Reserved for future use without adding versioning"] - pub reserved: NvU32, -} -#[doc = "! \\ingroup dispcontrol"] -pub type NV_GET_PREFERRED_STEREO_DISPLAY = NV_GET_PREFERRED_STEREO_DISPLAY_V1; -#[doc = "! \\ingroup dispcontrol"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_DISPLAY_ID_INFO_DATA_V1 { - #[doc = "!< [in] Structure version"] - pub version: NvU32, - #[doc = "!< [out] Locally unique ID (LUID) of the display adapter on which the given display is present."] - pub adapterId: LUID, - #[doc = "!< [out] The target identifier of the given display. This is also called AdapterRelativeId."] - pub targetId: NvU32, - #[doc = "!< Reserved for future use."] - pub reserved: [NvU32; 4usize], -} -#[doc = "! \\ingroup dispcontrol"] -pub type NV_DISPLAY_ID_INFO_DATA_V1 = _NV_DISPLAY_ID_INFO_DATA_V1; -#[doc = "! \\ingroup dispcontrol"] -pub type NV_DISPLAY_ID_INFO_DATA = NV_DISPLAY_ID_INFO_DATA_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_TARGET_INFO_DATA_V1 { - #[doc = "!< [in] Structure version"] - pub version: NvU32, - #[doc = "!< [in] Locally unique ID (LUID) of the display adapter on which the target is present."] - pub adapterId: LUID, - #[doc = "!< [in] The target identifier. This is also called AdapterRelativeId."] - pub targetId: NvU32, - #[doc = "!< [out] An array of displayIds corresponding to the input adapterId and targetId.\n!< If the input (targetId, adapterId) pair is a display grid (Mosaic/Surround),\n!< then the output contains the displayId of every display that is part of the display grid.\n!< Otherwise, it contains exactly one displayId.\n!< These displayId values are unique to this (targetId, adapterId) pair."] - pub displayId: [NvU32; 128usize], - #[doc = "!< [out] The number of displays returned in displayId array."] - pub displayIdCount: NvU32, - #[doc = "!< Reserved for future use."] - pub reserved: [NvU32; 4usize], -} -pub type NV_TARGET_INFO_DATA_V1 = _NV_TARGET_INFO_DATA_V1; -pub type NV_TARGET_INFO_DATA = NV_TARGET_INFO_DATA_V1; -#[doc = "! \\ingroup dispcontrol"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GET_VRR_INFO_V1 { - #[doc = "!< [in] Structure version"] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Reserved for future use"] - pub reservedEx: [NvU32; 4usize], -} -impl _NV_GET_VRR_INFO_V1 { - #[inline] - pub fn bIsVRREnabled(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsVRREnabled(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsVRREnabled_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsVRREnabled_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bIsVRRPossible(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsVRRPossible(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsVRRPossible_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsVRRPossible_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bIsVRRRequested(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsVRRRequested(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsVRRRequested_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsVRRRequested_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bIsVRRIndicatorEnabled(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsVRRIndicatorEnabled(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsVRRIndicatorEnabled_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsVRRIndicatorEnabled_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bIsDisplayInVRRMode(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsDisplayInVRRMode(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsDisplayInVRRMode_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsDisplayInVRRMode_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 27u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 27u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 27u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bIsVRREnabled: NvU32, - bIsVRRPossible: NvU32, - bIsVRRRequested: NvU32, - bIsVRRIndicatorEnabled: NvU32, - bIsDisplayInVRRMode: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsVRREnabled: u32 = unsafe { ::std::mem::transmute(bIsVRREnabled) }; - bIsVRREnabled as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let bIsVRRPossible: u32 = unsafe { ::std::mem::transmute(bIsVRRPossible) }; - bIsVRRPossible as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let bIsVRRRequested: u32 = unsafe { ::std::mem::transmute(bIsVRRRequested) }; - bIsVRRRequested as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let bIsVRRIndicatorEnabled: u32 = - unsafe { ::std::mem::transmute(bIsVRRIndicatorEnabled) }; - bIsVRRIndicatorEnabled as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let bIsDisplayInVRRMode: u32 = unsafe { ::std::mem::transmute(bIsDisplayInVRRMode) }; - bIsDisplayInVRRMode as u64 - }); - __bindgen_bitfield_unit.set(5usize, 27u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! \\ingroup dispcontrol"] -pub type NV_GET_VRR_INFO_V1 = _NV_GET_VRR_INFO_V1; -#[doc = "! \\ingroup dispcontrol"] -pub type NV_GET_VRR_INFO = NV_GET_VRR_INFO_V1; -#[doc = "! This structure defines the topology details."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_MOSAIC_TOPO_DETAILS { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< Logical GPU for this topology"] - pub hLogicalGPU: NvLogicalGpuHandle, - #[doc = "!< 0 means topology is valid with the current hardware."] - pub validityMask: NvU32, - #[doc = "!< Number of displays in a row"] - pub rowCount: NvU32, - #[doc = "!< Number of displays in a column"] - pub colCount: NvU32, - pub gpuLayout: [[NV_MOSAIC_TOPO_DETAILS__bindgen_ty_1; 8usize]; 8usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_MOSAIC_TOPO_DETAILS__bindgen_ty_1 { - #[doc = "!< Physical GPU to be used in the topology (0 if GPU missing)"] - pub hPhysicalGPU: NvPhysicalGpuHandle, - #[doc = "!< Connected display target (0 if no display connected)"] - pub displayOutputId: NvU32, - #[doc = "!< Pixels of overlap on left of target: (+overlap, -gap)"] - pub overlapX: NvS32, - #[doc = "!< Pixels of overlap on top of target: (+overlap, -gap)"] - pub overlapY: NvS32, -} -#[doc = "!< All mosaic topologies"] -pub const NV_MOSAIC_TOPO_TYPE_NV_MOSAIC_TOPO_TYPE_ALL: NV_MOSAIC_TOPO_TYPE = 0; -#[doc = "!< Basic Mosaic topologies"] -pub const NV_MOSAIC_TOPO_TYPE_NV_MOSAIC_TOPO_TYPE_BASIC: NV_MOSAIC_TOPO_TYPE = 1; -#[doc = "!< Passive Stereo topologies"] -pub const NV_MOSAIC_TOPO_TYPE_NV_MOSAIC_TOPO_TYPE_PASSIVE_STEREO: NV_MOSAIC_TOPO_TYPE = 2; -#[doc = "!< Not supported at this time"] -pub const NV_MOSAIC_TOPO_TYPE_NV_MOSAIC_TOPO_TYPE_SCALED_CLONE: NV_MOSAIC_TOPO_TYPE = 3; -#[doc = "!< Not supported at this time"] -pub const NV_MOSAIC_TOPO_TYPE_NV_MOSAIC_TOPO_TYPE_PASSIVE_STEREO_SCALED_CLONE: NV_MOSAIC_TOPO_TYPE = - 4; -#[doc = "!< Always leave this at end of the enum"] -pub const NV_MOSAIC_TOPO_TYPE_NV_MOSAIC_TOPO_TYPE_MAX: NV_MOSAIC_TOPO_TYPE = 5; -#[doc = "! These values refer to the different types of Mosaic topologies that are possible. When\n! getting the supported Mosaic topologies, you can specify one of these types to narrow down\n! the returned list to only those that match the given type."] -pub type NV_MOSAIC_TOPO_TYPE = ::std::os::raw::c_int; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_NONE: NV_MOSAIC_TOPO = 0; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_BEGIN_BASIC: NV_MOSAIC_TOPO = 1; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x2_BASIC: NV_MOSAIC_TOPO = 1; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_2x1_BASIC: NV_MOSAIC_TOPO = 2; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x3_BASIC: NV_MOSAIC_TOPO = 3; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_3x1_BASIC: NV_MOSAIC_TOPO = 4; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x4_BASIC: NV_MOSAIC_TOPO = 5; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_4x1_BASIC: NV_MOSAIC_TOPO = 6; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_2x2_BASIC: NV_MOSAIC_TOPO = 7; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_2x3_BASIC: NV_MOSAIC_TOPO = 8; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_2x4_BASIC: NV_MOSAIC_TOPO = 9; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_3x2_BASIC: NV_MOSAIC_TOPO = 10; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_4x2_BASIC: NV_MOSAIC_TOPO = 11; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x5_BASIC: NV_MOSAIC_TOPO = 12; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x6_BASIC: NV_MOSAIC_TOPO = 13; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_7x1_BASIC: NV_MOSAIC_TOPO = 14; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_END_BASIC: NV_MOSAIC_TOPO = 23; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_BEGIN_PASSIVE_STEREO: NV_MOSAIC_TOPO = 24; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x2_PASSIVE_STEREO: NV_MOSAIC_TOPO = 24; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_2x1_PASSIVE_STEREO: NV_MOSAIC_TOPO = 25; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x3_PASSIVE_STEREO: NV_MOSAIC_TOPO = 26; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_3x1_PASSIVE_STEREO: NV_MOSAIC_TOPO = 27; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x4_PASSIVE_STEREO: NV_MOSAIC_TOPO = 28; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_4x1_PASSIVE_STEREO: NV_MOSAIC_TOPO = 29; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_2x2_PASSIVE_STEREO: NV_MOSAIC_TOPO = 30; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_END_PASSIVE_STEREO: NV_MOSAIC_TOPO = 34; -pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_MAX: NV_MOSAIC_TOPO = 35; -#[doc = "! This is a complete list of supported Mosaic topologies.\n!\n! Using a \"Basic\" topology combines multiple monitors to create a single desktop.\n!\n! Using a \"Passive\" topology combines multiples monitors to create a passive stereo desktop.\n! In passive stereo, two identical topologies combine - one topology is used for the right eye and the other identical //! topology (targeting different displays) is used for the left eye. \\n\n! NOTE: common\\inc\\nvEscDef.h shadows a couple PASSIVE_STEREO enums. If this\n! enum list changes and effects the value of NV_MOSAIC_TOPO_BEGIN_PASSIVE_STEREO\n! please update the corresponding value in nvEscDef.h"] -pub type NV_MOSAIC_TOPO = ::std::os::raw::c_int; -#[doc = "! This is a \"topology brief\" structure. It tells you what you need to know about\n! a topology at a high level. A list of these is returned when you query for the\n! supported Mosaic information.\n!\n! If you need more detailed information about the topology, call\n! NvAPI_Mosaic_GetTopoGroup() with the topology value from this structure."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_MOSAIC_TOPO_BRIEF { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< The topology"] - pub topo: NV_MOSAIC_TOPO, - #[doc = "!< 1 if topo is enabled, else 0"] - pub enabled: NvU32, - #[doc = "!< 1 if topo *can* be enabled, else 0"] - pub isPossible: NvU32, -} -#[doc = "! Basic per-display settings that are used in setting/getting the Mosaic mode"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MOSAIC_DISPLAY_SETTING_V1 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< Per-display width"] - pub width: NvU32, - #[doc = "!< Per-display height"] - pub height: NvU32, - #[doc = "!< Bits per pixel"] - pub bpp: NvU32, - #[doc = "!< Display frequency"] - pub freq: NvU32, -} -#[doc = "! Basic per-display settings that are used in setting/getting the Mosaic mode"] -pub type NV_MOSAIC_DISPLAY_SETTING_V1 = _NV_MOSAIC_DISPLAY_SETTING_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_MOSAIC_DISPLAY_SETTING_V2 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< Per-display width"] - pub width: NvU32, - #[doc = "!< Per-display height"] - pub height: NvU32, - #[doc = "!< Bits per pixel"] - pub bpp: NvU32, - #[doc = "!< Display frequency"] - pub freq: NvU32, - #[doc = "!< Display frequency in x1k"] - pub rrx1k: NvU32, -} -pub type NV_MOSAIC_DISPLAY_SETTING = NV_MOSAIC_DISPLAY_SETTING_V2; -#[doc = "! This structure is used to contain a list of supported Mosaic topologies\n! along with the display settings that can be used."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MOSAIC_SUPPORTED_TOPO_INFO_V1 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< Number of topologies in below array"] - pub topoBriefsCount: NvU32, - #[doc = "!< List of supported topologies with only brief details"] - pub topoBriefs: [NV_MOSAIC_TOPO_BRIEF; 35usize], - #[doc = "!< Number of display settings in below array"] - pub displaySettingsCount: NvU32, - #[doc = "!< List of per display settings possible"] - pub displaySettings: [NV_MOSAIC_DISPLAY_SETTING_V1; 40usize], -} -#[doc = "! This structure is used to contain a list of supported Mosaic topologies\n! along with the display settings that can be used."] -pub type NV_MOSAIC_SUPPORTED_TOPO_INFO_V1 = _NV_MOSAIC_SUPPORTED_TOPO_INFO_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MOSAIC_SUPPORTED_TOPO_INFO_V2 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< Number of topologies in below array"] - pub topoBriefsCount: NvU32, - #[doc = "!< List of supported topologies with only brief details"] - pub topoBriefs: [NV_MOSAIC_TOPO_BRIEF; 35usize], - #[doc = "!< Number of display settings in below array"] - pub displaySettingsCount: NvU32, - #[doc = "!< List of per display settings possible"] - pub displaySettings: [NV_MOSAIC_DISPLAY_SETTING_V2; 40usize], -} -pub type NV_MOSAIC_SUPPORTED_TOPO_INFO_V2 = _NV_MOSAIC_SUPPORTED_TOPO_INFO_V2; -pub type NV_MOSAIC_SUPPORTED_TOPO_INFO = NV_MOSAIC_SUPPORTED_TOPO_INFO_V2; -#[doc = "! This structure defines a group of topologies that work together to create one\n! overall layout. All of the supported topologies are represented with this\n! structure.\n!\n! For example, a 'Passive Stereo' topology would be represented with this\n! structure, and would have separate topology details for the left and right eyes.\n! The count would be 2. A 'Basic' topology is also represented by this structure,\n! with a count of 1.\n!\n! The structure is primarily used internally, but is exposed to applications in a\n! read-only fashion because there are some details in it that might be useful\n! (like the number of rows/cols, or connected display information). A user can\n! get the filled-in structure by calling NvAPI_Mosaic_GetTopoGroup().\n!\n! You can then look at the detailed values within the structure. There are no\n! entrypoints which take this structure as input (effectively making it read-only)."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_MOSAIC_TOPO_GROUP { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< The brief details of this topo"] - pub brief: NV_MOSAIC_TOPO_BRIEF, - #[doc = "!< Number of topos in array below"] - pub count: NvU32, - pub topos: [NV_MOSAIC_TOPO_DETAILS; 2usize], -} -#[doc = "! \\ingroup mosaicapi\n! @{"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MOSAIC_GRID_TOPO_DISPLAY_V1 { - #[doc = "!< DisplayID of the display"] - pub displayId: NvU32, - #[doc = "!< (+overlap, -gap)"] - pub overlapX: NvS32, - #[doc = "!< (+overlap, -gap)"] - pub overlapY: NvS32, - #[doc = "!< Rotation of display"] - pub rotation: NV_ROTATE, - #[doc = "!< Reserved, must be 0"] - pub cloneGroup: NvU32, -} -#[doc = "! \\ingroup mosaicapi\n! @{"] -pub type NV_MOSAIC_GRID_TOPO_DISPLAY_V1 = _NV_MOSAIC_GRID_TOPO_DISPLAY_V1; -#[doc = "!< No pixel shift will be applied to this display."] -pub const _NV_PIXEL_SHIFT_TYPE_NV_PIXEL_SHIFT_TYPE_NO_PIXEL_SHIFT: _NV_PIXEL_SHIFT_TYPE = 0; -#[doc = "!< This display will be used to scanout top left pixels in 2x2 PixelShift configuration"] -pub const _NV_PIXEL_SHIFT_TYPE_NV_PIXEL_SHIFT_TYPE_2x2_TOP_LEFT_PIXELS: _NV_PIXEL_SHIFT_TYPE = 1; -#[doc = "!< This display will be used to scanout bottom right pixels in 2x2 PixelShift configuration"] -pub const _NV_PIXEL_SHIFT_TYPE_NV_PIXEL_SHIFT_TYPE_2x2_BOTTOM_RIGHT_PIXELS: _NV_PIXEL_SHIFT_TYPE = - 2; -#[doc = "!< This display will be used to scanout top right pixels in 2x2 PixelShift configuration"] -pub const _NV_PIXEL_SHIFT_TYPE_NV_PIXEL_SHIFT_TYPE_2x2_TOP_RIGHT_PIXELS: _NV_PIXEL_SHIFT_TYPE = 4; -#[doc = "!< This display will be used to scanout bottom left pixels in 2x2 PixelShift configuration"] -pub const _NV_PIXEL_SHIFT_TYPE_NV_PIXEL_SHIFT_TYPE_2x2_BOTTOM_LEFT_PIXELS: _NV_PIXEL_SHIFT_TYPE = 8; -pub type _NV_PIXEL_SHIFT_TYPE = ::std::os::raw::c_int; -pub use self::_NV_PIXEL_SHIFT_TYPE as NV_PIXEL_SHIFT_TYPE; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MOSAIC_GRID_TOPO_DISPLAY_V2 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< DisplayID of the display"] - pub displayId: NvU32, - #[doc = "!< (+overlap, -gap)"] - pub overlapX: NvS32, - #[doc = "!< (+overlap, -gap)"] - pub overlapY: NvS32, - #[doc = "!< Rotation of display"] - pub rotation: NV_ROTATE, - #[doc = "!< Reserved, must be 0"] - pub cloneGroup: NvU32, - #[doc = "!< Type of the pixel shift enabled display"] - pub pixelShiftType: NV_PIXEL_SHIFT_TYPE, -} -pub type NV_MOSAIC_GRID_TOPO_DISPLAY_V2 = _NV_MOSAIC_GRID_TOPO_DISPLAY_V2; -#[doc = "! \\ingroup mosaicapi\n! @{"] -pub type NV_MOSAIC_GRID_TOPO_DISPLAY = NV_MOSAIC_GRID_TOPO_DISPLAY_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MOSAIC_GRID_TOPO_V1 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< Number of rows"] - pub rows: NvU32, - #[doc = "!< Number of columns"] - pub columns: NvU32, - #[doc = "!< Number of display details"] - pub displayCount: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Displays are done as [(row * columns) + column]"] - pub displays: [NV_MOSAIC_GRID_TOPO_DISPLAY_V1; 64usize], - #[doc = "!< Display settings"] - pub displaySettings: NV_MOSAIC_DISPLAY_SETTING_V1, -} -impl _NV_MOSAIC_GRID_TOPO_V1 { - #[inline] - pub fn applyWithBezelCorrect(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_applyWithBezelCorrect(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn applyWithBezelCorrect_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_applyWithBezelCorrect_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn immersiveGaming(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_immersiveGaming(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn immersiveGaming_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_immersiveGaming_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn baseMosaic(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_baseMosaic(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn baseMosaic_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_baseMosaic_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn driverReloadAllowed(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_driverReloadAllowed(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn driverReloadAllowed_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_driverReloadAllowed_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn acceleratePrimaryDisplay(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } - } - #[inline] - pub fn set_acceleratePrimaryDisplay(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn acceleratePrimaryDisplay_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_acceleratePrimaryDisplay_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 27u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 27u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 27u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - applyWithBezelCorrect: NvU32, - immersiveGaming: NvU32, - baseMosaic: NvU32, - driverReloadAllowed: NvU32, - acceleratePrimaryDisplay: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let applyWithBezelCorrect: u32 = - unsafe { ::std::mem::transmute(applyWithBezelCorrect) }; - applyWithBezelCorrect as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let immersiveGaming: u32 = unsafe { ::std::mem::transmute(immersiveGaming) }; - immersiveGaming as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let baseMosaic: u32 = unsafe { ::std::mem::transmute(baseMosaic) }; - baseMosaic as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let driverReloadAllowed: u32 = unsafe { ::std::mem::transmute(driverReloadAllowed) }; - driverReloadAllowed as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let acceleratePrimaryDisplay: u32 = - unsafe { ::std::mem::transmute(acceleratePrimaryDisplay) }; - acceleratePrimaryDisplay as u64 - }); - __bindgen_bitfield_unit.set(5usize, 27u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_MOSAIC_GRID_TOPO_V1 = _NV_MOSAIC_GRID_TOPO_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MOSAIC_GRID_TOPO_V2 { - #[doc = "!< Version of this structure"] - pub version: NvU32, - #[doc = "!< Number of rows"] - pub rows: NvU32, - #[doc = "!< Number of columns"] - pub columns: NvU32, - #[doc = "!< Number of display details"] - pub displayCount: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Displays are done as [(row * columns) + column]"] - pub displays: [NV_MOSAIC_GRID_TOPO_DISPLAY_V2; 64usize], - #[doc = "!< Display settings"] - pub displaySettings: NV_MOSAIC_DISPLAY_SETTING_V1, -} -impl _NV_MOSAIC_GRID_TOPO_V2 { - #[inline] - pub fn applyWithBezelCorrect(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_applyWithBezelCorrect(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn applyWithBezelCorrect_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_applyWithBezelCorrect_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn immersiveGaming(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_immersiveGaming(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn immersiveGaming_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_immersiveGaming_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn baseMosaic(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_baseMosaic(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn baseMosaic_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_baseMosaic_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn driverReloadAllowed(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_driverReloadAllowed(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn driverReloadAllowed_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_driverReloadAllowed_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn acceleratePrimaryDisplay(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } - } - #[inline] - pub fn set_acceleratePrimaryDisplay(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn acceleratePrimaryDisplay_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_acceleratePrimaryDisplay_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn pixelShift(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } - } - #[inline] - pub fn set_pixelShift(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn pixelShift_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_pixelShift_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 26u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(6usize, 26u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 6usize, - 26u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 6usize, - 26u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - applyWithBezelCorrect: NvU32, - immersiveGaming: NvU32, - baseMosaic: NvU32, - driverReloadAllowed: NvU32, - acceleratePrimaryDisplay: NvU32, - pixelShift: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let applyWithBezelCorrect: u32 = - unsafe { ::std::mem::transmute(applyWithBezelCorrect) }; - applyWithBezelCorrect as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let immersiveGaming: u32 = unsafe { ::std::mem::transmute(immersiveGaming) }; - immersiveGaming as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let baseMosaic: u32 = unsafe { ::std::mem::transmute(baseMosaic) }; - baseMosaic as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let driverReloadAllowed: u32 = unsafe { ::std::mem::transmute(driverReloadAllowed) }; - driverReloadAllowed as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let acceleratePrimaryDisplay: u32 = - unsafe { ::std::mem::transmute(acceleratePrimaryDisplay) }; - acceleratePrimaryDisplay as u64 - }); - __bindgen_bitfield_unit.set(5usize, 1u8, { - let pixelShift: u32 = unsafe { ::std::mem::transmute(pixelShift) }; - pixelShift as u64 - }); - __bindgen_bitfield_unit.set(6usize, 26u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_MOSAIC_GRID_TOPO_V2 = _NV_MOSAIC_GRID_TOPO_V2; -pub type NV_MOSAIC_GRID_TOPO = NV_MOSAIC_GRID_TOPO_V2; -#[doc = "! \\ingroup mosaicapi"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_MOSAIC_DISPLAY_TOPO_STATUS { - pub version: NvU32, - #[doc = "!< (OUT) Any of the NV_MOSAIC_DISPLAYTOPO_ERROR_* flags."] - pub errorFlags: NvU32, - #[doc = "!< (OUT) Any of the NV_MOSAIC_DISPLAYTOPO_WARNING_* flags."] - pub warningFlags: NvU32, - #[doc = "!< (OUT) The number of valid entries in the displays array."] - pub displayCount: NvU32, - pub displays: [NV_MOSAIC_DISPLAY_TOPO_STATUS__bindgen_ty_1; 128usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_MOSAIC_DISPLAY_TOPO_STATUS__bindgen_ty_1 { - #[doc = "!< (OUT) The DisplayID of this display."] - pub displayId: NvU32, - #[doc = "!< (OUT) Any of the NV_MOSAIC_DISPLAYCAPS_PROBLEM_* flags."] - pub errorFlags: NvU32, - #[doc = "!< (OUT) Any of the NV_MOSAIC_DISPLAYTOPO_WARNING_* flags."] - pub warningFlags: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, -} -impl NV_MOSAIC_DISPLAY_TOPO_STATUS__bindgen_ty_1 { - #[inline] - pub fn supportsRotation(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_supportsRotation(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn supportsRotation_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_supportsRotation_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - supportsRotation: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let supportsRotation: u32 = unsafe { ::std::mem::transmute(supportsRotation) }; - supportsRotation as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! Used in NvAPI_GetCurrentMosaicTopology() and NvAPI_SetCurrentMosaicTopology()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_MOSAIC_TOPOLOGY { - #[doc = "!< Version number of the mosaic topology"] - pub version: NvU32, - #[doc = "!< Horizontal display count"] - pub rowCount: NvU32, - #[doc = "!< Vertical display count"] - pub colCount: NvU32, - pub gpuLayout: [[NV_MOSAIC_TOPOLOGY__bindgen_ty_1; 8usize]; 8usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_MOSAIC_TOPOLOGY__bindgen_ty_1 { - #[doc = "!< Physical GPU to be used in the topology"] - pub hPhysicalGPU: NvPhysicalGpuHandle, - #[doc = "!< Connected display target"] - pub displayOutputId: NvU32, - #[doc = "!< Pixels of overlap on the left of target: (+overlap, -gap)"] - pub overlapX: NvS32, - #[doc = "!< Pixels of overlap on the top of target: (+overlap, -gap)"] - pub overlapY: NvS32, -} -#[doc = "! Used in NvAPI_GetSupportedMosaicTopologies()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NV_MOSAIC_SUPPORTED_TOPOLOGIES { - pub version: NvU32, - #[doc = "!< Count of valid topologies"] - pub totalCount: NvU32, - #[doc = "!< Maximum number of topologies"] - pub topos: [NV_MOSAIC_TOPOLOGY; 16usize], -} -#[doc = "! Used in NvAPI_GSync_QueryCapabilities()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GSYNC_CAPABILITIES_V1 { - #[doc = "!< Version of the structure"] - pub version: NvU32, - #[doc = "!< Board ID"] - pub boardId: NvU32, - #[doc = "!< FPGA Revision"] - pub revision: NvU32, - #[doc = "!< Capabilities of the Sync board. Reserved for future use"] - pub capFlags: NvU32, -} -#[doc = "! Used in NvAPI_GSync_QueryCapabilities()."] -pub type NV_GSYNC_CAPABILITIES_V1 = _NV_GSYNC_CAPABILITIES_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GSYNC_CAPABILITIES_V2 { - #[doc = "!< Version of the structure"] - pub version: NvU32, - #[doc = "!< Board ID"] - pub boardId: NvU32, - #[doc = "!< FPGA major revision"] - pub revision: NvU32, - #[doc = "!< Capabilities of the Sync board. Reserved for future use"] - pub capFlags: NvU32, - #[doc = "!< FPGA minor revision"] - pub extendedRevision: NvU32, -} -pub type NV_GSYNC_CAPABILITIES_V2 = _NV_GSYNC_CAPABILITIES_V2; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GSYNC_CAPABILITIES_V3 { - #[doc = "!< Version of the structure"] - pub version: NvU32, - #[doc = "!< Board ID"] - pub boardId: NvU32, - #[doc = "!< FPGA major revision"] - pub revision: NvU32, - #[doc = "!< Capabilities of the Sync board. Reserved for future use"] - pub capFlags: NvU32, - #[doc = "!< FPGA minor revision"] - pub extendedRevision: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< This parameter returns the maximum possible value that can be programmed\n!< for multiplying / dividing house sync. Only valid if bIsMulDivSupported is set to 1."] - pub maxMulDivValue: NvU32, -} -impl _NV_GSYNC_CAPABILITIES_V3 { - #[inline] - pub fn bIsMulDivSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsMulDivSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsMulDivSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsMulDivSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bIsMulDivSupported: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsMulDivSupported: u32 = unsafe { ::std::mem::transmute(bIsMulDivSupported) }; - bIsMulDivSupported as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_GSYNC_CAPABILITIES_V3 = _NV_GSYNC_CAPABILITIES_V3; -pub type NV_GSYNC_CAPABILITIES = NV_GSYNC_CAPABILITIES_V3; -pub const _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_NONE: - _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR = 0; -pub const _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_PRIMARY: - _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR = 1; -pub const _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_SECONDARY: - _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR = 2; -pub const _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_TERTIARY: - _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR = 3; -pub const _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_QUARTERNARY: - _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR = 4; -#[doc = "! Connector values for a GPU. Used in NV_GSYNC_GPU."] -pub type _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR = ::std::os::raw::c_int; -#[doc = "! Connector values for a GPU. Used in NV_GSYNC_GPU."] -pub use self::_NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR as NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR; -pub const _NVAPI_GSYNC_DISPLAY_SYNC_STATE_NVAPI_GSYNC_DISPLAY_SYNC_STATE_UNSYNCED: - _NVAPI_GSYNC_DISPLAY_SYNC_STATE = 0; -pub const _NVAPI_GSYNC_DISPLAY_SYNC_STATE_NVAPI_GSYNC_DISPLAY_SYNC_STATE_SLAVE: - _NVAPI_GSYNC_DISPLAY_SYNC_STATE = 1; -pub const _NVAPI_GSYNC_DISPLAY_SYNC_STATE_NVAPI_GSYNC_DISPLAY_SYNC_STATE_MASTER: - _NVAPI_GSYNC_DISPLAY_SYNC_STATE = 2; -#[doc = "! Display sync states. Used in NV_GSYNC_DISPLAY."] -pub type _NVAPI_GSYNC_DISPLAY_SYNC_STATE = ::std::os::raw::c_int; -#[doc = "! Display sync states. Used in NV_GSYNC_DISPLAY."] -pub use self::_NVAPI_GSYNC_DISPLAY_SYNC_STATE as NVAPI_GSYNC_DISPLAY_SYNC_STATE; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GSYNC_GPU { - #[doc = "!< Version of the structure"] - pub version: NvU32, - #[doc = "!< GPU handle"] - pub hPhysicalGpu: NvPhysicalGpuHandle, - #[doc = "!< Indicates which connector on the device the GPU is connected to."] - pub connector: NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR, - #[doc = "!< GPU through which hPhysicalGpu is connected to the Sync device (if not directly connected)\n!< - this is NULL otherwise"] - pub hProxyPhysicalGpu: NvPhysicalGpuHandle, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - pub __bindgen_padding_0: u32, -} -impl _NV_GSYNC_GPU { - #[inline] - pub fn isSynced(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isSynced(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isSynced_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isSynced_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1(isSynced: NvU32, reserved: NvU32) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isSynced: u32 = unsafe { ::std::mem::transmute(isSynced) }; - isSynced as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_GSYNC_GPU = _NV_GSYNC_GPU; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GSYNC_DISPLAY { - #[doc = "!< Version of the structure"] - pub version: NvU32, - #[doc = "!< display identifier for displays.The GPU to which it is connected, can be retireved from NvAPI_SYS_GetPhysicalGpuFromDisplayId"] - pub displayId: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Is this display slave/master\n!< (Retrieved with topology or set by caller for enable/disable sync)"] - pub syncState: NVAPI_GSYNC_DISPLAY_SYNC_STATE, -} -impl _NV_GSYNC_DISPLAY { - #[inline] - pub fn isMasterable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_isMasterable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn isMasterable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_isMasterable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - isMasterable: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let isMasterable: u32 = unsafe { ::std::mem::transmute(isMasterable) }; - isMasterable as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_GSYNC_DISPLAY = _NV_GSYNC_DISPLAY; -pub const _NVAPI_GSYNC_POLARITY_NVAPI_GSYNC_POLARITY_RISING_EDGE: _NVAPI_GSYNC_POLARITY = 0; -pub const _NVAPI_GSYNC_POLARITY_NVAPI_GSYNC_POLARITY_FALLING_EDGE: _NVAPI_GSYNC_POLARITY = 1; -pub const _NVAPI_GSYNC_POLARITY_NVAPI_GSYNC_POLARITY_BOTH_EDGES: _NVAPI_GSYNC_POLARITY = 2; -#[doc = "! Source signal edge to be used for output pulse. See NV_GSYNC_CONTROL_PARAMS."] -pub type _NVAPI_GSYNC_POLARITY = ::std::os::raw::c_int; -#[doc = "! Source signal edge to be used for output pulse. See NV_GSYNC_CONTROL_PARAMS."] -pub use self::_NVAPI_GSYNC_POLARITY as NVAPI_GSYNC_POLARITY; -pub const _NVAPI_GSYNC_VIDEO_MODE_NVAPI_GSYNC_VIDEO_MODE_NONE: _NVAPI_GSYNC_VIDEO_MODE = 0; -pub const _NVAPI_GSYNC_VIDEO_MODE_NVAPI_GSYNC_VIDEO_MODE_TTL: _NVAPI_GSYNC_VIDEO_MODE = 1; -pub const _NVAPI_GSYNC_VIDEO_MODE_NVAPI_GSYNC_VIDEO_MODE_NTSCPALSECAM: _NVAPI_GSYNC_VIDEO_MODE = 2; -pub const _NVAPI_GSYNC_VIDEO_MODE_NVAPI_GSYNC_VIDEO_MODE_HDTV: _NVAPI_GSYNC_VIDEO_MODE = 3; -pub const _NVAPI_GSYNC_VIDEO_MODE_NVAPI_GSYNC_VIDEO_MODE_COMPOSITE: _NVAPI_GSYNC_VIDEO_MODE = 4; -#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] -pub type _NVAPI_GSYNC_VIDEO_MODE = ::std::os::raw::c_int; -#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] -pub use self::_NVAPI_GSYNC_VIDEO_MODE as NVAPI_GSYNC_VIDEO_MODE; -pub const _NVAPI_GSYNC_SYNC_SOURCE_NVAPI_GSYNC_SYNC_SOURCE_VSYNC: _NVAPI_GSYNC_SYNC_SOURCE = 0; -pub const _NVAPI_GSYNC_SYNC_SOURCE_NVAPI_GSYNC_SYNC_SOURCE_HOUSESYNC: _NVAPI_GSYNC_SYNC_SOURCE = 1; -#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] -pub type _NVAPI_GSYNC_SYNC_SOURCE = ::std::os::raw::c_int; -#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] -pub use self::_NVAPI_GSYNC_SYNC_SOURCE as NVAPI_GSYNC_SYNC_SOURCE; -#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GSYNC_DELAY { - #[doc = "!< Version of the structure"] - pub version: NvU32, - #[doc = "!< delay to be induced in number of horizontal lines."] - pub numLines: NvU32, - #[doc = "!< delay to be induced in number of pixels."] - pub numPixels: NvU32, - #[doc = "!< maximum number of lines supported at current display mode to induce delay. Updated by NvAPI_GSync_GetControlParameters(). Read only."] - pub maxLines: NvU32, - #[doc = "!< minimum number of pixels required at current display mode to induce delay. Updated by NvAPI_GSync_GetControlParameters(). Read only."] - pub minPixels: NvU32, -} -#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] -pub type NV_GSYNC_DELAY = _NV_GSYNC_DELAY; -#[doc = "! Used in NvAPI_GSync_GetControlParameters() and NvAPI_GSync_SetControlParameters()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GSYNC_CONTROL_PARAMS_V1 { - #[doc = "!< Version of the structure"] - pub version: NvU32, - #[doc = "!< Leading edge / Falling edge / both"] - pub polarity: NVAPI_GSYNC_POLARITY, - #[doc = "!< None, TTL, NTSCPALSECAM, HDTV"] - pub vmode: NVAPI_GSYNC_VIDEO_MODE, - #[doc = "!< Number of pulses to wait between framelock signal generation"] - pub interval: NvU32, - #[doc = "!< VSync/House sync"] - pub source: NVAPI_GSYNC_SYNC_SOURCE, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< The time delay between the frame sync signal and the GPUs signal."] - pub syncSkew: NV_GSYNC_DELAY, - #[doc = "!< Sync start delay for master."] - pub startupDelay: NV_GSYNC_DELAY, -} -impl _NV_GSYNC_CONTROL_PARAMS_V1 { - #[inline] - pub fn interlaceMode(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_interlaceMode(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn interlaceMode_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_interlaceMode_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn syncSourceIsOutput(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_syncSourceIsOutput(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn syncSourceIsOutput_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_syncSourceIsOutput_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 30u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 30u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 30u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - interlaceMode: NvU32, - syncSourceIsOutput: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let interlaceMode: u32 = unsafe { ::std::mem::transmute(interlaceMode) }; - interlaceMode as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let syncSourceIsOutput: u32 = unsafe { ::std::mem::transmute(syncSourceIsOutput) }; - syncSourceIsOutput as u64 - }); - __bindgen_bitfield_unit.set(2usize, 30u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! Used in NvAPI_GSync_GetControlParameters() and NvAPI_GSync_SetControlParameters()."] -pub type NV_GSYNC_CONTROL_PARAMS_V1 = _NV_GSYNC_CONTROL_PARAMS_V1; -pub const _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE_NVAPI_GSYNC_UNDEFINED_MODE: - _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE = 0; -pub const _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE_NVAPI_GSYNC_MULTIPLY_MODE: - _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE = 1; -pub const _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE_NVAPI_GSYNC_DIVIDE_MODE: - _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE = 2; -#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] -pub type _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE = ::std::os::raw::c_int; -#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] -pub use self::_NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE as NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GSYNC_CONTROL_PARAMS_V2 { - #[doc = "!< Version of the structure"] - pub version: NvU32, - #[doc = "!< Leading edge / Falling edge / both"] - pub polarity: NVAPI_GSYNC_POLARITY, - #[doc = "!< None, TTL, NTSCPALSECAM, HDTV"] - pub vmode: NVAPI_GSYNC_VIDEO_MODE, - #[doc = "!< Number of pulses to wait between framelock signal generation"] - pub interval: NvU32, - #[doc = "!< VSync/House sync"] - pub source: NVAPI_GSYNC_SYNC_SOURCE, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< The time delay between the frame sync signal and the GPUs signal."] - pub syncSkew: NV_GSYNC_DELAY, - #[doc = "!< Sync start delay for master."] - pub startupDelay: NV_GSYNC_DELAY, - #[doc = "!< Indicates multiplier/divider mode for the housesync signal.\n!< While setting multiplyDivideMode, source needs to be set as NVAPI_GSYNC_SYNC_SOURCE_HOUSESYNC."] - pub multiplyDivideMode: NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE, - #[doc = "!< Indicates the multiplier/divider value for the housesync signal. Only supported if bIsMulDivSupported field of the structure NV_GSYNC_CAPABILITIES is set to 1.\n!< The maximum supported value for this field can be obtained from maxMulDivValue field of the structure NV_GSYNC_CAPABILITIES."] - pub multiplyDivideValue: NvU8, -} -impl _NV_GSYNC_CONTROL_PARAMS_V2 { - #[inline] - pub fn interlaceMode(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_interlaceMode(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn interlaceMode_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_interlaceMode_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn syncSourceIsOutput(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_syncSourceIsOutput(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn syncSourceIsOutput_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_syncSourceIsOutput_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 30u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 30u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 30u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - interlaceMode: NvU32, - syncSourceIsOutput: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let interlaceMode: u32 = unsafe { ::std::mem::transmute(interlaceMode) }; - interlaceMode as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let syncSourceIsOutput: u32 = unsafe { ::std::mem::transmute(syncSourceIsOutput) }; - syncSourceIsOutput as u64 - }); - __bindgen_bitfield_unit.set(2usize, 30u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_GSYNC_CONTROL_PARAMS_V2 = _NV_GSYNC_CONTROL_PARAMS_V2; -pub type NV_GSYNC_CONTROL_PARAMS = NV_GSYNC_CONTROL_PARAMS_V2; -#[doc = "! Used in NvAPI_GSync_GetSyncStatus()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GSYNC_STATUS { - #[doc = "!< Version of the structure"] - pub version: NvU32, - #[doc = "!< Is timing in sync?"] - pub bIsSynced: NvU32, - #[doc = "!< Does the phase of the timing signal from the GPU = the phase of the master sync signal?"] - pub bIsStereoSynced: NvU32, - #[doc = "!< Is the sync signal available?"] - pub bIsSyncSignalAvailable: NvU32, -} -#[doc = "! Used in NvAPI_GSync_GetSyncStatus()."] -pub type NV_GSYNC_STATUS = _NV_GSYNC_STATUS; -pub const _NVAPI_GSYNC_RJ45_IO_NVAPI_GSYNC_RJ45_OUTPUT: _NVAPI_GSYNC_RJ45_IO = 0; -pub const _NVAPI_GSYNC_RJ45_IO_NVAPI_GSYNC_RJ45_INPUT: _NVAPI_GSYNC_RJ45_IO = 1; -#[doc = "!< This field is used to notify that the framelock is not actually present."] -pub const _NVAPI_GSYNC_RJ45_IO_NVAPI_GSYNC_RJ45_UNUSED: _NVAPI_GSYNC_RJ45_IO = 2; -#[doc = "! Used in NV_GSYNC_STATUS_PARAMS."] -pub type _NVAPI_GSYNC_RJ45_IO = ::std::os::raw::c_int; -#[doc = "! Used in NV_GSYNC_STATUS_PARAMS."] -pub use self::_NVAPI_GSYNC_RJ45_IO as NVAPI_GSYNC_RJ45_IO; -#[doc = "! \\ingroup gsyncapi\n! Used in NvAPI_GSync_GetStatusParameters()."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GSYNC_STATUS_PARAMS_V1 { - pub version: NvU32, - #[doc = "!< The refresh rate"] - pub refreshRate: NvU32, - #[doc = "!< Configured as input / output"] - pub RJ45_IO: [NVAPI_GSYNC_RJ45_IO; 2usize], - #[doc = "!< Connected to ethernet hub? [ERRONEOUSLY CONNECTED!]"] - pub RJ45_Ethernet: [NvU32; 2usize], - #[doc = "!< Incoming house sync frequency in Hz"] - pub houseSyncIncoming: NvU32, - #[doc = "!< Is house sync connected?"] - pub bHouseSync: NvU32, -} -#[doc = "! \\ingroup gsyncapi\n! Used in NvAPI_GSync_GetStatusParameters()."] -pub type NV_GSYNC_STATUS_PARAMS_V1 = _NV_GSYNC_STATUS_PARAMS_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GSYNC_STATUS_PARAMS_V2 { - pub version: NvU32, - #[doc = "!< The refresh rate"] - pub refreshRate: NvU32, - #[doc = "!< Configured as input / output"] - pub RJ45_IO: [NVAPI_GSYNC_RJ45_IO; 2usize], - #[doc = "!< Connected to ethernet hub? [ERRONEOUSLY CONNECTED!]"] - pub RJ45_Ethernet: [NvU32; 2usize], - #[doc = "!< Incoming house sync frequency in Hz"] - pub houseSyncIncoming: NvU32, - #[doc = "!< Is house sync connected?"] - pub bHouseSync: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, -} -impl _NV_GSYNC_STATUS_PARAMS_V2 { - #[inline] - pub fn bInternalSlave(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bInternalSlave(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bInternalSlave_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bInternalSlave_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bInternalSlave: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bInternalSlave: u32 = unsafe { ::std::mem::transmute(bInternalSlave) }; - bInternalSlave as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_GSYNC_STATUS_PARAMS_V2 = _NV_GSYNC_STATUS_PARAMS_V2; -pub type NV_GSYNC_STATUS_PARAMS = NV_GSYNC_STATUS_PARAMS_V2; -pub const _NV_RESOLVE_MODE_NV_RESOLVE_MODE_SAMPLE_0: _NV_RESOLVE_MODE = 0; -#[doc = "! \\ingroup dx\n! Valid modes for NvAPI_D3D11_ResolveSubresourceRegion() and NvAPI_D3D12_ResolveSubresourceRegion"] -pub type _NV_RESOLVE_MODE = ::std::os::raw::c_int; -#[doc = "! \\ingroup dx\n! Valid modes for NvAPI_D3D11_ResolveSubresourceRegion() and NvAPI_D3D12_ResolveSubresourceRegion"] -pub use self::_NV_RESOLVE_MODE as NV_RESOLVE_MODE; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of Single Pass Stereo HW feature\n! \\ingroup dx"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V1 { - pub version: NvU32, - pub bSinglePassStereoSupported: NvU32, -} -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of Single Pass Stereo HW feature\n! \\ingroup dx"] -pub type NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V1 = - _NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V2 { - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, -} -impl _NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V2 { - #[inline] - pub fn bSinglePassStereoSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bSinglePassStereoSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bSinglePassStereoSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bSinglePassStereoSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bSinglePassStereoXYZWSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_bSinglePassStereoXYZWSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bSinglePassStereoXYZWSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bSinglePassStereoXYZWSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 30u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 30u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 30u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bSinglePassStereoSupported: NvU32, - bSinglePassStereoXYZWSupported: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bSinglePassStereoSupported: u32 = - unsafe { ::std::mem::transmute(bSinglePassStereoSupported) }; - bSinglePassStereoSupported as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let bSinglePassStereoXYZWSupported: u32 = - unsafe { ::std::mem::transmute(bSinglePassStereoXYZWSupported) }; - bSinglePassStereoXYZWSupported as u64 - }); - __bindgen_bitfield_unit.set(2usize, 30u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V2 = - _NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V2; -pub type NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS = NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V2; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of MultiView HW feature\n! \\ingroup dx"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_QUERY_MULTIVIEW_SUPPORT_PARAMS_V1 { - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, -} -impl _NV_QUERY_MULTIVIEW_SUPPORT_PARAMS_V1 { - #[inline] - pub fn bMultiViewSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bMultiViewSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bMultiViewSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bMultiViewSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bSinglePassStereoSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_bSinglePassStereoSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bSinglePassStereoSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bSinglePassStereoSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bSinglePassStereoXYZWSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_bSinglePassStereoXYZWSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bSinglePassStereoXYZWSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bSinglePassStereoXYZWSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 29u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 29u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 29u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 29u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bMultiViewSupported: NvU32, - bSinglePassStereoSupported: NvU32, - bSinglePassStereoXYZWSupported: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bMultiViewSupported: u32 = unsafe { ::std::mem::transmute(bMultiViewSupported) }; - bMultiViewSupported as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let bSinglePassStereoSupported: u32 = - unsafe { ::std::mem::transmute(bSinglePassStereoSupported) }; - bSinglePassStereoSupported as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let bSinglePassStereoXYZWSupported: u32 = - unsafe { ::std::mem::transmute(bSinglePassStereoXYZWSupported) }; - bSinglePassStereoXYZWSupported as u64 - }); - __bindgen_bitfield_unit.set(3usize, 29u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of MultiView HW feature\n! \\ingroup dx"] -pub type NV_QUERY_MULTIVIEW_SUPPORT_PARAMS_V1 = _NV_QUERY_MULTIVIEW_SUPPORT_PARAMS_V1; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of MultiView HW feature\n! \\ingroup dx"] -pub type NV_QUERY_MULTIVIEW_SUPPORT_PARAMS = NV_QUERY_MULTIVIEW_SUPPORT_PARAMS_V1; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used for setting the Mode for MultiView HW Feature.\n! \\ingroup dx"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MULTIVIEW_PARAMS_V1 { - pub version: NvU32, - pub numViews: NvU32, - pub renderTargetIndexOffset: [NvU32; 4usize], - pub independentViewportMaskEnable: NvU8, -} -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used for setting the Mode for MultiView HW Feature.\n! \\ingroup dx"] -pub type NV_MULTIVIEW_PARAMS_V1 = _NV_MULTIVIEW_PARAMS_V1; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used for setting the Mode for MultiView HW Feature.\n! \\ingroup dx"] -pub type NV_MULTIVIEW_PARAMS = NV_MULTIVIEW_PARAMS_V1; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of Lens Matched Shading HW feature\n! \\ingroup dx"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_QUERY_MODIFIED_W_SUPPORT_PARAMS { - pub version: NvU32, - pub bModifiedWSupported: NvU32, -} -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of Lens Matched Shading HW feature\n! \\ingroup dx"] -pub type NV_QUERY_MODIFIED_W_SUPPORT_PARAMS_V1 = _NV_QUERY_MODIFIED_W_SUPPORT_PARAMS; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of Lens Matched Shading HW feature\n! \\ingroup dx"] -pub type NV_QUERY_MODIFIED_W_SUPPORT_PARAMS = NV_QUERY_MODIFIED_W_SUPPORT_PARAMS_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MODIFIED_W_COEFFICIENTS { - pub fA: f32, - pub fB: f32, - pub fAReserved: f32, - pub fBReserved: f32, - pub fReserved: [f32; 2usize], -} -pub type NV_MODIFIED_W_COEFFICIENTS = _NV_MODIFIED_W_COEFFICIENTS; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_MODIFIED_W_PARAMS { - pub version: NvU32, - pub numEntries: NvU32, - pub modifiedWCoefficients: [NV_MODIFIED_W_COEFFICIENTS; 16usize], - pub id: NvU32, - pub reserved: [NvU32; 16usize], -} -pub type NV_MODIFIED_W_PARAMS_V1 = _NV_MODIFIED_W_PARAMS; -pub type NV_MODIFIED_W_PARAMS = NV_MODIFIED_W_PARAMS_V1; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to get sleep status\n! \\ingroup dx"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GET_SLEEP_STATUS_PARAMS { - #[doc = "!< (IN) Structure version"] - pub version: NvU32, - #[doc = "!< (OUT) Is low latency mode enabled?"] - pub bLowLatencyMode: NvBool, - #[doc = "!< (OUT) Is fullscreen VRR enabled?"] - pub bFsVrr: NvBool, - #[doc = "!< (OUT) Is Control Panel overriding VSYNC ON?"] - pub bCplVsyncOn: NvBool, - #[doc = "!< (OUT) Latest sleep interval in microseconds."] - pub sleepIntervalUs: NvU32, - #[doc = "!< (OUT) Is NvAPI_D3D_Sleep() being called?"] - pub bUseGameSleep: NvBool, - #[doc = "!< (OUT) Is in fullscreen/iFlip mode?"] - pub bFullscreenIFlip: NvBool, - #[doc = "!< (OUT) Latest Frame Generation multiplier used."] - pub fgMultiplier: NvU8, - #[doc = "!< (IN) Reserved. Must be set to 0s."] - pub rsvd: [NvU8; 119usize], -} -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to get sleep status\n! \\ingroup dx"] -pub type NV_GET_SLEEP_STATUS_PARAMS_V1 = _NV_GET_SLEEP_STATUS_PARAMS; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to get sleep status\n! \\ingroup dx"] -pub type NV_GET_SLEEP_STATUS_PARAMS = NV_GET_SLEEP_STATUS_PARAMS_V1; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to set sleep mode\n! \\ingroup dx"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_SET_SLEEP_MODE_PARAMS { - #[doc = "!< (IN) Structure version"] - pub version: NvU32, - #[doc = "!< (IN) Low latency mode enable/disable."] - pub bLowLatencyMode: NvBool, - #[doc = "!< (IN) Request maximum GPU clock frequency regardless of workload."] - pub bLowLatencyBoost: NvBool, - #[doc = "!< (IN) Minimum frame interval in microseconds. 0 = no frame rate limit."] - pub minimumIntervalUs: NvU32, - #[doc = "!< (IN) Allow latency markers to be used for runtime optimizations."] - pub bUseMarkersToOptimize: NvBool, - #[doc = "!< (IN) Consider all submission overlaps (both in between frames and within each frame)."] - pub bUseMinQueueTime: NvBool, - #[doc = "!< (IN) Reserved. Must be set to 0s."] - pub rsvd: [NvU8; 30usize], -} -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to set sleep mode\n! \\ingroup dx"] -pub type NV_SET_SLEEP_MODE_PARAMS_V1 = _NV_SET_SLEEP_MODE_PARAMS; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to set sleep mode\n! \\ingroup dx"] -pub type NV_SET_SLEEP_MODE_PARAMS = NV_SET_SLEEP_MODE_PARAMS_V1; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to send Reflex Sync data to UMD\n! \\ingroup dx"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_SET_REFLEX_SYNC_PARAMS { - #[doc = "!< (IN) Structure version"] - pub version: NvU32, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< (IN) Interval between VBLANKs in microseconds. (0 means N/A)"] - pub vblankIntervalUs: NvU32, - #[doc = "!< (IN) Amount of time in the completed frame queue. Can be negative. (0 means N/A)"] - pub timeInQueueUs: NvS32, - #[doc = "!< (IN) Target amount of time in the completed frame queue. (0 means N/A)"] - pub timeInQueueUsTarget: NvU32, - #[doc = "!< (IN) Specify the frame generation multipler to use. (0 means driver should auto-detect)"] - pub fgMultiplier: NvU8, - #[doc = "!< (IN) Reserved. Must be set to 0s."] - pub rsvd: [NvU8; 27usize], -} -impl _NV_SET_REFLEX_SYNC_PARAMS { - #[inline] - pub fn bEnable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bEnable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bEnable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bEnable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bDisable(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_bDisable(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bDisable_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bDisable_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn flagsRsvd(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } - } - #[inline] - pub fn set_flagsRsvd(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 30u8, val as u64) - } - } - #[inline] - pub unsafe fn flagsRsvd_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 30u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_flagsRsvd_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 30u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bEnable: NvU32, - bDisable: NvU32, - flagsRsvd: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bEnable: u32 = unsafe { ::std::mem::transmute(bEnable) }; - bEnable as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let bDisable: u32 = unsafe { ::std::mem::transmute(bDisable) }; - bDisable as u64 - }); - __bindgen_bitfield_unit.set(2usize, 30u8, { - let flagsRsvd: u32 = unsafe { ::std::mem::transmute(flagsRsvd) }; - flagsRsvd as u64 - }); - __bindgen_bitfield_unit - } -} -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to send Reflex Sync data to UMD\n! \\ingroup dx"] -pub type NV_SET_REFLEX_SYNC_PARAMS_V1 = _NV_SET_REFLEX_SYNC_PARAMS; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to send Reflex Sync data to UMD\n! \\ingroup dx"] -pub type NV_SET_REFLEX_SYNC_PARAMS = NV_SET_REFLEX_SYNC_PARAMS_V1; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to get latency report.\n! \\ingroup dx"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LATENCY_RESULT_PARAMS { - #[doc = "!< (IN) Structure version"] - pub version: NvU32, - pub frameReport: [_NV_LATENCY_RESULT_PARAMS_FrameReport; 64usize], - pub rsvd: [NvU8; 32usize], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LATENCY_RESULT_PARAMS_FrameReport { - #[doc = "!< (OUT)"] - pub frameID: NvU64, - #[doc = "!< (OUT)"] - pub inputSampleTime: NvU64, - #[doc = "!< (OUT)"] - pub simStartTime: NvU64, - #[doc = "!< (OUT)"] - pub simEndTime: NvU64, - #[doc = "!< (OUT)"] - pub renderSubmitStartTime: NvU64, - #[doc = "!< (OUT)"] - pub renderSubmitEndTime: NvU64, - #[doc = "!< (OUT)"] - pub presentStartTime: NvU64, - #[doc = "!< (OUT)"] - pub presentEndTime: NvU64, - #[doc = "!< (OUT)"] - pub driverStartTime: NvU64, - #[doc = "!< (OUT)"] - pub driverEndTime: NvU64, - #[doc = "!< (OUT)"] - pub osRenderQueueStartTime: NvU64, - #[doc = "!< (OUT)"] - pub osRenderQueueEndTime: NvU64, - #[doc = "!< (OUT)"] - pub gpuRenderStartTime: NvU64, - #[doc = "!< (OUT)"] - pub gpuRenderEndTime: NvU64, - #[doc = "!< (OUT) Difference between gpuRenderStartTime and gpuRenderEndTime, excluding the idles in between, in microseconds."] - pub gpuActiveRenderTimeUs: NvU32, - #[doc = "!< (OUT) Difference between previous and current frame's gpuRenderEndTime, in microseconds."] - pub gpuFrameTimeUs: NvU32, - #[doc = "!< (OUT)"] - pub cameraConstructedTime: NvU64, - #[doc = "!< (OUT) Cross adapter copy time in microseconds."] - pub crossAdapterCopyTimeUs: NvU32, - #[doc = "!< (OUT) Frame generation time in microseconds."] - pub aiFrameTimeUs: NvU32, - pub rsvd: [NvU8; 104usize], -} -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to get latency report.\n! \\ingroup dx"] -pub type NV_LATENCY_RESULT_PARAMS_V1 = _NV_LATENCY_RESULT_PARAMS; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to get latency report.\n! \\ingroup dx"] -pub type NV_LATENCY_RESULT_PARAMS = NV_LATENCY_RESULT_PARAMS_V1; -pub const NV_LATENCY_MARKER_TYPE_SIMULATION_START: NV_LATENCY_MARKER_TYPE = 0; -pub const NV_LATENCY_MARKER_TYPE_SIMULATION_END: NV_LATENCY_MARKER_TYPE = 1; -pub const NV_LATENCY_MARKER_TYPE_RENDERSUBMIT_START: NV_LATENCY_MARKER_TYPE = 2; -pub const NV_LATENCY_MARKER_TYPE_RENDERSUBMIT_END: NV_LATENCY_MARKER_TYPE = 3; -pub const NV_LATENCY_MARKER_TYPE_PRESENT_START: NV_LATENCY_MARKER_TYPE = 4; -pub const NV_LATENCY_MARKER_TYPE_PRESENT_END: NV_LATENCY_MARKER_TYPE = 5; -pub const NV_LATENCY_MARKER_TYPE_INPUT_SAMPLE: NV_LATENCY_MARKER_TYPE = 6; -pub const NV_LATENCY_MARKER_TYPE_TRIGGER_FLASH: NV_LATENCY_MARKER_TYPE = 7; -pub const NV_LATENCY_MARKER_TYPE_PC_LATENCY_PING: NV_LATENCY_MARKER_TYPE = 8; -pub const NV_LATENCY_MARKER_TYPE_OUT_OF_BAND_RENDERSUBMIT_START: NV_LATENCY_MARKER_TYPE = 9; -pub const NV_LATENCY_MARKER_TYPE_OUT_OF_BAND_RENDERSUBMIT_END: NV_LATENCY_MARKER_TYPE = 10; -pub const NV_LATENCY_MARKER_TYPE_OUT_OF_BAND_PRESENT_START: NV_LATENCY_MARKER_TYPE = 11; -pub const NV_LATENCY_MARKER_TYPE_OUT_OF_BAND_PRESENT_END: NV_LATENCY_MARKER_TYPE = 12; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used define latency marker type\n! \\ingroup dx"] -pub type NV_LATENCY_MARKER_TYPE = ::std::os::raw::c_int; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used set latency markers\n! \\ingroup dx"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LATENCY_MARKER_PARAMS { - #[doc = "!< (IN) Structure version"] - pub version: NvU32, - pub frameID: NvU64, - pub markerType: NV_LATENCY_MARKER_TYPE, - pub rsvd0: NvU64, - pub rsvd: [NvU8; 56usize], -} -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used set latency markers\n! \\ingroup dx"] -pub type NV_LATENCY_MARKER_PARAMS_V1 = _NV_LATENCY_MARKER_PARAMS; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used set latency markers\n! \\ingroup dx"] -pub type NV_LATENCY_MARKER_PARAMS = NV_LATENCY_MARKER_PARAMS_V1; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used in NvAPI_D3D12_SetAsyncFrameMarker and NvAPI_D3D11_SetAsyncFrameMarker\n! \\ingroup dx"] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_ASYNC_FRAME_MARKER_PARAMS_V1 { - #[doc = "!< (IN) Structure version"] - pub version: NvU32, - pub frameID: NvU64, - pub markerType: NV_LATENCY_MARKER_TYPE, - pub presentFrameID: NvU64, - pub vendorInternal: NvBool, - pub rsvd: [NvU8; 55usize], -} -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used in NvAPI_D3D12_SetAsyncFrameMarker and NvAPI_D3D11_SetAsyncFrameMarker\n! \\ingroup dx"] -pub type NV_ASYNC_FRAME_MARKER_PARAMS_V1 = _NV_ASYNC_FRAME_MARKER_PARAMS_V1; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used in NvAPI_D3D12_SetAsyncFrameMarker and NvAPI_D3D11_SetAsyncFrameMarker\n! \\ingroup dx"] -pub type NV_ASYNC_FRAME_MARKER_PARAMS = NV_ASYNC_FRAME_MARKER_PARAMS_V1; -pub const NV_OUT_OF_BAND_CQ_TYPE_OUT_OF_BAND_RENDER: NV_OUT_OF_BAND_CQ_TYPE = 0; -pub const NV_OUT_OF_BAND_CQ_TYPE_OUT_OF_BAND_PRESENT: NV_OUT_OF_BAND_CQ_TYPE = 1; -pub const NV_OUT_OF_BAND_CQ_TYPE_OUT_OF_BAND_IGNORE: NV_OUT_OF_BAND_CQ_TYPE = 2; -pub const NV_OUT_OF_BAND_CQ_TYPE_OUT_OF_BAND_RENDER_PRESENT: NV_OUT_OF_BAND_CQ_TYPE = 3; -#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used in NvAPI_D3D12_NotifyOutOfBandCommandQueue\n! \\ingroup dx"] -pub type NV_OUT_OF_BAND_CQ_TYPE = ::std::os::raw::c_int; -pub const _NV_D3D12_WORKSTATION_FEATURE_TYPE_NV_D3D12_WORKSTATION_FEATURE_TYPE_PRESENT_BARRIER: - _NV_D3D12_WORKSTATION_FEATURE_TYPE = 1; -pub const _NV_D3D12_WORKSTATION_FEATURE_TYPE_NV_D3D12_WORKSTATION_FEATURE_TYPE_RDMA_BAR1_SUPPORT: - _NV_D3D12_WORKSTATION_FEATURE_TYPE = 2; -#[doc = "! \\ingroup DX"] -pub type _NV_D3D12_WORKSTATION_FEATURE_TYPE = ::std::os::raw::c_int; -#[doc = "! \\ingroup DX"] -pub use self::_NV_D3D12_WORKSTATION_FEATURE_TYPE as NV_D3D12_WORKSTATION_FEATURE_TYPE; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_D3D12_WORKSTATION_FEATURE_RDMA_PROPERTIES { - pub rdmaHeapSize: NvU64, -} -pub type NV_D3D12_WORKSTATION_FEATURE_RDMA_PROPERTIES = - _NV_D3D12_WORKSTATION_FEATURE_RDMA_PROPERTIES; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_INITIALIZED: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 1; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_ENABLED: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 2; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_DLL_EXISTS: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 4; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_DLL_LOADED: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 8; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_DLL_SELECTED: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 16; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_PRESET: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 32; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_PERF_MODE: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 64; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_SCALING_RATIO: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 128; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_OPTIMAL_SETTINGS: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 256; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_CREATED: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 512; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_EVALUATE: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 1024; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_FG_MODE: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 8192; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_SR_DLAA_MODE: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 16384; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_FG_MULTI_FRAME: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 32768; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_ERR_FAILED: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 65536; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_ERR_DENIED: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 131072; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_ERR_DRS: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 262144; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_ERR_NOT_FOUND: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 524288; -pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_ERR_DLL_LOAD: - NV_NGX_DLSS_OVERRIDE_BITFIELD = 1048576; -pub type NV_NGX_DLSS_OVERRIDE_BITFIELD = ::std::os::raw::c_int; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_NGX_DLSS_OVERRIDE_GET_STATE_PARAMS_V1 { - #[doc = "!< [in] Structure version"] - pub version: NvU32, - #[doc = "!< [in] Process Identifier"] - pub processIdentifier: NvU32, - #[doc = "!< [out] Feedback bits for Super Resolution"] - pub feedbackMaskSR: NvU64, - #[doc = "!< [out] Feedback bits for Ray Reconstruction"] - pub feedbackMaskRR: NvU64, - #[doc = "!< [out] Feedback bits for Frame Generation"] - pub feedbackMaskFG: NvU64, - #[doc = "!< [out] Scaling Ratio"] - pub scalingRatio: NvF32, - #[doc = "!< [out] Performance Mode"] - pub performanceMode: NvU32, - #[doc = "!< [out] Render Preset for SR/RR"] - pub renderPreset: NvU32, - #[doc = "!< [out] FG Override Frame Count Target"] - pub frameGenerationCount: NvU32, - #[doc = "!< [out] Render Preset for FG"] - pub frameGenerationPreset: NvU32, - #[doc = "!< [out] Frame Generation Mode"] - pub frameGenerationMode: NvU32, - #[doc = "!< Reserved for future use. Must be zero."] - pub reserved: [NvU32; 2usize], -} -pub type NV_NGX_DLSS_OVERRIDE_GET_STATE_PARAMS_V1 = _NV_NGX_DLSS_OVERRIDE_GET_STATE_PARAMS_V1; -pub type NV_NGX_DLSS_OVERRIDE_GET_STATE_PARAMS = NV_NGX_DLSS_OVERRIDE_GET_STATE_PARAMS_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_NGX_DLSS_OVERRIDE_SET_STATE_PARAMS_V1 { - #[doc = "!< [in] Structure version"] - pub version: NvU32, - #[doc = "!< [in] Process identifier of caller"] - pub processIdentifier: NvU32, - #[doc = "!< [in] DLSS feature ID"] - pub feature: NvU32, - #[doc = "!< [in] Feedback bits for DLSS feature"] - pub feedbackMask: NvU64, - #[doc = "!< Reserved for future use. Must be zero."] - pub reserved: [NvU64; 4usize], -} -pub type NV_NGX_DLSS_OVERRIDE_SET_STATE_PARAMS_V1 = _NV_NGX_DLSS_OVERRIDE_SET_STATE_PARAMS_V1; -pub type NV_NGX_DLSS_OVERRIDE_SET_STATE_PARAMS = NV_NGX_DLSS_OVERRIDE_SET_STATE_PARAMS_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct NVVIOTOPOLOGYTARGET { - #[doc = "!< Handle to Physical GPU (This could be NULL for GVI device if its not binded)"] - pub hPhysicalGpu: NvPhysicalGpuHandle, - #[doc = "!, -} -impl _NV_DISPLAY_DRIVER_INFO { - #[inline] - pub fn bIsDCHDriver(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsDCHDriver(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsDCHDriver_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsDCHDriver_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bIsNVIDIAStudioPackage(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsNVIDIAStudioPackage(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsNVIDIAStudioPackage_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsNVIDIAStudioPackage_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bIsNVIDIAGameReadyPackage(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsNVIDIAGameReadyPackage(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsNVIDIAGameReadyPackage_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsNVIDIAGameReadyPackage_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bIsNVIDIARTXProductionBranchPackage(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsNVIDIARTXProductionBranchPackage(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsNVIDIARTXProductionBranchPackage_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsNVIDIARTXProductionBranchPackage_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bIsNVIDIARTXNewFeatureBranchPackage(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsNVIDIARTXNewFeatureBranchPackage(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsNVIDIARTXNewFeatureBranchPackage_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsNVIDIARTXNewFeatureBranchPackage_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 27u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 27u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 27u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bIsDCHDriver: NvU32, - bIsNVIDIAStudioPackage: NvU32, - bIsNVIDIAGameReadyPackage: NvU32, - bIsNVIDIARTXProductionBranchPackage: NvU32, - bIsNVIDIARTXNewFeatureBranchPackage: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsDCHDriver: u32 = unsafe { ::std::mem::transmute(bIsDCHDriver) }; - bIsDCHDriver as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let bIsNVIDIAStudioPackage: u32 = - unsafe { ::std::mem::transmute(bIsNVIDIAStudioPackage) }; - bIsNVIDIAStudioPackage as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let bIsNVIDIAGameReadyPackage: u32 = - unsafe { ::std::mem::transmute(bIsNVIDIAGameReadyPackage) }; - bIsNVIDIAGameReadyPackage as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let bIsNVIDIARTXProductionBranchPackage: u32 = - unsafe { ::std::mem::transmute(bIsNVIDIARTXProductionBranchPackage) }; - bIsNVIDIARTXProductionBranchPackage as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let bIsNVIDIARTXNewFeatureBranchPackage: u32 = - unsafe { ::std::mem::transmute(bIsNVIDIARTXNewFeatureBranchPackage) }; - bIsNVIDIARTXNewFeatureBranchPackage as u64 - }); - __bindgen_bitfield_unit.set(5usize, 27u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_DISPLAY_DRIVER_INFO_V1 = _NV_DISPLAY_DRIVER_INFO; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_DISPLAY_DRIVER_INFO_V2 { - #[doc = "!< Structure Version."] - pub version: NvU32, - #[doc = "!< Contains the driver version after successful return."] - pub driverVersion: NvU32, - #[doc = "!< Contains the driver-branch string after successful return."] - pub szBuildBranch: NvAPI_ShortString, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< (OUT) Contains the driver base branch string after successful return."] - pub szBuildBaseBranch: NvAPI_ShortString, - #[doc = "!< Reserved for future use"] - pub reservedEx: NvU32, -} -impl _NV_DISPLAY_DRIVER_INFO_V2 { - #[inline] - pub fn bIsDCHDriver(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsDCHDriver(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsDCHDriver_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsDCHDriver_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bIsNVIDIAStudioPackage(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsNVIDIAStudioPackage(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsNVIDIAStudioPackage_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsNVIDIAStudioPackage_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bIsNVIDIAGameReadyPackage(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsNVIDIAGameReadyPackage(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsNVIDIAGameReadyPackage_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 2usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsNVIDIAGameReadyPackage_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 2usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bIsNVIDIARTXProductionBranchPackage(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsNVIDIARTXProductionBranchPackage(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(3usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsNVIDIARTXProductionBranchPackage_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 3usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsNVIDIARTXProductionBranchPackage_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 3usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn bIsNVIDIARTXNewFeatureBranchPackage(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } - } - #[inline] - pub fn set_bIsNVIDIARTXNewFeatureBranchPackage(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(4usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bIsNVIDIARTXNewFeatureBranchPackage_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 4usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bIsNVIDIARTXNewFeatureBranchPackage_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 4usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } - } - #[inline] - pub fn set_reserved(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(5usize, 27u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 5usize, - 27u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 5usize, - 27u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bIsDCHDriver: NvU32, - bIsNVIDIAStudioPackage: NvU32, - bIsNVIDIAGameReadyPackage: NvU32, - bIsNVIDIARTXProductionBranchPackage: NvU32, - bIsNVIDIARTXNewFeatureBranchPackage: NvU32, - reserved: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bIsDCHDriver: u32 = unsafe { ::std::mem::transmute(bIsDCHDriver) }; - bIsDCHDriver as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let bIsNVIDIAStudioPackage: u32 = - unsafe { ::std::mem::transmute(bIsNVIDIAStudioPackage) }; - bIsNVIDIAStudioPackage as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let bIsNVIDIAGameReadyPackage: u32 = - unsafe { ::std::mem::transmute(bIsNVIDIAGameReadyPackage) }; - bIsNVIDIAGameReadyPackage as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let bIsNVIDIARTXProductionBranchPackage: u32 = - unsafe { ::std::mem::transmute(bIsNVIDIARTXProductionBranchPackage) }; - bIsNVIDIARTXProductionBranchPackage as u64 - }); - __bindgen_bitfield_unit.set(4usize, 1u8, { - let bIsNVIDIARTXNewFeatureBranchPackage: u32 = - unsafe { ::std::mem::transmute(bIsNVIDIARTXNewFeatureBranchPackage) }; - bIsNVIDIARTXNewFeatureBranchPackage as u64 - }); - __bindgen_bitfield_unit.set(5usize, 27u8, { - let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; - reserved as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_DISPLAY_DRIVER_INFO_V2 = _NV_DISPLAY_DRIVER_INFO_V2; -pub type NV_DISPLAY_DRIVER_INFO = NV_DISPLAY_DRIVER_INFO_V2; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_PHYSICAL_GPU_HANDLE_DATA { - pub hPhysicalGpu: NvPhysicalGpuHandle, - pub adapterType: NV_ADAPTER_TYPE, - pub reserved2: [NvU32; 4usize], -} -pub type NV_PHYSICAL_GPU_HANDLE_DATA = _NV_PHYSICAL_GPU_HANDLE_DATA; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_PHYSICAL_GPUS { - pub version: NvU32, - pub gpuHandleData: [NV_PHYSICAL_GPU_HANDLE_DATA; 64usize], - pub gpuHandleCount: NvU32, - pub reserved: [NvU32; 4usize], -} -pub type NV_PHYSICAL_GPUS_V1 = _NV_PHYSICAL_GPUS; -pub type NV_PHYSICAL_GPUS = NV_PHYSICAL_GPUS_V1; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LOGICAL_GPU_HANDLE_DATA { - pub hLogicalGpu: NvLogicalGpuHandle, - pub adapterType: NV_ADAPTER_TYPE, - pub reserved: [NvU32; 4usize], -} -pub type NV_LOGICAL_GPU_HANDLE_DATA = _NV_LOGICAL_GPU_HANDLE_DATA; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_LOGICAL_GPUS { - pub version: NvU32, - pub gpuHandleData: [NV_LOGICAL_GPU_HANDLE_DATA; 64usize], - pub gpuHandleCount: NvU32, - pub reserved: [NvU32; 4usize], -} -pub type NV_LOGICAL_GPUS_V1 = _NV_LOGICAL_GPUS; -pub type NV_LOGICAL_GPUS = NV_LOGICAL_GPUS_V1; -pub const _NV_NGX_DRIVER_FEATURE_ID_NV_NGX_DRIVER_FEATURE_ID_SET_FLIP_CONFIG_V2: - _NV_NGX_DRIVER_FEATURE_ID = 3423695; -pub type _NV_NGX_DRIVER_FEATURE_ID = ::std::os::raw::c_int; -pub use self::_NV_NGX_DRIVER_FEATURE_ID as NV_NGX_DRIVER_FEATURE_ID; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_NGX_DRIVER_FEATURE_SUPPORT_INFO { - #[doc = "!< [IN] Feature ID to query"] - pub featureId: NV_NGX_DRIVER_FEATURE_ID, - pub _bitfield_align_1: [u32; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - #[doc = "!< Reserved for future use"] - pub reserved2: [NvU32; 2usize], -} -impl _NV_NGX_DRIVER_FEATURE_SUPPORT_INFO { - #[inline] - pub fn bSupported(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_bSupported(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub unsafe fn bSupported_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 0usize, - 1u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_bSupported_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 0usize, - 1u8, - val as u64, - ) - } - } - #[inline] - pub fn reserved1(&self) -> NvU32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } - } - #[inline] - pub fn set_reserved1(&mut self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 31u8, val as u64) - } - } - #[inline] - pub unsafe fn reserved1_raw(this: *const Self) -> NvU32 { - unsafe { - ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( - ::std::ptr::addr_of!((*this)._bitfield_1), - 1usize, - 31u8, - ) as u32) - } - } - #[inline] - pub unsafe fn set_reserved1_raw(this: *mut Self, val: NvU32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( - ::std::ptr::addr_of_mut!((*this)._bitfield_1), - 1usize, - 31u8, - val as u64, - ) - } - } - #[inline] - pub fn new_bitfield_1( - bSupported: NvU32, - reserved1: NvU32, - ) -> __BindgenBitfieldUnit<[u8; 4usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let bSupported: u32 = unsafe { ::std::mem::transmute(bSupported) }; - bSupported as u64 - }); - __bindgen_bitfield_unit.set(1usize, 31u8, { - let reserved1: u32 = unsafe { ::std::mem::transmute(reserved1) }; - reserved1 as u64 - }); - __bindgen_bitfield_unit - } -} -pub type NV_NGX_DRIVER_FEATURE_SUPPORT_INFO = _NV_NGX_DRIVER_FEATURE_SUPPORT_INFO; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_NGX_GET_DRIVER_FEATURE_SUPPORT_PARAMS_V1 { - #[doc = "!< [IN] Structure version"] - pub version: NvU32, - #[doc = "!< [IN] Number of features to query (must be <= NVAPI_MAX_NGX_FEATURES_PER_QUERY)"] - pub featureCount: NvU32, - #[doc = "!< [INOUT] Feature query array"] - pub featureSupportInfo: [NV_NGX_DRIVER_FEATURE_SUPPORT_INFO; 16usize], - #[doc = "!< Reserved for future use"] - pub reserved: [NvU32; 6usize], -} -pub type NV_NGX_GET_DRIVER_FEATURE_SUPPORT_PARAMS_V1 = _NV_NGX_GET_DRIVER_FEATURE_SUPPORT_PARAMS_V1; -pub type NV_NGX_GET_DRIVER_FEATURE_SUPPORT_PARAMS = NV_NGX_GET_DRIVER_FEATURE_SUPPORT_PARAMS_V1; -#[doc = " Callback settings common to all client callbacks."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1 { - #[doc = " [in] Generic callback parameter which will be passed to the callback."] - pub pCallbackParam: *mut ::std::os::raw::c_void, - #[doc = " Reserved bytes for future expansion."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Callback settings common to all client callbacks."] -pub type NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1 = _NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1; -#[doc = " Callback settings common to all client callbacks."] -pub type NV_GPU_CLIENT_CALLBACK_SETTINGS_SUPER_V1 = NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1; -#[doc = " Callback settings common to all periodic client callbacks."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_PERIODIC_CALLBACK_SETTINGS_SUPER_V1 { - #[doc = " [in] Super class data."] - pub super_: NV_GPU_CLIENT_CALLBACK_SETTINGS_SUPER_V1, - #[doc = " [in] Minimum interval at which callback will be called.\n\n The callback may be invoked slower than this interval if underlying\n sampling rate does not align precisely to the provided period."] - pub callbackPeriodms: NvU32, - #[doc = " Reserved bytes for future expansion."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Callback settings common to all periodic client callbacks."] -pub type NV_GPU_CLIENT_PERIODIC_CALLBACK_SETTINGS_SUPER_V1 = - _NV_GPU_CLIENT_PERIODIC_CALLBACK_SETTINGS_SUPER_V1; -#[doc = " Callback data common to all client callbacks."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_CALLBACK_DATA_SUPER_V1 { - #[doc = " [out] Generic callback parameter which was passed in at registration time."] - pub pCallbackParam: *mut ::std::os::raw::c_void, - #[doc = " Reserved bytes for future expansion."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Callback data common to all client callbacks."] -pub type NV_GPU_CLIENT_CALLBACK_DATA_SUPER_V1 = _NV_GPU_CLIENT_CALLBACK_DATA_SUPER_V1; -pub const _NV_GPU_CLIENT_UTIL_DOMAIN_ID_NV_GPU_CLIENT_UTIL_DOMAIN_GRAPHICS: - _NV_GPU_CLIENT_UTIL_DOMAIN_ID = 0; -pub const _NV_GPU_CLIENT_UTIL_DOMAIN_ID_NV_GPU_CLIENT_UTIL_DOMAIN_FRAME_BUFFER: - _NV_GPU_CLIENT_UTIL_DOMAIN_ID = 1; -pub const _NV_GPU_CLIENT_UTIL_DOMAIN_ID_NV_GPU_CLIENT_UTIL_DOMAIN_VIDEO: - _NV_GPU_CLIENT_UTIL_DOMAIN_ID = 2; -#[doc = " Reserved for future use."] -pub const _NV_GPU_CLIENT_UTIL_DOMAIN_ID_NV_GPU_CLIENT_UTIL_DOMAIN_RSVD: - _NV_GPU_CLIENT_UTIL_DOMAIN_ID = 3; -#[doc = " Enumeration of different utilization domains"] -pub type _NV_GPU_CLIENT_UTIL_DOMAIN_ID = ::std::os::raw::c_int; -#[doc = " Enumeration of different utilization domains"] -pub use self::_NV_GPU_CLIENT_UTIL_DOMAIN_ID as NV_GPU_CLIENT_UTIL_DOMAIN_ID; -#[doc = " Data specific to a single utilization domain."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_UTILIZATION_DATA_V1 { - #[doc = " [out] Utilization domain identifier."] - pub utilId: NV_GPU_CLIENT_UTIL_DOMAIN_ID, - #[doc = " [out] Percentage of time where the domain is considered busy since the\n last sample. Units of percent*100; i.e. 5000 = 50%."] - pub utilizationPercent: NvU32, - #[doc = " Reserved bytes for future expansion."] - pub rsvd: [NvU8; 61usize], -} -#[doc = " Data specific to a single utilization domain."] -pub type NV_GPU_CLIENT_UTILIZATION_DATA_V1 = _NV_GPU_CLIENT_UTILIZATION_DATA_V1; -#[doc = " Data passed back to callback registered with\n @ref NvAPI_GPU_ClientRegisterForUtilizationSampleUpdates."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_CALLBACK_UTILIZATION_DATA_V1 { - #[doc = " [out] Super struct."] - pub super_: NV_GPU_CLIENT_CALLBACK_DATA_SUPER_V1, - #[doc = " [out] Number of valid entries in `utils` array."] - pub numUtils: NvU32, - #[doc = " [out] Time at which data was collected. Represented as elapsed\n microseconds since 00:00:00 UTC on January 1, 1970."] - pub timestamp: NvU64, - #[doc = " Reserved bytes for future expansion."] - pub rsvd: [NvU8; 64usize], - #[doc = " [out] Status data for each utilization domain."] - pub utils: [NV_GPU_CLIENT_UTILIZATION_DATA_V1; 4usize], -} -#[doc = " Data passed back to callback registered with\n @ref NvAPI_GPU_ClientRegisterForUtilizationSampleUpdates."] -pub type NV_GPU_CLIENT_CALLBACK_UTILIZATION_DATA_V1 = _NV_GPU_CLIENT_CALLBACK_UTILIZATION_DATA_V1; -#[doc = " Function prototype for a periodic utilization data callback that will be registered with NvAPI."] -pub type NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_V1 = ::std::option::Option< - unsafe extern "C" fn( - hPhysicalGpu: NvPhysicalGpuHandle, - pData: *mut NV_GPU_CLIENT_CALLBACK_UTILIZATION_DATA_V1, - ), ->; -#[doc = " Data required to register a periodic callback for utilization data."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_SETTINGS_V1 { - #[doc = " [in] Structure Version, must always be first."] - pub version: NvU32, - #[doc = " [in] Generic callback settings. Some data within will be passed to the\n callback when invoked."] - pub super_: NV_GPU_CLIENT_PERIODIC_CALLBACK_SETTINGS_SUPER_V1, - #[doc = " [in] Callback. Pass in NULL or nullptr to indicate request to unregister."] - pub callback: NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_V1, - #[doc = " Reserved bytes for future expansion."] - pub rsvd: [NvU8; 64usize], -} -#[doc = " Data required to register a periodic callback for utilization data."] -pub type NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_SETTINGS_V1 = - _NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_SETTINGS_V1; -#[doc = " Data required to register a periodic callback for utilization data."] -pub type NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_SETTINGS = - NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_SETTINGS_V1; -pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_INVALID: _NV_RISE_CONTENT_TYPE = 0; -pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_TEXT: _NV_RISE_CONTENT_TYPE = 1; -pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_GRAPH: _NV_RISE_CONTENT_TYPE = 2; -pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_CUSTOM_BEHAVIOR: _NV_RISE_CONTENT_TYPE = 3; -pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_CUSTOM_BEHAVIOR_RESULT: _NV_RISE_CONTENT_TYPE = - 4; -pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_INSTALLING: _NV_RISE_CONTENT_TYPE = 5; -pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_PROGRESS_UPDATE: _NV_RISE_CONTENT_TYPE = 6; -pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_READY: _NV_RISE_CONTENT_TYPE = 7; -pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_DOWNLOAD_REQUEST: _NV_RISE_CONTENT_TYPE = 8; -pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_UPDATE_INFO: _NV_RISE_CONTENT_TYPE = 9; -#[doc = " Enumeration of different RISE content types."] -pub type _NV_RISE_CONTENT_TYPE = ::std::os::raw::c_int; -#[doc = " Enumeration of different RISE content types."] -pub use self::_NV_RISE_CONTENT_TYPE as NV_RISE_CONTENT_TYPE; -#[doc = " Data passed back to callback."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_RISE_CALLBACK_DATA_V1 { - #[doc = " Super struct."] - pub super_: NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1, - #[doc = " RISE type of content"] - pub contentType: NV_RISE_CONTENT_TYPE, - #[doc = " RISE content."] - pub content: NvAPI_String, - #[doc = " Is this the last in the batch?"] - pub completed: NvBool, -} -#[doc = " Data passed back to callback."] -pub type NV_RISE_CALLBACK_DATA_V1 = _NV_RISE_CALLBACK_DATA_V1; -#[doc = " Callback for RISE update callbacks."] -pub type NV_RISE_CALLBACK_V1 = - ::std::option::Option; -#[doc = " Data required to register an update callback from the RISE."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_RISE_CALLBACK_SETTINGS_V1 { - #[doc = " [in] Structure Version, must always be first."] - pub version: NvU32, - #[doc = " [in] Generic callback parameter which will be passed to the callback."] - pub super_: NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1, - #[doc = " [in] Callback. Pass in NULL or nullptr to indicate request to unregister."] - pub callback: NV_RISE_CALLBACK_V1, - #[doc = " Reserved, must be set to zero by client."] - pub reserved: [NvU8; 32usize], -} -#[doc = " Data required to register an update callback from the RISE."] -pub type NV_RISE_CALLBACK_SETTINGS_V1 = _NV_RISE_CALLBACK_SETTINGS_V1; -#[doc = " Data required to register an update callback from the RISE."] -pub type NV_RISE_CALLBACK_SETTINGS = NV_RISE_CALLBACK_SETTINGS_V1; -#[doc = " Request contents sent to RISE."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_REQUEST_RISE_SETTINGS_V1 { - #[doc = " [in] Structure Version, must always be first."] - pub version: NvU32, - #[doc = " RISE type of content"] - pub contentType: NV_RISE_CONTENT_TYPE, - #[doc = " RISE request content."] - pub content: NvAPI_String, - #[doc = " Is the request fully sent?"] - pub completed: NvBool, - #[doc = " Reserved, must be set to zero by client."] - pub reserved: [NvU8; 32usize], -} -#[doc = " Request contents sent to RISE."] -pub type NV_REQUEST_RISE_SETTINGS_V1 = _NV_REQUEST_RISE_SETTINGS_V1; -#[doc = " Request contents sent to RISE."] -pub type NV_REQUEST_RISE_SETTINGS = NV_REQUEST_RISE_SETTINGS_V1; -#[doc = " Request contents sent to RISE."] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _NV_UNINSTALL_RISE_SETTINGS_V1 { - #[doc = " [in] Structure Version, must always be first."] - pub version: NvU32, - #[doc = " Reserved, must be set to zero by client."] - pub reserved: [NvU8; 32usize], -} -#[doc = " Request contents sent to RISE."] -pub type NV_UNINSTALL_RISE_SETTINGS_V1 = _NV_UNINSTALL_RISE_SETTINGS_V1; -#[doc = " Request contents sent to RISE."] -pub type NV_UNINSTALL_RISE_SETTINGS = NV_UNINSTALL_RISE_SETTINGS_V1; +// bindgen nvapi.h -o nvapi.rs --no-layout-tests --allowlist-type "Nv.*" --allowlist-type "NV_.*" +/* automatically generated by rust-bindgen 0.72.1 */ + +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + *(core::ptr::addr_of!((*this).storage) as *const u8).offset(byte_index as isize) + }; + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { + byte | mask + } else { + byte & !mask + } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = unsafe { + (core::ptr::addr_of_mut!((*this).storage) as *mut u8).offset(byte_index as isize) + }; + unsafe { *byte = Self::change_bit(*byte, index, val) }; + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::()); + let mut val = 0; + for i in 0..(bit_width as usize) { + if unsafe { Self::raw_get_bit(this, i + bit_offset) } { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::()); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; + } + } +} +pub type DWORD = ::std::os::raw::c_ulong; +pub type ULONG_PTR = ::std::os::raw::c_ulonglong; +pub type SIZE_T = ULONG_PTR; +pub type LONG = ::std::os::raw::c_long; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _LUID { + pub LowPart: DWORD, + pub HighPart: LONG, +} +pub type LUID = _LUID; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MEMORY_RANGE { + pub BaseAddress: *mut ::std::os::raw::c_void, + pub Length: SIZE_T, +} +pub type NV_MEMORY_RANGE = _NV_MEMORY_RANGE; +pub type NvU64 = ::std::os::raw::c_ulonglong; +pub type NvS64 = ::std::os::raw::c_longlong; +pub type NvS32 = ::std::os::raw::c_int; +pub type NvU32 = ::std::os::raw::c_uint; +pub type NvS16 = ::std::os::raw::c_short; +pub type NvU16 = ::std::os::raw::c_ushort; +pub type NvU8 = ::std::os::raw::c_uchar; +pub type NvS8 = ::std::os::raw::c_schar; +pub type NvF32 = f32; +pub type NvF64 = f64; +pub type NvBool = NvU8; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_RECT { + pub left: NvU32, + pub top: NvU32, + pub right: NvU32, + pub bottom: NvU32, +} +pub type NV_RECT = _NV_RECT; +#[doc = "! \\addtogroup nvapihandles\n! NVAPI Handles - These handles are retrieved from various calls and passed in to others in NvAPI\n! These are meant to be opaque types. Do not assume they correspond to indices, HDCs,\n! display indexes or anything else.\n!\n! Most handles remain valid until a display re-configuration (display mode set) or GPU\n! reconfiguration (going into or out of SLI modes) occurs. If NVAPI_HANDLE_INVALIDATED\n! is received by an app, it should discard all handles, and re-enumerate them.\n! @{"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvLogicalGpuHandle__ { + pub unused: ::std::os::raw::c_int, +} +#[doc = "! \\addtogroup nvapihandles\n! NVAPI Handles - These handles are retrieved from various calls and passed in to others in NvAPI\n! These are meant to be opaque types. Do not assume they correspond to indices, HDCs,\n! display indexes or anything else.\n!\n! Most handles remain valid until a display re-configuration (display mode set) or GPU\n! reconfiguration (going into or out of SLI modes) occurs. If NVAPI_HANDLE_INVALIDATED\n! is received by an app, it should discard all handles, and re-enumerate them.\n! @{"] +pub type NvLogicalGpuHandle = *mut NvLogicalGpuHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvPhysicalGpuHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvPhysicalGpuHandle = *mut NvPhysicalGpuHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvDisplayHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvDisplayHandle = *mut NvDisplayHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvMonitorHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvMonitorHandle = *mut NvMonitorHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvUnAttachedDisplayHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvUnAttachedDisplayHandle = *mut NvUnAttachedDisplayHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvVisualComputingDeviceHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvVisualComputingDeviceHandle = *mut NvVisualComputingDeviceHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvEventHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvEventHandle = *mut NvEventHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvHICHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvHICHandle = *mut NvHICHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvGSyncDeviceHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvGSyncDeviceHandle = *mut NvGSyncDeviceHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvVioHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvVioHandle = *mut NvVioHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvTransitionHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvTransitionHandle = *mut NvTransitionHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvAudioHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvAudioHandle = *mut NvAudioHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Nv3DVPContextHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type Nv3DVPContextHandle = *mut Nv3DVPContextHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Nv3DVPTransceiverHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type Nv3DVPTransceiverHandle = *mut Nv3DVPTransceiverHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Nv3DVPGlassesHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type Nv3DVPGlassesHandle = *mut Nv3DVPGlassesHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvPcfClientHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvPcfClientHandle = *mut NvPcfClientHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvSourceHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvSourceHandle = *mut NvSourceHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvTargetHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvTargetHandle = *mut NvTargetHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvPresentBarrierClientHandle__ { + pub unused: ::std::os::raw::c_int, +} +pub type NvPresentBarrierClientHandle = *mut NvPresentBarrierClientHandle__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvSBox { + pub sX: NvS32, + pub sY: NvS32, + pub sWidth: NvS32, + pub sHeight: NvS32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NvGUID { + pub data1: NvU32, + pub data2: NvU16, + pub data3: NvU16, + pub data4: [NvU8; 8usize], +} +pub type NvLUID = NvGUID; +pub type NvAPI_String = [::std::os::raw::c_char; 4096usize]; +pub type NvAPI_LongString = [::std::os::raw::c_char; 256usize]; +pub type NvAPI_ShortString = [::std::os::raw::c_char; 64usize]; +pub type NvAPI_UnicodeShortString = [NvU16; 64usize]; +#[doc = "!< Success. Request is completed."] +pub const _NvAPI_Status_NVAPI_OK: _NvAPI_Status = 0; +#[doc = "!< Generic error"] +pub const _NvAPI_Status_NVAPI_ERROR: _NvAPI_Status = -1; +#[doc = "!< NVAPI support library cannot be loaded."] +pub const _NvAPI_Status_NVAPI_LIBRARY_NOT_FOUND: _NvAPI_Status = -2; +#[doc = "!< not implemented in current driver installation"] +pub const _NvAPI_Status_NVAPI_NO_IMPLEMENTATION: _NvAPI_Status = -3; +#[doc = "!< NvAPI_Initialize has not been called (successfully)"] +pub const _NvAPI_Status_NVAPI_API_NOT_INITIALIZED: _NvAPI_Status = -4; +#[doc = "!< The argument/parameter value is not valid or NULL."] +pub const _NvAPI_Status_NVAPI_INVALID_ARGUMENT: _NvAPI_Status = -5; +#[doc = "!< No NVIDIA display driver, or NVIDIA GPU driving a display, was found."] +pub const _NvAPI_Status_NVAPI_NVIDIA_DEVICE_NOT_FOUND: _NvAPI_Status = -6; +#[doc = "!< No more items to enumerate"] +pub const _NvAPI_Status_NVAPI_END_ENUMERATION: _NvAPI_Status = -7; +#[doc = "!< Invalid handle"] +pub const _NvAPI_Status_NVAPI_INVALID_HANDLE: _NvAPI_Status = -8; +#[doc = "!< An argument's structure version is not supported"] +pub const _NvAPI_Status_NVAPI_INCOMPATIBLE_STRUCT_VERSION: _NvAPI_Status = -9; +#[doc = "!< The handle is no longer valid (likely due to GPU or display re-configuration)"] +pub const _NvAPI_Status_NVAPI_HANDLE_INVALIDATED: _NvAPI_Status = -10; +#[doc = "!< No NVIDIA OpenGL context is current (but needs to be)"] +pub const _NvAPI_Status_NVAPI_OPENGL_CONTEXT_NOT_CURRENT: _NvAPI_Status = -11; +#[doc = "!< An invalid pointer, usually NULL, was passed as a parameter"] +pub const _NvAPI_Status_NVAPI_INVALID_POINTER: _NvAPI_Status = -14; +#[doc = "!< OpenGL Expert is not supported by the current drivers"] +pub const _NvAPI_Status_NVAPI_NO_GL_EXPERT: _NvAPI_Status = -12; +#[doc = "!< OpenGL Expert is supported, but driver instrumentation is currently disabled"] +pub const _NvAPI_Status_NVAPI_INSTRUMENTATION_DISABLED: _NvAPI_Status = -13; +#[doc = "!< OpenGL does not support Nsight"] +pub const _NvAPI_Status_NVAPI_NO_GL_NSIGHT: _NvAPI_Status = -15; +#[doc = "!< Expected a logical GPU handle for one or more parameters"] +pub const _NvAPI_Status_NVAPI_EXPECTED_LOGICAL_GPU_HANDLE: _NvAPI_Status = -100; +#[doc = "!< Expected a physical GPU handle for one or more parameters"] +pub const _NvAPI_Status_NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE: _NvAPI_Status = -101; +#[doc = "!< Expected an NV display handle for one or more parameters"] +pub const _NvAPI_Status_NVAPI_EXPECTED_DISPLAY_HANDLE: _NvAPI_Status = -102; +#[doc = "!< The combination of parameters is not valid."] +pub const _NvAPI_Status_NVAPI_INVALID_COMBINATION: _NvAPI_Status = -103; +#[doc = "!< Requested feature is not supported in the selected GPU"] +pub const _NvAPI_Status_NVAPI_NOT_SUPPORTED: _NvAPI_Status = -104; +#[doc = "!< No port ID was found for the I2C transaction"] +pub const _NvAPI_Status_NVAPI_PORTID_NOT_FOUND: _NvAPI_Status = -105; +#[doc = "!< Expected an unattached display handle as one of the input parameters."] +pub const _NvAPI_Status_NVAPI_EXPECTED_UNATTACHED_DISPLAY_HANDLE: _NvAPI_Status = -106; +#[doc = "!< Invalid perf level"] +pub const _NvAPI_Status_NVAPI_INVALID_PERF_LEVEL: _NvAPI_Status = -107; +#[doc = "!< Device is busy; request not fulfilled"] +pub const _NvAPI_Status_NVAPI_DEVICE_BUSY: _NvAPI_Status = -108; +#[doc = "!< NV persist file is not found"] +pub const _NvAPI_Status_NVAPI_NV_PERSIST_FILE_NOT_FOUND: _NvAPI_Status = -109; +#[doc = "!< NV persist data is not found"] +pub const _NvAPI_Status_NVAPI_PERSIST_DATA_NOT_FOUND: _NvAPI_Status = -110; +#[doc = "!< Expected a TV output display"] +pub const _NvAPI_Status_NVAPI_EXPECTED_TV_DISPLAY: _NvAPI_Status = -111; +#[doc = "!< Expected a TV output on the D Connector - HDTV_EIAJ4120."] +pub const _NvAPI_Status_NVAPI_EXPECTED_TV_DISPLAY_ON_DCONNECTOR: _NvAPI_Status = -112; +#[doc = "!< SLI is not active on this device."] +pub const _NvAPI_Status_NVAPI_NO_ACTIVE_SLI_TOPOLOGY: _NvAPI_Status = -113; +#[doc = "!< Setup of SLI rendering mode is not possible right now."] +pub const _NvAPI_Status_NVAPI_SLI_RENDERING_MODE_NOTALLOWED: _NvAPI_Status = -114; +#[doc = "!< Expected a digital flat panel."] +pub const _NvAPI_Status_NVAPI_EXPECTED_DIGITAL_FLAT_PANEL: _NvAPI_Status = -115; +#[doc = "!< Argument exceeds the expected size."] +pub const _NvAPI_Status_NVAPI_ARGUMENT_EXCEED_MAX_SIZE: _NvAPI_Status = -116; +#[doc = "!< Inhibit is ON due to one of the flags in NV_GPU_DISPLAY_CHANGE_INHIBIT or SLI active."] +pub const _NvAPI_Status_NVAPI_DEVICE_SWITCHING_NOT_ALLOWED: _NvAPI_Status = -117; +#[doc = "!< Testing of clocks is not supported."] +pub const _NvAPI_Status_NVAPI_TESTING_CLOCKS_NOT_SUPPORTED: _NvAPI_Status = -118; +#[doc = "!< The specified underscan config is from an unknown source (e.g. INF)"] +pub const _NvAPI_Status_NVAPI_UNKNOWN_UNDERSCAN_CONFIG: _NvAPI_Status = -119; +#[doc = "!< Timeout while reconfiguring GPUs"] +pub const _NvAPI_Status_NVAPI_TIMEOUT_RECONFIGURING_GPU_TOPO: _NvAPI_Status = -120; +#[doc = "!< Requested data was not found"] +pub const _NvAPI_Status_NVAPI_DATA_NOT_FOUND: _NvAPI_Status = -121; +#[doc = "!< Expected an analog display"] +pub const _NvAPI_Status_NVAPI_EXPECTED_ANALOG_DISPLAY: _NvAPI_Status = -122; +#[doc = "!< No SLI video bridge is present"] +pub const _NvAPI_Status_NVAPI_NO_VIDLINK: _NvAPI_Status = -123; +#[doc = "!< NVAPI requires a reboot for the settings to take effect"] +pub const _NvAPI_Status_NVAPI_REQUIRES_REBOOT: _NvAPI_Status = -124; +#[doc = "!< The function is not supported with the current Hybrid mode."] +pub const _NvAPI_Status_NVAPI_INVALID_HYBRID_MODE: _NvAPI_Status = -125; +#[doc = "!< The target types are not all the same"] +pub const _NvAPI_Status_NVAPI_MIXED_TARGET_TYPES: _NvAPI_Status = -126; +#[doc = "!< The function is not supported from 32-bit on a 64-bit system."] +pub const _NvAPI_Status_NVAPI_SYSWOW64_NOT_SUPPORTED: _NvAPI_Status = -127; +#[doc = "!< There is no implicit GPU topology active. Use NVAPI_SetHybridMode to change topology."] +pub const _NvAPI_Status_NVAPI_IMPLICIT_SET_GPU_TOPOLOGY_CHANGE_NOT_ALLOWED: _NvAPI_Status = -128; +#[doc = "!< Prompt the user to close all non-migratable applications."] +pub const _NvAPI_Status_NVAPI_REQUEST_USER_TO_CLOSE_NON_MIGRATABLE_APPS: _NvAPI_Status = -129; +#[doc = "!< Could not allocate sufficient memory to complete the call."] +pub const _NvAPI_Status_NVAPI_OUT_OF_MEMORY: _NvAPI_Status = -130; +#[doc = "!< The previous operation that is transferring information to or from this surface is incomplete."] +pub const _NvAPI_Status_NVAPI_WAS_STILL_DRAWING: _NvAPI_Status = -131; +#[doc = "!< The file was not found."] +pub const _NvAPI_Status_NVAPI_FILE_NOT_FOUND: _NvAPI_Status = -132; +#[doc = "!< There are too many unique instances of a particular type of state object."] +pub const _NvAPI_Status_NVAPI_TOO_MANY_UNIQUE_STATE_OBJECTS: _NvAPI_Status = -133; +#[doc = "!< The method call is invalid. For example, a method's parameter may not be a valid pointer."] +pub const _NvAPI_Status_NVAPI_INVALID_CALL: _NvAPI_Status = -134; +#[doc = "!< d3d10_1.dll cannot be loaded."] +pub const _NvAPI_Status_NVAPI_D3D10_1_LIBRARY_NOT_FOUND: _NvAPI_Status = -135; +#[doc = "!< Couldn't find the function in the loaded DLL."] +pub const _NvAPI_Status_NVAPI_FUNCTION_NOT_FOUND: _NvAPI_Status = -136; +#[doc = "!< The application will require Administrator privileges to access this API.\n!< The application can be elevated to a higher permission level by selecting \"Run as Administrator\"."] +pub const _NvAPI_Status_NVAPI_INVALID_USER_PRIVILEGE: _NvAPI_Status = -137; +#[doc = "!< The handle corresponds to GDIPrimary."] +pub const _NvAPI_Status_NVAPI_EXPECTED_NON_PRIMARY_DISPLAY_HANDLE: _NvAPI_Status = -138; +#[doc = "!< Setting Physx GPU requires that the GPU is compute-capable."] +pub const _NvAPI_Status_NVAPI_EXPECTED_COMPUTE_GPU_HANDLE: _NvAPI_Status = -139; +#[doc = "!< The Stereo part of NVAPI failed to initialize completely. Check if the stereo driver is installed."] +pub const _NvAPI_Status_NVAPI_STEREO_NOT_INITIALIZED: _NvAPI_Status = -140; +#[doc = "!< Access to stereo-related registry keys or values has failed."] +pub const _NvAPI_Status_NVAPI_STEREO_REGISTRY_ACCESS_FAILED: _NvAPI_Status = -141; +#[doc = "!< The given registry profile type is not supported."] +pub const _NvAPI_Status_NVAPI_STEREO_REGISTRY_PROFILE_TYPE_NOT_SUPPORTED: _NvAPI_Status = -142; +#[doc = "!< The given registry value is not supported."] +pub const _NvAPI_Status_NVAPI_STEREO_REGISTRY_VALUE_NOT_SUPPORTED: _NvAPI_Status = -143; +#[doc = "!< Stereo is not enabled and the function needed it to execute completely."] +pub const _NvAPI_Status_NVAPI_STEREO_NOT_ENABLED: _NvAPI_Status = -144; +#[doc = "!< Stereo is not turned on and the function needed it to execute completely."] +pub const _NvAPI_Status_NVAPI_STEREO_NOT_TURNED_ON: _NvAPI_Status = -145; +#[doc = "!< Invalid device interface."] +pub const _NvAPI_Status_NVAPI_STEREO_INVALID_DEVICE_INTERFACE: _NvAPI_Status = -146; +#[doc = "!< Separation percentage or JPEG image capture quality is out of [0-100] range."] +pub const _NvAPI_Status_NVAPI_STEREO_PARAMETER_OUT_OF_RANGE: _NvAPI_Status = -147; +#[doc = "!< The given frustum adjust mode is not supported."] +pub const _NvAPI_Status_NVAPI_STEREO_FRUSTUM_ADJUST_MODE_NOT_SUPPORTED: _NvAPI_Status = -148; +#[doc = "!< The mosaic topology is not possible given the current state of the hardware."] +pub const _NvAPI_Status_NVAPI_TOPO_NOT_POSSIBLE: _NvAPI_Status = -149; +#[doc = "!< An attempt to do a display resolution mode change has failed."] +pub const _NvAPI_Status_NVAPI_MODE_CHANGE_FAILED: _NvAPI_Status = -150; +#[doc = "!< d3d11.dll/d3d11_beta.dll cannot be loaded."] +pub const _NvAPI_Status_NVAPI_D3D11_LIBRARY_NOT_FOUND: _NvAPI_Status = -151; +#[doc = "!< Address is outside of valid range."] +pub const _NvAPI_Status_NVAPI_INVALID_ADDRESS: _NvAPI_Status = -152; +#[doc = "!< The pre-allocated string is too small to hold the result."] +pub const _NvAPI_Status_NVAPI_STRING_TOO_SMALL: _NvAPI_Status = -153; +#[doc = "!< The input does not match any of the available devices."] +pub const _NvAPI_Status_NVAPI_MATCHING_DEVICE_NOT_FOUND: _NvAPI_Status = -154; +#[doc = "!< Driver is running."] +pub const _NvAPI_Status_NVAPI_DRIVER_RUNNING: _NvAPI_Status = -155; +#[doc = "!< Driver is not running."] +pub const _NvAPI_Status_NVAPI_DRIVER_NOTRUNNING: _NvAPI_Status = -156; +#[doc = "!< A driver reload is required to apply these settings."] +pub const _NvAPI_Status_NVAPI_ERROR_DRIVER_RELOAD_REQUIRED: _NvAPI_Status = -157; +#[doc = "!< Intended setting is not allowed."] +pub const _NvAPI_Status_NVAPI_SET_NOT_ALLOWED: _NvAPI_Status = -158; +#[doc = "!< Information can't be returned due to \"advanced display topology\"."] +pub const _NvAPI_Status_NVAPI_ADVANCED_DISPLAY_TOPOLOGY_REQUIRED: _NvAPI_Status = -159; +#[doc = "!< Setting is not found."] +pub const _NvAPI_Status_NVAPI_SETTING_NOT_FOUND: _NvAPI_Status = -160; +#[doc = "!< Setting size is too large."] +pub const _NvAPI_Status_NVAPI_SETTING_SIZE_TOO_LARGE: _NvAPI_Status = -161; +#[doc = "!< There are too many settings for a profile."] +pub const _NvAPI_Status_NVAPI_TOO_MANY_SETTINGS_IN_PROFILE: _NvAPI_Status = -162; +#[doc = "!< Profile is not found."] +pub const _NvAPI_Status_NVAPI_PROFILE_NOT_FOUND: _NvAPI_Status = -163; +#[doc = "!< Profile name is duplicated."] +pub const _NvAPI_Status_NVAPI_PROFILE_NAME_IN_USE: _NvAPI_Status = -164; +#[doc = "!< Profile name is empty."] +pub const _NvAPI_Status_NVAPI_PROFILE_NAME_EMPTY: _NvAPI_Status = -165; +#[doc = "!< Application not found in the Profile."] +pub const _NvAPI_Status_NVAPI_EXECUTABLE_NOT_FOUND: _NvAPI_Status = -166; +#[doc = "!< Application already exists in the other profile."] +pub const _NvAPI_Status_NVAPI_EXECUTABLE_ALREADY_IN_USE: _NvAPI_Status = -167; +#[doc = "!< Data Type mismatch"] +pub const _NvAPI_Status_NVAPI_DATATYPE_MISMATCH: _NvAPI_Status = -168; +#[doc = "!< The profile passed as parameter has been removed and is no longer valid."] +pub const _NvAPI_Status_NVAPI_PROFILE_REMOVED: _NvAPI_Status = -169; +#[doc = "!< An unregistered resource was passed as a parameter."] +pub const _NvAPI_Status_NVAPI_UNREGISTERED_RESOURCE: _NvAPI_Status = -170; +#[doc = "!< The DisplayId corresponds to a display which is not within the normal outputId range."] +pub const _NvAPI_Status_NVAPI_ID_OUT_OF_RANGE: _NvAPI_Status = -171; +#[doc = "!< Display topology is not valid so the driver cannot do a mode set on this configuration."] +pub const _NvAPI_Status_NVAPI_DISPLAYCONFIG_VALIDATION_FAILED: _NvAPI_Status = -172; +#[doc = "!< Display Port Multi-Stream topology has been changed."] +pub const _NvAPI_Status_NVAPI_DPMST_CHANGED: _NvAPI_Status = -173; +#[doc = "!< Input buffer is insufficient to hold the contents."] +pub const _NvAPI_Status_NVAPI_INSUFFICIENT_BUFFER: _NvAPI_Status = -174; +#[doc = "!< No access to the caller."] +pub const _NvAPI_Status_NVAPI_ACCESS_DENIED: _NvAPI_Status = -175; +#[doc = "!< The requested action cannot be performed without Mosaic being enabled."] +pub const _NvAPI_Status_NVAPI_MOSAIC_NOT_ACTIVE: _NvAPI_Status = -176; +#[doc = "!< The surface is relocated away from video memory."] +pub const _NvAPI_Status_NVAPI_SHARE_RESOURCE_RELOCATED: _NvAPI_Status = -177; +#[doc = "!< The user should disable DWM before calling NvAPI."] +pub const _NvAPI_Status_NVAPI_REQUEST_USER_TO_DISABLE_DWM: _NvAPI_Status = -178; +#[doc = "!< D3D device status is D3DERR_DEVICELOST or D3DERR_DEVICENOTRESET - the user has to reset the device."] +pub const _NvAPI_Status_NVAPI_D3D_DEVICE_LOST: _NvAPI_Status = -179; +#[doc = "!< The requested action cannot be performed in the current state."] +pub const _NvAPI_Status_NVAPI_INVALID_CONFIGURATION: _NvAPI_Status = -180; +#[doc = "!< Call failed as stereo handshake not completed."] +pub const _NvAPI_Status_NVAPI_STEREO_HANDSHAKE_NOT_DONE: _NvAPI_Status = -181; +#[doc = "!< The path provided was too short to determine the correct NVDRS_APPLICATION"] +pub const _NvAPI_Status_NVAPI_EXECUTABLE_PATH_IS_AMBIGUOUS: _NvAPI_Status = -182; +#[doc = "!< Default stereo profile is not currently defined"] +pub const _NvAPI_Status_NVAPI_DEFAULT_STEREO_PROFILE_IS_NOT_DEFINED: _NvAPI_Status = -183; +#[doc = "!< Default stereo profile does not exist"] +pub const _NvAPI_Status_NVAPI_DEFAULT_STEREO_PROFILE_DOES_NOT_EXIST: _NvAPI_Status = -184; +#[doc = "!< A cluster is already defined with the given configuration."] +pub const _NvAPI_Status_NVAPI_CLUSTER_ALREADY_EXISTS: _NvAPI_Status = -185; +#[doc = "!< The input display id is not that of a multi stream enabled connector or a display device in a multi stream topology"] +pub const _NvAPI_Status_NVAPI_DPMST_DISPLAY_ID_EXPECTED: _NvAPI_Status = -186; +#[doc = "!< The input display id is not valid or the monitor associated to it does not support the current operation"] +pub const _NvAPI_Status_NVAPI_INVALID_DISPLAY_ID: _NvAPI_Status = -187; +#[doc = "!< While playing secure audio stream, stream goes out of sync"] +pub const _NvAPI_Status_NVAPI_STREAM_IS_OUT_OF_SYNC: _NvAPI_Status = -188; +#[doc = "!< Older audio driver version than required"] +pub const _NvAPI_Status_NVAPI_INCOMPATIBLE_AUDIO_DRIVER: _NvAPI_Status = -189; +#[doc = "!< Value already set, setting again not allowed."] +pub const _NvAPI_Status_NVAPI_VALUE_ALREADY_SET: _NvAPI_Status = -190; +#[doc = "!< Requested operation timed out"] +pub const _NvAPI_Status_NVAPI_TIMEOUT: _NvAPI_Status = -191; +#[doc = "!< The requested workstation feature set has incomplete driver internal allocation resources"] +pub const _NvAPI_Status_NVAPI_GPU_WORKSTATION_FEATURE_INCOMPLETE: _NvAPI_Status = -192; +#[doc = "!< Call failed because InitActivation was not called."] +pub const _NvAPI_Status_NVAPI_STEREO_INIT_ACTIVATION_NOT_DONE: _NvAPI_Status = -193; +#[doc = "!< The requested action cannot be performed without Sync being enabled."] +pub const _NvAPI_Status_NVAPI_SYNC_NOT_ACTIVE: _NvAPI_Status = -194; +#[doc = "!< The requested action cannot be performed without Sync Master being enabled."] +pub const _NvAPI_Status_NVAPI_SYNC_MASTER_NOT_FOUND: _NvAPI_Status = -195; +#[doc = "!< Invalid displays passed in the NV_GSYNC_DISPLAY pointer."] +pub const _NvAPI_Status_NVAPI_INVALID_SYNC_TOPOLOGY: _NvAPI_Status = -196; +#[doc = "!< The specified signing algorithm is not supported. Either an incorrect value was entered or the current installed driver/hardware does not support the input value."] +pub const _NvAPI_Status_NVAPI_ECID_SIGN_ALGO_UNSUPPORTED: _NvAPI_Status = -197; +#[doc = "!< The encrypted public key verification has failed."] +pub const _NvAPI_Status_NVAPI_ECID_KEY_VERIFICATION_FAILED: _NvAPI_Status = -198; +#[doc = "!< The device's firmware is out of date."] +pub const _NvAPI_Status_NVAPI_FIRMWARE_OUT_OF_DATE: _NvAPI_Status = -199; +#[doc = "!< The device's firmware is not supported."] +pub const _NvAPI_Status_NVAPI_FIRMWARE_REVISION_NOT_SUPPORTED: _NvAPI_Status = -200; +#[doc = "!< The caller is not authorized to modify the License."] +pub const _NvAPI_Status_NVAPI_LICENSE_CALLER_AUTHENTICATION_FAILED: _NvAPI_Status = -201; +#[doc = "!< The user tried to use a deferred context without registering the device first"] +pub const _NvAPI_Status_NVAPI_D3D_DEVICE_NOT_REGISTERED: _NvAPI_Status = -202; +#[doc = "!< Head or SourceId was not reserved for the VR Display before doing the Modeset or the dedicated display."] +pub const _NvAPI_Status_NVAPI_RESOURCE_NOT_ACQUIRED: _NvAPI_Status = -203; +#[doc = "!< Provided timing is not supported."] +pub const _NvAPI_Status_NVAPI_TIMING_NOT_SUPPORTED: _NvAPI_Status = -204; +#[doc = "!< HDCP Encryption Failed for the device. Would be applicable when the device is HDCP Capable."] +pub const _NvAPI_Status_NVAPI_HDCP_ENCRYPTION_FAILED: _NvAPI_Status = -205; +#[doc = "!< Provided mode is over sink device pclk limitation."] +pub const _NvAPI_Status_NVAPI_PCLK_LIMITATION_FAILED: _NvAPI_Status = -206; +#[doc = "!< No connector on GPU found."] +pub const _NvAPI_Status_NVAPI_NO_CONNECTOR_FOUND: _NvAPI_Status = -207; +#[doc = "!< When a non-HDCP capable HMD is connected, we would inform user by this code."] +pub const _NvAPI_Status_NVAPI_HDCP_DISABLED: _NvAPI_Status = -208; +#[doc = "!< Atleast an API is still being called"] +pub const _NvAPI_Status_NVAPI_API_IN_USE: _NvAPI_Status = -209; +#[doc = "!< No display found on Nvidia GPU(s)."] +pub const _NvAPI_Status_NVAPI_NVIDIA_DISPLAY_NOT_FOUND: _NvAPI_Status = -210; +#[doc = "!< Priv security violation, improper access to a secured register."] +pub const _NvAPI_Status_NVAPI_PRIV_SEC_VIOLATION: _NvAPI_Status = -211; +#[doc = "!< NVAPI cannot be called by this vendor"] +pub const _NvAPI_Status_NVAPI_INCORRECT_VENDOR: _NvAPI_Status = -212; +#[doc = "!< DirectMode Display is already in use"] +pub const _NvAPI_Status_NVAPI_DISPLAY_IN_USE: _NvAPI_Status = -213; +#[doc = "!< The Config is having Non-NVidia GPU with Non-HDCP HMD connected"] +pub const _NvAPI_Status_NVAPI_UNSUPPORTED_CONFIG_NON_HDCP_HMD: _NvAPI_Status = -214; +#[doc = "!< GPU's Max Display Limit has Reached"] +pub const _NvAPI_Status_NVAPI_MAX_DISPLAY_LIMIT_REACHED: _NvAPI_Status = -215; +#[doc = "!< DirectMode not Enabled on the Display"] +pub const _NvAPI_Status_NVAPI_INVALID_DIRECT_MODE_DISPLAY: _NvAPI_Status = -216; +#[doc = "!< GPU is in debug mode, OC is NOT allowed."] +pub const _NvAPI_Status_NVAPI_GPU_IN_DEBUG_MODE: _NvAPI_Status = -217; +#[doc = "!< No NvAPI context was found for this D3D object"] +pub const _NvAPI_Status_NVAPI_D3D_CONTEXT_NOT_FOUND: _NvAPI_Status = -218; +#[doc = "!< there is version mismatch between stereo driver and dx driver"] +pub const _NvAPI_Status_NVAPI_STEREO_VERSION_MISMATCH: _NvAPI_Status = -219; +#[doc = "!< GPU is not powered and so the request cannot be completed."] +pub const _NvAPI_Status_NVAPI_GPU_NOT_POWERED: _NvAPI_Status = -220; +#[doc = "!< The display driver update in progress."] +pub const _NvAPI_Status_NVAPI_ERROR_DRIVER_RELOAD_IN_PROGRESS: _NvAPI_Status = -221; +#[doc = "!< Wait for HW resources allocation"] +pub const _NvAPI_Status_NVAPI_WAIT_FOR_HW_RESOURCE: _NvAPI_Status = -222; +#[doc = "!< operation requires further HDCP action"] +pub const _NvAPI_Status_NVAPI_REQUIRE_FURTHER_HDCP_ACTION: _NvAPI_Status = -223; +#[doc = "!< Dynamic Mux transition failure"] +pub const _NvAPI_Status_NVAPI_DISPLAY_MUX_TRANSITION_FAILED: _NvAPI_Status = -224; +#[doc = "!< Invalid DSC version"] +pub const _NvAPI_Status_NVAPI_INVALID_DSC_VERSION: _NvAPI_Status = -225; +#[doc = "!< Invalid DSC slice count"] +pub const _NvAPI_Status_NVAPI_INVALID_DSC_SLICECOUNT: _NvAPI_Status = -226; +#[doc = "!< Invalid DSC output BPP"] +pub const _NvAPI_Status_NVAPI_INVALID_DSC_OUTPUT_BPP: _NvAPI_Status = -227; +#[doc = "!< There was an error while loading nvapi.dll from the driver store."] +pub const _NvAPI_Status_NVAPI_FAILED_TO_LOAD_FROM_DRIVER_STORE: _NvAPI_Status = -228; +#[doc = "!< OpenGL does not export Vulkan fake extensions"] +pub const _NvAPI_Status_NVAPI_NO_VULKAN: _NvAPI_Status = -229; +#[doc = "!< A request for NvTOPPs telemetry CData has already been made and is pending a response."] +pub const _NvAPI_Status_NVAPI_REQUEST_PENDING: _NvAPI_Status = -230; +#[doc = "!< Operation cannot be performed because the resource is in use."] +pub const _NvAPI_Status_NVAPI_RESOURCE_IN_USE: _NvAPI_Status = -231; +#[doc = "!< Device kernel image is invalid"] +pub const _NvAPI_Status_NVAPI_INVALID_IMAGE: _NvAPI_Status = -232; +#[doc = "!< PTX JIT compilation failed"] +pub const _NvAPI_Status_NVAPI_INVALID_PTX: _NvAPI_Status = -233; +#[doc = "!< Uncorrectable NVLink error was detected during the execution"] +pub const _NvAPI_Status_NVAPI_NVLINK_UNCORRECTABLE: _NvAPI_Status = -234; +#[doc = "!< PTX JIT compiler library was not found."] +pub const _NvAPI_Status_NVAPI_JIT_COMPILER_NOT_FOUND: _NvAPI_Status = -235; +#[doc = "!< Device kernel source is invalid."] +pub const _NvAPI_Status_NVAPI_INVALID_SOURCE: _NvAPI_Status = -236; +#[doc = "!< While executing a kernel, the device encountered an illegal instruction."] +pub const _NvAPI_Status_NVAPI_ILLEGAL_INSTRUCTION: _NvAPI_Status = -237; +#[doc = "!< While executing a kernel, the device program counter wrapped its address space"] +pub const _NvAPI_Status_NVAPI_INVALID_PC: _NvAPI_Status = -238; +#[doc = "!< An exception occurred on the device while executing a kernel"] +pub const _NvAPI_Status_NVAPI_LAUNCH_FAILED: _NvAPI_Status = -239; +#[doc = "!< Attempted operation is not permitted."] +pub const _NvAPI_Status_NVAPI_NOT_PERMITTED: _NvAPI_Status = -240; +#[doc = "!< The callback function has already been registered."] +pub const _NvAPI_Status_NVAPI_CALLBACK_ALREADY_REGISTERED: _NvAPI_Status = -241; +#[doc = "!< The callback function is not found or not registered."] +pub const _NvAPI_Status_NVAPI_CALLBACK_NOT_FOUND: _NvAPI_Status = -242; +#[doc = "!< Invalid Wire Format for the VR HMD"] +pub const _NvAPI_Status_NVAPI_INVALID_OUTPUT_WIRE_FORMAT: _NvAPI_Status = -243; +#[doc = "! NvAPI Status Values\n! All NvAPI functions return one of these codes.\n! \\ingroup nvapistatus"] +pub type _NvAPI_Status = ::std::os::raw::c_int; +#[doc = "! NvAPI Status Values\n! All NvAPI functions return one of these codes.\n! \\ingroup nvapistatus"] +pub use self::_NvAPI_Status as NvAPI_Status; +#[doc = "! \\ingroup driverapi\n! Used in NvAPI_GPU_GetMemoryInfo()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_DISPLAY_DRIVER_MEMORY_INFO_V1 { + #[doc = "!< Version info"] + pub version: NvU32, + #[doc = "!< Size(in kb) of the physical framebuffer."] + pub dedicatedVideoMemory: NvU32, + #[doc = "!< Size(in kb) of the available physical framebuffer for allocating video memory surfaces."] + pub availableDedicatedVideoMemory: NvU32, + #[doc = "!< Size(in kb) of system memory the driver allocates at load time."] + pub systemVideoMemory: NvU32, + #[doc = "!< Size(in kb) of shared system memory that driver is allowed to commit for surfaces across all allocations."] + pub sharedSystemMemory: NvU32, +} +#[doc = "! \\ingroup driverapi\n! Used in NvAPI_GPU_GetMemoryInfo()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_DISPLAY_DRIVER_MEMORY_INFO_V2 { + #[doc = "!< Version info"] + pub version: NvU32, + #[doc = "!< Size(in kb) of the physical framebuffer."] + pub dedicatedVideoMemory: NvU32, + #[doc = "!< Size(in kb) of the available physical framebuffer for allocating video memory surfaces."] + pub availableDedicatedVideoMemory: NvU32, + #[doc = "!< Size(in kb) of system memory the driver allocates at load time."] + pub systemVideoMemory: NvU32, + #[doc = "!< Size(in kb) of shared system memory that driver is allowed to commit for surfaces across all allocations."] + pub sharedSystemMemory: NvU32, + #[doc = "!< Size(in kb) of the current available physical framebuffer for allocating video memory surfaces."] + pub curAvailableDedicatedVideoMemory: NvU32, +} +#[doc = "! \\ingroup driverapi\n! Used in NvAPI_GPU_GetMemoryInfo()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_DISPLAY_DRIVER_MEMORY_INFO_V3 { + #[doc = "!< Version info"] + pub version: NvU32, + #[doc = "!< Size(in kb) of the physical framebuffer."] + pub dedicatedVideoMemory: NvU32, + #[doc = "!< Size(in kb) of the available physical framebuffer for allocating video memory surfaces."] + pub availableDedicatedVideoMemory: NvU32, + #[doc = "!< Size(in kb) of system memory the driver allocates at load time."] + pub systemVideoMemory: NvU32, + #[doc = "!< Size(in kb) of shared system memory that driver is allowed to commit for surfaces across all allocations."] + pub sharedSystemMemory: NvU32, + #[doc = "!< Size(in kb) of the current available physical framebuffer for allocating video memory surfaces."] + pub curAvailableDedicatedVideoMemory: NvU32, + #[doc = "!< Size(in kb) of the total size of memory released as a result of the evictions."] + pub dedicatedVideoMemoryEvictionsSize: NvU32, + #[doc = "!< Indicates the number of eviction events that caused an allocation to be removed from dedicated video memory to free GPU\n!< video memory to make room for other allocations."] + pub dedicatedVideoMemoryEvictionCount: NvU32, +} +#[doc = "! \\ingroup driverapi"] +pub type NV_DISPLAY_DRIVER_MEMORY_INFO = NV_DISPLAY_DRIVER_MEMORY_INFO_V3; +#[doc = "! \\ingroup driverapi\n! Used in NvAPI_GPU_GetMemoryInfoEx()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_MEMORY_INFO_EX_V1 { + #[doc = "!< Structure version"] + pub version: NvU32, + #[doc = "!< Size(in bytes) of the physical framebuffer. Refers to the dedicated video memory on discrete GPUs."] + pub dedicatedVideoMemory: NvU64, + #[doc = "!< Size(in bytes) of the available physical framebuffer for allocating video memory surfaces."] + pub availableDedicatedVideoMemory: NvU64, + #[doc = "!< Size(in bytes) of system memory the driver allocates at load time. It is a substitute for dedicated video memory.\n!< Typically used with integrated GPUs that do not have dedicated video memory."] + pub systemVideoMemory: NvU64, + #[doc = "!< Size(in bytes) of shared system memory that driver is allowed to commit for surfaces across all allocations.\n!< On discrete GPUs, it is used to utilize system memory for various operations. It does not need to be reserved during boot.\n!< It may be used by both GPU and CPU, and has an \"on-demand\" type of usage."] + pub sharedSystemMemory: NvU64, + #[doc = "!< Size(in bytes) of the current available physical framebuffer for allocating video memory surfaces."] + pub curAvailableDedicatedVideoMemory: NvU64, + #[doc = "!< Size(in bytes) of the total size of memory released as a result of the evictions."] + pub dedicatedVideoMemoryEvictionsSize: NvU64, + #[doc = "!< Indicates the number of eviction events that caused an allocation to be removed from dedicated video memory to free GPU\n!< video memory to make room for other allocations."] + pub dedicatedVideoMemoryEvictionCount: NvU64, + #[doc = "!< Size(in bytes) of the total size of memory allocated as a result of the promotions."] + pub dedicatedVideoMemoryPromotionsSize: NvU64, + #[doc = "!< Indicates the number of promotion events that caused an allocation to be promoted to dedicated video memory"] + pub dedicatedVideoMemoryPromotionCount: NvU64, +} +#[doc = "! \\ingroup driverapi"] +pub type NV_GPU_MEMORY_INFO_EX = NV_GPU_MEMORY_INFO_EX_V1; +#[doc = "! \\ingroup dx\n! Used in NvAPI_D3D10_GetCurrentSLIState(), and NvAPI_D3D_GetCurrentSLIState()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GET_CURRENT_SLI_STATE_V1 { + #[doc = "!< Structure version"] + pub version: NvU32, + #[doc = "!< [OUT] The maximum possible value of numAFRGroups"] + pub maxNumAFRGroups: NvU32, + #[doc = "!< [OUT] The number of AFR groups enabled in the system"] + pub numAFRGroups: NvU32, + #[doc = "!< [OUT] The AFR group index for the frame currently being rendered"] + pub currentAFRIndex: NvU32, + #[doc = "!< [OUT] What the AFR group index will be for the next frame (i.e. after calling Present)"] + pub nextFrameAFRIndex: NvU32, + #[doc = "!< [OUT] The AFR group index that was used for the previous frame (~0 if more than one frame has not been rendered yet)"] + pub previousFrameAFRIndex: NvU32, + #[doc = "!< [OUT] Boolean: Is this frame the first time running on the current AFR group"] + pub bIsCurAFRGroupNew: NvU32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GET_CURRENT_SLI_STATE_V2 { + #[doc = "!< Structure version"] + pub version: NvU32, + #[doc = "!< [OUT] The maximum possible value of numAFRGroups"] + pub maxNumAFRGroups: NvU32, + #[doc = "!< [OUT] The number of AFR groups enabled in the system"] + pub numAFRGroups: NvU32, + #[doc = "!< [OUT] The AFR group index for the frame currently being rendered"] + pub currentAFRIndex: NvU32, + #[doc = "!< [OUT] What the AFR group index will be for the next frame (i.e. after calling Present)"] + pub nextFrameAFRIndex: NvU32, + #[doc = "!< [OUT] The AFR group index that was used for the previous frame (~0 if more than one frame has not been rendered yet)"] + pub previousFrameAFRIndex: NvU32, + #[doc = "!< [OUT] Boolean: Is this frame the first time running on the current AFR group"] + pub bIsCurAFRGroupNew: NvU32, + #[doc = "!< [OUT] The number of GPUs used in VR-SLI. If it is 0 VR-SLI is not active"] + pub numVRSLIGpus: NvU32, +} +pub const _NV_StereoActiveEye_NVAPI_STEREO_EYE_RIGHT: _NV_StereoActiveEye = 1; +pub const _NV_StereoActiveEye_NVAPI_STEREO_EYE_LEFT: _NV_StereoActiveEye = 2; +pub const _NV_StereoActiveEye_NVAPI_STEREO_EYE_MONO: _NV_StereoActiveEye = 3; +#[doc = "! \\ingroup stereoapi"] +pub type _NV_StereoActiveEye = ::std::os::raw::c_int; +#[doc = "! \\ingroup stereoapi"] +pub use self::_NV_StereoActiveEye as NV_STEREO_ACTIVE_EYE; +pub const _NV_StereoDriverMode_NVAPI_STEREO_DRIVER_MODE_AUTOMATIC: _NV_StereoDriverMode = 0; +pub const _NV_StereoDriverMode_NVAPI_STEREO_DRIVER_MODE_DIRECT: _NV_StereoDriverMode = 2; +#[doc = "! \\ingroup stereoapi"] +pub type _NV_StereoDriverMode = ::std::os::raw::c_int; +#[doc = "! \\ingroup stereoapi"] +pub use self::_NV_StereoDriverMode as NV_STEREO_DRIVER_MODE; +pub const _NV_DP_LINK_RATE_NV_DP_1_62GBPS: _NV_DP_LINK_RATE = 6; +pub const _NV_DP_LINK_RATE_NV_DP_2_70GBPS: _NV_DP_LINK_RATE = 10; +pub const _NV_DP_LINK_RATE_NV_DP_5_40GBPS: _NV_DP_LINK_RATE = 20; +pub const _NV_DP_LINK_RATE_NV_DP_8_10GBPS: _NV_DP_LINK_RATE = 30; +pub const _NV_DP_LINK_RATE_NV_EDP_2_16GBPS: _NV_DP_LINK_RATE = 8; +pub const _NV_DP_LINK_RATE_NV_EDP_2_43GBPS: _NV_DP_LINK_RATE = 9; +pub const _NV_DP_LINK_RATE_NV_EDP_3_24GBPS: _NV_DP_LINK_RATE = 12; +pub const _NV_DP_LINK_RATE_NV_EDP_4_32GBPS: _NV_DP_LINK_RATE = 16; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub type _NV_DP_LINK_RATE = ::std::os::raw::c_int; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub use self::_NV_DP_LINK_RATE as NV_DP_LINK_RATE; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_1_62Gbps: _NV_DP2X_LINK_RATE = 162; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_2_16Gbps: _NV_DP2X_LINK_RATE = 216; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_2_43Gbps: _NV_DP2X_LINK_RATE = 243; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_2_50Gbps: _NV_DP2X_LINK_RATE = 250; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_2_70Gbps: _NV_DP2X_LINK_RATE = 270; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_3_24Gbps: _NV_DP2X_LINK_RATE = 324; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_4_32Gbps: _NV_DP2X_LINK_RATE = 432; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_5_40Gbps: _NV_DP2X_LINK_RATE = 540; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_6_75Gbps: _NV_DP2X_LINK_RATE = 675; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_8_10Gbps: _NV_DP2X_LINK_RATE = 810; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_10_0Gbps: _NV_DP2X_LINK_RATE = 1000; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_13_5Gbps: _NV_DP2X_LINK_RATE = 1350; +pub const _NV_DP2X_LINK_RATE_NV_DP2X_20_0Gbps: _NV_DP2X_LINK_RATE = 2000; +pub type _NV_DP2X_LINK_RATE = ::std::os::raw::c_int; +pub use self::_NV_DP2X_LINK_RATE as NV_DP2X_LINK_RATE; +pub const _NV_DP_LANE_COUNT_NV_DP_1_LANE: _NV_DP_LANE_COUNT = 1; +pub const _NV_DP_LANE_COUNT_NV_DP_2_LANE: _NV_DP_LANE_COUNT = 2; +pub const _NV_DP_LANE_COUNT_NV_DP_4_LANE: _NV_DP_LANE_COUNT = 4; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub type _NV_DP_LANE_COUNT = ::std::os::raw::c_int; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub use self::_NV_DP_LANE_COUNT as NV_DP_LANE_COUNT; +pub const _NV_DP_COLOR_FORMAT_NV_DP_COLOR_FORMAT_RGB: _NV_DP_COLOR_FORMAT = 0; +pub const _NV_DP_COLOR_FORMAT_NV_DP_COLOR_FORMAT_YCbCr422: _NV_DP_COLOR_FORMAT = 1; +pub const _NV_DP_COLOR_FORMAT_NV_DP_COLOR_FORMAT_YCbCr444: _NV_DP_COLOR_FORMAT = 2; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub type _NV_DP_COLOR_FORMAT = ::std::os::raw::c_int; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub use self::_NV_DP_COLOR_FORMAT as NV_DP_COLOR_FORMAT; +pub const _NV_DP_COLORIMETRY_NV_DP_COLORIMETRY_RGB: _NV_DP_COLORIMETRY = 0; +pub const _NV_DP_COLORIMETRY_NV_DP_COLORIMETRY_YCbCr_ITU601: _NV_DP_COLORIMETRY = 1; +pub const _NV_DP_COLORIMETRY_NV_DP_COLORIMETRY_YCbCr_ITU709: _NV_DP_COLORIMETRY = 2; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub type _NV_DP_COLORIMETRY = ::std::os::raw::c_int; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub use self::_NV_DP_COLORIMETRY as NV_DP_COLORIMETRY; +pub const _NV_DP_DYNAMIC_RANGE_NV_DP_DYNAMIC_RANGE_VESA: _NV_DP_DYNAMIC_RANGE = 0; +pub const _NV_DP_DYNAMIC_RANGE_NV_DP_DYNAMIC_RANGE_CEA: _NV_DP_DYNAMIC_RANGE = 1; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub type _NV_DP_DYNAMIC_RANGE = ::std::os::raw::c_int; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub use self::_NV_DP_DYNAMIC_RANGE as NV_DP_DYNAMIC_RANGE; +pub const _NV_DP_BPC_NV_DP_BPC_DEFAULT: _NV_DP_BPC = 0; +pub const _NV_DP_BPC_NV_DP_BPC_6: _NV_DP_BPC = 1; +pub const _NV_DP_BPC_NV_DP_BPC_8: _NV_DP_BPC = 2; +pub const _NV_DP_BPC_NV_DP_BPC_10: _NV_DP_BPC = 3; +pub const _NV_DP_BPC_NV_DP_BPC_12: _NV_DP_BPC = 4; +pub const _NV_DP_BPC_NV_DP_BPC_16: _NV_DP_BPC = 5; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub type _NV_DP_BPC = ::std::os::raw::c_int; +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PORT_INFO."] +pub use self::_NV_DP_BPC as NV_DP_BPC; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_EDID_V1 { + pub version: NvU32, + pub EDID_Data: [NvU8; 256usize], +} +#[doc = "! Used in NvAPI_GPU_GetEDID()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_EDID_V2 { + #[doc = "!< Structure version"] + pub version: NvU32, + pub EDID_Data: [NvU8; 256usize], + pub sizeofEDID: NvU32, +} +#[doc = "! Used in NvAPI_GPU_GetEDID()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_EDID_V3 { + #[doc = "!< Structure version"] + pub version: NvU32, + pub EDID_Data: [NvU8; 256usize], + pub sizeofEDID: NvU32, + #[doc = "!< ID which always returned in a monotonically increasing counter.\n!< Across a split-EDID read we need to verify that all calls returned the same edidId.\n!< This counter is incremented if we get the updated EDID."] + pub edidId: NvU32, + #[doc = "!< Which 256-byte page of the EDID we want to read. Start at 0.\n!< If the read succeeds with edidSize > NV_EDID_DATA_SIZE,\n!< call back again with offset+256 until we have read the entire buffer"] + pub offset: NvU32, +} +#[doc = "! Used in NvAPI_GPU_GetEDID()"] +pub type NV_EDID = NV_EDID_V3; +#[doc = "!< the EDID which is actively used by the driver, it could be _RAW/_COOKED/_FORCED/_INF."] +pub const NV_EDID_FLAG_NV_EDID_FLAG_DEFAULT: NV_EDID_FLAG = 0; +#[doc = "!< the EDID which is not modified by the driver. If there's no _FORCED edid engaged, it\n!< will be the unmodified monitor EDID from the I2C bus. Otherwise it is original _FORCED edid."] +pub const NV_EDID_FLAG_NV_EDID_FLAG_RAW: NV_EDID_FLAG = 1; +#[doc = "!< the EDID has been modified by the driver for compatibility"] +pub const NV_EDID_FLAG_NV_EDID_FLAG_COOKED: NV_EDID_FLAG = 2; +#[doc = "!< the EDID is forced by the end-user over s/w interface,"] +pub const NV_EDID_FLAG_NV_EDID_FLAG_FORCED: NV_EDID_FLAG = 3; +#[doc = "!< the EDID is from monitor INF"] +pub const NV_EDID_FLAG_NV_EDID_FLAG_INF: NV_EDID_FLAG = 4; +#[doc = "!< the EDID is from the monitor over I2C bus without any modification."] +pub const NV_EDID_FLAG_NV_EDID_FLAG_HW: NV_EDID_FLAG = 5; +pub type NV_EDID_FLAG = ::std::os::raw::c_int; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_VGA_15_PIN: _NV_GPU_CONNECTOR_TYPE = 0; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_TV_COMPOSITE: _NV_GPU_CONNECTOR_TYPE = 16; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_TV_SVIDEO: _NV_GPU_CONNECTOR_TYPE = 17; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_TV_HDTV_COMPONENT: _NV_GPU_CONNECTOR_TYPE = 19; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_TV_SCART: _NV_GPU_CONNECTOR_TYPE = 20; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_TV_COMPOSITE_SCART_ON_EIAJ4120: + _NV_GPU_CONNECTOR_TYPE = 22; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_TV_HDTV_EIAJ4120: _NV_GPU_CONNECTOR_TYPE = 23; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_PC_POD_HDTV_YPRPB: _NV_GPU_CONNECTOR_TYPE = 24; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_PC_POD_SVIDEO: _NV_GPU_CONNECTOR_TYPE = 25; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_PC_POD_COMPOSITE: _NV_GPU_CONNECTOR_TYPE = 26; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DVI_I_TV_SVIDEO: _NV_GPU_CONNECTOR_TYPE = 32; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DVI_I_TV_COMPOSITE: _NV_GPU_CONNECTOR_TYPE = + 33; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DVI_I: _NV_GPU_CONNECTOR_TYPE = 48; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DVI_D: _NV_GPU_CONNECTOR_TYPE = 49; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_ADC: _NV_GPU_CONNECTOR_TYPE = 50; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_LFH_DVI_I_1: _NV_GPU_CONNECTOR_TYPE = 56; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_LFH_DVI_I_2: _NV_GPU_CONNECTOR_TYPE = 57; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_SPWG: _NV_GPU_CONNECTOR_TYPE = 64; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_OEM: _NV_GPU_CONNECTOR_TYPE = 65; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DISPLAYPORT_EXTERNAL: _NV_GPU_CONNECTOR_TYPE = + 70; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DISPLAYPORT_INTERNAL: _NV_GPU_CONNECTOR_TYPE = + 71; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_DISPLAYPORT_MINI_EXT: _NV_GPU_CONNECTOR_TYPE = + 72; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_HDMI_A: _NV_GPU_CONNECTOR_TYPE = 97; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_HDMI_C_MINI: _NV_GPU_CONNECTOR_TYPE = 99; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_LFH_DISPLAYPORT_1: _NV_GPU_CONNECTOR_TYPE = + 100; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_LFH_DISPLAYPORT_2: _NV_GPU_CONNECTOR_TYPE = + 101; +#[doc = "!< Deprecated."] +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_VIRTUAL_WFD: _NV_GPU_CONNECTOR_TYPE = 112; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_USB_C: _NV_GPU_CONNECTOR_TYPE = 113; +pub const _NV_GPU_CONNECTOR_TYPE_NVAPI_GPU_CONNECTOR_UNKNOWN: _NV_GPU_CONNECTOR_TYPE = -1; +#[doc = "! \\ingroup gpu\n! Used in NV_GPU_CONNECTOR_DATA"] +pub type _NV_GPU_CONNECTOR_TYPE = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpu\n! Used in NV_GPU_CONNECTOR_DATA"] +pub use self::_NV_GPU_CONNECTOR_TYPE as NV_GPU_CONNECTOR_TYPE; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_NONE: _NV_DISPLAY_TV_FORMAT = 0; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_NTSCM: _NV_DISPLAY_TV_FORMAT = 1; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_NTSCJ: _NV_DISPLAY_TV_FORMAT = 2; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_PALM: _NV_DISPLAY_TV_FORMAT = 4; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_PALBDGH: _NV_DISPLAY_TV_FORMAT = 8; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_PALN: _NV_DISPLAY_TV_FORMAT = 16; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_PALNC: _NV_DISPLAY_TV_FORMAT = 32; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_576i: _NV_DISPLAY_TV_FORMAT = 256; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_480i: _NV_DISPLAY_TV_FORMAT = 512; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_ED_480p: _NV_DISPLAY_TV_FORMAT = 1024; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_ED_576p: _NV_DISPLAY_TV_FORMAT = 2048; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_720p: _NV_DISPLAY_TV_FORMAT = 4096; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_1080i: _NV_DISPLAY_TV_FORMAT = 8192; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_1080p: _NV_DISPLAY_TV_FORMAT = 16384; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_720p50: _NV_DISPLAY_TV_FORMAT = 32768; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_1080p24: _NV_DISPLAY_TV_FORMAT = 65536; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_1080i50: _NV_DISPLAY_TV_FORMAT = 131072; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_1080p50: _NV_DISPLAY_TV_FORMAT = 262144; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp30: _NV_DISPLAY_TV_FORMAT = 524288; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp30_3840: _NV_DISPLAY_TV_FORMAT = 524288; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp25: _NV_DISPLAY_TV_FORMAT = 1048576; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp25_3840: _NV_DISPLAY_TV_FORMAT = + 1048576; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp24: _NV_DISPLAY_TV_FORMAT = 2097152; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp24_3840: _NV_DISPLAY_TV_FORMAT = + 2097152; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp24_SMPTE: _NV_DISPLAY_TV_FORMAT = + 4194304; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp50_3840: _NV_DISPLAY_TV_FORMAT = + 8388608; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp60_3840: _NV_DISPLAY_TV_FORMAT = + 9437184; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp30_4096: _NV_DISPLAY_TV_FORMAT = + 10485760; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp25_4096: _NV_DISPLAY_TV_FORMAT = + 11534336; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp24_4096: _NV_DISPLAY_TV_FORMAT = + 12582912; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp50_4096: _NV_DISPLAY_TV_FORMAT = + 13631488; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp60_4096: _NV_DISPLAY_TV_FORMAT = + 14680064; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp24_7680: _NV_DISPLAY_TV_FORMAT = + 16777216; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp25_7680: _NV_DISPLAY_TV_FORMAT = + 33554432; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp30_7680: _NV_DISPLAY_TV_FORMAT = + 67108864; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp48_7680: _NV_DISPLAY_TV_FORMAT = + 134217728; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp50_7680: _NV_DISPLAY_TV_FORMAT = + 150994944; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp60_7680: _NV_DISPLAY_TV_FORMAT = + 167772160; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp100_7680: _NV_DISPLAY_TV_FORMAT = + 184549376; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_8Kp120_7680: _NV_DISPLAY_TV_FORMAT = + 201326592; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp48_3840: _NV_DISPLAY_TV_FORMAT = + 218103808; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp48_4096: _NV_DISPLAY_TV_FORMAT = + 234881024; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp100_4096: _NV_DISPLAY_TV_FORMAT = + 251658240; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp100_3840: _NV_DISPLAY_TV_FORMAT = + 268435456; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp120_4096: _NV_DISPLAY_TV_FORMAT = + 285212672; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp120_3840: _NV_DISPLAY_TV_FORMAT = + 301989888; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp100_5120: _NV_DISPLAY_TV_FORMAT = + 318767104; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp120_5120: _NV_DISPLAY_TV_FORMAT = + 335544320; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp24_5120: _NV_DISPLAY_TV_FORMAT = + 352321536; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp25_5120: _NV_DISPLAY_TV_FORMAT = + 369098752; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp30_5120: _NV_DISPLAY_TV_FORMAT = + 385875968; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp48_5120: _NV_DISPLAY_TV_FORMAT = + 402653184; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp50_5120: _NV_DISPLAY_TV_FORMAT = + 419430400; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_4Kp60_5120: _NV_DISPLAY_TV_FORMAT = + 536870912; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp24_10240: _NV_DISPLAY_TV_FORMAT = + 553648128; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp25_10240: _NV_DISPLAY_TV_FORMAT = + 570425344; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp30_10240: _NV_DISPLAY_TV_FORMAT = + 587202560; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp48_10240: _NV_DISPLAY_TV_FORMAT = + 603979776; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp50_10240: _NV_DISPLAY_TV_FORMAT = + 620756992; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp60_10240: _NV_DISPLAY_TV_FORMAT = + 637534208; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp100_10240: _NV_DISPLAY_TV_FORMAT = + 654311424; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_UHD_10Kp120_10240: _NV_DISPLAY_TV_FORMAT = + 671088640; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_SD_OTHER: _NV_DISPLAY_TV_FORMAT = 805306368; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_ED_OTHER: _NV_DISPLAY_TV_FORMAT = 1073741824; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_HD_OTHER: _NV_DISPLAY_TV_FORMAT = 1342177280; +pub const _NV_DISPLAY_TV_FORMAT_NV_DISPLAY_TV_FORMAT_ANY: _NV_DISPLAY_TV_FORMAT = -2147483648; +#[doc = "! \\ingroup tvapi\n! Used in NV_DISPLAY_TV_OUTPUT_INFO"] +pub type _NV_DISPLAY_TV_FORMAT = ::std::os::raw::c_int; +#[doc = "! \\ingroup tvapi\n! Used in NV_DISPLAY_TV_OUTPUT_INFO"] +pub use self::_NV_DISPLAY_TV_FORMAT as NV_DISPLAY_TV_FORMAT; +pub const _NV_TARGET_VIEW_MODE_NV_VIEW_MODE_STANDARD: _NV_TARGET_VIEW_MODE = 0; +pub const _NV_TARGET_VIEW_MODE_NV_VIEW_MODE_CLONE: _NV_TARGET_VIEW_MODE = 1; +pub const _NV_TARGET_VIEW_MODE_NV_VIEW_MODE_HSPAN: _NV_TARGET_VIEW_MODE = 2; +pub const _NV_TARGET_VIEW_MODE_NV_VIEW_MODE_VSPAN: _NV_TARGET_VIEW_MODE = 3; +pub const _NV_TARGET_VIEW_MODE_NV_VIEW_MODE_DUALVIEW: _NV_TARGET_VIEW_MODE = 4; +pub const _NV_TARGET_VIEW_MODE_NV_VIEW_MODE_MULTIVIEW: _NV_TARGET_VIEW_MODE = 5; +#[doc = "! Used in NvAPI_SetView()."] +pub type _NV_TARGET_VIEW_MODE = ::std::os::raw::c_int; +#[doc = "! Used in NvAPI_SetView()."] +pub use self::_NV_TARGET_VIEW_MODE as NV_TARGET_VIEW_MODE; +#[doc = "!< No change"] +pub const _NV_SCALING_NV_SCALING_DEFAULT: _NV_SCALING = 0; +#[doc = "!< Balanced - Full Screen"] +pub const _NV_SCALING_NV_SCALING_GPU_SCALING_TO_CLOSEST: _NV_SCALING = 1; +#[doc = "!< Force GPU - Full Screen"] +pub const _NV_SCALING_NV_SCALING_GPU_SCALING_TO_NATIVE: _NV_SCALING = 2; +#[doc = "!< Force GPU - Centered\\No Scaling"] +pub const _NV_SCALING_NV_SCALING_GPU_SCANOUT_TO_NATIVE: _NV_SCALING = 3; +#[doc = "!< Force GPU - Aspect Ratio"] +pub const _NV_SCALING_NV_SCALING_GPU_SCALING_TO_ASPECT_SCANOUT_TO_NATIVE: _NV_SCALING = 5; +#[doc = "!< Balanced - Aspect Ratio"] +pub const _NV_SCALING_NV_SCALING_GPU_SCALING_TO_ASPECT_SCANOUT_TO_CLOSEST: _NV_SCALING = 6; +#[doc = "!< Balanced - Centered\\No Scaling"] +pub const _NV_SCALING_NV_SCALING_GPU_SCANOUT_TO_CLOSEST: _NV_SCALING = 7; +#[doc = "!< Force GPU - Integer Scaling"] +pub const _NV_SCALING_NV_SCALING_GPU_INTEGER_ASPECT_SCALING: _NV_SCALING = 8; +pub const _NV_SCALING_NV_SCALING_MONITOR_SCALING: _NV_SCALING = 1; +pub const _NV_SCALING_NV_SCALING_ADAPTER_SCALING: _NV_SCALING = 2; +pub const _NV_SCALING_NV_SCALING_CENTERED: _NV_SCALING = 3; +pub const _NV_SCALING_NV_SCALING_ASPECT_SCALING: _NV_SCALING = 5; +#[doc = "!< For future use"] +pub const _NV_SCALING_NV_SCALING_CUSTOMIZED: _NV_SCALING = 255; +#[doc = "! Scaling modes - used in NvAPI_SetViewEx().\n! \\ingroup dispcontrol"] +pub type _NV_SCALING = ::std::os::raw::c_int; +#[doc = "! Scaling modes - used in NvAPI_SetViewEx().\n! \\ingroup dispcontrol"] +pub use self::_NV_SCALING as NV_SCALING; +pub const _NV_ROTATE_NV_ROTATE_0: _NV_ROTATE = 0; +pub const _NV_ROTATE_NV_ROTATE_90: _NV_ROTATE = 1; +pub const _NV_ROTATE_NV_ROTATE_180: _NV_ROTATE = 2; +pub const _NV_ROTATE_NV_ROTATE_270: _NV_ROTATE = 3; +pub const _NV_ROTATE_NV_ROTATE_IGNORED: _NV_ROTATE = 4; +#[doc = "! \\ingroup dispcontrol"] +pub type _NV_ROTATE = ::std::os::raw::c_int; +#[doc = "! \\ingroup dispcontrol"] +pub use self::_NV_ROTATE as NV_ROTATE; +#[doc = "!< unknown. Driver will choose one as following value."] +pub const _NV_FORMAT_NV_FORMAT_UNKNOWN: _NV_FORMAT = 0; +#[doc = "!< for 8bpp mode"] +pub const _NV_FORMAT_NV_FORMAT_P8: _NV_FORMAT = 41; +#[doc = "!< for 16bpp mode"] +pub const _NV_FORMAT_NV_FORMAT_R5G6B5: _NV_FORMAT = 23; +#[doc = "!< for 32bpp mode"] +pub const _NV_FORMAT_NV_FORMAT_A8R8G8B8: _NV_FORMAT = 21; +#[doc = "!< for 64bpp(floating point) mode."] +pub const _NV_FORMAT_NV_FORMAT_A16B16G16R16F: _NV_FORMAT = 113; +#[doc = "! Color formats- used in NvAPI_SetViewEx().\n! \\ingroup dispcontrol"] +pub type _NV_FORMAT = ::std::os::raw::c_int; +#[doc = "! Color formats- used in NvAPI_SetViewEx().\n! \\ingroup dispcontrol"] +pub use self::_NV_FORMAT as NV_FORMAT; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_VIEWPORTF { + #[doc = "!< x-coordinate of the viewport top-left point"] + pub x: f32, + #[doc = "!< y-coordinate of the viewport top-left point"] + pub y: f32, + #[doc = "!< Width of the viewport"] + pub w: f32, + #[doc = "!< Height of the viewport"] + pub h: f32, +} +#[doc = "!< get the current timing"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_CURRENT: _NV_TIMING_OVERRIDE = 0; +#[doc = "!< the timing the driver will use based the current policy"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_AUTO: _NV_TIMING_OVERRIDE = 1; +#[doc = "!< EDID timing"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_EDID: _NV_TIMING_OVERRIDE = 2; +#[doc = "!< VESA DMT timing"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_DMT: _NV_TIMING_OVERRIDE = 3; +#[doc = "!< VESA DMT timing with reduced blanking"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_DMT_RB: _NV_TIMING_OVERRIDE = 4; +#[doc = "!< VESA CVT timing"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_CVT: _NV_TIMING_OVERRIDE = 5; +#[doc = "!< VESA CVT timing with reduced blanking"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_CVT_RB: _NV_TIMING_OVERRIDE = 6; +#[doc = "!< VESA GTF timing"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_GTF: _NV_TIMING_OVERRIDE = 7; +#[doc = "!< EIA 861x pre-defined timing"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_EIA861: _NV_TIMING_OVERRIDE = 8; +#[doc = "!< analog SD/HDTV timing"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_ANALOG_TV: _NV_TIMING_OVERRIDE = 9; +#[doc = "!< NV custom timings"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_CUST: _NV_TIMING_OVERRIDE = 10; +#[doc = "!< NV pre-defined timing (basically the PsF timings)"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_NV_PREDEFINED: _NV_TIMING_OVERRIDE = 11; +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_NV_PSF: _NV_TIMING_OVERRIDE = 11; +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_NV_ASPR: _NV_TIMING_OVERRIDE = 12; +#[doc = "!< Override for SDI timing"] +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVERRIDE_SDI: _NV_TIMING_OVERRIDE = 13; +pub const _NV_TIMING_OVERRIDE_NV_TIMING_OVRRIDE_MAX: _NV_TIMING_OVERRIDE = 14; +#[doc = "! \\ingroup dispcontrol\n! The timing override is not supported yet; must be set to _AUTO. \\n"] +pub type _NV_TIMING_OVERRIDE = ::std::os::raw::c_int; +#[doc = "! \\ingroup dispcontrol\n! The timing override is not supported yet; must be set to _AUTO. \\n"] +pub use self::_NV_TIMING_OVERRIDE as NV_TIMING_OVERRIDE; +#[doc = "! \\ingroup dispcontrol\n! NVIDIA-specific timing extras \\n\n! Used in NV_TIMING."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct tagNV_TIMINGEXT { + #[doc = "!< Reserved for NVIDIA hardware-based enhancement, such as double-scan."] + pub flag: NvU32, + #[doc = "!< Logical refresh rate to present"] + pub rr: NvU16, + #[doc = "!< Physical vertical refresh rate in 0.001Hz"] + pub rrx1k: NvU32, + #[doc = "!< Display aspect ratio Hi(aspect):horizontal-aspect, Low(aspect):vertical-aspect"] + pub aspect: NvU32, + #[doc = "!< Bit-wise pixel repetition factor: 0x1:no pixel repetition; 0x2:each pixel repeats twice horizontally,.."] + pub rep: NvU16, + #[doc = "!< Timing standard"] + pub status: NvU32, + #[doc = "!< Timing name"] + pub name: [NvU8; 40usize], +} +#[doc = "! \\ingroup dispcontrol\n! NVIDIA-specific timing extras \\n\n! Used in NV_TIMING."] +pub type NV_TIMINGEXT = tagNV_TIMINGEXT; +#[doc = "! \\ingroup dispcontrol\n!The very basic timing structure based on the VESA standard:\n! \\code\n! |<----------------------------htotal--------------------------->|\n! ---------\"active\" video-------->|<-------blanking------>|<-----\n! |<-------hvisible-------->|<-hb->|<-hfp->|<-hsw->|<-hbp->|<-hb->|\n! --------- -+-------------------------+ | | | | |\n! A A | | | | | | |\n! : : | | | | | | |\n! : : | | | | | | |\n! :vertical| addressable video | | | | | |\n! : visible| | | | | | |\n! : : | | | | | | |\n! : : | | | | | | |\n! vertical V | | | | | | |\n! total --+-------------------------+ | | | | |\n! : vb border | | | | |\n! : -----------------------------------+ | | | |\n! : vfp front porch | | | |\n! : -------------------------------------------+ | | |\n! : vsw sync width | | |\n! : ---------------------------------------------------+ | |\n! : vbp back porch | |\n! : -----------------------------------------------------------+ |\n! V vb border |\n! ---------------------------------------------------------------------------+\n! \\endcode"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_TIMING { + #[doc = "!< horizontal visible"] + pub HVisible: NvU16, + #[doc = "!< horizontal border"] + pub HBorder: NvU16, + #[doc = "!< horizontal front porch"] + pub HFrontPorch: NvU16, + #[doc = "!< horizontal sync width"] + pub HSyncWidth: NvU16, + #[doc = "!< horizontal total"] + pub HTotal: NvU16, + #[doc = "!< horizontal sync polarity: 1-negative, 0-positive"] + pub HSyncPol: NvU8, + #[doc = "!< vertical visible"] + pub VVisible: NvU16, + #[doc = "!< vertical border"] + pub VBorder: NvU16, + #[doc = "!< vertical front porch"] + pub VFrontPorch: NvU16, + #[doc = "!< vertical sync width"] + pub VSyncWidth: NvU16, + #[doc = "!< vertical total"] + pub VTotal: NvU16, + #[doc = "!< vertical sync polarity: 1-negative, 0-positive"] + pub VSyncPol: NvU8, + #[doc = "!< 1-interlaced, 0-progressive"] + pub interlaced: NvU16, + #[doc = "!< pixel clock in 10 kHz"] + pub pclk: NvU32, + pub etc: NV_TIMINGEXT, +} +#[doc = "! \\ingroup dispcontrol\n!The very basic timing structure based on the VESA standard:\n! \\code\n! |<----------------------------htotal--------------------------->|\n! ---------\"active\" video-------->|<-------blanking------>|<-----\n! |<-------hvisible-------->|<-hb->|<-hfp->|<-hsw->|<-hbp->|<-hb->|\n! --------- -+-------------------------+ | | | | |\n! A A | | | | | | |\n! : : | | | | | | |\n! : : | | | | | | |\n! :vertical| addressable video | | | | | |\n! : visible| | | | | | |\n! : : | | | | | | |\n! : : | | | | | | |\n! vertical V | | | | | | |\n! total --+-------------------------+ | | | | |\n! : vb border | | | | |\n! : -----------------------------------+ | | | |\n! : vfp front porch | | | |\n! : -------------------------------------------+ | | |\n! : vsw sync width | | |\n! : ---------------------------------------------------+ | |\n! : vbp back porch | |\n! : -----------------------------------------------------------+ |\n! V vb border |\n! ---------------------------------------------------------------------------+\n! \\endcode"] +pub type NV_TIMING = _NV_TIMING; +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_SetView() and NvAPI_GetView()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_VIEW_TARGET_INFO { + #[doc = "!< (IN) structure version"] + pub version: NvU32, + #[doc = "!< (IN) target count"] + pub count: NvU32, + pub target: [NV_VIEW_TARGET_INFO__bindgen_ty_1; 2usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_VIEW_TARGET_INFO__bindgen_ty_1 { + #[doc = "!< (IN/OUT) Device mask"] + pub deviceMask: NvU32, + #[doc = "!< (IN/OUT) Source ID - values will be based on the number of heads exposed per GPU."] + pub sourceId: NvU32, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +impl NV_VIEW_TARGET_INFO__bindgen_ty_1 { + #[inline] + pub fn bPrimary(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bPrimary(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bPrimary_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bPrimary_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bInterlaced(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bInterlaced(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bInterlaced_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bInterlaced_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bGDIPrimary(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_bGDIPrimary(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bGDIPrimary_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bGDIPrimary_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bForceModeSet(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_bForceModeSet(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bForceModeSet_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bForceModeSet_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bPrimary: NvU32, + bInterlaced: NvU32, + bGDIPrimary: NvU32, + bForceModeSet: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bPrimary: u32 = unsafe { ::std::mem::transmute(bPrimary) }; + bPrimary as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bInterlaced: u32 = unsafe { ::std::mem::transmute(bInterlaced) }; + bInterlaced as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let bGDIPrimary: u32 = unsafe { ::std::mem::transmute(bGDIPrimary) }; + bGDIPrimary as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let bForceModeSet: u32 = unsafe { ::std::mem::transmute(bForceModeSet) }; + bForceModeSet as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup dispcontrol\n! Used in NV_DISPLAY_PATH_INFO."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_DISPLAY_PATH { + #[doc = "!< (IN) Device mask"] + pub deviceMask: NvU32, + #[doc = "!< (IN) Values will be based on the number of heads exposed per GPU(0, 1?)"] + pub sourceId: NvU32, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + #[doc = "!< (IN) Specify connector type. For TV only."] + pub connector: NV_GPU_CONNECTOR_TYPE, + #[doc = "!< (IN) Width of the mode"] + pub width: NvU32, + #[doc = "!< (IN) Height of the mode"] + pub height: NvU32, + #[doc = "!< (IN) Depth of the mode"] + pub depth: NvU32, + #[doc = "!< Color format if it needs to be specified. Not used now."] + pub colorFormat: NV_FORMAT, + #[doc = "!< (IN) Rotation setting."] + pub rotation: NV_ROTATE, + #[doc = "!< (IN) Scaling setting"] + pub scaling: NV_SCALING, + #[doc = "!< (IN) Refresh rate of the mode"] + pub refreshRate: NvU32, + pub _bitfield_align_2: [u8; 0], + pub _bitfield_2: __BindgenBitfieldUnit<[u8; 1usize]>, + #[doc = "!< (IN) To choose the last TV format set this value to NV_DISPLAY_TV_FORMAT_NONE"] + pub tvFormat: NV_DISPLAY_TV_FORMAT, + #[doc = "!< (IN/OUT) X-offset of this display on the Windows desktop"] + pub posx: NvU32, + #[doc = "!< (IN/OUT) Y-offset of this display on the Windows desktop"] + pub posy: NvU32, + pub _bitfield_align_3: [u32; 0], + pub _bitfield_3: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl NV_DISPLAY_PATH { + #[inline] + pub fn bPrimary(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bPrimary(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bPrimary_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bPrimary_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1(bPrimary: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bPrimary: u32 = unsafe { ::std::mem::transmute(bPrimary) }; + bPrimary as u64 + }); + __bindgen_bitfield_unit + } + #[inline] + pub fn interlaced(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_interlaced(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_2.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn interlaced_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_2), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_interlaced_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_2(interlaced: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let interlaced: u32 = unsafe { ::std::mem::transmute(interlaced) }; + interlaced as u64 + }); + __bindgen_bitfield_unit + } + #[inline] + pub fn bGDIPrimary(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_3.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bGDIPrimary(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_3.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bGDIPrimary_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_3), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bGDIPrimary_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_3), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bForceModeSet(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_3.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bForceModeSet(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_3.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bForceModeSet_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_3), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bForceModeSet_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_3), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bFocusDisplay(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_3.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_bFocusDisplay(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_3.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bFocusDisplay_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_3), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bFocusDisplay_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_3), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn gpuId(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_3.get(3usize, 24u8) as u32) } + } + #[inline] + pub fn set_gpuId(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_3.set(3usize, 24u8, val as u64) + } + } + #[inline] + pub unsafe fn gpuId_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_3), + 3usize, + 24u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_gpuId_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_3), + 3usize, + 24u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_3( + bGDIPrimary: NvU32, + bForceModeSet: NvU32, + bFocusDisplay: NvU32, + gpuId: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bGDIPrimary: u32 = unsafe { ::std::mem::transmute(bGDIPrimary) }; + bGDIPrimary as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bForceModeSet: u32 = unsafe { ::std::mem::transmute(bForceModeSet) }; + bForceModeSet as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let bFocusDisplay: u32 = unsafe { ::std::mem::transmute(bFocusDisplay) }; + bFocusDisplay as u64 + }); + __bindgen_bitfield_unit.set(3usize, 24u8, { + let gpuId: u32 = unsafe { ::std::mem::transmute(gpuId) }; + gpuId as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_SetViewEx() and NvAPI_GetViewEx()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_DISPLAY_PATH_INFO_V3 { + #[doc = "!< (IN) Structure version"] + pub version: NvU32, + #[doc = "!< (IN) Path count"] + pub count: NvU32, + pub path: [NV_DISPLAY_PATH; 2usize], +} +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_SetViewEx() and NvAPI_GetViewEx()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_DISPLAY_PATH_INFO { + #[doc = "!< (IN) Structure version"] + pub version: NvU32, + #[doc = "!< (IN) Path count"] + pub count: NvU32, + pub path: [NV_DISPLAY_PATH; 4usize], +} +#[doc = "\n! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_POSITION { + pub x: NvS32, + pub y: NvS32, +} +#[doc = "\n! \\ingroup dispcontrol"] +pub type NV_POSITION = _NV_POSITION; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_RESOLUTION { + pub width: NvU32, + pub height: NvU32, + pub colorDepth: NvU32, +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_RESOLUTION = _NV_RESOLUTION; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO_V1 { + pub version: NvU32, + #[doc = "!< (IN) rotation setting."] + pub rotation: NV_ROTATE, + #[doc = "!< (IN) scaling setting."] + pub scaling: NV_SCALING, + #[doc = "!< (IN) Non-interlaced Refresh Rate of the mode, multiplied by 1000, 0 = ignored\n!< This is the value which driver reports to the OS."] + pub refreshRate1K: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Specify connector type. For TV only, ignored if tvFormat == NV_DISPLAY_TV_FORMAT_NONE"] + pub connector: NV_GPU_CONNECTOR_TYPE, + #[doc = "!< (IN) to choose the last TV format set this value to NV_DISPLAY_TV_FORMAT_NONE\n!< In case of NvAPI_DISP_GetDisplayConfig(), this field will indicate the currently applied TV format;\n!< if no TV format is applied, this field will have NV_DISPLAY_TV_FORMAT_NONE value.\n!< In case of NvAPI_DISP_SetDisplayConfig(), this field should only be set in case of TVs;\n!< for other displays this field will be ignored and resolution & refresh rate specified in input will be used to apply the TV format."] + pub tvFormat: NV_DISPLAY_TV_FORMAT, + #[doc = "!< Ignored if timingOverride == NV_TIMING_OVERRIDE_CURRENT"] + pub timingOverride: NV_TIMING_OVERRIDE, + #[doc = "!< Scan out timing, valid only if timingOverride == NV_TIMING_OVERRIDE_CUST\n!< The value NV_TIMING::NV_TIMINGEXT::rrx1k is obtained from the EDID. The driver may\n!< tweak this value for HDTV, stereo, etc., before reporting it to the OS."] + pub timing: NV_TIMING, +} +impl _NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO_V1 { + #[inline] + pub fn interlaced(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_interlaced(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn interlaced_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_interlaced_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn primary(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_primary(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn primary_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_primary_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reservedBit1(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_reservedBit1(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn reservedBit1_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reservedBit1_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn disableVirtualModeSupport(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_disableVirtualModeSupport(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn disableVirtualModeSupport_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_disableVirtualModeSupport_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isPreferredUnscaledTarget(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_isPreferredUnscaledTarget(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isPreferredUnscaledTarget_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isPreferredUnscaledTarget_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 27u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 27u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 27u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + interlaced: NvU32, + primary: NvU32, + reservedBit1: NvU32, + disableVirtualModeSupport: NvU32, + isPreferredUnscaledTarget: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let interlaced: u32 = unsafe { ::std::mem::transmute(interlaced) }; + interlaced as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let primary: u32 = unsafe { ::std::mem::transmute(primary) }; + primary as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let reservedBit1: u32 = unsafe { ::std::mem::transmute(reservedBit1) }; + reservedBit1 as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let disableVirtualModeSupport: u32 = + unsafe { ::std::mem::transmute(disableVirtualModeSupport) }; + disableVirtualModeSupport as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let isPreferredUnscaledTarget: u32 = + unsafe { ::std::mem::transmute(isPreferredUnscaledTarget) }; + isPreferredUnscaledTarget as u64 + }); + __bindgen_bitfield_unit.set(5usize, 27u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO_V1 = + _NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO_V1; +#[doc = "! \\ingroup dispcontrol"] +pub type NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO = NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO_V1; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_DISPLAYCONFIG_PATH_TARGET_INFO_V1 { + #[doc = "!< Display ID"] + pub displayId: NvU32, + #[doc = "!< May be NULL if no advanced settings are required. NULL for Non-NVIDIA Display."] + pub details: *mut NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO, +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_DISPLAYCONFIG_PATH_TARGET_INFO_V1 = _NV_DISPLAYCONFIG_PATH_TARGET_INFO_V1; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_DISPLAYCONFIG_PATH_TARGET_INFO_V2 { + #[doc = "!< Display ID"] + pub displayId: NvU32, + #[doc = "!< May be NULL if no advanced settings are required"] + pub details: *mut NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO, + #[doc = "!< Windows CCD target ID. Must be present only for non-NVIDIA adapter, for NVIDIA adapter this parameter is ignored."] + pub targetId: NvU32, +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_DISPLAYCONFIG_PATH_TARGET_INFO_V2 = _NV_DISPLAYCONFIG_PATH_TARGET_INFO_V2; +#[doc = "! \\ingroup dispcontrol\n! As version is not defined for this structure, we will be using version of NV_DISPLAYCONFIG_PATH_INFO"] +pub type NV_DISPLAYCONFIG_PATH_TARGET_INFO = NV_DISPLAYCONFIG_PATH_TARGET_INFO_V2; +pub const _NV_DISPLAYCONFIG_SPANNING_ORIENTATION_NV_DISPLAYCONFIG_SPAN_NONE: + _NV_DISPLAYCONFIG_SPANNING_ORIENTATION = 0; +pub const _NV_DISPLAYCONFIG_SPANNING_ORIENTATION_NV_DISPLAYCONFIG_SPAN_HORIZONTAL: + _NV_DISPLAYCONFIG_SPANNING_ORIENTATION = 1; +pub const _NV_DISPLAYCONFIG_SPANNING_ORIENTATION_NV_DISPLAYCONFIG_SPAN_VERTICAL: + _NV_DISPLAYCONFIG_SPANNING_ORIENTATION = 2; +#[doc = "! \\ingroup dispcontrol"] +pub type _NV_DISPLAYCONFIG_SPANNING_ORIENTATION = ::std::os::raw::c_int; +#[doc = "! \\ingroup dispcontrol"] +pub use self::_NV_DISPLAYCONFIG_SPANNING_ORIENTATION as NV_DISPLAYCONFIG_SPANNING_ORIENTATION; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1 { + pub resolution: NV_RESOLUTION, + #[doc = "!< Ignored at present, must be NV_FORMAT_UNKNOWN (0)"] + pub colorFormat: NV_FORMAT, + #[doc = "!< Is all positions are 0 or invalid, displays will be automatically\n!< positioned from left to right with GDI Primary at 0,0, and all\n!< other displays in the order of the path array."] + pub position: NV_POSITION, + #[doc = "!< Spanning is only supported on XP"] + pub spanningOrientation: NV_DISPLAYCONFIG_SPANNING_ORIENTATION, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl _NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1 { + #[inline] + pub fn bGDIPrimary(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bGDIPrimary(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bGDIPrimary_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bGDIPrimary_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bSLIFocus(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bSLIFocus(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bSLIFocus_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bSLIFocus_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 30u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 30u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 30u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bGDIPrimary: NvU32, + bSLIFocus: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bGDIPrimary: u32 = unsafe { ::std::mem::transmute(bGDIPrimary) }; + bGDIPrimary as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bSLIFocus: u32 = unsafe { ::std::mem::transmute(bSLIFocus) }; + bSLIFocus as u64 + }); + __bindgen_bitfield_unit.set(2usize, 30u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1 = _NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_DISPLAYCONFIG_PATH_INFO_V1 { + pub version: NvU32, + #[doc = "!< This field is reserved. There is ongoing debate if we need this field.\n!< Identifies sourceIds used by Windows. If all sourceIds are 0,\n!< these will be computed automatically."] + pub reserved_sourceId: NvU32, + #[doc = "!< Number of elements in targetInfo array"] + pub targetInfoCount: NvU32, + pub targetInfo: *mut NV_DISPLAYCONFIG_PATH_TARGET_INFO_V1, + #[doc = "!< May be NULL if mode info is not important"] + pub sourceModeInfo: *mut NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1, +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_DISPLAYCONFIG_PATH_INFO_V1 = _NV_DISPLAYCONFIG_PATH_INFO_V1; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_DISPLAYCONFIG_PATH_INFO { + pub version: NvU32, + pub __bindgen_anon_1: _NV_DISPLAYCONFIG_PATH_INFO__bindgen_ty_1, + #[doc = "!< Number of elements in targetInfo array"] + pub targetInfoCount: NvU32, + pub targetInfo: *mut NV_DISPLAYCONFIG_PATH_TARGET_INFO_V2, + #[doc = "!< May be NULL if mode info is not important"] + pub sourceModeInfo: *mut NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Used by Non-NVIDIA adapter for pointer to OS Adapter of LUID\n!< type, type casted to void *."] + pub pOSAdapterID: *mut ::std::os::raw::c_void, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union _NV_DISPLAYCONFIG_PATH_INFO__bindgen_ty_1 { + #[doc = "!< Identifies sourceId used by Windows CCD. This can be optionally set."] + pub sourceId: NvU32, + #[doc = "!< Only for compatibility"] + pub reserved_sourceId: NvU32, +} +impl _NV_DISPLAYCONFIG_PATH_INFO { + #[inline] + pub fn IsNonNVIDIAAdapter(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_IsNonNVIDIAAdapter(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn IsNonNVIDIAAdapter_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_IsNonNVIDIAAdapter_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + IsNonNVIDIAAdapter: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let IsNonNVIDIAAdapter: u32 = unsafe { ::std::mem::transmute(IsNonNVIDIAAdapter) }; + IsNonNVIDIAAdapter as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_DISPLAYCONFIG_PATH_INFO_V2 = _NV_DISPLAYCONFIG_PATH_INFO; +#[doc = "! \\ingroup dispcontrol"] +pub type NV_DISPLAYCONFIG_PATH_INFO = NV_DISPLAYCONFIG_PATH_INFO_V2; +#[doc = "! \\ingroup dispcontrol"] +pub type NV_DISPLAYCONFIG_SOURCE_MODE_INFO = NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1; +pub const _NV_DISPLAYCONFIG_FLAGS_NV_DISPLAYCONFIG_VALIDATE_ONLY: _NV_DISPLAYCONFIG_FLAGS = 1; +pub const _NV_DISPLAYCONFIG_FLAGS_NV_DISPLAYCONFIG_SAVE_TO_PERSISTENCE: _NV_DISPLAYCONFIG_FLAGS = 2; +#[doc = "!< Driver reload is permitted if necessary"] +pub const _NV_DISPLAYCONFIG_FLAGS_NV_DISPLAYCONFIG_DRIVER_RELOAD_ALLOWED: _NV_DISPLAYCONFIG_FLAGS = + 4; +#[doc = "!< Refresh OS mode list."] +pub const _NV_DISPLAYCONFIG_FLAGS_NV_DISPLAYCONFIG_FORCE_MODE_ENUMERATION: _NV_DISPLAYCONFIG_FLAGS = + 8; +#[doc = "!< Tell OS to avoid optimizing CommitVidPn call during a modeset"] +pub const _NV_DISPLAYCONFIG_FLAGS_NV_FORCE_COMMIT_VIDPN: _NV_DISPLAYCONFIG_FLAGS = 16; +#[doc = "! \\ingroup dispcontrol"] +pub type _NV_DISPLAYCONFIG_FLAGS = ::std::os::raw::c_int; +#[doc = "! \\ingroup dispcontrol"] +pub use self::_NV_DISPLAYCONFIG_FLAGS as NV_DISPLAYCONFIG_FLAGS; +pub type NvAPI_UnicodeString = [NvU16; 2048usize]; +pub type NvAPI_LPCWSTR = *const NvU16; +pub const _NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID_NVAPI_GPU_PERF_VOLTAGE_INFO_DOMAIN_CORE: + _NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID = 0; +pub const _NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID_NVAPI_GPU_PERF_VOLTAGE_INFO_DOMAIN_UNDEFINED: + _NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID = 16; +#[doc = "! \\ingroup gpuclock"] +pub type _NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpuclock"] +pub use self::_NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID as NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID; +pub const _NV_GPU_PUBLIC_CLOCK_ID_NVAPI_GPU_PUBLIC_CLOCK_GRAPHICS: _NV_GPU_PUBLIC_CLOCK_ID = 0; +pub const _NV_GPU_PUBLIC_CLOCK_ID_NVAPI_GPU_PUBLIC_CLOCK_MEMORY: _NV_GPU_PUBLIC_CLOCK_ID = 4; +pub const _NV_GPU_PUBLIC_CLOCK_ID_NVAPI_GPU_PUBLIC_CLOCK_PROCESSOR: _NV_GPU_PUBLIC_CLOCK_ID = 7; +pub const _NV_GPU_PUBLIC_CLOCK_ID_NVAPI_GPU_PUBLIC_CLOCK_VIDEO: _NV_GPU_PUBLIC_CLOCK_ID = 8; +pub const _NV_GPU_PUBLIC_CLOCK_ID_NVAPI_GPU_PUBLIC_CLOCK_UNDEFINED: _NV_GPU_PUBLIC_CLOCK_ID = 32; +#[doc = "! \\ingroup gpuclock"] +pub type _NV_GPU_PUBLIC_CLOCK_ID = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpuclock"] +pub use self::_NV_GPU_PUBLIC_CLOCK_ID as NV_GPU_PUBLIC_CLOCK_ID; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P0: _NV_GPU_PERF_PSTATE_ID = 0; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P1: _NV_GPU_PERF_PSTATE_ID = 1; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P2: _NV_GPU_PERF_PSTATE_ID = 2; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P3: _NV_GPU_PERF_PSTATE_ID = 3; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P4: _NV_GPU_PERF_PSTATE_ID = 4; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P5: _NV_GPU_PERF_PSTATE_ID = 5; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P6: _NV_GPU_PERF_PSTATE_ID = 6; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P7: _NV_GPU_PERF_PSTATE_ID = 7; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P8: _NV_GPU_PERF_PSTATE_ID = 8; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P9: _NV_GPU_PERF_PSTATE_ID = 9; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P10: _NV_GPU_PERF_PSTATE_ID = 10; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P11: _NV_GPU_PERF_PSTATE_ID = 11; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P12: _NV_GPU_PERF_PSTATE_ID = 12; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P13: _NV_GPU_PERF_PSTATE_ID = 13; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P14: _NV_GPU_PERF_PSTATE_ID = 14; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_P15: _NV_GPU_PERF_PSTATE_ID = 15; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_UNDEFINED: _NV_GPU_PERF_PSTATE_ID = 16; +pub const _NV_GPU_PERF_PSTATE_ID_NVAPI_GPU_PERF_PSTATE_ALL: _NV_GPU_PERF_PSTATE_ID = 17; +#[doc = "! \\addtogroup gpupstate\n! @{"] +pub type _NV_GPU_PERF_PSTATE_ID = ::std::os::raw::c_int; +#[doc = "! \\addtogroup gpupstate\n! @{"] +pub use self::_NV_GPU_PERF_PSTATE_ID as NV_GPU_PERF_PSTATE_ID; +#[doc = "! Clock domains that use single frequency value within given pstate"] +pub const NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID_NVAPI_GPU_PERF_PSTATE20_CLOCK_TYPE_SINGLE: + NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID = 0; +#[doc = "! Clock domains that allow range of frequency values within given pstate"] +pub const NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID_NVAPI_GPU_PERF_PSTATE20_CLOCK_TYPE_RANGE: + NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID = 1; +#[doc = "! Used to identify clock type"] +pub type NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID = ::std::os::raw::c_int; +#[doc = "! Used to describe both voltage and frequency deltas"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PERF_PSTATES20_PARAM_DELTA { + #[doc = "! Value of parameter delta (in respective units [kHz, uV])"] + pub value: NvS32, + pub valueRange: NV_GPU_PERF_PSTATES20_PARAM_DELTA__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PERF_PSTATES20_PARAM_DELTA__bindgen_ty_1 { + #[doc = "! Min value allowed for parameter delta (in respective units [kHz, uV])"] + pub min: NvS32, + #[doc = "! Max value allowed for parameter delta (in respective units [kHz, uV])"] + pub max: NvS32, +} +#[doc = "! Used to describe single clock entry"] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct NV_GPU_PSTATE20_CLOCK_ENTRY_V1 { + #[doc = "! ID of the clock domain"] + pub domainId: NV_GPU_PUBLIC_CLOCK_ID, + #[doc = "! Clock type ID"] + pub typeId: NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "! Current frequency delta from nominal settings in (kHz)"] + pub freqDelta_kHz: NV_GPU_PERF_PSTATES20_PARAM_DELTA, + pub data: NV_GPU_PSTATE20_CLOCK_ENTRY_V1__bindgen_ty_1, +} +#[doc = "! Clock domain type dependant information"] +#[repr(C)] +#[derive(Copy, Clone)] +pub union NV_GPU_PSTATE20_CLOCK_ENTRY_V1__bindgen_ty_1 { + pub single: NV_GPU_PSTATE20_CLOCK_ENTRY_V1__bindgen_ty_1__bindgen_ty_1, + pub range: NV_GPU_PSTATE20_CLOCK_ENTRY_V1__bindgen_ty_1__bindgen_ty_2, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PSTATE20_CLOCK_ENTRY_V1__bindgen_ty_1__bindgen_ty_1 { + #[doc = "! Clock frequency within given pstate in (kHz)"] + pub freq_kHz: NvU32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PSTATE20_CLOCK_ENTRY_V1__bindgen_ty_1__bindgen_ty_2 { + #[doc = "! Min clock frequency within given pstate in (kHz)"] + pub minFreq_kHz: NvU32, + #[doc = "! Max clock frequency within given pstate in (kHz)"] + pub maxFreq_kHz: NvU32, + #[doc = "! Voltage domain ID and value range in (uV) required for this clock"] + pub domainId: NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID, + pub minVoltage_uV: NvU32, + pub maxVoltage_uV: NvU32, +} +impl NV_GPU_PSTATE20_CLOCK_ENTRY_V1 { + #[inline] + pub fn bIsEditable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsEditable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsEditable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsEditable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsEditable: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsEditable: u32 = unsafe { ::std::mem::transmute(bIsEditable) }; + bIsEditable as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! Used to describe single base voltage entry"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY_V1 { + #[doc = "! ID of the voltage domain"] + pub domainId: NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "! Current base voltage settings in [uV]"] + pub volt_uV: NvU32, + pub voltDelta_uV: NV_GPU_PERF_PSTATES20_PARAM_DELTA, +} +impl NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY_V1 { + #[inline] + pub fn bIsEditable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsEditable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsEditable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsEditable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsEditable: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsEditable: u32 = unsafe { ::std::mem::transmute(bIsEditable) }; + bIsEditable as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! Used in NvAPI_GPU_GetPstates20() interface call."] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct NV_GPU_PERF_PSTATES20_INFO_V1 { + #[doc = "! Version info of the structure (NV_GPU_PERF_PSTATES20_INFO_VER)"] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "! Number of populated pstates"] + pub numPstates: NvU32, + #[doc = "! Number of populated clocks (per pstate)"] + pub numClocks: NvU32, + #[doc = "! Number of populated base voltages (per pstate)"] + pub numBaseVoltages: NvU32, + pub pstates: [NV_GPU_PERF_PSTATES20_INFO_V1__bindgen_ty_1; 16usize], +} +#[doc = "! Performance state (P-State) settings\n! Valid index range is 0 to numPstates-1"] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct NV_GPU_PERF_PSTATES20_INFO_V1__bindgen_ty_1 { + #[doc = "! ID of the P-State"] + pub pstateId: NV_GPU_PERF_PSTATE_ID, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "! Array of clock entries\n! Valid index range is 0 to numClocks-1"] + pub clocks: [NV_GPU_PSTATE20_CLOCK_ENTRY_V1; 8usize], + #[doc = "! Array of baseVoltage entries\n! Valid index range is 0 to numBaseVoltages-1"] + pub baseVoltages: [NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY_V1; 4usize], +} +impl NV_GPU_PERF_PSTATES20_INFO_V1__bindgen_ty_1 { + #[inline] + pub fn bIsEditable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsEditable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsEditable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsEditable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsEditable: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsEditable: u32 = unsafe { ::std::mem::transmute(bIsEditable) }; + bIsEditable as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +impl NV_GPU_PERF_PSTATES20_INFO_V1 { + #[inline] + pub fn bIsEditable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsEditable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsEditable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsEditable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsEditable: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsEditable: u32 = unsafe { ::std::mem::transmute(bIsEditable) }; + bIsEditable as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! Used in NvAPI_GPU_GetPstates20() interface call."] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_PERF_PSTATES20_INFO_V2 { + #[doc = "! Version info of the structure (NV_GPU_PERF_PSTATES20_INFO_VER)"] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "! Number of populated pstates"] + pub numPstates: NvU32, + #[doc = "! Number of populated clocks (per pstate)"] + pub numClocks: NvU32, + #[doc = "! Number of populated base voltages (per pstate)"] + pub numBaseVoltages: NvU32, + pub pstates: [_NV_GPU_PERF_PSTATES20_INFO_V2__bindgen_ty_1; 16usize], + pub ov: _NV_GPU_PERF_PSTATES20_INFO_V2__bindgen_ty_2, +} +#[doc = "! Performance state (P-State) settings\n! Valid index range is 0 to numPstates-1"] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_PERF_PSTATES20_INFO_V2__bindgen_ty_1 { + #[doc = "! ID of the P-State"] + pub pstateId: NV_GPU_PERF_PSTATE_ID, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "! Array of clock entries\n! Valid index range is 0 to numClocks-1"] + pub clocks: [NV_GPU_PSTATE20_CLOCK_ENTRY_V1; 8usize], + #[doc = "! Array of baseVoltage entries\n! Valid index range is 0 to numBaseVoltages-1"] + pub baseVoltages: [NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY_V1; 4usize], +} +impl _NV_GPU_PERF_PSTATES20_INFO_V2__bindgen_ty_1 { + #[inline] + pub fn bIsEditable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsEditable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsEditable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsEditable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsEditable: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsEditable: u32 = unsafe { ::std::mem::transmute(bIsEditable) }; + bIsEditable as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! OV settings - Please refer to NVIDIA over-volting recommendation to understand impact of this functionality\n! Valid index range is 0 to numVoltages-1"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_PERF_PSTATES20_INFO_V2__bindgen_ty_2 { + #[doc = "! Number of populated voltages"] + pub numVoltages: NvU32, + #[doc = "! Array of voltage entries\n! Valid index range is 0 to numVoltages-1"] + pub voltages: [NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY_V1; 4usize], +} +impl _NV_GPU_PERF_PSTATES20_INFO_V2 { + #[inline] + pub fn bIsEditable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsEditable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsEditable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsEditable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsEditable: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsEditable: u32 = unsafe { ::std::mem::transmute(bIsEditable) }; + bIsEditable as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! Used in NvAPI_GPU_GetPstates20() interface call."] +pub type NV_GPU_PERF_PSTATES20_INFO_V2 = _NV_GPU_PERF_PSTATES20_INFO_V2; +#[doc = "! Used in NvAPI_GPU_GetPstates20() interface call."] +pub type NV_GPU_PERF_PSTATES20_INFO = NV_GPU_PERF_PSTATES20_INFO_V2; +#[doc = "! \\ingroup driverapi\n! Used in NvAPI_GetDisplayDriverVersion()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_DISPLAY_DRIVER_VERSION { + pub version: NvU32, + pub drvVersion: NvU32, + pub bldChangeListNum: NvU32, + pub szBuildBranchString: NvAPI_ShortString, + pub szAdapterString: NvAPI_ShortString, +} +pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_UNINITIALIZED: NV_MONITOR_CONN_TYPE = 0; +pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_VGA: NV_MONITOR_CONN_TYPE = 1; +pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_COMPONENT: NV_MONITOR_CONN_TYPE = 2; +pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_SVIDEO: NV_MONITOR_CONN_TYPE = 3; +pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_HDMI: NV_MONITOR_CONN_TYPE = 4; +pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_DVI: NV_MONITOR_CONN_TYPE = 5; +pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_LVDS: NV_MONITOR_CONN_TYPE = 6; +pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_DP: NV_MONITOR_CONN_TYPE = 7; +pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_COMPOSITE: NV_MONITOR_CONN_TYPE = 8; +pub const NV_MONITOR_CONN_TYPE_NV_MONITOR_CONN_TYPE_UNKNOWN: NV_MONITOR_CONN_TYPE = -1; +#[doc = "! \\ingroup gpu"] +pub type NV_MONITOR_CONN_TYPE = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_DISPLAYIDS { + pub version: NvU32, + #[doc = "!< out: vga, tv, dvi, hdmi and dp. This is reserved for future use and clients should not rely on this information. Instead get the\n!< GPU connector type from NvAPI_GPU_GetConnectorInfo/NvAPI_GPU_GetConnectorInfoEx"] + pub connectorType: NV_MONITOR_CONN_TYPE, + #[doc = "!< this is a unique identifier for each device"] + pub displayId: NvU32, + pub _bitfield_align_1: [u16; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl _NV_GPU_DISPLAYIDS { + #[inline] + pub fn isDynamic(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isDynamic(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isDynamic_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isDynamic_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMultiStreamRootNode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMultiStreamRootNode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMultiStreamRootNode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMultiStreamRootNode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isActive(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_isActive(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isActive_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isActive_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isCluster(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_isCluster(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isCluster_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isCluster_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isOSVisible(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_isOSVisible(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isOSVisible_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isOSVisible_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isWFD(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_isWFD(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isWFD_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isWFD_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isConnected(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } + } + #[inline] + pub fn set_isConnected(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isConnected_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 6usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isConnected_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reservedInternal(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 10u8) as u32) } + } + #[inline] + pub fn set_reservedInternal(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 10u8, val as u64) + } + } + #[inline] + pub unsafe fn reservedInternal_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 7usize, + 10u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reservedInternal_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 7usize, + 10u8, + val as u64, + ) + } + } + #[inline] + pub fn isPhysicallyConnected(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) } + } + #[inline] + pub fn set_isPhysicallyConnected(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(17usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isPhysicallyConnected_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 17usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isPhysicallyConnected_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 17usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 14u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(18usize, 14u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 18usize, + 14u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 18usize, + 14u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isDynamic: NvU32, + isMultiStreamRootNode: NvU32, + isActive: NvU32, + isCluster: NvU32, + isOSVisible: NvU32, + isWFD: NvU32, + isConnected: NvU32, + reservedInternal: NvU32, + isPhysicallyConnected: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isDynamic: u32 = unsafe { ::std::mem::transmute(isDynamic) }; + isDynamic as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isMultiStreamRootNode: u32 = + unsafe { ::std::mem::transmute(isMultiStreamRootNode) }; + isMultiStreamRootNode as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let isActive: u32 = unsafe { ::std::mem::transmute(isActive) }; + isActive as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let isCluster: u32 = unsafe { ::std::mem::transmute(isCluster) }; + isCluster as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let isOSVisible: u32 = unsafe { ::std::mem::transmute(isOSVisible) }; + isOSVisible as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let isWFD: u32 = unsafe { ::std::mem::transmute(isWFD) }; + isWFD as u64 + }); + __bindgen_bitfield_unit.set(6usize, 1u8, { + let isConnected: u32 = unsafe { ::std::mem::transmute(isConnected) }; + isConnected as u64 + }); + __bindgen_bitfield_unit.set(7usize, 10u8, { + let reservedInternal: u32 = unsafe { ::std::mem::transmute(reservedInternal) }; + reservedInternal as u64 + }); + __bindgen_bitfield_unit.set(17usize, 1u8, { + let isPhysicallyConnected: u32 = + unsafe { ::std::mem::transmute(isPhysicallyConnected) }; + isPhysicallyConnected as u64 + }); + __bindgen_bitfield_unit.set(18usize, 14u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup gpu"] +pub type NV_GPU_DISPLAYIDS = _NV_GPU_DISPLAYIDS; +pub const NV_SYSTEM_TYPE_NV_SYSTEM_TYPE_UNKNOWN: NV_SYSTEM_TYPE = 0; +pub const NV_SYSTEM_TYPE_NV_SYSTEM_TYPE_LAPTOP: NV_SYSTEM_TYPE = 1; +pub const NV_SYSTEM_TYPE_NV_SYSTEM_TYPE_DESKTOP: NV_SYSTEM_TYPE = 2; +#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetSystemType()"] +pub type NV_SYSTEM_TYPE = ::std::os::raw::c_int; +pub const _NV_GPU_OUTPUT_TYPE_NVAPI_GPU_OUTPUT_UNKNOWN: _NV_GPU_OUTPUT_TYPE = 0; +#[doc = "!< CRT display device"] +pub const _NV_GPU_OUTPUT_TYPE_NVAPI_GPU_OUTPUT_CRT: _NV_GPU_OUTPUT_TYPE = 1; +#[doc = "!< Digital Flat Panel display device"] +pub const _NV_GPU_OUTPUT_TYPE_NVAPI_GPU_OUTPUT_DFP: _NV_GPU_OUTPUT_TYPE = 2; +#[doc = "!< TV display device"] +pub const _NV_GPU_OUTPUT_TYPE_NVAPI_GPU_OUTPUT_TV: _NV_GPU_OUTPUT_TYPE = 3; +#[doc = "! \\ingroup gpu\n! used in NvAPI_GPU_GetOutputType()"] +pub type _NV_GPU_OUTPUT_TYPE = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpu\n! used in NvAPI_GPU_GetOutputType()"] +pub use self::_NV_GPU_OUTPUT_TYPE as NV_GPU_OUTPUT_TYPE; +pub const _NV_GPU_TYPE_NV_SYSTEM_TYPE_GPU_UNKNOWN: _NV_GPU_TYPE = 0; +#[doc = "!< Integrated GPU"] +pub const _NV_GPU_TYPE_NV_SYSTEM_TYPE_IGPU: _NV_GPU_TYPE = 1; +#[doc = "!< Discrete GPU"] +pub const _NV_GPU_TYPE_NV_SYSTEM_TYPE_DGPU: _NV_GPU_TYPE = 2; +#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetGPUType()."] +pub type _NV_GPU_TYPE = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetGPUType()."] +pub use self::_NV_GPU_TYPE as NV_GPU_TYPE; +pub const _NV_GPU_BUS_TYPE_NVAPI_GPU_BUS_TYPE_UNDEFINED: _NV_GPU_BUS_TYPE = 0; +pub const _NV_GPU_BUS_TYPE_NVAPI_GPU_BUS_TYPE_PCI: _NV_GPU_BUS_TYPE = 1; +pub const _NV_GPU_BUS_TYPE_NVAPI_GPU_BUS_TYPE_AGP: _NV_GPU_BUS_TYPE = 2; +pub const _NV_GPU_BUS_TYPE_NVAPI_GPU_BUS_TYPE_PCI_EXPRESS: _NV_GPU_BUS_TYPE = 3; +pub const _NV_GPU_BUS_TYPE_NVAPI_GPU_BUS_TYPE_FPCI: _NV_GPU_BUS_TYPE = 4; +pub const _NV_GPU_BUS_TYPE_NVAPI_GPU_BUS_TYPE_AXI: _NV_GPU_BUS_TYPE = 5; +#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetBusType()"] +pub type _NV_GPU_BUS_TYPE = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetBusType()"] +pub use self::_NV_GPU_BUS_TYPE as NV_GPU_BUS_TYPE; +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_BOARD_INFO { + #[doc = "!< structure version"] + pub version: NvU32, + #[doc = "!< Board Serial Number"] + pub BoardNum: [NvU8; 16usize], +} +#[doc = "! \\ingroup gpu"] +pub type NV_BOARD_INFO_V1 = _NV_BOARD_INFO; +#[doc = "! \\ingroup gpu"] +pub type NV_BOARD_INFO = NV_BOARD_INFO_V1; +#[doc = "! Used in NvAPI_GPU_GetArchInfo()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_ARCH_INFO_V1 { + pub version: NvU32, + pub architecture: NvU32, + pub implementation: NvU32, + pub revision: NvU32, +} +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_T2X: _NV_GPU_ARCHITECTURE_ID = -536870880; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_T3X: _NV_GPU_ARCHITECTURE_ID = -536870864; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_T4X: _NV_GPU_ARCHITECTURE_ID = -536870848; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_T12X: _NV_GPU_ARCHITECTURE_ID = -536870848; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_NV40: _NV_GPU_ARCHITECTURE_ID = 64; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_NV50: _NV_GPU_ARCHITECTURE_ID = 80; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_G78: _NV_GPU_ARCHITECTURE_ID = 96; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_G80: _NV_GPU_ARCHITECTURE_ID = 128; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_G90: _NV_GPU_ARCHITECTURE_ID = 144; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GT200: _NV_GPU_ARCHITECTURE_ID = 160; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GF100: _NV_GPU_ARCHITECTURE_ID = 192; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GF110: _NV_GPU_ARCHITECTURE_ID = 208; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GK100: _NV_GPU_ARCHITECTURE_ID = 224; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GK110: _NV_GPU_ARCHITECTURE_ID = 240; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GK200: _NV_GPU_ARCHITECTURE_ID = 256; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GM000: _NV_GPU_ARCHITECTURE_ID = 272; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GM200: _NV_GPU_ARCHITECTURE_ID = 288; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GP100: _NV_GPU_ARCHITECTURE_ID = 304; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GV100: _NV_GPU_ARCHITECTURE_ID = 320; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GV110: _NV_GPU_ARCHITECTURE_ID = 336; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_TU100: _NV_GPU_ARCHITECTURE_ID = 352; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GA100: _NV_GPU_ARCHITECTURE_ID = 368; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_AD100: _NV_GPU_ARCHITECTURE_ID = 400; +pub const _NV_GPU_ARCHITECTURE_ID_NV_GPU_ARCHITECTURE_GB200: _NV_GPU_ARCHITECTURE_ID = 432; +#[doc = "! NV_GPU_ARCH_INFO() values to identify Architecture level for the GPU."] +pub type _NV_GPU_ARCHITECTURE_ID = ::std::os::raw::c_int; +#[doc = "! NV_GPU_ARCH_INFO() values to identify Architecture level for the GPU."] +pub use self::_NV_GPU_ARCHITECTURE_ID as NV_GPU_ARCHITECTURE_ID; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_T20: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_T30: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_T35: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 5; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_T40: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_T124: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV40: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV41: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 1; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV42: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV43: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 3; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV44: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV44A: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 10; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV46: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV47: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 7; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV49: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 9; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV4B: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 11; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV4C: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 12; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV4E: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 14; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV50: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV63: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 3; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_NV67: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 7; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_G84: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_G86: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_G92: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_G94: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_G96: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_G98: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 8; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT200: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT212: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT214: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT215: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 3; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT216: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 5; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT218: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 8; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_MCP77: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 10; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT21C: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 11; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_MCP79: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 12; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GT21A: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 13; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_MCP89: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 15; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF100: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF104: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF106: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 3; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF108: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 1; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF110: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF116: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF117: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 7; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF118: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 8; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GF119: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 9; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GK104: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GK106: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GK107: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 7; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GK20A: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 10; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GK110: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GK208: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 8; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GM204: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GM206: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP100: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP000: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 1; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP102: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP104: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP106: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP107: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 7; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GP108: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 8; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GV100: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GV10B: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 11; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU100: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU102: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU104: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU106: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 6; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU116: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 8; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU117: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 7; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_TU000: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 1; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GA100: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 0; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GA102: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GA104: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_AD102: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_AD103: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 3; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_AD104: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 4; +pub const _NV_GPU_ARCH_IMPLEMENTATION_ID_NV_GPU_ARCH_IMPLEMENTATION_GB202: + _NV_GPU_ARCH_IMPLEMENTATION_ID = 2; +#[doc = "! NV_GPU_ARCH_INFO() values to identify GPU Architecture Implementation."] +pub type _NV_GPU_ARCH_IMPLEMENTATION_ID = ::std::os::raw::c_int; +#[doc = "! NV_GPU_ARCH_INFO() values to identify GPU Architecture Implementation."] +pub use self::_NV_GPU_ARCH_IMPLEMENTATION_ID as NV_GPU_ARCH_IMPLEMENTATION_ID; +#[doc = "!< QT chip"] +pub const _NV_GPU_CHIP_REVISION_NV_GPU_CHIP_REV_EMULATION_QT: _NV_GPU_CHIP_REVISION = 0; +#[doc = "!< FPGA implementation of the chipset"] +pub const _NV_GPU_CHIP_REVISION_NV_GPU_CHIP_REV_EMULATION_FPGA: _NV_GPU_CHIP_REVISION = 1; +#[doc = "!< First silicon chipset revision"] +pub const _NV_GPU_CHIP_REVISION_NV_GPU_CHIP_REV_A01: _NV_GPU_CHIP_REVISION = 17; +#[doc = "!< Second Silicon chipset revision"] +pub const _NV_GPU_CHIP_REVISION_NV_GPU_CHIP_REV_A02: _NV_GPU_CHIP_REVISION = 18; +#[doc = "!< Third Silicon chipset revision"] +pub const _NV_GPU_CHIP_REVISION_NV_GPU_CHIP_REV_A03: _NV_GPU_CHIP_REVISION = 19; +#[doc = "!< Unknown chip revision"] +pub const _NV_GPU_CHIP_REVISION_NV_GPU_CHIP_REV_UNKNOWN: _NV_GPU_CHIP_REVISION = -1; +pub type _NV_GPU_CHIP_REVISION = ::std::os::raw::c_int; +pub use self::_NV_GPU_CHIP_REVISION as NV_GPU_CHIP_REVISION; +#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetArchInfo()"] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct NV_GPU_ARCH_INFO_V2 { + pub version: NvU32, + pub __bindgen_anon_1: NV_GPU_ARCH_INFO_V2__bindgen_ty_1, + pub __bindgen_anon_2: NV_GPU_ARCH_INFO_V2__bindgen_ty_2, + pub __bindgen_anon_3: NV_GPU_ARCH_INFO_V2__bindgen_ty_3, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union NV_GPU_ARCH_INFO_V2__bindgen_ty_1 { + #[doc = "!< architecture and architecture_id are the same. The former is NvU32 while the latter is an enum made for readability."] + pub architecture: NvU32, + #[doc = "!< specifies the architecture level for the GPU."] + pub architecture_id: NV_GPU_ARCHITECTURE_ID, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union NV_GPU_ARCH_INFO_V2__bindgen_ty_2 { + #[doc = "!< implementation and implementation_id are the same. The former is NvU32 while the latter is an enum made for readability."] + pub implementation: NvU32, + #[doc = "!< specifies the implementation of the architecture for the GPU."] + pub implementation_id: NV_GPU_ARCH_IMPLEMENTATION_ID, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union NV_GPU_ARCH_INFO_V2__bindgen_ty_3 { + #[doc = "!< revision and revision_id are the same. The former is NvU32 while the latter is an enum made for readability."] + pub revision: NvU32, + #[doc = "!< specifies the architecture revision of the GPU."] + pub revision_id: NV_GPU_CHIP_REVISION, +} +#[doc = "! \\ingroup gpu"] +pub type NV_GPU_ARCH_INFO = NV_GPU_ARCH_INFO_V2; +#[doc = "!< Set i2cSpeedKhz to I2C_SPEED_DEFAULT if default I2C speed is to be chosen, ie.use the current frequency setting."] +pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_DEFAULT: NV_I2C_SPEED = 0; +pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_3KHZ: NV_I2C_SPEED = 1; +pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_10KHZ: NV_I2C_SPEED = 2; +pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_33KHZ: NV_I2C_SPEED = 3; +pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_100KHZ: NV_I2C_SPEED = 4; +pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_200KHZ: NV_I2C_SPEED = 5; +pub const NV_I2C_SPEED_NVAPI_I2C_SPEED_400KHZ: NV_I2C_SPEED = 6; +pub type NV_I2C_SPEED = ::std::os::raw::c_int; +#[doc = "! Used in NvAPI_I2CRead() and NvAPI_I2CWrite()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_I2C_INFO_V1 { + #[doc = "!< The structure version."] + pub version: NvU32, + #[doc = "!< The Display Mask of the concerned display."] + pub displayMask: NvU32, + #[doc = "!< This flag indicates either the DDC port (TRUE) or the communication port\n!< (FALSE) of the concerned display."] + pub bIsDDCPort: NvU8, + #[doc = "!< The address of the I2C slave. The address should be shifted left by one. For\n!< example, the I2C address 0x50, often used for reading EDIDs, would be stored\n!< here as 0xA0. This matches the position within the byte sent by the master, as\n!< the last bit is reserved to specify the read or write direction."] + pub i2cDevAddress: NvU8, + #[doc = "!< The I2C target register address. May be NULL, which indicates no register\n!< address should be sent."] + pub pbI2cRegAddress: *mut NvU8, + #[doc = "!< The size in bytes of target register address. If pbI2cRegAddress is NULL, this\n!< field must be 0."] + pub regAddrSize: NvU32, + #[doc = "!< The buffer of data which is to be read or written (depending on the command)."] + pub pbData: *mut NvU8, + #[doc = "!< The size of the data buffer, pbData, to be read or written."] + pub cbSize: NvU32, + #[doc = "!< The target speed of the transaction (between 28Kbps to 40Kbps; not guaranteed)."] + pub i2cSpeed: NvU32, +} +#[doc = "! Used in NvAPI_I2CRead() and NvAPI_I2CWrite()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_I2C_INFO_V2 { + #[doc = "!< The structure version."] + pub version: NvU32, + #[doc = "!< The Display Mask of the concerned display."] + pub displayMask: NvU32, + #[doc = "!< This flag indicates either the DDC port (TRUE) or the communication port\n!< (FALSE) of the concerned display."] + pub bIsDDCPort: NvU8, + #[doc = "!< The address of the I2C slave. The address should be shifted left by one. For\n!< example, the I2C address 0x50, often used for reading EDIDs, would be stored\n!< here as 0xA0. This matches the position within the byte sent by the master, as\n!< the last bit is reserved to specify the read or write direction."] + pub i2cDevAddress: NvU8, + #[doc = "!< The I2C target register address. May be NULL, which indicates no register\n!< address should be sent."] + pub pbI2cRegAddress: *mut NvU8, + #[doc = "!< The size in bytes of target register address. If pbI2cRegAddress is NULL, this\n!< field must be 0."] + pub regAddrSize: NvU32, + #[doc = "!< The buffer of data which is to be read or written (depending on the command)."] + pub pbData: *mut NvU8, + #[doc = "!< The size of the data buffer, pbData, to be read or written."] + pub cbSize: NvU32, + #[doc = "!< Deprecated, Must be set to NVAPI_I2C_SPEED_DEPRECATED."] + pub i2cSpeed: NvU32, + #[doc = "!< The target speed of the transaction in (kHz) (Chosen from the enum NV_I2C_SPEED)."] + pub i2cSpeedKhz: NV_I2C_SPEED, +} +#[doc = "! Used in NvAPI_I2CRead() and NvAPI_I2CWrite()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_I2C_INFO_V3 { + #[doc = "!< The structure version."] + pub version: NvU32, + #[doc = "!< The Display Mask of the concerned display."] + pub displayMask: NvU32, + #[doc = "!< This flag indicates either the DDC port (TRUE) or the communication port\n!< (FALSE) of the concerned display."] + pub bIsDDCPort: NvU8, + #[doc = "!< The address of the I2C slave. The address should be shifted left by one. For\n!< example, the I2C address 0x50, often used for reading EDIDs, would be stored\n!< here as 0xA0. This matches the position within the byte sent by the master, as\n!< the last bit is reserved to specify the read or write direction."] + pub i2cDevAddress: NvU8, + #[doc = "!< The I2C target register address. May be NULL, which indicates no register\n!< address should be sent."] + pub pbI2cRegAddress: *mut NvU8, + #[doc = "!< The size in bytes of target register address. If pbI2cRegAddress is NULL, this\n!< field must be 0."] + pub regAddrSize: NvU32, + #[doc = "!< The buffer of data which is to be read or written (depending on the command)."] + pub pbData: *mut NvU8, + #[doc = "!< The size of the data buffer, pbData, to be read or written."] + pub cbSize: NvU32, + #[doc = "!< Deprecated, Must be set to NVAPI_I2C_SPEED_DEPRECATED."] + pub i2cSpeed: NvU32, + #[doc = "!< The target speed of the transaction in (kHz) (Chosen from the enum NV_I2C_SPEED)."] + pub i2cSpeedKhz: NV_I2C_SPEED, + #[doc = "!< The portid on which device is connected (remember to set bIsPortIdSet if this value is set)\n!< Optional for pre-Kepler"] + pub portId: NvU8, + #[doc = "!< set this flag on if and only if portid value is set"] + pub bIsPortIdSet: NvU32, +} +#[doc = "! Used in NvAPI_I2CRead() and NvAPI_I2CWrite()"] +pub type NV_I2C_INFO = NV_I2C_INFO_V3; +pub const _NV_GPU_HDCP_FUSE_STATE_NV_GPU_HDCP_FUSE_STATE_UNKNOWN: _NV_GPU_HDCP_FUSE_STATE = 0; +pub const _NV_GPU_HDCP_FUSE_STATE_NV_GPU_HDCP_FUSE_STATE_DISABLED: _NV_GPU_HDCP_FUSE_STATE = 1; +pub const _NV_GPU_HDCP_FUSE_STATE_NV_GPU_HDCP_FUSE_STATE_ENABLED: _NV_GPU_HDCP_FUSE_STATE = 2; +#[doc = "! HDCP fuse states - used in NV_GPU_GET_HDCP_SUPPORT_STATUS"] +pub type _NV_GPU_HDCP_FUSE_STATE = ::std::os::raw::c_int; +#[doc = "! HDCP fuse states - used in NV_GPU_GET_HDCP_SUPPORT_STATUS"] +pub use self::_NV_GPU_HDCP_FUSE_STATE as NV_GPU_HDCP_FUSE_STATE; +pub const _NV_GPU_HDCP_KEY_SOURCE_NV_GPU_HDCP_KEY_SOURCE_UNKNOWN: _NV_GPU_HDCP_KEY_SOURCE = 0; +pub const _NV_GPU_HDCP_KEY_SOURCE_NV_GPU_HDCP_KEY_SOURCE_NONE: _NV_GPU_HDCP_KEY_SOURCE = 1; +pub const _NV_GPU_HDCP_KEY_SOURCE_NV_GPU_HDCP_KEY_SOURCE_CRYPTO_ROM: _NV_GPU_HDCP_KEY_SOURCE = 2; +pub const _NV_GPU_HDCP_KEY_SOURCE_NV_GPU_HDCP_KEY_SOURCE_SBIOS: _NV_GPU_HDCP_KEY_SOURCE = 3; +pub const _NV_GPU_HDCP_KEY_SOURCE_NV_GPU_HDCP_KEY_SOURCE_I2C_ROM: _NV_GPU_HDCP_KEY_SOURCE = 4; +pub const _NV_GPU_HDCP_KEY_SOURCE_NV_GPU_HDCP_KEY_SOURCE_FUSES: _NV_GPU_HDCP_KEY_SOURCE = 5; +#[doc = "! HDCP key sources - used in NV_GPU_GET_HDCP_SUPPORT_STATUS"] +pub type _NV_GPU_HDCP_KEY_SOURCE = ::std::os::raw::c_int; +#[doc = "! HDCP key sources - used in NV_GPU_GET_HDCP_SUPPORT_STATUS"] +pub use self::_NV_GPU_HDCP_KEY_SOURCE as NV_GPU_HDCP_KEY_SOURCE; +pub const _NV_GPU_HDCP_KEY_SOURCE_STATE_NV_GPU_HDCP_KEY_SOURCE_STATE_UNKNOWN: + _NV_GPU_HDCP_KEY_SOURCE_STATE = 0; +pub const _NV_GPU_HDCP_KEY_SOURCE_STATE_NV_GPU_HDCP_KEY_SOURCE_STATE_ABSENT: + _NV_GPU_HDCP_KEY_SOURCE_STATE = 1; +pub const _NV_GPU_HDCP_KEY_SOURCE_STATE_NV_GPU_HDCP_KEY_SOURCE_STATE_PRESENT: + _NV_GPU_HDCP_KEY_SOURCE_STATE = 2; +#[doc = "! HDCP key source states - used in NV_GPU_GET_HDCP_SUPPORT_STATUS"] +pub type _NV_GPU_HDCP_KEY_SOURCE_STATE = ::std::os::raw::c_int; +#[doc = "! HDCP key source states - used in NV_GPU_GET_HDCP_SUPPORT_STATUS"] +pub use self::_NV_GPU_HDCP_KEY_SOURCE_STATE as NV_GPU_HDCP_KEY_SOURCE_STATE; +#[doc = "! HDPC support status - used in NvAPI_GPU_GetHDCPSupportStatus()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_GET_HDCP_SUPPORT_STATUS { + pub version: NvU32, + #[doc = "! Structure version constucted by macro #NV_GPU_GET_HDCP_SUPPORT_STATUS"] + pub hdcpFuseState: NV_GPU_HDCP_FUSE_STATE, + #[doc = "! GPU's HDCP fuse state"] + pub hdcpKeySource: NV_GPU_HDCP_KEY_SOURCE, + #[doc = "! GPU's HDCP key source"] + pub hdcpKeySourceState: NV_GPU_HDCP_KEY_SOURCE_STATE, +} +#[doc = "! @}"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_COMPUTE_GPU_TOPOLOGY_V1 { + #[doc = "!< Structure version"] + pub version: NvU32, + #[doc = "!< Total number of compute-capable GPUs"] + pub gpuCount: NvU32, + #[doc = "!< Array of compute-capable physical GPUs."] + pub computeGpus: [NV_COMPUTE_GPU_TOPOLOGY_V1__bindgen_ty_1; 8usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_COMPUTE_GPU_TOPOLOGY_V1__bindgen_ty_1 { + #[doc = "!< Compute-capable physical GPU handle"] + pub hPhysicalGpu: NvPhysicalGpuHandle, + #[doc = "!< One or more flags from \\ref nvcomp_gpu_top"] + pub flags: NvU32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COMPUTE_GPU { + #[doc = "!< Compute-capable physical GPU handle"] + pub hPhysicalGpu: NvPhysicalGpuHandle, + #[doc = "!< One or more flags from \\ref nvcomp_gpu_top"] + pub flags: NvU32, +} +pub type NV_COMPUTE_GPU = _NV_COMPUTE_GPU; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COMPUTE_GPU_TOPOLOGY_V2 { + #[doc = "!< Structure version"] + pub version: NvU32, + #[doc = "!< Size of array"] + pub gpuCount: NvU32, + #[doc = "!< Array of compute-capable physical GPUs (allocate memory of size of Physical gpuCount of system)."] + pub computeGpus: *mut NV_COMPUTE_GPU, +} +pub type NV_COMPUTE_GPU_TOPOLOGY_V2 = _NV_COMPUTE_GPU_TOPOLOGY_V2; +pub type NV_COMPUTE_GPU_TOPOLOGY = NV_COMPUTE_GPU_TOPOLOGY_V2; +pub const _NV_ECC_CONFIGURATION_NV_ECC_CONFIGURATION_NOT_SUPPORTED: _NV_ECC_CONFIGURATION = 0; +#[doc = "!< Changes require a POST to take effect"] +pub const _NV_ECC_CONFIGURATION_NV_ECC_CONFIGURATION_DEFERRED: _NV_ECC_CONFIGURATION = 1; +#[doc = "!< Changes can optionally be made to take effect immediately"] +pub const _NV_ECC_CONFIGURATION_NV_ECC_CONFIGURATION_IMMEDIATE: _NV_ECC_CONFIGURATION = 2; +#[doc = "! \\addtogroup gpuecc\n! Used in NV_GPU_ECC_STATUS_INFO."] +pub type _NV_ECC_CONFIGURATION = ::std::os::raw::c_int; +#[doc = "! \\addtogroup gpuecc\n! Used in NV_GPU_ECC_STATUS_INFO."] +pub use self::_NV_ECC_CONFIGURATION as NV_ECC_CONFIGURATION; +#[doc = "! \\ingroup gpuecc\n! Used in NvAPI_GPU_GetECCStatusInfo()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_ECC_STATUS_INFO { + #[doc = "!< Structure version"] + pub version: NvU32, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + #[doc = "!< Supported ECC memory feature configuration options"] + pub configurationOptions: NV_ECC_CONFIGURATION, + pub _bitfield_align_2: [u8; 0], + pub _bitfield_2: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +impl NV_GPU_ECC_STATUS_INFO { + #[inline] + pub fn isSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1(isSupported: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isSupported: u32 = unsafe { ::std::mem::transmute(isSupported) }; + isSupported as u64 + }); + __bindgen_bitfield_unit + } + #[inline] + pub fn isEnabled(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isEnabled(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_2.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isEnabled_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_2), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isEnabled_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_2(isEnabled: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isEnabled: u32 = unsafe { ::std::mem::transmute(isEnabled) }; + isEnabled as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup gpuecc\n! Used in NvAPI_GPU_GetECCErrorInfo()/"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_ECC_ERROR_INFO { + #[doc = "!< Structure version"] + pub version: NvU32, + pub current: NV_GPU_ECC_ERROR_INFO__bindgen_ty_1, + pub aggregate: NV_GPU_ECC_ERROR_INFO__bindgen_ty_2, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_ECC_ERROR_INFO__bindgen_ty_1 { + #[doc = "!< Number of single-bit ECC errors detected since last boot"] + pub singleBitErrors: NvU64, + #[doc = "!< Number of double-bit ECC errors detected since last boot"] + pub doubleBitErrors: NvU64, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_ECC_ERROR_INFO__bindgen_ty_2 { + #[doc = "!< Number of single-bit ECC errors detected since last counter reset"] + pub singleBitErrors: NvU64, + #[doc = "!< Number of double-bit ECC errors detected since last counter reset"] + pub doubleBitErrors: NvU64, +} +#[doc = "! \\ingroup gpuecc\n! Used in NvAPI_GPU_GetECCConfigurationInfo()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_ECC_CONFIGURATION_INFO { + pub version: NvU32, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +impl NV_GPU_ECC_CONFIGURATION_INFO { + #[inline] + pub fn isEnabled(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isEnabled(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isEnabled_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isEnabled_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isEnabledByDefault(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isEnabledByDefault(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isEnabledByDefault_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isEnabledByDefault_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isEnabled: NvU32, + isEnabledByDefault: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isEnabled: u32 = unsafe { ::std::mem::transmute(isEnabled) }; + isEnabled as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isEnabledByDefault: u32 = unsafe { ::std::mem::transmute(isEnabledByDefault) }; + isEnabledByDefault as u64 + }); + __bindgen_bitfield_unit + } +} +pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_NONE: NV_QSYNC_EVENT = 0; +pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_SYNC_LOSS: NV_QSYNC_EVENT = 1; +pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_SYNC_GAIN: NV_QSYNC_EVENT = 2; +pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_HOUSESYNC_GAIN: NV_QSYNC_EVENT = 3; +pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_HOUSESYNC_LOSS: NV_QSYNC_EVENT = 4; +pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_RJ45_GAIN: NV_QSYNC_EVENT = 5; +pub const NV_QSYNC_EVENT_NV_QSYNC_EVENT_RJ45_LOSS: NV_QSYNC_EVENT = 6; +pub type NV_QSYNC_EVENT = ::std::os::raw::c_int; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_QSYNC_EVENT_DATA { + pub qsyncEvent: NV_QSYNC_EVENT, + pub reserved: [NvU32; 7usize], +} +#[doc = "! Callback for QSYNC event"] +pub type NVAPI_CALLBACK_QSYNCEVENT = ::std::option::Option< + unsafe extern "C" fn( + qyncEventData: NV_QSYNC_EVENT_DATA, + callbackParam: *mut ::std::os::raw::c_void, + ), +>; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_DISPLAY_OUTPUT_MODE_CHANGE_EVENT_DATA { + #[doc = "!< displayId of the display"] + pub displayId: NvU32, + #[doc = "!< display output mode"] + pub outputMode: NvU32, +} +pub type NV_DISPLAY_OUTPUT_MODE_CHANGE_EVENT_DATA = _NV_DISPLAY_OUTPUT_MODE_CHANGE_EVENT_DATA; +#[doc = "! Callback for Display Output Mode change events"] +pub type NVAPI_CALLBACK_DISPLAY_OUTPUT_MODE_CHANGE_EVENT = ::std::option::Option< + unsafe extern "C" fn( + pEventData: *mut NV_DISPLAY_OUTPUT_MODE_CHANGE_EVENT_DATA, + callbackParam: *mut ::std::os::raw::c_void, + ), +>; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_DISPLAY_COLORIMETRY_CHANGE_EVENT_DATA { + #[doc = "!< displayId of the monitor"] + pub displayId: NvU32, + #[doc = "!< min luminance, cd/m^2"] + pub min_luminance: f32, + #[doc = "!< max 100% frame luminance, cd/m^2"] + pub max_full_frame_luminance: f32, + #[doc = "!< max 10% frame luminance, cd/m^2"] + pub max_luminance: f32, + #[doc = "!< HDR brightness luminance scaling factor applied by GPU on output pixels"] + pub hdrBrightnessLuminanceScalingFactor: f32, + #[doc = "!< red primary chromaticity coordinate x"] + pub red_primary_x: f32, + #[doc = "!< red primary chromaticity coordinate y"] + pub red_primary_y: f32, + #[doc = "!< green primary chromaticity coordinate x"] + pub green_primary_x: f32, + #[doc = "!< green primary chromaticity coordinate y"] + pub green_primary_y: f32, + #[doc = "!< blue primary chromaticity coordinate x"] + pub blue_primary_x: f32, + #[doc = "!< blue primary chromaticity coordinate y"] + pub blue_primary_y: f32, + #[doc = "!< white point chromaticity coordinate x"] + pub white_point_x: f32, + #[doc = "!< white point chromaticity coordinate y"] + pub white_point_y: f32, +} +pub type NV_DISPLAY_COLORIMETRY_CHANGE_EVENT_DATA = _NV_DISPLAY_COLORIMETRY_CHANGE_EVENT_DATA; +#[doc = "! Callback for Display Colorimetry change events"] +pub type NVAPI_CALLBACK_DISPLAY_COLORIMETRY_CHANGE_EVENT = ::std::option::Option< + unsafe extern "C" fn( + pEventData: *mut NV_DISPLAY_COLORIMETRY_CHANGE_EVENT_DATA, + callbackParam: *mut ::std::os::raw::c_void, + ), +>; +pub const NV_EVENT_TYPE_NV_EVENT_TYPE_NONE: NV_EVENT_TYPE = 0; +pub const NV_EVENT_TYPE_NV_EVENT_TYPE_QSYNC: NV_EVENT_TYPE = 6; +pub const NV_EVENT_TYPE_NV_EVENT_TYPE_DISPLAY_OUTPUT_MODE_CHANGE: NV_EVENT_TYPE = 103; +pub const NV_EVENT_TYPE_NV_EVENT_TYPE_DISPLAY_COLORIMETRY_CHANGE: NV_EVENT_TYPE = 104; +#[doc = "! Enum for Event IDs"] +pub type NV_EVENT_TYPE = ::std::os::raw::c_int; +#[doc = "! Core NV_EVENT_REGISTER_CALLBACK structure declaration"] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct NV_EVENT_REGISTER_CALLBACK { + #[doc = "!< version field to ensure minimum version compatibility"] + pub version: NvU32, + #[doc = "!< ID of the event being sent"] + pub eventId: NV_EVENT_TYPE, + #[doc = "!< This value will be passed back to the callback function when an event occurs"] + pub callbackParam: *mut ::std::os::raw::c_void, + pub nvCallBackFunc: NV_EVENT_REGISTER_CALLBACK__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union NV_EVENT_REGISTER_CALLBACK__bindgen_ty_1 { + #[doc = "!< Callback function pointer for QSYNC events"] + pub nvQSYNCEventCallback: NVAPI_CALLBACK_QSYNCEVENT, + #[doc = "!< Callback function pointer for Display Output Mode change events"] + pub nvDisplayOutputModeChangeEventCallback: NVAPI_CALLBACK_DISPLAY_OUTPUT_MODE_CHANGE_EVENT, + #[doc = "!< Callback function pointer for Display Colorimetry change events"] + pub nvDisplayColorimetryChangeEventCallback: NVAPI_CALLBACK_DISPLAY_COLORIMETRY_CHANGE_EVENT, +} +#[doc = "!< NVIDIA RTX VR Ready"] +pub const _NV_GPU_WORKSTATION_FEATURE_TYPE_NV_GPU_WORKSTATION_FEATURE_TYPE_NVIDIA_RTX_VR_READY: + _NV_GPU_WORKSTATION_FEATURE_TYPE = 1; +#[doc = "!< DEPRECATED name - do not use"] +pub const _NV_GPU_WORKSTATION_FEATURE_TYPE_NV_GPU_WORKSTATION_FEATURE_TYPE_QUADRO_VR_READY: + _NV_GPU_WORKSTATION_FEATURE_TYPE = 1; +pub const _NV_GPU_WORKSTATION_FEATURE_TYPE_NV_GPU_WORKSTATION_FEATURE_TYPE_PROVIZ: + _NV_GPU_WORKSTATION_FEATURE_TYPE = 2; +#[doc = "! \\ingroup gpu"] +pub type _NV_GPU_WORKSTATION_FEATURE_TYPE = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpu"] +pub use self::_NV_GPU_WORKSTATION_FEATURE_TYPE as NV_GPU_WORKSTATION_FEATURE_TYPE; +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_SCANOUT_INTENSITY_DATA_V1 { + #[doc = "!< version of this structure"] + pub version: NvU32, + #[doc = "!< width of the input texture"] + pub width: NvU32, + #[doc = "!< height of the input texture"] + pub height: NvU32, + #[doc = "!< array of floating values building an intensity RGB texture"] + pub blendingTexture: *mut f32, +} +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_SCANOUT_INTENSITY_DATA_V2 { + #[doc = "!< version of this structure"] + pub version: NvU32, + #[doc = "!< width of the input texture"] + pub width: NvU32, + #[doc = "!< height of the input texture"] + pub height: NvU32, + #[doc = "!< array of floating values building an intensity RGB texture"] + pub blendingTexture: *mut f32, + #[doc = "!< array of floating values building an offset texture"] + pub offsetTexture: *mut f32, + #[doc = "!< number of channels per pixel in the offset texture"] + pub offsetTexChannels: NvU32, +} +#[doc = "! \\ingroup gpu"] +pub type NV_SCANOUT_INTENSITY_DATA = NV_SCANOUT_INTENSITY_DATA_V2; +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_SCANOUT_INTENSITY_STATE_DATA { + #[doc = "!< version of this structure"] + pub version: NvU32, + #[doc = "!< intensity is enabled or not"] + pub bEnabled: NvU32, +} +#[doc = "! \\ingroup gpu"] +pub type NV_SCANOUT_INTENSITY_STATE_DATA = _NV_SCANOUT_INTENSITY_STATE_DATA; +pub const NV_GPU_WARPING_VERTICE_FORMAT_NV_GPU_WARPING_VERTICE_FORMAT_TRIANGLESTRIP_XYUVRQ: + NV_GPU_WARPING_VERTICE_FORMAT = 0; +pub const NV_GPU_WARPING_VERTICE_FORMAT_NV_GPU_WARPING_VERTICE_FORMAT_TRIANGLES_XYUVRQ: + NV_GPU_WARPING_VERTICE_FORMAT = 1; +#[doc = "! \\ingroup gpu"] +pub type NV_GPU_WARPING_VERTICE_FORMAT = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_SCANOUT_WARPING_DATA { + #[doc = "!< version of this structure"] + pub version: NvU32, + #[doc = "!< width of the input texture"] + pub vertices: *mut f32, + #[doc = "!< format of the input vertices"] + pub vertexFormat: NV_GPU_WARPING_VERTICE_FORMAT, + #[doc = "!< number of the input vertices"] + pub numVertices: ::std::os::raw::c_int, + #[doc = "!< rectangle in desktop coordinates describing the source area for the warping"] + pub textureRect: *mut NvSBox, +} +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_SCANOUT_WARPING_STATE_DATA { + #[doc = "!< version of this structure"] + pub version: NvU32, + #[doc = "!< warping is enabled or not"] + pub bEnabled: NvU32, +} +#[doc = "! \\ingroup gpu"] +pub type NV_SCANOUT_WARPING_STATE_DATA = _NV_SCANOUT_WARPING_STATE_DATA; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_WARPING_RESAMPLING_METHOD : NV_GPU_SCANOUT_COMPOSITION_PARAMETER = 0 ; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_SCANOUT_INTENSITY_METHOD : NV_GPU_SCANOUT_COMPOSITION_PARAMETER = 1 ; +pub type NV_GPU_SCANOUT_COMPOSITION_PARAMETER = ::std::os::raw::c_int; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_SET_TO_DEFAULT : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 0 ; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BILINEAR : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 256 ; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_TRIANGULAR : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 257 ; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_BELL_SHAPED : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 258 ; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_BSPLINE : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 259 ; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_ADAPTIVE_TRIANGULAR : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 260 ; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_ADAPTIVE_BELL_SHAPED : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 261 ; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_ADAPTIVE_BSPLINE : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 262 ; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_SCANOUT_INTENSITY_NO_GAMMA : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 512 ; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_SCANOUT_INTENSITY_COLOR_GAMMA : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 513 ; +pub const NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_SCANOUT_INTENSITY_COLOR_AND_OFFSET_GAMMA : NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = 514 ; +#[doc = "! This enum defines a collection of scanout composition values that can be used to configure\n! the supported scanout composition settings"] +pub type NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetScanoutConfigurationEx()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_SCANOUT_INFORMATION { + #[doc = "!< Structure version, needs to be initialized with NV_SCANOUT_INFORMATION_VER."] + pub version: NvU32, + #[doc = "!< Operating system display device rect in desktop coordinates displayId is scanning out from."] + pub sourceDesktopRect: NvSBox, + #[doc = "!< Area inside the sourceDesktopRect which is scanned out to the display."] + pub sourceViewportRect: NvSBox, + #[doc = "!< Area inside the rect described by targetDisplayWidth/Height sourceViewportRect is scanned out to."] + pub targetViewportRect: NvSBox, + #[doc = "!< Horizontal size of the active resolution scanned out to the display."] + pub targetDisplayWidth: NvU32, + #[doc = "!< Vertical size of the active resolution scanned out to the display."] + pub targetDisplayHeight: NvU32, + #[doc = "!< If targets are cloned views of the sourceDesktopRect the cloned targets have an importance assigned (0:primary,1 secondary,...)."] + pub cloneImportance: NvU32, + #[doc = "!< Rotation performed between the sourceViewportRect and the targetViewportRect."] + pub sourceToTargetRotation: NV_ROTATE, +} +#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetScanoutConfigurationEx()."] +pub type NV_SCANOUT_INFORMATION = _NV_SCANOUT_INFORMATION; +#[doc = "!< Represents Bare Metal GPU"] +pub const _NV_VIRTUALIZATION_MODE_NV_VIRTUALIZATION_MODE_NONE: _NV_VIRTUALIZATION_MODE = 0; +#[doc = "!< Represents GPU-Passthrough"] +pub const _NV_VIRTUALIZATION_MODE_NV_VIRTUALIZATION_MODE_NMOS: _NV_VIRTUALIZATION_MODE = 1; +#[doc = "!< Represents vGPU inside virtual machine"] +pub const _NV_VIRTUALIZATION_MODE_NV_VIRTUALIZATION_MODE_VGX: _NV_VIRTUALIZATION_MODE = 2; +#[doc = "!< Represents VGX hypervisor in vGPU mode"] +pub const _NV_VIRTUALIZATION_MODE_NV_VIRTUALIZATION_MODE_HOST_VGPU: _NV_VIRTUALIZATION_MODE = 3; +#[doc = "! \\ingroup gpu"] +pub type _NV_VIRTUALIZATION_MODE = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpu"] +pub use self::_NV_VIRTUALIZATION_MODE as NV_VIRTUALIZATION_MODE; +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_VIRTUALIZATION_INFO { + #[doc = "!< Structure version"] + pub version: NvU32, + #[doc = "!< one of NV_VIRTUALIZATION_MODE."] + pub virtualizationMode: NV_VIRTUALIZATION_MODE, + #[doc = "!< reserved for future use. Should be set to ZERO."] + pub reserved: NvU32, +} +#[doc = "! \\ingroup gpu"] +pub type NV_GPU_VIRTUALIZATION_INFO_V1 = _NV_GPU_VIRTUALIZATION_INFO; +#[doc = "! \\ingroup gpu"] +pub type NV_GPU_VIRTUALIZATION_INFO = NV_GPU_VIRTUALIZATION_INFO_V1; +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LOGICAL_GPU_DATA_V1 { + #[doc = "!< [in] Structure version."] + pub version: NvU32, + #[doc = "!< [out] Returns OS-AdapterId. User must send memory buffer of size atleast equal to the size of LUID structure before calling the NVAPI."] + pub pOSAdapterId: *mut ::std::os::raw::c_void, + #[doc = "!< [out] Number of physical GPU handles associated with the specified logical GPU handle."] + pub physicalGpuCount: NvU32, + #[doc = "!< [out] This array will be filled with physical GPU handles associated with the given logical GPU handle.\n!< The array index refers to the Physical Gpu Index (Idx).\n!< Idx value is the same as D3D11 MultiGPUDevice GPU index, D3D12 node index, OpenGL GL_NV_gpu_multicast GPU index.\n!< When converted to a bit mask (1 << Idx), it matches:\n!< 1. Vulkan deviceNodeMask in VkPhysicalDeviceIDProperties\n!< 2. CUDA deviceNodeMask returned by cuDeviceGetLuid"] + pub physicalGpuHandles: [NvPhysicalGpuHandle; 64usize], + #[doc = "!< Reserved for future use. Should be set to ZERO."] + pub reserved: [NvU32; 8usize], +} +#[doc = "! \\ingroup gpu"] +pub type NV_LOGICAL_GPU_DATA_V1 = _NV_LOGICAL_GPU_DATA_V1; +#[doc = "! \\ingroup gpu"] +pub type NV_LOGICAL_GPU_DATA = NV_LOGICAL_GPU_DATA_V1; +#[doc = "! License string"] +pub type NvAPI_LicenseString = [::std::os::raw::c_char; 128usize]; +pub const _NV_LICENSE_FEATURE_TYPE_NV_LICENSE_FEATURE_UNKNOWN: _NV_LICENSE_FEATURE_TYPE = 0; +pub const _NV_LICENSE_FEATURE_TYPE_NV_LICENSE_FEATURE_VGPU: _NV_LICENSE_FEATURE_TYPE = 1; +pub const _NV_LICENSE_FEATURE_TYPE_NV_LICENSE_FEATURE_NVIDIA_RTX: _NV_LICENSE_FEATURE_TYPE = 2; +#[doc = "!< DEPRECATED name - do not use"] +pub const _NV_LICENSE_FEATURE_TYPE_NV_LICENSE_FEATURE_QUADRO: _NV_LICENSE_FEATURE_TYPE = 2; +pub const _NV_LICENSE_FEATURE_TYPE_NV_LICENSE_FEATURE_GAMING: _NV_LICENSE_FEATURE_TYPE = 3; +pub const _NV_LICENSE_FEATURE_TYPE_NV_LICENSE_FEATURE_COMPUTE: _NV_LICENSE_FEATURE_TYPE = 4; +#[doc = "! Used in NV_LICENSE_FEATURE_DETAILS"] +pub type _NV_LICENSE_FEATURE_TYPE = ::std::os::raw::c_int; +#[doc = "! Used in NV_LICENSE_FEATURE_DETAILS"] +pub use self::_NV_LICENSE_FEATURE_TYPE as NV_LICENSE_FEATURE_TYPE; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LICENSE_EXPIRY_DETAILS { + #[doc = "!< Year value of license expiry"] + pub year: NvU32, + #[doc = "!< Month value of license expiry"] + pub month: NvU16, + #[doc = "!< Day value of license expiry"] + pub day: NvU16, + #[doc = "!< Hour value of license expiry"] + pub hour: NvU16, + #[doc = "!< Minutes value of license expiry"] + pub min: NvU16, + #[doc = "!< Seconds value of license expiry"] + pub sec: NvU16, + #[doc = "!< License expiry status"] + pub status: NvU8, +} +pub type NV_LICENSE_EXPIRY_DETAILS = _NV_LICENSE_EXPIRY_DETAILS; +#[doc = "! Used in NV_LICENSABLE_FEATURES"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LICENSE_FEATURE_DETAILS_V1 { + #[doc = "!< IN - Structure version."] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Feature code that corresponds to the licensable feature."] + pub featureCode: NV_LICENSE_FEATURE_TYPE, + #[doc = "!< Deprecated"] + pub licenseInfo: NvAPI_LicenseString, +} +impl _NV_LICENSE_FEATURE_DETAILS_V1 { + #[inline] + pub fn isEnabled(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isEnabled(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isEnabled_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isEnabled_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isEnabled: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isEnabled: u32 = unsafe { ::std::mem::transmute(isEnabled) }; + isEnabled as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! Used in NV_LICENSABLE_FEATURES"] +pub type NV_LICENSE_FEATURE_DETAILS_V1 = _NV_LICENSE_FEATURE_DETAILS_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LICENSE_FEATURE_DETAILS_V2 { + #[doc = "!< Unused."] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Feature code that corresponds to the licensable feature."] + pub featureCode: NV_LICENSE_FEATURE_TYPE, + #[doc = "!< Deprecated"] + pub licenseInfo: NvAPI_LicenseString, + #[doc = "!< Nvidia Grid licensable product name."] + pub productName: NvAPI_LicenseString, +} +impl _NV_LICENSE_FEATURE_DETAILS_V2 { + #[inline] + pub fn isEnabled(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isEnabled(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isEnabled_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isEnabled_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isEnabled: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isEnabled: u32 = unsafe { ::std::mem::transmute(isEnabled) }; + isEnabled as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_LICENSE_FEATURE_DETAILS_V2 = _NV_LICENSE_FEATURE_DETAILS_V2; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LICENSE_FEATURE_DETAILS_V3 { + #[doc = "!< Unused."] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Feature code that corresponds to the licensable feature."] + pub featureCode: NV_LICENSE_FEATURE_TYPE, + #[doc = "!< Deprecated"] + pub licenseInfo: NvAPI_LicenseString, + #[doc = "!< Nvidia Grid licensable product name."] + pub productName: NvAPI_LicenseString, +} +impl _NV_LICENSE_FEATURE_DETAILS_V3 { + #[inline] + pub fn isEnabled(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isEnabled(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isEnabled_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isEnabled_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isFeatureEnabled(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isFeatureEnabled(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isFeatureEnabled_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isFeatureEnabled_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 30u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 30u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 30u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isEnabled: NvU32, + isFeatureEnabled: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isEnabled: u32 = unsafe { ::std::mem::transmute(isEnabled) }; + isEnabled as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isFeatureEnabled: u32 = unsafe { ::std::mem::transmute(isFeatureEnabled) }; + isFeatureEnabled as u64 + }); + __bindgen_bitfield_unit.set(2usize, 30u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_LICENSE_FEATURE_DETAILS_V3 = _NV_LICENSE_FEATURE_DETAILS_V3; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LICENSE_FEATURE_DETAILS_V4 { + #[doc = "!< Unused."] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Feature code that corresponds to the licensable feature."] + pub featureCode: NV_LICENSE_FEATURE_TYPE, + #[doc = "!< Deprecated"] + pub licenseInfo: NvAPI_LicenseString, + #[doc = "!< Nvidia Grid licensable product name."] + pub productName: NvAPI_LicenseString, + #[doc = "!< License expiry information."] + pub licenseExpiry: NV_LICENSE_EXPIRY_DETAILS, +} +impl _NV_LICENSE_FEATURE_DETAILS_V4 { + #[inline] + pub fn isEnabled(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isEnabled(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isEnabled_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isEnabled_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isFeatureEnabled(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isFeatureEnabled(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isFeatureEnabled_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isFeatureEnabled_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 30u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 30u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 30u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isEnabled: NvU32, + isFeatureEnabled: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isEnabled: u32 = unsafe { ::std::mem::transmute(isEnabled) }; + isEnabled as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isFeatureEnabled: u32 = unsafe { ::std::mem::transmute(isFeatureEnabled) }; + isFeatureEnabled as u64 + }); + __bindgen_bitfield_unit.set(2usize, 30u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_LICENSE_FEATURE_DETAILS_V4 = _NV_LICENSE_FEATURE_DETAILS_V4; +#[doc = "! Used in NV_LICENSABLE_FEATURES"] +pub type NV_LICENSE_FEATURE_DETAILS = NV_LICENSE_FEATURE_DETAILS_V1; +#[doc = "! Licensable features"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LICENSABLE_FEATURES_V1 { + #[doc = "!< IN - Structure version."] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< The number of licensable features."] + pub licensableFeatureCount: NvU32, + #[doc = "!< Dynamic signature required for Authentication of the components,\n!< signature length limited to NV_LICENSE_SIGNATURE_SIZE"] + pub signature: [NvU8; 128usize], + #[doc = "!< Array of licensable features"] + pub licenseDetails: [NV_LICENSE_FEATURE_DETAILS_V1; 3usize], +} +impl _NV_LICENSABLE_FEATURES_V1 { + #[inline] + pub fn isLicenseSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isLicenseSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isLicenseSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isLicenseSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isLicenseSupported: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isLicenseSupported: u32 = unsafe { ::std::mem::transmute(isLicenseSupported) }; + isLicenseSupported as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! Licensable features"] +pub type NV_LICENSABLE_FEATURES_V1 = _NV_LICENSABLE_FEATURES_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LICENSABLE_FEATURES_V2 { + #[doc = "!< IN - Structure version."] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< The number of licensable features."] + pub licensableFeatureCount: NvU32, + #[doc = "!< Dynamic signature required for Authentication of the components,\n!< signature length limited to NV_LICENSE_SIGNATURE_SIZE"] + pub signature: [NvU8; 128usize], + #[doc = "!< Array of licensable features"] + pub licenseDetails: [NV_LICENSE_FEATURE_DETAILS_V2; 3usize], +} +impl _NV_LICENSABLE_FEATURES_V2 { + #[inline] + pub fn isLicenseSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isLicenseSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isLicenseSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isLicenseSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isLicenseSupported: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isLicenseSupported: u32 = unsafe { ::std::mem::transmute(isLicenseSupported) }; + isLicenseSupported as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_LICENSABLE_FEATURES_V2 = _NV_LICENSABLE_FEATURES_V2; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LICENSABLE_FEATURES_V3 { + #[doc = "!< IN - Structure version."] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< The number of licensable features."] + pub licensableFeatureCount: NvU32, + #[doc = "!< Dynamic signature required for Authentication of the components,\n!< signature length limited to NV_LICENSE_SIGNATURE_SIZE"] + pub signature: [NvU8; 128usize], + #[doc = "!< Array of licensable features"] + pub licenseDetails: [NV_LICENSE_FEATURE_DETAILS_V3; 3usize], +} +impl _NV_LICENSABLE_FEATURES_V3 { + #[inline] + pub fn isLicenseSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isLicenseSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isLicenseSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isLicenseSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isLicenseSupported: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isLicenseSupported: u32 = unsafe { ::std::mem::transmute(isLicenseSupported) }; + isLicenseSupported as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_LICENSABLE_FEATURES_V3 = _NV_LICENSABLE_FEATURES_V3; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LICENSABLE_FEATURES_V4 { + #[doc = "!< IN - Structure version."] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< The number of licensable features."] + pub licensableFeatureCount: NvU32, + #[doc = "!< Dynamic signature required for Authentication of the components,\n!< signature length limited to NV_LICENSE_SIGNATURE_SIZE"] + pub signature: [NvU8; 128usize], + #[doc = "!< Array of licensable features"] + pub licenseDetails: [NV_LICENSE_FEATURE_DETAILS_V4; 3usize], +} +impl _NV_LICENSABLE_FEATURES_V4 { + #[inline] + pub fn isLicenseSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isLicenseSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isLicenseSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isLicenseSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isLicenseSupported: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isLicenseSupported: u32 = unsafe { ::std::mem::transmute(isLicenseSupported) }; + isLicenseSupported as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_LICENSABLE_FEATURES_V4 = _NV_LICENSABLE_FEATURES_V4; +pub type NV_LICENSABLE_FEATURES = NV_LICENSABLE_FEATURES_V4; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_ENCODER_STATISTICS_V1 { + #[doc = "!< [in] Structure version value."] + pub version: NvU32, + #[doc = "!< [out] Count of active encoder sessions."] + pub sessionsCount: NvU32, + #[doc = "!< [out] Trailing average FPS of all active sessions."] + pub averageFps: NvU32, + #[doc = "!< [out] Encode latency in microseconds."] + pub averageLatency: NvU32, +} +pub type NV_ENCODER_STATISTICS_V1 = _NV_ENCODER_STATISTICS_V1; +pub type NV_ENCODER_STATISTICS = NV_ENCODER_STATISTICS_V1; +pub const _NV_ENCODER_TYPE_NV_ENCODER_H264: _NV_ENCODER_TYPE = 0; +pub const _NV_ENCODER_TYPE_NV_ENCODER_HEVC: _NV_ENCODER_TYPE = 1; +pub const _NV_ENCODER_TYPE_NV_ENCODER_UNKNOWN: _NV_ENCODER_TYPE = -1; +pub type _NV_ENCODER_TYPE = ::std::os::raw::c_int; +pub use self::_NV_ENCODER_TYPE as NV_ENCODER_TYPE; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_ENCODER_PER_SESSION_INFO_V1 { + #[doc = "!< Unique session ID."] + pub sessionId: NvU32, + #[doc = "!< Owning process ID."] + pub processId: NvU32, + #[doc = "!< Owning vGPU instance ID (only valid on vGPU hosts, otherwise zero)."] + pub vgpuInstance: NvU32, + #[doc = "!< Video encoder type."] + pub codecType: NV_ENCODER_TYPE, + #[doc = "!< Current encode horizontal resolution."] + pub hResolution: NvU32, + #[doc = "!< Current encode vertical resolution."] + pub vResolution: NvU32, + #[doc = "!< Moving average encode frames per second."] + pub averageEncodeFps: NvU32, + #[doc = "!< Moving average encode latency in microseconds."] + pub averageEncodeLatency: NvU32, +} +pub type NV_ENCODER_PER_SESSION_INFO_V1 = _NV_ENCODER_PER_SESSION_INFO_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_ENCODER_SESSIONS_INFO_V1 { + #[doc = "!< [in] Structure version value."] + pub version: NvU32, + #[doc = "!< [out] Count of active encoder sessions."] + pub sessionsCount: NvU32, + #[doc = "!< [out] Array of session info. Caller should allocate memory for this field before making\n!< the NvAPI_GPU_GetEncoderSessionsInfo() call, memory allocated should be of\n!< size = sizeof(NV_ENCODER_PER_SESSION_INFO_V1) * NV_ENCODER_SESSION_INFO_MAX_ENTRIES_V1."] + pub pSessionInfo: *mut NV_ENCODER_PER_SESSION_INFO_V1, +} +pub type NV_ENCODER_SESSIONS_INFO_V1 = _NV_ENCODER_SESSIONS_INFO_V1; +pub type NV_ENCODER_SESSIONS_INFO = NV_ENCODER_SESSIONS_INFO_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_INFO_V1 { + #[doc = "!< Structure Version."] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl _NV_GPU_INFO_V1 { + #[inline] + pub fn bIsExternalGpu(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsExternalGpu(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsExternalGpu_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsExternalGpu_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsExternalGpu: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsExternalGpu: u32 = unsafe { ::std::mem::transmute(bIsExternalGpu) }; + bIsExternalGpu as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_GPU_INFO_V1 = _NV_GPU_INFO_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_INFO_V2 { + #[doc = "!< Structure Version."] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Reserved for future use"] + pub reserved1: NvU64, + #[doc = "!< Number of \"Ray Tracing Cores\" supported by the GPU."] + pub rayTracingCores: NvU32, + #[doc = "!< Number of \"Tensor Cores\" supported by the GPU."] + pub tensorCores: NvU32, + #[doc = "!< Reserved for future use."] + pub reserved2: [NvU32; 14usize], +} +impl _NV_GPU_INFO_V2 { + #[inline] + pub fn bIsExternalGpu(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsExternalGpu(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsExternalGpu_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsExternalGpu_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved0(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved0(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved0_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved0_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsExternalGpu: NvU32, + reserved0: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsExternalGpu: u32 = unsafe { ::std::mem::transmute(bIsExternalGpu) }; + bIsExternalGpu as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved0: u32 = unsafe { ::std::mem::transmute(reserved0) }; + reserved0 as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_GPU_INFO_V2 = _NV_GPU_INFO_V2; +pub type NV_GPU_INFO = NV_GPU_INFO_V2; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_VR_READY_V1 { + #[doc = "!< Structure Version."] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl _NV_GPU_VR_READY_V1 { + #[inline] + pub fn isVRReady(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isVRReady(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isVRReady_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isVRReady_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isVRReady: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isVRReady: u32 = unsafe { ::std::mem::transmute(isVRReady) }; + isVRReady as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_GPU_VR_READY_V1 = _NV_GPU_VR_READY_V1; +pub type NV_GPU_VR_READY = NV_GPU_VR_READY_V1; +pub const _NV_ADAPTER_TYPE_NV_ADAPTER_TYPE_UNKNOWN: _NV_ADAPTER_TYPE = 0; +pub const _NV_ADAPTER_TYPE_NV_ADAPTER_TYPE_WDDM: _NV_ADAPTER_TYPE = 1; +pub const _NV_ADAPTER_TYPE_NV_ADAPTER_TYPE_MCDM: _NV_ADAPTER_TYPE = 2; +pub const _NV_ADAPTER_TYPE_NV_ADAPTER_TYPE_TCC: _NV_ADAPTER_TYPE = 4; +pub const _NV_ADAPTER_TYPE_NV_ADAPTER_TYPE_LAST: _NV_ADAPTER_TYPE = -1; +pub type _NV_ADAPTER_TYPE = ::std::os::raw::c_int; +pub use self::_NV_ADAPTER_TYPE as NV_ADAPTER_TYPE; +#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetGspFeatures()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_GSP_INFO_V1 { + #[doc = "!< [in] Structure version"] + pub version: NvU32, + #[doc = "!< [out] Contains GSP firmware version"] + pub firmwareVersion: [NvU8; 64usize], + #[doc = "!< Reserved for future use"] + pub reserved: NvU32, +} +#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetGspFeatures()."] +pub type NV_GPU_GSP_INFO_V1 = _NV_GPU_GSP_INFO_V1; +#[doc = "! \\ingroup gpu\n! Used in NvAPI_GPU_GetGspFeatures()."] +pub type NV_GPU_GSP_INFO = NV_GPU_GSP_INFO_V1; +#[doc = "! \\fn NvAPI_GPU_GetUUID(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_UUID *pGpuUuid)\n! DESCRIPTION: This function returns the GPU UUID for the specified physical GPU handle.\n! The UUID is returned in GUID format (16 bytes).\n!\n! SUPPORTED OS: Windows 10 and higher\n!\n!\n! TCC_SUPPORTED\n!\n! MCDM_SUPPORTED\n!\n! \\since Release: 595\n!\n! \\param [in] hPhysicalGpu Physical GPU handle to get UUID for\n! \\param [in,out] pGpuUuid Pointer to structure that will receive the GPU UUID\n!\n! \\retval NVAPI_OK Request completed successfully\n! \\return This API can return any of the error codes enumerated in #NvAPI_Status.\n!\n! \\ingroup gpu\n\n! Used in NvAPI_GPU_GetUUID()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_UUID_V1 { + pub version: NvU32, + pub uuid: [NvU8; 16usize], +} +#[doc = "! \\fn NvAPI_GPU_GetUUID(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_UUID *pGpuUuid)\n! DESCRIPTION: This function returns the GPU UUID for the specified physical GPU handle.\n! The UUID is returned in GUID format (16 bytes).\n!\n! SUPPORTED OS: Windows 10 and higher\n!\n!\n! TCC_SUPPORTED\n!\n! MCDM_SUPPORTED\n!\n! \\since Release: 595\n!\n! \\param [in] hPhysicalGpu Physical GPU handle to get UUID for\n! \\param [in,out] pGpuUuid Pointer to structure that will receive the GPU UUID\n!\n! \\retval NVAPI_OK Request completed successfully\n! \\return This API can return any of the error codes enumerated in #NvAPI_Status.\n!\n! \\ingroup gpu\n\n! Used in NvAPI_GPU_GetUUID()"] +pub type NV_GPU_UUID_V1 = _NV_GPU_UUID_V1; +#[doc = "! \\fn NvAPI_GPU_GetUUID(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_UUID *pGpuUuid)\n! DESCRIPTION: This function returns the GPU UUID for the specified physical GPU handle.\n! The UUID is returned in GUID format (16 bytes).\n!\n! SUPPORTED OS: Windows 10 and higher\n!\n!\n! TCC_SUPPORTED\n!\n! MCDM_SUPPORTED\n!\n! \\since Release: 595\n!\n! \\param [in] hPhysicalGpu Physical GPU handle to get UUID for\n! \\param [in,out] pGpuUuid Pointer to structure that will receive the GPU UUID\n!\n! \\retval NVAPI_OK Request completed successfully\n! \\return This API can return any of the error codes enumerated in #NvAPI_Status.\n!\n! \\ingroup gpu\n\n! Used in NvAPI_GPU_GetUUID()"] +pub type NV_GPU_UUID = NV_GPU_UUID_V1; +#[doc = "! \\ingroup gpupstate\n! Used in NvAPI_GPU_GetPstatesInfoEx()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PERF_PSTATES_INFO_V1 { + pub version: NvU32, + #[doc = "!< - bit 0 indicates if perfmon is enabled or not\n!< - bit 1 indicates if dynamic Pstate is capable or not\n!< - bit 2 indicates if dynamic Pstate is enable or not\n!< - all other bits must be set to 0"] + pub flags: NvU32, + #[doc = "!< The number of available p-states"] + pub numPstates: NvU32, + #[doc = "!< The number of clock domains supported by each P-State"] + pub numClocks: NvU32, + pub pstates: [NV_GPU_PERF_PSTATES_INFO_V1__bindgen_ty_1; 16usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PERF_PSTATES_INFO_V1__bindgen_ty_1 { + #[doc = "!< ID of the p-state."] + pub pstateId: NV_GPU_PERF_PSTATE_ID, + #[doc = "!< - bit 0 indicates if the PCIE limit is GEN1 or GEN2\n!< - bit 1 indicates if the Pstate is overclocked or not\n!< - bit 2 indicates if the Pstate is overclockable or not\n!< - all other bits must be set to 0"] + pub flags: NvU32, + pub clocks: [NV_GPU_PERF_PSTATES_INFO_V1__bindgen_ty_1__bindgen_ty_1; 32usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PERF_PSTATES_INFO_V1__bindgen_ty_1__bindgen_ty_1 { + #[doc = "!< ID of the clock domain"] + pub domainId: NV_GPU_PUBLIC_CLOCK_ID, + #[doc = "!< Reserved. Must be set to 0"] + pub flags: NvU32, + #[doc = "!< Clock frequency in kHz"] + pub freq: NvU32, +} +#[doc = "! \\ingroup gpupstate"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PERF_PSTATES_INFO_V2 { + pub version: NvU32, + #[doc = "!< - bit 0 indicates if perfmon is enabled or not\n!< - bit 1 indicates if dynamic Pstate is capable or not\n!< - bit 2 indicates if dynamic Pstate is enable or not\n!< - all other bits must be set to 0"] + pub flags: NvU32, + #[doc = "!< The number of available p-states"] + pub numPstates: NvU32, + #[doc = "!< The number of clock domains supported by each P-State"] + pub numClocks: NvU32, + pub numVoltages: NvU32, + #[doc = "!< Valid index range is 0 to numVoltages-1"] + pub pstates: [NV_GPU_PERF_PSTATES_INFO_V2__bindgen_ty_1; 16usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PERF_PSTATES_INFO_V2__bindgen_ty_1 { + #[doc = "!< ID of the p-state."] + pub pstateId: NV_GPU_PERF_PSTATE_ID, + #[doc = "!< - bit 0 indicates if the PCIE limit is GEN1 or GEN2\n!< - bit 1 indicates if the Pstate is overclocked or not\n!< - bit 2 indicates if the Pstate is overclockable or not\n!< - all other bits must be set to 0"] + pub flags: NvU32, + pub clocks: [NV_GPU_PERF_PSTATES_INFO_V2__bindgen_ty_1__bindgen_ty_1; 32usize], + pub voltages: [NV_GPU_PERF_PSTATES_INFO_V2__bindgen_ty_1__bindgen_ty_2; 16usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PERF_PSTATES_INFO_V2__bindgen_ty_1__bindgen_ty_1 { + pub domainId: NV_GPU_PUBLIC_CLOCK_ID, + #[doc = "!< bit 0 indicates if this clock is overclockable\n!< all other bits must be set to 0"] + pub flags: NvU32, + pub freq: NvU32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_PERF_PSTATES_INFO_V2__bindgen_ty_1__bindgen_ty_2 { + #[doc = "!< ID of the voltage domain, containing flags and mvolt info"] + pub domainId: NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID, + #[doc = "!< Reserved for future use. Must be set to 0"] + pub flags: NvU32, + #[doc = "!< Voltage in mV"] + pub mvolt: NvU32, +} +#[doc = "! \\ingroup gpupstate"] +pub type NV_GPU_PERF_PSTATES_INFO = NV_GPU_PERF_PSTATES_INFO_V2; +#[doc = "! \\ingroup gpupstate\n! Used in NvAPI_GPU_GetDynamicPstatesInfoEx()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_DYNAMIC_PSTATES_INFO_EX { + #[doc = "!< Structure version"] + pub version: NvU32, + #[doc = "!< bit 0 indicates if the dynamic Pstate is enabled or not"] + pub flags: NvU32, + pub utilization: [NV_GPU_DYNAMIC_PSTATES_INFO_EX__bindgen_ty_1; 8usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_DYNAMIC_PSTATES_INFO_EX__bindgen_ty_1 { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + #[doc = "!< Percentage of time where the domain is considered busy in the last 1 second interval"] + pub percentage: NvU32, +} +impl NV_GPU_DYNAMIC_PSTATES_INFO_EX__bindgen_ty_1 { + #[inline] + pub fn bIsPresent(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsPresent(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsPresent_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsPresent_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1(bIsPresent: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsPresent: u32 = unsafe { ::std::mem::transmute(bIsPresent) }; + bIsPresent as u64 + }); + __bindgen_bitfield_unit + } +} +pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_NONE: NV_THERMAL_TARGET = 0; +#[doc = "!< GPU core temperature requires NvPhysicalGpuHandle"] +pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_GPU: NV_THERMAL_TARGET = 1; +#[doc = "!< GPU memory temperature requires NvPhysicalGpuHandle"] +pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_MEMORY: NV_THERMAL_TARGET = 2; +#[doc = "!< GPU power supply temperature requires NvPhysicalGpuHandle"] +pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_POWER_SUPPLY: NV_THERMAL_TARGET = 4; +#[doc = "!< GPU board ambient temperature requires NvPhysicalGpuHandle"] +pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_BOARD: NV_THERMAL_TARGET = 8; +#[doc = "!< Visual Computing Device Board temperature requires NvVisualComputingDeviceHandle"] +pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_VCD_BOARD: NV_THERMAL_TARGET = 9; +#[doc = "!< Visual Computing Device Inlet temperature requires NvVisualComputingDeviceHandle"] +pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_VCD_INLET: NV_THERMAL_TARGET = 10; +#[doc = "!< Visual Computing Device Outlet temperature requires NvVisualComputingDeviceHandle"] +pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_VCD_OUTLET: NV_THERMAL_TARGET = 11; +pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_ALL: NV_THERMAL_TARGET = 15; +pub const NV_THERMAL_TARGET_NVAPI_THERMAL_TARGET_UNKNOWN: NV_THERMAL_TARGET = -1; +#[doc = "! \\ingroup gputhermal\n! Used in NV_GPU_THERMAL_SETTINGS"] +pub type NV_THERMAL_TARGET = ::std::os::raw::c_int; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_NONE: NV_THERMAL_CONTROLLER = 0; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_GPU_INTERNAL: NV_THERMAL_CONTROLLER = 1; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_ADM1032: NV_THERMAL_CONTROLLER = 2; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_MAX6649: NV_THERMAL_CONTROLLER = 3; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_MAX1617: NV_THERMAL_CONTROLLER = 4; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_LM99: NV_THERMAL_CONTROLLER = 5; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_LM89: NV_THERMAL_CONTROLLER = 6; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_LM64: NV_THERMAL_CONTROLLER = 7; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_ADT7473: NV_THERMAL_CONTROLLER = 8; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_SBMAX6649: NV_THERMAL_CONTROLLER = 9; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_VBIOSEVT: NV_THERMAL_CONTROLLER = 10; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_OS: NV_THERMAL_CONTROLLER = 11; +pub const NV_THERMAL_CONTROLLER_NVAPI_THERMAL_CONTROLLER_UNKNOWN: NV_THERMAL_CONTROLLER = -1; +#[doc = "! \\ingroup gputhermal\n! Used in NV_GPU_THERMAL_SETTINGS"] +pub type NV_THERMAL_CONTROLLER = ::std::os::raw::c_int; +#[doc = "! \\ingroup gputhermal\n! Used in NvAPI_GPU_GetThermalSettings()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_THERMAL_SETTINGS_V1 { + #[doc = "!< structure version"] + pub version: NvU32, + #[doc = "!< number of associated thermal sensors"] + pub count: NvU32, + pub sensor: [NV_GPU_THERMAL_SETTINGS_V1__bindgen_ty_1; 3usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_THERMAL_SETTINGS_V1__bindgen_ty_1 { + #[doc = "!< internal, ADM1032, MAX6649..."] + pub controller: NV_THERMAL_CONTROLLER, + #[doc = "!< The min default temperature value of the thermal sensor in degree Celsius"] + pub defaultMinTemp: NvU32, + #[doc = "!< The max default temperature value of the thermal sensor in degree Celsius"] + pub defaultMaxTemp: NvU32, + #[doc = "!< The current temperature value of the thermal sensor in degree Celsius"] + pub currentTemp: NvU32, + #[doc = "!< Thermal sensor targeted @ GPU, memory, chipset, powersupply, Visual Computing Device, etc."] + pub target: NV_THERMAL_TARGET, +} +#[doc = "! \\ingroup gputhermal"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_THERMAL_SETTINGS_V2 { + #[doc = "!< structure version"] + pub version: NvU32, + #[doc = "!< number of associated thermal sensors"] + pub count: NvU32, + pub sensor: [NV_GPU_THERMAL_SETTINGS_V2__bindgen_ty_1; 3usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_THERMAL_SETTINGS_V2__bindgen_ty_1 { + #[doc = "!< internal, ADM1032, MAX6649..."] + pub controller: NV_THERMAL_CONTROLLER, + #[doc = "!< Minimum default temperature value of the thermal sensor in degree Celsius"] + pub defaultMinTemp: NvS32, + #[doc = "!< Maximum default temperature value of the thermal sensor in degree Celsius"] + pub defaultMaxTemp: NvS32, + #[doc = "!< Current temperature value of the thermal sensor in degree Celsius"] + pub currentTemp: NvS32, + #[doc = "!< Thermal sensor targeted - GPU, memory, chipset, powersupply, Visual Computing Device, etc"] + pub target: NV_THERMAL_TARGET, +} +#[doc = "! \\ingroup gputhermal"] +pub type NV_GPU_THERMAL_SETTINGS = NV_GPU_THERMAL_SETTINGS_V2; +#[doc = "! \\ingroup gpuclock\n! Used in NvAPI_GPU_GetAllClockFrequencies()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_CLOCK_FREQUENCIES_V1 { + #[doc = "!< Structure version"] + pub version: NvU32, + #[doc = "!< These bits are reserved for future use."] + pub reserved: NvU32, + pub domain: [NV_GPU_CLOCK_FREQUENCIES_V1__bindgen_ty_1; 32usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_CLOCK_FREQUENCIES_V1__bindgen_ty_1 { + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Clock frequency (kHz)"] + pub frequency: NvU32, +} +impl NV_GPU_CLOCK_FREQUENCIES_V1__bindgen_ty_1 { + #[inline] + pub fn bIsPresent(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsPresent(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsPresent_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsPresent_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsPresent: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsPresent: u32 = unsafe { ::std::mem::transmute(bIsPresent) }; + bIsPresent as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub const NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE_NV_GPU_CLOCK_FREQUENCIES_CURRENT_FREQ: + NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE = 0; +pub const NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE_NV_GPU_CLOCK_FREQUENCIES_BASE_CLOCK: + NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE = 1; +pub const NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE_NV_GPU_CLOCK_FREQUENCIES_BOOST_CLOCK: + NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE = 2; +pub const NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE_NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE_NUM: + NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE = 3; +#[doc = "! \\ingroup gpuclock\n! Used in NvAPI_GPU_GetAllClockFrequencies()"] +pub type NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpuclock\n! Used in NvAPI_GPU_GetAllClockFrequencies()"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_CLOCK_FREQUENCIES_V2 { + #[doc = "!< Structure version"] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + pub domain: [NV_GPU_CLOCK_FREQUENCIES_V2__bindgen_ty_1; 32usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_CLOCK_FREQUENCIES_V2__bindgen_ty_1 { + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Clock frequency (kHz)"] + pub frequency: NvU32, +} +impl NV_GPU_CLOCK_FREQUENCIES_V2__bindgen_ty_1 { + #[inline] + pub fn bIsPresent(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsPresent(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsPresent_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsPresent_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsPresent: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsPresent: u32 = unsafe { ::std::mem::transmute(bIsPresent) }; + bIsPresent as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +impl NV_GPU_CLOCK_FREQUENCIES_V2 { + #[inline] + pub fn ClockType(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32) } + } + #[inline] + pub fn set_ClockType(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn ClockType_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 4u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_ClockType_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 20u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 20u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 20u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 20u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved1(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u32) } + } + #[inline] + pub fn set_reserved1(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(24usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved1_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 24usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved1_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 24usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + ClockType: NvU32, + reserved: NvU32, + reserved1: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 4u8, { + let ClockType: u32 = unsafe { ::std::mem::transmute(ClockType) }; + ClockType as u64 + }); + __bindgen_bitfield_unit.set(4usize, 20u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit.set(24usize, 8u8, { + let reserved1: u32 = unsafe { ::std::mem::transmute(reserved1) }; + reserved1 as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup gpuclock\n! Used in NvAPI_GPU_GetAllClockFrequencies()"] +pub type NV_GPU_CLOCK_FREQUENCIES = NV_GPU_CLOCK_FREQUENCIES_V2; +pub const _NV_GPU_ILLUMINATION_ATTRIB_NV_GPU_IA_LOGO_BRIGHTNESS: _NV_GPU_ILLUMINATION_ATTRIB = 0; +pub const _NV_GPU_ILLUMINATION_ATTRIB_NV_GPU_IA_SLI_BRIGHTNESS: _NV_GPU_ILLUMINATION_ATTRIB = 1; +#[doc = "! \\ingroup gpu"] +pub type _NV_GPU_ILLUMINATION_ATTRIB = ::std::os::raw::c_int; +#[doc = "! \\ingroup gpu"] +pub use self::_NV_GPU_ILLUMINATION_ATTRIB as NV_GPU_ILLUMINATION_ATTRIB; +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_QUERY_ILLUMINATION_SUPPORT_PARM_V1 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< The handle of the GPU that you are checking for the specified attribute.\n!< note that this is the GPU that is managing the attribute.\n!< Only a single GPU can manage an given attribute on a given HW element,\n!< regardless of how many are attatched.\n!< I.E. only one GPU will be used to control the brightness of the LED on an SLI bridge,\n!< regardless of how many are physicaly attached.\n!< You enumerate thru the GPUs with this call to determine which GPU is managing the attribute."] + pub hPhysicalGpu: NvPhysicalGpuHandle, + #[doc = "!< An enumeration value specifying the Illumination attribute to be querried.\n!< refer to enum \\ref NV_GPU_ILLUMINATION_ATTRIB."] + pub Attribute: NV_GPU_ILLUMINATION_ATTRIB, + #[doc = "!< A boolean indicating if the attribute is supported."] + pub bSupported: NvU32, +} +#[doc = "! \\ingroup gpu"] +pub type NV_GPU_QUERY_ILLUMINATION_SUPPORT_PARM_V1 = _NV_GPU_QUERY_ILLUMINATION_SUPPORT_PARM_V1; +#[doc = "! \\ingroup gpu"] +pub type NV_GPU_QUERY_ILLUMINATION_SUPPORT_PARM = NV_GPU_QUERY_ILLUMINATION_SUPPORT_PARM_V1; +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_GET_ILLUMINATION_PARM_V1 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< The handle of the GPU that you are checking for the specified attribute.\n!< Note that this is the GPU that is managing the attribute.\n!< Only a single GPU can manage an given attribute on a given HW element,\n!< regardless of how many are attatched.\n!< I.E. only one GPU will be used to control the brightness of the LED on an SLI bridge,\n!< regardless of how many are physicaly attached.\n!< You enumerate thru the GPUs with this call to determine which GPU is managing the attribute."] + pub hPhysicalGpu: NvPhysicalGpuHandle, + #[doc = "!< An enumeration value specifying the Illumination attribute to be querried.\n!< refer to enum \\ref NV_GPU_ILLUMINATION_ATTRIB."] + pub Attribute: NV_GPU_ILLUMINATION_ATTRIB, + #[doc = "!< A DWORD that will contain the current value of the specified attribute."] + pub Value: NvU32, +} +#[doc = "! \\ingroup gpu"] +pub type NV_GPU_GET_ILLUMINATION_PARM_V1 = _NV_GPU_GET_ILLUMINATION_PARM_V1; +#[doc = "! \\ingroup gpu"] +pub type NV_GPU_GET_ILLUMINATION_PARM = NV_GPU_GET_ILLUMINATION_PARM_V1; +#[doc = "! \\ingroup gpu"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_SET_ILLUMINATION_PARM_V1 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< The handle of the GPU that you are checking for the specified attribute.\n!< Note that this is the GPU that is managing the attribute.\n!< Only a single GPU can manage an given attribute on a given HW element,\n!< regardless of how many are attatched.\n!< I.E. only one GPU will be used to control the brightness of the LED on an SLI bridge,\n!< regardless of how many are physicaly attached.\n!< You enumerate thru the GPUs with this call to determine which GPU is managing the attribute."] + pub hPhysicalGpu: NvPhysicalGpuHandle, + #[doc = "!< An enumeration value specifying the Illumination attribute to be querried.\n!< refer to enum \\ref NV_GPU_ILLUMINATION_ATTRIB."] + pub Attribute: NV_GPU_ILLUMINATION_ATTRIB, + #[doc = "!< A DWORD containing the new value for the specified attribute.\n!< This should be specified as a percentage of the full range of the attribute\n!< (0-100; 0 = off, 100 = full brightness)\n!< If a value is specified outside this range, NVAPI_INVALID_ARGUMENT will be returned."] + pub Value: NvU32, +} +#[doc = "! \\ingroup gpu"] +pub type NV_GPU_SET_ILLUMINATION_PARM_V1 = _NV_GPU_SET_ILLUMINATION_PARM_V1; +#[doc = "! \\ingroup gpu"] +pub type NV_GPU_SET_ILLUMINATION_PARM = NV_GPU_SET_ILLUMINATION_PARM_V1; +pub const NV_GPU_CLIENT_ILLUM_CTRL_MODE_NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB: + NV_GPU_CLIENT_ILLUM_CTRL_MODE = 0; +pub const NV_GPU_CLIENT_ILLUM_CTRL_MODE_NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB: + NV_GPU_CLIENT_ILLUM_CTRL_MODE = 1; +pub const NV_GPU_CLIENT_ILLUM_CTRL_MODE_NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL: + NV_GPU_CLIENT_ILLUM_CTRL_MODE = 0; +pub const NV_GPU_CLIENT_ILLUM_CTRL_MODE_NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR: + NV_GPU_CLIENT_ILLUM_CTRL_MODE = 1; +pub const NV_GPU_CLIENT_ILLUM_CTRL_MODE_NV_GPU_CLIENT_ILLUM_CTRL_MODE_INVALID: + NV_GPU_CLIENT_ILLUM_CTRL_MODE = 255; +#[doc = " Enumeration of control modes that can be applied to Illumination Zones."] +pub type NV_GPU_CLIENT_ILLUM_CTRL_MODE = ::std::os::raw::c_int; +pub const NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_GPU_TOP_0: + NV_GPU_CLIENT_ILLUM_ZONE_LOCATION = 0; +pub const NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_GPU_FRONT_0: + NV_GPU_CLIENT_ILLUM_ZONE_LOCATION = 8; +pub const NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_GPU_BACK_0: + NV_GPU_CLIENT_ILLUM_ZONE_LOCATION = 12; +pub const NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_SLI_TOP_0: + NV_GPU_CLIENT_ILLUM_ZONE_LOCATION = 32; +pub const NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_INVALID: + NV_GPU_CLIENT_ILLUM_ZONE_LOCATION = -1; +#[doc = " Enumeration of locations where an Illumination Zone might be present.\n Encoding used -\n 1:0 - Number specifier (0)\n 4:2 - Location (TOP)\n 7:5 - Type (GPU/SLI)"] +pub type NV_GPU_CLIENT_ILLUM_ZONE_LOCATION = ::std::os::raw::c_int; +pub const NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_INVALID: + NV_GPU_CLIENT_ILLUM_DEVICE_TYPE = 0; +pub const NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_MCUV10: + NV_GPU_CLIENT_ILLUM_DEVICE_TYPE = 1; +pub const NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_GPIO_PWM_RGBW_V10: + NV_GPU_CLIENT_ILLUM_DEVICE_TYPE = 2; +pub const NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_GPIO_PWM_SINGLE_COLOR_V10 : NV_GPU_CLIENT_ILLUM_DEVICE_TYPE = 3 ; +#[doc = " Enumeration of ILLUM_DEVICEs."] +pub type NV_GPU_CLIENT_ILLUM_DEVICE_TYPE = ::std::os::raw::c_int; +pub const NV_GPU_CLIENT_ILLUM_ZONE_TYPE_NV_GPU_CLIENT_ILLUM_ZONE_TYPE_INVALID: + NV_GPU_CLIENT_ILLUM_ZONE_TYPE = 0; +pub const NV_GPU_CLIENT_ILLUM_ZONE_TYPE_NV_GPU_CLIENT_ILLUM_ZONE_TYPE_RGB: + NV_GPU_CLIENT_ILLUM_ZONE_TYPE = 1; +pub const NV_GPU_CLIENT_ILLUM_ZONE_TYPE_NV_GPU_CLIENT_ILLUM_ZONE_TYPE_COLOR_FIXED: + NV_GPU_CLIENT_ILLUM_ZONE_TYPE = 2; +pub const NV_GPU_CLIENT_ILLUM_ZONE_TYPE_NV_GPU_CLIENT_ILLUM_ZONE_TYPE_RGBW: + NV_GPU_CLIENT_ILLUM_ZONE_TYPE = 3; +pub const NV_GPU_CLIENT_ILLUM_ZONE_TYPE_NV_GPU_CLIENT_ILLUM_ZONE_TYPE_SINGLE_COLOR: + NV_GPU_CLIENT_ILLUM_ZONE_TYPE = 4; +#[doc = " Enumeration of ILLUM_ZONEs."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_TYPE = ::std::os::raw::c_int; +pub const NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE_NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_HALF_HALT : NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE = 0 ; +pub const NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE_NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_FULL_HALT : NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE = 1 ; +pub const NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE_NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_FULL_REPEAT : NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE = 2 ; +pub const NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE_NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_INVALID : NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE = 255 ; +#[doc = " Enumeration of Cycle types for piecewise linear control mode."] +pub type NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE = ::std::os::raw::c_int; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1\n Describes the static information of illumination device type MCUV10."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_MCUV10 { + #[doc = " I2C Device Index: Pointing to the illumination device in I2C Devices Table."] + pub i2cDevIdx: NvU8, +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1\n Describes the static information of illumination device type MCUV10."] +pub type NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_MCUV10 = _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_MCUV10; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1\n Describes the static information of illum device type GPIO_PWM_RGBW."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_RGBW { + #[doc = " Red drive GPIO pin."] + pub gpioPinRed: NvU8, + #[doc = " Green drive GPIO pin."] + pub gpioPinGreen: NvU8, + #[doc = " Blue drive GPIO pin."] + pub gpioPinBlue: NvU8, + #[doc = " White drive GPIO pin."] + pub gpioPinWhite: NvU8, +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1\n Describes the static information of illum device type GPIO_PWM_RGBW."] +pub type NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_RGBW = + _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_RGBW; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1\n Describes the static information of illum device type GPIO_PWM_SINGLE_COLOR."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_SINGLE_COLOR { + #[doc = " Single Color GPIO pin."] + pub gpioPinSingleColor: NvU8, +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1\n Describes the static information of illum device type GPIO_PWM_SINGLE_COLOR."] +pub type NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_SINGLE_COLOR = + _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_SINGLE_COLOR; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1 { + #[doc = " Type of the illumination device."] + pub type_: NV_GPU_CLIENT_ILLUM_DEVICE_TYPE, + #[doc = " Supported control modes for this illumination device."] + pub ctrlModeMask: NvU32, + pub data: _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1__bindgen_ty_1, + #[doc = " Reserved for future."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Union of illumination device info data. Interpreted as per\n @ref NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1::type"] +#[repr(C)] +#[derive(Copy, Clone)] +pub union _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1__bindgen_ty_1 { + pub mcuv10: NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_MCUV10, + pub gpioPwmRgbwv10: NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_RGBW, + pub gpioPwmSingleColorv10: NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_SINGLE_COLOR, + #[doc = " Reserved bytes for possible future extension of this struct."] + pub rsvd: [NvU8; 64usize], +} +pub type NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1 = _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_PARAMS_V1 { + #[doc = " Version of structure. Must always be first member."] + pub version: NvU32, + #[doc = " Number of illumination devices present."] + pub numIllumDevices: NvU32, + #[doc = " Reserved bytes for possible future extension of this struct."] + pub rsvd: [NvU8; 64usize], + pub devices: [NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1; 32usize], +} +pub type NV_GPU_CLIENT_ILLUM_DEVICE_INFO_PARAMS_V1 = _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_PARAMS_V1; +pub type NV_GPU_CLIENT_ILLUM_DEVICE_INFO_PARAMS = NV_GPU_CLIENT_ILLUM_DEVICE_INFO_PARAMS_V1; +#[doc = " Structure representing the data required for synchronization."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_CLIENT_ILLUM_DEVICE_SYNC_V1 { + #[doc = " Boolean representing the need for synchronization."] + pub bSync: NvBool, + #[doc = " Time stamp value required for synchronization."] + pub timeStampms: NvU64, + #[doc = " Reserved for future."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Structure representing the device control parameters of each ILLUM_DEVICE."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_V1 { + #[doc = " Type of the illum device."] + pub type_: NV_GPU_CLIENT_ILLUM_DEVICE_TYPE, + #[doc = " Structure containing the synchronization data for the illumination device."] + pub syncData: NV_GPU_CLIENT_ILLUM_DEVICE_SYNC_V1, + #[doc = " Reserved for future."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Structure representing the device control parameters of each ILLUM_DEVICE."] +pub type NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL = NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_V1; +#[doc = " Structure representing the control parameters of ILLUM_DEVICE-s."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_PARAMS_V1 { + #[doc = " Version of structure. Must always be first member."] + pub version: NvU32, + #[doc = " Number of illumination devices present."] + pub numIllumDevices: NvU32, + #[doc = " Reserved bytes for possible future extension of this struct."] + pub rsvd: [NvU8; 64usize], + pub devices: [NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_V1; 32usize], +} +#[doc = " Structure representing the control parameters of ILLUM_DEVICE-s."] +pub type NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_PARAMS = NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_PARAMS_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGB { + pub rsvd: NvU8, +} +pub type NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGB = _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGB; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1\n Describes the static information of illum zone type RGBW."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGBW { + pub rsvd: NvU8, +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1\n Describes the static information of illum zone type RGBW."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGBW = _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGBW; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1\n Describes the static information of illum zone type SINGLE_COLOR."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_SINGLE_COLOR { + pub rsvd: NvU8, +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1\n Describes the static information of illum zone type SINGLE_COLOR."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_SINGLE_COLOR = + _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_SINGLE_COLOR; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1 { + pub type_: NV_GPU_CLIENT_ILLUM_ZONE_TYPE, + #[doc = " Index pointing to an Illumination Device that controls this zone."] + pub illumDeviceIdx: NvU8, + #[doc = " Provider index for representing logical to physical zone mapping."] + pub provIdx: NvU8, + #[doc = " Location of the zone on the board."] + pub zoneLocation: NV_GPU_CLIENT_ILLUM_ZONE_LOCATION, + pub data: _NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1__bindgen_ty_1, + pub rsvd: [NvU8; 64usize], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union _NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1__bindgen_ty_1 { + pub rgb: NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGB, + pub rgbw: NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGBW, + pub singleColor: NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_SINGLE_COLOR, + #[doc = " Reserved bytes for possible future extension of this struct."] + pub rsvd: [NvU8; 64usize], +} +pub type NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1 = _NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_INFO_PARAMS_V1 { + #[doc = " Version of structure. Must always be first member."] + pub version: NvU32, + #[doc = " Number of illumination zones present."] + pub numIllumZones: NvU32, + #[doc = " Reserved bytes for possible future extension of this struct."] + pub rsvd: [NvU8; 64usize], + pub zones: [NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1; 32usize], +} +pub type NV_GPU_CLIENT_ILLUM_ZONE_INFO_PARAMS_V1 = _NV_GPU_CLIENT_ILLUM_ZONE_INFO_PARAMS_V1; +pub type NV_GPU_CLIENT_ILLUM_ZONE_INFO_PARAMS = NV_GPU_CLIENT_ILLUM_ZONE_INFO_PARAMS_V1; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB\n Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB_PARAMS { + #[doc = " Red compenent of color applied to the zone."] + pub colorR: NvU8, + #[doc = " Green compenent of color applied to the zone."] + pub colorG: NvU8, + #[doc = " Blue compenent of color applied to the zone."] + pub colorB: NvU8, + #[doc = " Brightness perecentage value of the zone."] + pub brightnessPct: NvU8, +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB\n Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB_PARAMS = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB_PARAMS; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB { + #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] + pub rgbParams: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB_PARAMS, +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB; +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR { + #[doc = " Type of cycle effect to apply."] + pub cycleType: NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE, + #[doc = " Number of times to repeat function within group period."] + pub grpCount: NvU8, + #[doc = " Time in ms to transition from color A to color B."] + pub riseTimems: NvU16, + #[doc = " Time in ms to transition from color B to color A."] + pub fallTimems: NvU16, + #[doc = " Time in ms to remain at color A before color A to color B transition."] + pub ATimems: NvU16, + #[doc = " Time in ms to remain at color B before color B to color A transition."] + pub BTimems: NvU16, + #[doc = " Time in ms to remain idle before next group of repeated function cycles."] + pub grpIdleTimems: NvU16, + #[doc = " Time in ms to offset the cycle relative to other zones."] + pub phaseOffsetms: NvU16, +} +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB { + #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] + pub rgbParams: [NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB_PARAMS; 2usize], + pub piecewiseLinearData: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR, +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illumination zone of type\n \\ref NV_GPU_CLIENT_ILLUM_ZONE_TYPE_RGB."] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB { + pub data: _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB__bindgen_ty_1, + #[doc = " Reserved for future."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Union of illumination zone control data for zone of type NV_GPU_CLIENT_ILLUM_ZONE_TYPE_RGB.\n Interpreted as per ctrlMode."] +#[repr(C)] +#[derive(Copy, Clone)] +pub union _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB__bindgen_ty_1 { + pub manualRGB: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB, + pub piecewiseLinearRGB: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB, + #[doc = " Reserved bytes for possible future extension of this struct."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illumination zone of type\n \\ref NV_GPU_CLIENT_ILLUM_ZONE_TYPE_RGB."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB = _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB; +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED\n Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_RGB."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED_PARAMS { + #[doc = " Brightness percentage value of the zone."] + pub brightnessPct: NvU8, +} +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED\n Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_RGB."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED_PARAMS = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED_PARAMS; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED { + #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] + pub colorFixedParams: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED_PARAMS, +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_COLOR_FIXED { + #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] + pub colorFixedParams: [NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED_PARAMS; 2usize], + pub piecewiseLinearData: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR, +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED\n Data required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_COLOR_FIXED = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_COLOR_FIXED; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illum zone of type\n \\ref NV_GPU_CLIENT_ILLUM_ZONE_TYPE_COLOR_FIXED."] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED { + pub data: _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED__bindgen_ty_1, + #[doc = " Reserved for future."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Union of illum zone control data for zone of type NV_GPU_CLIENT_ILLUM_ZONE_TYPE_COLOR_FIXED.\n Interpreted as per ctrlMode."] +#[repr(C)] +#[derive(Copy, Clone)] +pub union _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED__bindgen_ty_1 { + pub manualColorFixed: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED, + pub piecewiseLinearColorFixed: + NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_COLOR_FIXED, + #[doc = " Reserved bytes for possible future extension of this struct."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illum zone of type\n \\ref NV_GPU_CLIENT_ILLUM_ZONE_TYPE_COLOR_FIXED."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED; +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW\n Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGBW."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW_PARAMS { + #[doc = " Red component of color applied to the zone."] + pub colorR: NvU8, + #[doc = " Green component of color applied to the zone."] + pub colorG: NvU8, + #[doc = " Blue component of color applied to the zone."] + pub colorB: NvU8, + #[doc = " White component of color applied to the zone."] + pub colorW: NvU8, + #[doc = " Brightness percentage value of the zone."] + pub brightnessPct: NvU8, +} +#[doc = " Used in \\ref NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW\n Parameters required to represent control mode of type\n \\ref NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGBW."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW_PARAMS = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW_PARAMS; +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_RGBW\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_RGBW."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW { + #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_RGBW."] + pub rgbwParams: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW_PARAMS, +} +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_RGBW\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_RGBW."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW; +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_RGBW\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGBW."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGBW { + #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGBW."] + pub rgbwParams: [NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW_PARAMS; 2usize], + pub piecewiseLinearData: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR, +} +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_RGBW\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGBW."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGBW = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGBW; +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illum zone of type\n \\ref NV_GPU_ILLUM_ZONE_TYPE_RGBW."] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW { + pub data: _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW__bindgen_ty_1, + #[doc = " Reserved for future."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Union of illum zone control data for zone of type NV_GPU_ILLUM_ZONE_TYPE_RGBW.\n Interpreted as per ctrlMode."] +#[repr(C)] +#[derive(Copy, Clone)] +pub union _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW__bindgen_ty_1 { + pub manualRGBW: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW, + pub piecewiseLinearRGBW: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGBW, + #[doc = " Reserved bytes for possible future extension of this struct."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illum zone of type\n \\ref NV_GPU_ILLUM_ZONE_TYPE_RGBW."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW = _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW; +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR\n Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_SINGLE_COLOR."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR_PARAMS { + #[doc = " Brightness percentage value of the zone."] + pub brightnessPct: NvU8, +} +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR\n Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_SINGLE_COLOR."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR_PARAMS = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR_PARAMS; +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_SINGLE_COLOR."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR { + #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_SINGLE_COLOR."] + pub singleColorParams: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR_PARAMS, +} +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_MANUAL_SINGLE_COLOR."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR; +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_SINGLE_COLOR."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_SINGLE_COLOR { + #[doc = " Parameters required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_SINGLE_COLOR."] + pub singleColorParams: + [NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR_PARAMS; 2usize], + pub piecewiseLinearData: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR, +} +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR\n Data required to represent control mode of type\n \\ref NV_GPU_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_SINGLE_COLOR."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_SINGLE_COLOR = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_SINGLE_COLOR; +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illum zone of type\n \\ref NV_GPU_ILLUM_ZONE_TYPE_SINGLE_COLOR."] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR { + pub data: _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR__bindgen_ty_1, + #[doc = " Reserved for future."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Union of illum zone control data for zone of type NV_GPU_ILLUM_ZONE_TYPE_SINGLE_COLOR.\n Interpreted as per ctrlMode."] +#[repr(C)] +#[derive(Copy, Clone)] +pub union _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR__bindgen_ty_1 { + pub manualSingleColor: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR, + pub piecewiseLinearSingleColor: + NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_SINGLE_COLOR, + #[doc = " Reserved bytes for possible future extension of this struct."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Used in \\ref NV_GPU_ILLUM_ZONE_CONTROL_V1\n Describes the control data for illum zone of type\n \\ref NV_GPU_ILLUM_ZONE_TYPE_SINGLE_COLOR."] +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR = + _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1 { + pub type_: NV_GPU_CLIENT_ILLUM_ZONE_TYPE, + pub ctrlMode: NV_GPU_CLIENT_ILLUM_CTRL_MODE, + pub data: _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1__bindgen_ty_1, + pub rsvd: [NvU8; 64usize], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1__bindgen_ty_1 { + pub rgb: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB, + pub colorFixed: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED, + pub rgbw: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW, + pub singleColor: NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR, + pub rsvd: [NvU8; 64usize], +} +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1 = _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS_V1 { + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = " Number of illumination zones present."] + pub numIllumZonesControl: NvU32, + #[doc = " Reserved bytes for possible future extension of this struct."] + pub rsvd: [NvU8; 64usize], + pub zones: [NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1; 32usize], +} +impl _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS_V1 { + #[inline] + pub fn bDefault(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bDefault(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bDefault_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bDefault_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn rsvdField(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_rsvdField(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn rsvdField_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_rsvdField_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bDefault: NvU32, + rsvdField: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bDefault: u32 = unsafe { ::std::mem::transmute(bDefault) }; + bDefault as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let rsvdField: u32 = unsafe { ::std::mem::transmute(rsvdField) }; + rsvdField as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS_V1 = _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS_V1; +pub type NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS = NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS_V1; +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_GetDisplayPortInfo()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_DISPLAY_PORT_INFO_V1 { + #[doc = "!< Structure version"] + pub version: NvU32, + #[doc = "!< DPCD version of the monitor"] + pub dpcd_ver: NvU32, + #[doc = "!< Maximum supported link rate"] + pub maxLinkRate: NV_DP_LINK_RATE, + #[doc = "!< Maximum supported lane count"] + pub maxLaneCount: NV_DP_LANE_COUNT, + #[doc = "!< Current link rate"] + pub curLinkRate: NV_DP_LINK_RATE, + #[doc = "!< Current lane count"] + pub curLaneCount: NV_DP_LANE_COUNT, + #[doc = "!< Current color format"] + pub colorFormat: NV_DP_COLOR_FORMAT, + #[doc = "!< Dynamic range"] + pub dynamicRange: NV_DP_DYNAMIC_RANGE, + #[doc = "!< Ignored in RGB space"] + pub colorimetry: NV_DP_COLORIMETRY, + #[doc = "!< Current bit-per-component"] + pub bpc: NV_DP_BPC, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl _NV_DISPLAY_PORT_INFO_V1 { + #[inline] + pub fn isDp(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isDp(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isDp_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isDp_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isInternalDp(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isInternalDp(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isInternalDp_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isInternalDp_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isColorCtrlSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_isColorCtrlSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isColorCtrlSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isColorCtrlSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is6BPCSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_is6BPCSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is6BPCSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is6BPCSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is8BPCSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_is8BPCSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is8BPCSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is8BPCSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is10BPCSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_is10BPCSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is10BPCSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is10BPCSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is12BPCSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } + } + #[inline] + pub fn set_is12BPCSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is12BPCSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 6usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is12BPCSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is16BPCSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } + } + #[inline] + pub fn set_is16BPCSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is16BPCSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 7usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is16BPCSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 7usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isYCrCb420Supported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) } + } + #[inline] + pub fn set_isYCrCb420Supported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isYCrCb420Supported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 8usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isYCrCb420Supported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 8usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isYCrCb422Supported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) } + } + #[inline] + pub fn set_isYCrCb422Supported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(9usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isYCrCb422Supported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 9usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isYCrCb422Supported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 9usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isYCrCb444Supported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) } + } + #[inline] + pub fn set_isYCrCb444Supported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(10usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isYCrCb444Supported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 10usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isYCrCb444Supported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 10usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isRgb444SupportedOnCurrentMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) } + } + #[inline] + pub fn set_isRgb444SupportedOnCurrentMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(11usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isRgb444SupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 11usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isRgb444SupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 11usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isYCbCr444SupportedOnCurrentMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) } + } + #[inline] + pub fn set_isYCbCr444SupportedOnCurrentMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(12usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isYCbCr444SupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 12usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isYCbCr444SupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 12usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isYCbCr422SupportedOnCurrentMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) } + } + #[inline] + pub fn set_isYCbCr422SupportedOnCurrentMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(13usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isYCbCr422SupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 13usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isYCbCr422SupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 13usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isYCbCr420SupportedOnCurrentMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) } + } + #[inline] + pub fn set_isYCbCr420SupportedOnCurrentMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(14usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isYCbCr420SupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 14usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isYCbCr420SupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 14usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is6BPCSupportedOnCurrentMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) } + } + #[inline] + pub fn set_is6BPCSupportedOnCurrentMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(15usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is6BPCSupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 15usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is6BPCSupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 15usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is8BPCSupportedOnCurrentMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) } + } + #[inline] + pub fn set_is8BPCSupportedOnCurrentMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(16usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is8BPCSupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 16usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is8BPCSupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 16usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is10BPCSupportedOnCurrentMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) } + } + #[inline] + pub fn set_is10BPCSupportedOnCurrentMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(17usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is10BPCSupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 17usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is10BPCSupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 17usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is12BPCSupportedOnCurrentMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) } + } + #[inline] + pub fn set_is12BPCSupportedOnCurrentMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(18usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is12BPCSupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 18usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is12BPCSupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 18usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is16BPCSupportedOnCurrentMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u32) } + } + #[inline] + pub fn set_is16BPCSupportedOnCurrentMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(19usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is16BPCSupportedOnCurrentMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 19usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is16BPCSupportedOnCurrentMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 19usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonxvYCC601Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonxvYCC601Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(20usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonxvYCC601Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 20usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonxvYCC601Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 20usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonxvYCC709Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonxvYCC709Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(21usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonxvYCC709Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 21usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonxvYCC709Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 21usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonsYCC601Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonsYCC601Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(22usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonsYCC601Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 22usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonsYCC601Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 22usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonAdobeYCC601Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonAdobeYCC601Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(23usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonAdobeYCC601Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 23usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonAdobeYCC601Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 23usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonAdobeRGBCapable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonAdobeRGBCapable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(24usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonAdobeRGBCapable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 24usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonAdobeRGBCapable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 24usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonBT2020RGBCapable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonBT2020RGBCapable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(25usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonBT2020RGBCapable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 25usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonBT2020RGBCapable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 25usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonBT2020YCCCapable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonBT2020YCCCapable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(26usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonBT2020YCCCapable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 26usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonBT2020YCCCapable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 26usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonBT2020cYCCCapable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonBT2020cYCCCapable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(27usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonBT2020cYCCCapable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 27usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonBT2020cYCCCapable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 27usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 4u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(28usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 28usize, + 4u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 28usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isDp: NvU32, + isInternalDp: NvU32, + isColorCtrlSupported: NvU32, + is6BPCSupported: NvU32, + is8BPCSupported: NvU32, + is10BPCSupported: NvU32, + is12BPCSupported: NvU32, + is16BPCSupported: NvU32, + isYCrCb420Supported: NvU32, + isYCrCb422Supported: NvU32, + isYCrCb444Supported: NvU32, + isRgb444SupportedOnCurrentMode: NvU32, + isYCbCr444SupportedOnCurrentMode: NvU32, + isYCbCr422SupportedOnCurrentMode: NvU32, + isYCbCr420SupportedOnCurrentMode: NvU32, + is6BPCSupportedOnCurrentMode: NvU32, + is8BPCSupportedOnCurrentMode: NvU32, + is10BPCSupportedOnCurrentMode: NvU32, + is12BPCSupportedOnCurrentMode: NvU32, + is16BPCSupportedOnCurrentMode: NvU32, + isMonxvYCC601Capable: NvU32, + isMonxvYCC709Capable: NvU32, + isMonsYCC601Capable: NvU32, + isMonAdobeYCC601Capable: NvU32, + isMonAdobeRGBCapable: NvU32, + isMonBT2020RGBCapable: NvU32, + isMonBT2020YCCCapable: NvU32, + isMonBT2020cYCCCapable: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isDp: u32 = unsafe { ::std::mem::transmute(isDp) }; + isDp as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isInternalDp: u32 = unsafe { ::std::mem::transmute(isInternalDp) }; + isInternalDp as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let isColorCtrlSupported: u32 = unsafe { ::std::mem::transmute(isColorCtrlSupported) }; + isColorCtrlSupported as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let is6BPCSupported: u32 = unsafe { ::std::mem::transmute(is6BPCSupported) }; + is6BPCSupported as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let is8BPCSupported: u32 = unsafe { ::std::mem::transmute(is8BPCSupported) }; + is8BPCSupported as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let is10BPCSupported: u32 = unsafe { ::std::mem::transmute(is10BPCSupported) }; + is10BPCSupported as u64 + }); + __bindgen_bitfield_unit.set(6usize, 1u8, { + let is12BPCSupported: u32 = unsafe { ::std::mem::transmute(is12BPCSupported) }; + is12BPCSupported as u64 + }); + __bindgen_bitfield_unit.set(7usize, 1u8, { + let is16BPCSupported: u32 = unsafe { ::std::mem::transmute(is16BPCSupported) }; + is16BPCSupported as u64 + }); + __bindgen_bitfield_unit.set(8usize, 1u8, { + let isYCrCb420Supported: u32 = unsafe { ::std::mem::transmute(isYCrCb420Supported) }; + isYCrCb420Supported as u64 + }); + __bindgen_bitfield_unit.set(9usize, 1u8, { + let isYCrCb422Supported: u32 = unsafe { ::std::mem::transmute(isYCrCb422Supported) }; + isYCrCb422Supported as u64 + }); + __bindgen_bitfield_unit.set(10usize, 1u8, { + let isYCrCb444Supported: u32 = unsafe { ::std::mem::transmute(isYCrCb444Supported) }; + isYCrCb444Supported as u64 + }); + __bindgen_bitfield_unit.set(11usize, 1u8, { + let isRgb444SupportedOnCurrentMode: u32 = + unsafe { ::std::mem::transmute(isRgb444SupportedOnCurrentMode) }; + isRgb444SupportedOnCurrentMode as u64 + }); + __bindgen_bitfield_unit.set(12usize, 1u8, { + let isYCbCr444SupportedOnCurrentMode: u32 = + unsafe { ::std::mem::transmute(isYCbCr444SupportedOnCurrentMode) }; + isYCbCr444SupportedOnCurrentMode as u64 + }); + __bindgen_bitfield_unit.set(13usize, 1u8, { + let isYCbCr422SupportedOnCurrentMode: u32 = + unsafe { ::std::mem::transmute(isYCbCr422SupportedOnCurrentMode) }; + isYCbCr422SupportedOnCurrentMode as u64 + }); + __bindgen_bitfield_unit.set(14usize, 1u8, { + let isYCbCr420SupportedOnCurrentMode: u32 = + unsafe { ::std::mem::transmute(isYCbCr420SupportedOnCurrentMode) }; + isYCbCr420SupportedOnCurrentMode as u64 + }); + __bindgen_bitfield_unit.set(15usize, 1u8, { + let is6BPCSupportedOnCurrentMode: u32 = + unsafe { ::std::mem::transmute(is6BPCSupportedOnCurrentMode) }; + is6BPCSupportedOnCurrentMode as u64 + }); + __bindgen_bitfield_unit.set(16usize, 1u8, { + let is8BPCSupportedOnCurrentMode: u32 = + unsafe { ::std::mem::transmute(is8BPCSupportedOnCurrentMode) }; + is8BPCSupportedOnCurrentMode as u64 + }); + __bindgen_bitfield_unit.set(17usize, 1u8, { + let is10BPCSupportedOnCurrentMode: u32 = + unsafe { ::std::mem::transmute(is10BPCSupportedOnCurrentMode) }; + is10BPCSupportedOnCurrentMode as u64 + }); + __bindgen_bitfield_unit.set(18usize, 1u8, { + let is12BPCSupportedOnCurrentMode: u32 = + unsafe { ::std::mem::transmute(is12BPCSupportedOnCurrentMode) }; + is12BPCSupportedOnCurrentMode as u64 + }); + __bindgen_bitfield_unit.set(19usize, 1u8, { + let is16BPCSupportedOnCurrentMode: u32 = + unsafe { ::std::mem::transmute(is16BPCSupportedOnCurrentMode) }; + is16BPCSupportedOnCurrentMode as u64 + }); + __bindgen_bitfield_unit.set(20usize, 1u8, { + let isMonxvYCC601Capable: u32 = unsafe { ::std::mem::transmute(isMonxvYCC601Capable) }; + isMonxvYCC601Capable as u64 + }); + __bindgen_bitfield_unit.set(21usize, 1u8, { + let isMonxvYCC709Capable: u32 = unsafe { ::std::mem::transmute(isMonxvYCC709Capable) }; + isMonxvYCC709Capable as u64 + }); + __bindgen_bitfield_unit.set(22usize, 1u8, { + let isMonsYCC601Capable: u32 = unsafe { ::std::mem::transmute(isMonsYCC601Capable) }; + isMonsYCC601Capable as u64 + }); + __bindgen_bitfield_unit.set(23usize, 1u8, { + let isMonAdobeYCC601Capable: u32 = + unsafe { ::std::mem::transmute(isMonAdobeYCC601Capable) }; + isMonAdobeYCC601Capable as u64 + }); + __bindgen_bitfield_unit.set(24usize, 1u8, { + let isMonAdobeRGBCapable: u32 = unsafe { ::std::mem::transmute(isMonAdobeRGBCapable) }; + isMonAdobeRGBCapable as u64 + }); + __bindgen_bitfield_unit.set(25usize, 1u8, { + let isMonBT2020RGBCapable: u32 = + unsafe { ::std::mem::transmute(isMonBT2020RGBCapable) }; + isMonBT2020RGBCapable as u64 + }); + __bindgen_bitfield_unit.set(26usize, 1u8, { + let isMonBT2020YCCCapable: u32 = + unsafe { ::std::mem::transmute(isMonBT2020YCCCapable) }; + isMonBT2020YCCCapable as u64 + }); + __bindgen_bitfield_unit.set(27usize, 1u8, { + let isMonBT2020cYCCCapable: u32 = + unsafe { ::std::mem::transmute(isMonBT2020cYCCCapable) }; + isMonBT2020cYCCCapable as u64 + }); + __bindgen_bitfield_unit.set(28usize, 4u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_GetDisplayPortInfo()."] +pub type NV_DISPLAY_PORT_INFO_V1 = _NV_DISPLAY_PORT_INFO_V1; +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_GetDisplayPortInfo()."] +pub type NV_DISPLAY_PORT_INFO = NV_DISPLAY_PORT_INFO_V1; +#[doc = "! \\ingroup dispcontrol\n! DisplayPort configuration settings - used in NvAPI_SetDisplayPort()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_DISPLAY_PORT_CONFIG { + #[doc = "!< Structure version - 2 is the latest"] + pub version: NvU32, + #[doc = "!< Link rate"] + pub linkRate: NV_DP_LINK_RATE, + #[doc = "!< Lane count"] + pub laneCount: NV_DP_LANE_COUNT, + #[doc = "!< Color format to set"] + pub colorFormat: NV_DP_COLOR_FORMAT, + #[doc = "!< Dynamic range"] + pub dynamicRange: NV_DP_DYNAMIC_RANGE, + #[doc = "!< Ignored in RGB space"] + pub colorimetry: NV_DP_COLORIMETRY, + #[doc = "!< Bit-per-component"] + pub bpc: NV_DP_BPC, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +impl NV_DISPLAY_PORT_CONFIG { + #[inline] + pub fn isHPD(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isHPD(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isHPD_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isHPD_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isSetDeferred(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isSetDeferred(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isSetDeferred_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isSetDeferred_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isChromaLpfOff(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_isChromaLpfOff(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isChromaLpfOff_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isChromaLpfOff_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isDitherOff(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_isDitherOff(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isDitherOff_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isDitherOff_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn testLinkTrain(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_testLinkTrain(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn testLinkTrain_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_testLinkTrain_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn testColorChange(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_testColorChange(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn testColorChange_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_testColorChange_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isHPD: NvU32, + isSetDeferred: NvU32, + isChromaLpfOff: NvU32, + isDitherOff: NvU32, + testLinkTrain: NvU32, + testColorChange: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isHPD: u32 = unsafe { ::std::mem::transmute(isHPD) }; + isHPD as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isSetDeferred: u32 = unsafe { ::std::mem::transmute(isSetDeferred) }; + isSetDeferred as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let isChromaLpfOff: u32 = unsafe { ::std::mem::transmute(isChromaLpfOff) }; + isChromaLpfOff as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let isDitherOff: u32 = unsafe { ::std::mem::transmute(isDitherOff) }; + isDitherOff as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let testLinkTrain: u32 = unsafe { ::std::mem::transmute(testLinkTrain) }; + testLinkTrain as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let testColorChange: u32 = unsafe { ::std::mem::transmute(testColorChange) }; + testColorChange as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_GetHDMISupportInfo()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDMI_SUPPORT_INFO_V1 { + #[doc = "!< Structure version"] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Revision number of the EDID 861 extension"] + pub EDID861ExtRev: NvU32, +} +impl _NV_HDMI_SUPPORT_INFO_V1 { + #[inline] + pub fn isGpuHDMICapable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isGpuHDMICapable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isGpuHDMICapable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isGpuHDMICapable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonUnderscanCapable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonUnderscanCapable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonUnderscanCapable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonUnderscanCapable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonBasicAudioCapable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonBasicAudioCapable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonBasicAudioCapable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonBasicAudioCapable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonYCbCr444Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonYCbCr444Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonYCbCr444Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonYCbCr444Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonYCbCr422Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonYCbCr422Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonYCbCr422Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonYCbCr422Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonxvYCC601Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonxvYCC601Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonxvYCC601Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonxvYCC601Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonxvYCC709Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonxvYCC709Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonxvYCC709Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 6usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonxvYCC709Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonHDMI(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonHDMI(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonHDMI_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 7usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonHDMI_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 7usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 24u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 24u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 8usize, + 24u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 8usize, + 24u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isGpuHDMICapable: NvU32, + isMonUnderscanCapable: NvU32, + isMonBasicAudioCapable: NvU32, + isMonYCbCr444Capable: NvU32, + isMonYCbCr422Capable: NvU32, + isMonxvYCC601Capable: NvU32, + isMonxvYCC709Capable: NvU32, + isMonHDMI: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isGpuHDMICapable: u32 = unsafe { ::std::mem::transmute(isGpuHDMICapable) }; + isGpuHDMICapable as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isMonUnderscanCapable: u32 = + unsafe { ::std::mem::transmute(isMonUnderscanCapable) }; + isMonUnderscanCapable as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let isMonBasicAudioCapable: u32 = + unsafe { ::std::mem::transmute(isMonBasicAudioCapable) }; + isMonBasicAudioCapable as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let isMonYCbCr444Capable: u32 = unsafe { ::std::mem::transmute(isMonYCbCr444Capable) }; + isMonYCbCr444Capable as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let isMonYCbCr422Capable: u32 = unsafe { ::std::mem::transmute(isMonYCbCr422Capable) }; + isMonYCbCr422Capable as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let isMonxvYCC601Capable: u32 = unsafe { ::std::mem::transmute(isMonxvYCC601Capable) }; + isMonxvYCC601Capable as u64 + }); + __bindgen_bitfield_unit.set(6usize, 1u8, { + let isMonxvYCC709Capable: u32 = unsafe { ::std::mem::transmute(isMonxvYCC709Capable) }; + isMonxvYCC709Capable as u64 + }); + __bindgen_bitfield_unit.set(7usize, 1u8, { + let isMonHDMI: u32 = unsafe { ::std::mem::transmute(isMonHDMI) }; + isMonHDMI as u64 + }); + __bindgen_bitfield_unit.set(8usize, 24u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_GetHDMISupportInfo()."] +pub type NV_HDMI_SUPPORT_INFO_V1 = _NV_HDMI_SUPPORT_INFO_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDMI_SUPPORT_INFO_V2 { + #[doc = "!< Structure version"] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Revision number of the EDID 861 extension"] + pub EDID861ExtRev: NvU32, +} +impl _NV_HDMI_SUPPORT_INFO_V2 { + #[inline] + pub fn isGpuHDMICapable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isGpuHDMICapable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isGpuHDMICapable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isGpuHDMICapable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonUnderscanCapable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonUnderscanCapable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonUnderscanCapable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonUnderscanCapable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonBasicAudioCapable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonBasicAudioCapable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonBasicAudioCapable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonBasicAudioCapable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonYCbCr444Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonYCbCr444Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonYCbCr444Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonYCbCr444Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonYCbCr422Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonYCbCr422Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonYCbCr422Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonYCbCr422Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonxvYCC601Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonxvYCC601Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonxvYCC601Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonxvYCC601Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonxvYCC709Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonxvYCC709Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonxvYCC709Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 6usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonxvYCC709Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonHDMI(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonHDMI(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonHDMI_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 7usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonHDMI_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 7usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonsYCC601Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonsYCC601Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonsYCC601Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 8usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonsYCC601Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 8usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonAdobeYCC601Capable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonAdobeYCC601Capable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(9usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonAdobeYCC601Capable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 9usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonAdobeYCC601Capable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 9usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isMonAdobeRGBCapable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMonAdobeRGBCapable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(10usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMonAdobeRGBCapable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 10usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMonAdobeRGBCapable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 10usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 21u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(11usize, 21u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 11usize, + 21u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 11usize, + 21u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isGpuHDMICapable: NvU32, + isMonUnderscanCapable: NvU32, + isMonBasicAudioCapable: NvU32, + isMonYCbCr444Capable: NvU32, + isMonYCbCr422Capable: NvU32, + isMonxvYCC601Capable: NvU32, + isMonxvYCC709Capable: NvU32, + isMonHDMI: NvU32, + isMonsYCC601Capable: NvU32, + isMonAdobeYCC601Capable: NvU32, + isMonAdobeRGBCapable: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isGpuHDMICapable: u32 = unsafe { ::std::mem::transmute(isGpuHDMICapable) }; + isGpuHDMICapable as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isMonUnderscanCapable: u32 = + unsafe { ::std::mem::transmute(isMonUnderscanCapable) }; + isMonUnderscanCapable as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let isMonBasicAudioCapable: u32 = + unsafe { ::std::mem::transmute(isMonBasicAudioCapable) }; + isMonBasicAudioCapable as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let isMonYCbCr444Capable: u32 = unsafe { ::std::mem::transmute(isMonYCbCr444Capable) }; + isMonYCbCr444Capable as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let isMonYCbCr422Capable: u32 = unsafe { ::std::mem::transmute(isMonYCbCr422Capable) }; + isMonYCbCr422Capable as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let isMonxvYCC601Capable: u32 = unsafe { ::std::mem::transmute(isMonxvYCC601Capable) }; + isMonxvYCC601Capable as u64 + }); + __bindgen_bitfield_unit.set(6usize, 1u8, { + let isMonxvYCC709Capable: u32 = unsafe { ::std::mem::transmute(isMonxvYCC709Capable) }; + isMonxvYCC709Capable as u64 + }); + __bindgen_bitfield_unit.set(7usize, 1u8, { + let isMonHDMI: u32 = unsafe { ::std::mem::transmute(isMonHDMI) }; + isMonHDMI as u64 + }); + __bindgen_bitfield_unit.set(8usize, 1u8, { + let isMonsYCC601Capable: u32 = unsafe { ::std::mem::transmute(isMonsYCC601Capable) }; + isMonsYCC601Capable as u64 + }); + __bindgen_bitfield_unit.set(9usize, 1u8, { + let isMonAdobeYCC601Capable: u32 = + unsafe { ::std::mem::transmute(isMonAdobeYCC601Capable) }; + isMonAdobeYCC601Capable as u64 + }); + __bindgen_bitfield_unit.set(10usize, 1u8, { + let isMonAdobeRGBCapable: u32 = unsafe { ::std::mem::transmute(isMonAdobeRGBCapable) }; + isMonAdobeRGBCapable as u64 + }); + __bindgen_bitfield_unit.set(11usize, 21u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_HDMI_SUPPORT_INFO_V2 = _NV_HDMI_SUPPORT_INFO_V2; +pub type NV_HDMI_SUPPORT_INFO = NV_HDMI_SUPPORT_INFO_V2; +#[doc = "!< Returns the fields in the infoframe with values set by the manufacturer - NVIDIA/OEM."] +pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_GET_DEFAULT: NV_INFOFRAME_CMD = 0; +#[doc = "!< Sets the fields in the infoframe to auto, and infoframe to the default infoframe for use in a set."] +pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_RESET: NV_INFOFRAME_CMD = 1; +#[doc = "!< Get the current infoframe state."] +pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_GET: NV_INFOFRAME_CMD = 2; +#[doc = "!< Set the current infoframe state (flushed to the monitor), the values are one time and do not persist."] +pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_SET: NV_INFOFRAME_CMD = 3; +#[doc = "!< Get the override infoframe state, non-override fields will be set to value = AUTO, overridden fields will have the current override values."] +pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_GET_OVERRIDE: NV_INFOFRAME_CMD = 4; +#[doc = "!< Set the override infoframe state, non-override fields will be set to value = AUTO, other values indicate override; persist across modeset/reboot"] +pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_SET_OVERRIDE: NV_INFOFRAME_CMD = 5; +#[doc = "!< get properties associated with infoframe (each of the infoframe type will have properties)"] +pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_GET_PROPERTY: NV_INFOFRAME_CMD = 6; +#[doc = "!< set properties associated with infoframe"] +pub const NV_INFOFRAME_CMD_NV_INFOFRAME_CMD_SET_PROPERTY: NV_INFOFRAME_CMD = 7; +#[doc = "! \\ingroup dispcontrol"] +pub type NV_INFOFRAME_CMD = ::std::os::raw::c_int; +#[doc = "!< Driver determines whether to send infoframes."] +pub const NV_INFOFRAME_PROPERTY_MODE_NV_INFOFRAME_PROPERTY_MODE_AUTO: NV_INFOFRAME_PROPERTY_MODE = + 0; +#[doc = "!< Driver always sends infoframe."] +pub const NV_INFOFRAME_PROPERTY_MODE_NV_INFOFRAME_PROPERTY_MODE_ENABLE: NV_INFOFRAME_PROPERTY_MODE = + 1; +#[doc = "!< Driver never sends infoframe."] +pub const NV_INFOFRAME_PROPERTY_MODE_NV_INFOFRAME_PROPERTY_MODE_DISABLE: + NV_INFOFRAME_PROPERTY_MODE = 2; +#[doc = "!< Driver only sends infoframe when client requests it via infoframe escape call."] +pub const NV_INFOFRAME_PROPERTY_MODE_NV_INFOFRAME_PROPERTY_MODE_ALLOW_OVERRIDE: + NV_INFOFRAME_PROPERTY_MODE = 3; +pub type NV_INFOFRAME_PROPERTY_MODE = ::std::os::raw::c_int; +pub const NV_INFOFRAME_PROPERTY_BLACKLIST_NV_INFOFRAME_PROPERTY_BLACKLIST_FALSE: + NV_INFOFRAME_PROPERTY_BLACKLIST = 0; +pub const NV_INFOFRAME_PROPERTY_BLACKLIST_NV_INFOFRAME_PROPERTY_BLACKLIST_TRUE: + NV_INFOFRAME_PROPERTY_BLACKLIST = 1; +#[doc = "! Returns whether the current monitor is in blacklist or force this monitor to be in blacklist."] +pub type NV_INFOFRAME_PROPERTY_BLACKLIST = ::std::os::raw::c_int; +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct NV_INFOFRAME_PROPERTY { + pub _bitfield_align_1: [u16; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl NV_INFOFRAME_PROPERTY { + #[inline] + pub fn mode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32) } + } + #[inline] + pub fn set_mode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn mode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 4u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_mode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn blackList(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 2u8) as u32) } + } + #[inline] + pub fn set_blackList(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn blackList_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_blackList_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 10u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 10u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 6usize, + 10u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 10u8, + val as u64, + ) + } + } + #[inline] + pub fn version(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 8u8) as u32) } + } + #[inline] + pub fn set_version(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(16usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn version_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 16usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_version_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 16usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn length(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u32) } + } + #[inline] + pub fn set_length(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(24usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn length_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 24usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_length_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 24usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + mode: NvU32, + blackList: NvU32, + reserved: NvU32, + version: NvU32, + length: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 4u8, { + let mode: u32 = unsafe { ::std::mem::transmute(mode) }; + mode as u64 + }); + __bindgen_bitfield_unit.set(4usize, 2u8, { + let blackList: u32 = unsafe { ::std::mem::transmute(blackList) }; + blackList as u64 + }); + __bindgen_bitfield_unit.set(6usize, 10u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit.set(16usize, 8u8, { + let version: u32 = unsafe { ::std::mem::transmute(version) }; + version as u64 + }); + __bindgen_bitfield_unit.set(24usize, 8u8, { + let length: u32 = unsafe { ::std::mem::transmute(length) }; + length as u64 + }); + __bindgen_bitfield_unit + } +} +pub const NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_NODATA: + NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO = 0; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_OVERSCAN: + NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO = 1; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_UNDERSCAN: + NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO = 2; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_FUTURE: + NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO = 3; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_AUTO: + NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO = 7; +#[doc = "! Byte1 related"] +pub type NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_NOT_PRESENT: + NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA = 0; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_VERTICAL_PRESENT : NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_HORIZONTAL_PRESENT : NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_BOTH_PRESENT: + NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA = 3; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_AUTO: + NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA = 7; +pub type NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO_NV_INFOFRAME_FIELD_VALUE_AVI_AFI_ABSENT: + NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO = 0; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO_NV_INFOFRAME_FIELD_VALUE_AVI_AFI_PRESENT: + NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO = 1; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO_NV_INFOFRAME_FIELD_VALUE_AVI_AFI_AUTO: + NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO = 3; +pub type NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_RGB: + NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT = 0; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_YCbCr422 : NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_YCbCr444 : NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_FUTURE : NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_AUTO: + NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT = 7; +pub type NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_F17_NV_INFOFRAME_FIELD_VALUE_AVI_F17_FALSE: + NV_INFOFRAME_FIELD_VALUE_AVI_F17 = 0; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_F17_NV_INFOFRAME_FIELD_VALUE_AVI_F17_TRUE: + NV_INFOFRAME_FIELD_VALUE_AVI_F17 = 1; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_F17_NV_INFOFRAME_FIELD_VALUE_AVI_F17_AUTO: + NV_INFOFRAME_FIELD_VALUE_AVI_F17 = 3; +pub type NV_INFOFRAME_FIELD_VALUE_AVI_F17 = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NO_AFD : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE01 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE02 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE03 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_LETTERBOX_GT16x9 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 4 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE05 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 5 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE06 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 6 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE07 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 7 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_EQUAL_CODEDFRAME : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 8 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_CENTER_4x3 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 9 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_CENTER_16x9 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 10 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_CENTER_14x9 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 11 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE12 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 12 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_4x3_ON_14x9 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 13 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_16x9_ON_14x9 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 14 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_16x9_ON_4x3 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 15 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = 31 ; +#[doc = "! Byte2 related"] +pub type NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_NO_DATA : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_4x3 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_16x9 : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_FUTURE : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME = 7 ; +pub type NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_NO_DATA : NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_SMPTE_170M : NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_ITUR_BT709 : NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_USE_EXTENDED_COLORIMETRY : NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_AUTO: + NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY = 7; +pub type NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_NO_DATA : NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_HORIZONTAL : NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_VERTICAL : NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_BOTH : NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING = 7 ; +#[doc = "! Byte 3 related"] +pub type NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_DEFAULT : NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_LIMITED_RANGE : NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_FULL_RANGE : NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_RESERVED : NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION = 7 ; +pub type NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_XVYCC601 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_XVYCC709 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_SYCC601 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_ADOBEYCC601 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_ADOBERGB : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 4 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_RESERVED05 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 5 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_RESERVED06 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 6 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_RESERVED07 : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 7 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = 15 ; +pub type NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ITC_NV_INFOFRAME_FIELD_VALUE_AVI_ITC_VIDEO_CONTENT: + NV_INFOFRAME_FIELD_VALUE_AVI_ITC = 0; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ITC_NV_INFOFRAME_FIELD_VALUE_AVI_ITC_ITCONTENT: + NV_INFOFRAME_FIELD_VALUE_AVI_ITC = 1; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_ITC_NV_INFOFRAME_FIELD_VALUE_AVI_ITC_AUTO: + NV_INFOFRAME_FIELD_VALUE_AVI_ITC = 3; +pub type NV_INFOFRAME_FIELD_VALUE_AVI_ITC = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NONE : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X02 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X03 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X04 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X05 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 4 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X06 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 5 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X07 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 6 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X08 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 7 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X09 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 8 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X10 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 9 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED10 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 10 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED11 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 11 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED12 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 12 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED13 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 13 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED14 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 14 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED15 : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 15 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = 31 ; +#[doc = "! Byte 4 related"] +pub type NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_GRAPHICS : NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_PHOTO : NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_CINEMA : NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_GAME: + NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE = 3; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_AUTO: + NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE = 7; +pub type NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_LIMITED_RANGE : NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_FULL_RANGE : NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_RESERVED02 : NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_RESERVED03 : NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_AUTO : NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION = 7 ; +pub type NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION = ::std::os::raw::c_int; +#[doc = "! Adding an Auto bit to each field"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_INFOFRAME_VIDEO { + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 23usize]>, +} +impl NV_INFOFRAME_VIDEO { + #[inline] + pub fn vic(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) } + } + #[inline] + pub fn set_vic(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn vic_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_vic_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn pixelRepeat(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 5u8) as u32) } + } + #[inline] + pub fn set_pixelRepeat(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 5u8, val as u64) + } + } + #[inline] + pub unsafe fn pixelRepeat_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 8usize, + 5u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_pixelRepeat_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 8usize, + 5u8, + val as u64, + ) + } + } + #[inline] + pub fn colorSpace(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 3u8) as u32) } + } + #[inline] + pub fn set_colorSpace(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(13usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn colorSpace_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 13usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_colorSpace_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 13usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn colorimetry(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 3u8) as u32) } + } + #[inline] + pub fn set_colorimetry(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(16usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn colorimetry_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 16usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_colorimetry_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 16usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn extendedColorimetry(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 4u8) as u32) } + } + #[inline] + pub fn set_extendedColorimetry(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(19usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn extendedColorimetry_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 19usize, + 4u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_extendedColorimetry_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 19usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn rgbQuantizationRange(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 3u8) as u32) } + } + #[inline] + pub fn set_rgbQuantizationRange(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(23usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn rgbQuantizationRange_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 23usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_rgbQuantizationRange_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 23usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn yccQuantizationRange(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 3u8) as u32) } + } + #[inline] + pub fn set_yccQuantizationRange(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(26usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn yccQuantizationRange_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 26usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_yccQuantizationRange_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 26usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn itContent(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 2u8) as u32) } + } + #[inline] + pub fn set_itContent(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(29usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn itContent_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 29usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_itContent_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 29usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn contentTypes(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 3u8) as u32) } + } + #[inline] + pub fn set_contentTypes(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(32usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn contentTypes_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 32usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_contentTypes_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 32usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn scanInfo(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(35usize, 3u8) as u32) } + } + #[inline] + pub fn set_scanInfo(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(35usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn scanInfo_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 35usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_scanInfo_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 35usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn activeFormatInfoPresent(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(38usize, 2u8) as u32) } + } + #[inline] + pub fn set_activeFormatInfoPresent(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(38usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn activeFormatInfoPresent_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 38usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_activeFormatInfoPresent_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 38usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn activeFormatAspectRatio(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(40usize, 5u8) as u32) } + } + #[inline] + pub fn set_activeFormatAspectRatio(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(40usize, 5u8, val as u64) + } + } + #[inline] + pub unsafe fn activeFormatAspectRatio_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 40usize, + 5u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_activeFormatAspectRatio_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 40usize, + 5u8, + val as u64, + ) + } + } + #[inline] + pub fn picAspectRatio(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(45usize, 3u8) as u32) } + } + #[inline] + pub fn set_picAspectRatio(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(45usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn picAspectRatio_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 45usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_picAspectRatio_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 45usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn nonuniformScaling(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 3u8) as u32) } + } + #[inline] + pub fn set_nonuniformScaling(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(48usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn nonuniformScaling_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 48usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_nonuniformScaling_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 48usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn barInfo(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(51usize, 3u8) as u32) } + } + #[inline] + pub fn set_barInfo(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(51usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn barInfo_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 51usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_barInfo_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 51usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn top_bar(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(64usize, 17u8) as u32) } + } + #[inline] + pub fn set_top_bar(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(64usize, 17u8, val as u64) + } + } + #[inline] + pub unsafe fn top_bar_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 64usize, + 17u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_top_bar_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 64usize, + 17u8, + val as u64, + ) + } + } + #[inline] + pub fn bottom_bar(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(96usize, 17u8) as u32) } + } + #[inline] + pub fn set_bottom_bar(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(96usize, 17u8, val as u64) + } + } + #[inline] + pub unsafe fn bottom_bar_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 96usize, + 17u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bottom_bar_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 96usize, + 17u8, + val as u64, + ) + } + } + #[inline] + pub fn left_bar(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(128usize, 17u8) as u32) } + } + #[inline] + pub fn set_left_bar(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(128usize, 17u8, val as u64) + } + } + #[inline] + pub unsafe fn left_bar_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 128usize, + 17u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_left_bar_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 128usize, + 17u8, + val as u64, + ) + } + } + #[inline] + pub fn right_bar(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(160usize, 17u8) as u32) } + } + #[inline] + pub fn set_right_bar(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(160usize, 17u8, val as u64) + } + } + #[inline] + pub unsafe fn right_bar_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 160usize, + 17u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_right_bar_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 160usize, + 17u8, + val as u64, + ) + } + } + #[inline] + pub fn Future17(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(177usize, 2u8) as u32) } + } + #[inline] + pub fn set_Future17(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(177usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn Future17_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 177usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_Future17_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 177usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn Future47(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(179usize, 2u8) as u32) } + } + #[inline] + pub fn set_Future47(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(179usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn Future47_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 23usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 179usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_Future47_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 23usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 179usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + vic: NvU32, + pixelRepeat: NvU32, + colorSpace: NvU32, + colorimetry: NvU32, + extendedColorimetry: NvU32, + rgbQuantizationRange: NvU32, + yccQuantizationRange: NvU32, + itContent: NvU32, + contentTypes: NvU32, + scanInfo: NvU32, + activeFormatInfoPresent: NvU32, + activeFormatAspectRatio: NvU32, + picAspectRatio: NvU32, + nonuniformScaling: NvU32, + barInfo: NvU32, + top_bar: NvU32, + bottom_bar: NvU32, + left_bar: NvU32, + right_bar: NvU32, + Future17: NvU32, + Future47: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 23usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 23usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 8u8, { + let vic: u32 = unsafe { ::std::mem::transmute(vic) }; + vic as u64 + }); + __bindgen_bitfield_unit.set(8usize, 5u8, { + let pixelRepeat: u32 = unsafe { ::std::mem::transmute(pixelRepeat) }; + pixelRepeat as u64 + }); + __bindgen_bitfield_unit.set(13usize, 3u8, { + let colorSpace: u32 = unsafe { ::std::mem::transmute(colorSpace) }; + colorSpace as u64 + }); + __bindgen_bitfield_unit.set(16usize, 3u8, { + let colorimetry: u32 = unsafe { ::std::mem::transmute(colorimetry) }; + colorimetry as u64 + }); + __bindgen_bitfield_unit.set(19usize, 4u8, { + let extendedColorimetry: u32 = unsafe { ::std::mem::transmute(extendedColorimetry) }; + extendedColorimetry as u64 + }); + __bindgen_bitfield_unit.set(23usize, 3u8, { + let rgbQuantizationRange: u32 = unsafe { ::std::mem::transmute(rgbQuantizationRange) }; + rgbQuantizationRange as u64 + }); + __bindgen_bitfield_unit.set(26usize, 3u8, { + let yccQuantizationRange: u32 = unsafe { ::std::mem::transmute(yccQuantizationRange) }; + yccQuantizationRange as u64 + }); + __bindgen_bitfield_unit.set(29usize, 2u8, { + let itContent: u32 = unsafe { ::std::mem::transmute(itContent) }; + itContent as u64 + }); + __bindgen_bitfield_unit.set(32usize, 3u8, { + let contentTypes: u32 = unsafe { ::std::mem::transmute(contentTypes) }; + contentTypes as u64 + }); + __bindgen_bitfield_unit.set(35usize, 3u8, { + let scanInfo: u32 = unsafe { ::std::mem::transmute(scanInfo) }; + scanInfo as u64 + }); + __bindgen_bitfield_unit.set(38usize, 2u8, { + let activeFormatInfoPresent: u32 = + unsafe { ::std::mem::transmute(activeFormatInfoPresent) }; + activeFormatInfoPresent as u64 + }); + __bindgen_bitfield_unit.set(40usize, 5u8, { + let activeFormatAspectRatio: u32 = + unsafe { ::std::mem::transmute(activeFormatAspectRatio) }; + activeFormatAspectRatio as u64 + }); + __bindgen_bitfield_unit.set(45usize, 3u8, { + let picAspectRatio: u32 = unsafe { ::std::mem::transmute(picAspectRatio) }; + picAspectRatio as u64 + }); + __bindgen_bitfield_unit.set(48usize, 3u8, { + let nonuniformScaling: u32 = unsafe { ::std::mem::transmute(nonuniformScaling) }; + nonuniformScaling as u64 + }); + __bindgen_bitfield_unit.set(51usize, 3u8, { + let barInfo: u32 = unsafe { ::std::mem::transmute(barInfo) }; + barInfo as u64 + }); + __bindgen_bitfield_unit.set(64usize, 17u8, { + let top_bar: u32 = unsafe { ::std::mem::transmute(top_bar) }; + top_bar as u64 + }); + __bindgen_bitfield_unit.set(96usize, 17u8, { + let bottom_bar: u32 = unsafe { ::std::mem::transmute(bottom_bar) }; + bottom_bar as u64 + }); + __bindgen_bitfield_unit.set(128usize, 17u8, { + let left_bar: u32 = unsafe { ::std::mem::transmute(left_bar) }; + left_bar as u64 + }); + __bindgen_bitfield_unit.set(160usize, 17u8, { + let right_bar: u32 = unsafe { ::std::mem::transmute(right_bar) }; + right_bar as u64 + }); + __bindgen_bitfield_unit.set(177usize, 2u8, { + let Future17: u32 = unsafe { ::std::mem::transmute(Future17) }; + Future17 as u64 + }); + __bindgen_bitfield_unit.set(179usize, 2u8, { + let Future47: u32 = unsafe { ::std::mem::transmute(Future47) }; + Future47 as u64 + }); + __bindgen_bitfield_unit + } +} +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_IN_HEADER : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_2 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_3 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_4 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_5 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 4 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_6 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 5 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_7 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 6 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_8 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 7 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = 15 ; +#[doc = "! Byte 1 related"] +pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_IN_HEADER : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_PCM : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_AC3 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_MPEG1 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_MP3 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 4 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_MPEG2 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 5 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_AACLC : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 6 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_DTS : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 7 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_ATRAC : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 8 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_DSD : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 9 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_EAC3 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 10 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_DTSHD : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 11 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_MLP : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 12 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_DST : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 13 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_WMAPRO : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 14 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_USE_CODING_EXTENSION_TYPE : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 15 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = 31 ; +pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_IN_HEADER : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_16BITS : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_20BITS : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_24BITS : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE = 7 ; +#[doc = "! Byte 2 related"] +pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_IN_HEADER : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_32000HZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_44100HZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_48000HZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_88200KHZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 4 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_96000KHZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 5 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_176400KHZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 6 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_192000KHZ : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 7 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = 15 ; +pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_USE_CODING_TYPE : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_HEAAC : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_HEAACV2 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_MPEGSURROUND : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE04 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 4 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE05 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 5 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE06 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 6 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE07 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 7 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE08 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 8 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE09 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 9 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE10 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 10 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE11 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 11 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE12 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 12 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE13 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 13 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE14 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 14 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE15 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 15 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE16 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 16 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE17 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 17 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE18 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 18 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE19 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 19 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE20 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 20 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE21 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 21 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE22 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 22 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE23 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 23 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE24 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 24 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE25 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 25 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE26 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 26 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE27 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 27 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE28 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 28 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE29 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 29 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE30 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 30 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE31 : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 31 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = 63 ; +#[doc = "! Byte 3 related"] +pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_X_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_X_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_X_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_X_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_RC_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 4 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_RC_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 5 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_RC_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 6 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_RC_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 7 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_RR_RL_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 8 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_RR_RL_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 9 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 10 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 11 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_RC_RR_RL_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 12 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_RC_RR_RL_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 13 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_RC_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 14 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_RC_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 15 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_RRC_RLC_RR_RL_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 16 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_RRC_RLC_RR_RL_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 17 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_RRC_RLC_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 18 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_RRC_RLC_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 19 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_X_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 20 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_X_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 21 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_X_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 22 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_X_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 23 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_RC_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 24 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_RC_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 25 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_RC_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 26 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_RC_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 27 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_RR_RL_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 28 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_RR_RL_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 29 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 30 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 31 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_FCH_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 32 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_FCH_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 33 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_X_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 34 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_X_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 35 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRH_FLH_RR_RL_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 36 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRH_FLH_RR_RL_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 37 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRW_FLW_RR_RL_X_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 38 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRW_FLW_RR_RL_X_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 39 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_RC_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 40 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_RC_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 41 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FCH_RC_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 42 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FCH_RC_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 43 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_FCH_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 44 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_FCH_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 45 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRH_FLH_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 46 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRH_FLH_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 47 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRW_FLW_RR_RL_FC_X_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 48 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRW_FLW_RR_RL_FC_LFE_FR_FL : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 49 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = 511 ; +#[doc = "! Byte 4 related"] +pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_NO_DATA : NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_0DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_PLUS10DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_RESERVED03 : NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL = 7 ; +#[doc = "! Byte 5 related"] +pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_0DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_1DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_2DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 2 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_3DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 3 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_4DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 4 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_5DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 5 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_6DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 6 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_7DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 7 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_8DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 8 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_9DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 9 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_10DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 10 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_11DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 11 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_12DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 12 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_13DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 13 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_14DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 14 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_15DB : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 15 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_AUTO : NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = 31 ; +pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES = ::std::os::raw::c_int; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_PERMITTED : NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX = 0 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_PROHIBITED : NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX = 1 ; +pub const NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_AUTO: + NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX = 3; +pub type NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX = ::std::os::raw::c_int; +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct NV_INFOFRAME_AUDIO { + pub _bitfield_align_1: [u16; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 14usize]>, + pub __bindgen_padding_0: u16, +} +impl NV_INFOFRAME_AUDIO { + #[inline] + pub fn codingType(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 5u8) as u32) } + } + #[inline] + pub fn set_codingType(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 5u8, val as u64) + } + } + #[inline] + pub unsafe fn codingType_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 5u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_codingType_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 5u8, + val as u64, + ) + } + } + #[inline] + pub fn codingExtensionType(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 6u8) as u32) } + } + #[inline] + pub fn set_codingExtensionType(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 6u8, val as u64) + } + } + #[inline] + pub unsafe fn codingExtensionType_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 6u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_codingExtensionType_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 6u8, + val as u64, + ) + } + } + #[inline] + pub fn sampleSize(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 3u8) as u32) } + } + #[inline] + pub fn set_sampleSize(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(11usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn sampleSize_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 11usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_sampleSize_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 11usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn sampleRate(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 4u8) as u32) } + } + #[inline] + pub fn set_sampleRate(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(14usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn sampleRate_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 14usize, + 4u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_sampleRate_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 14usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn channelCount(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 4u8) as u32) } + } + #[inline] + pub fn set_channelCount(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(18usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn channelCount_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 18usize, + 4u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_channelCount_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 18usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn speakerPlacement(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 9u8) as u32) } + } + #[inline] + pub fn set_speakerPlacement(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(22usize, 9u8, val as u64) + } + } + #[inline] + pub unsafe fn speakerPlacement_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 22usize, + 9u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_speakerPlacement_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 22usize, + 9u8, + val as u64, + ) + } + } + #[inline] + pub fn downmixInhibit(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 2u8) as u32) } + } + #[inline] + pub fn set_downmixInhibit(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(32usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn downmixInhibit_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 32usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_downmixInhibit_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 32usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn lfePlaybackLevel(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(34usize, 3u8) as u32) } + } + #[inline] + pub fn set_lfePlaybackLevel(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(34usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn lfePlaybackLevel_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 34usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_lfePlaybackLevel_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 34usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn levelShift(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(37usize, 5u8) as u32) } + } + #[inline] + pub fn set_levelShift(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(37usize, 5u8, val as u64) + } + } + #[inline] + pub unsafe fn levelShift_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 37usize, + 5u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_levelShift_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 37usize, + 5u8, + val as u64, + ) + } + } + #[inline] + pub fn Future12(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(42usize, 2u8) as u32) } + } + #[inline] + pub fn set_Future12(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(42usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn Future12_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 42usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_Future12_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 42usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn Future2x(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(44usize, 4u8) as u32) } + } + #[inline] + pub fn set_Future2x(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(44usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn Future2x_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 44usize, + 4u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_Future2x_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 44usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn Future3x(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 4u8) as u32) } + } + #[inline] + pub fn set_Future3x(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(48usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn Future3x_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 48usize, + 4u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_Future3x_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 48usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn Future52(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(52usize, 2u8) as u32) } + } + #[inline] + pub fn set_Future52(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(52usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn Future52_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 52usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_Future52_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 52usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn Future6(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(54usize, 9u8) as u32) } + } + #[inline] + pub fn set_Future6(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(54usize, 9u8, val as u64) + } + } + #[inline] + pub unsafe fn Future6_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 54usize, + 9u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_Future6_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 54usize, + 9u8, + val as u64, + ) + } + } + #[inline] + pub fn Future7(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(64usize, 9u8) as u32) } + } + #[inline] + pub fn set_Future7(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(64usize, 9u8, val as u64) + } + } + #[inline] + pub unsafe fn Future7_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 64usize, + 9u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_Future7_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 64usize, + 9u8, + val as u64, + ) + } + } + #[inline] + pub fn Future8(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(73usize, 9u8) as u32) } + } + #[inline] + pub fn set_Future8(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(73usize, 9u8, val as u64) + } + } + #[inline] + pub unsafe fn Future8_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 73usize, + 9u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_Future8_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 73usize, + 9u8, + val as u64, + ) + } + } + #[inline] + pub fn Future9(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(82usize, 9u8) as u32) } + } + #[inline] + pub fn set_Future9(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(82usize, 9u8, val as u64) + } + } + #[inline] + pub unsafe fn Future9_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 82usize, + 9u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_Future9_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 82usize, + 9u8, + val as u64, + ) + } + } + #[inline] + pub fn Future10(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(96usize, 9u8) as u32) } + } + #[inline] + pub fn set_Future10(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(96usize, 9u8, val as u64) + } + } + #[inline] + pub unsafe fn Future10_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 14usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 96usize, + 9u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_Future10_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 14usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 96usize, + 9u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + codingType: NvU32, + codingExtensionType: NvU32, + sampleSize: NvU32, + sampleRate: NvU32, + channelCount: NvU32, + speakerPlacement: NvU32, + downmixInhibit: NvU32, + lfePlaybackLevel: NvU32, + levelShift: NvU32, + Future12: NvU32, + Future2x: NvU32, + Future3x: NvU32, + Future52: NvU32, + Future6: NvU32, + Future7: NvU32, + Future8: NvU32, + Future9: NvU32, + Future10: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 14usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 14usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 5u8, { + let codingType: u32 = unsafe { ::std::mem::transmute(codingType) }; + codingType as u64 + }); + __bindgen_bitfield_unit.set(5usize, 6u8, { + let codingExtensionType: u32 = unsafe { ::std::mem::transmute(codingExtensionType) }; + codingExtensionType as u64 + }); + __bindgen_bitfield_unit.set(11usize, 3u8, { + let sampleSize: u32 = unsafe { ::std::mem::transmute(sampleSize) }; + sampleSize as u64 + }); + __bindgen_bitfield_unit.set(14usize, 4u8, { + let sampleRate: u32 = unsafe { ::std::mem::transmute(sampleRate) }; + sampleRate as u64 + }); + __bindgen_bitfield_unit.set(18usize, 4u8, { + let channelCount: u32 = unsafe { ::std::mem::transmute(channelCount) }; + channelCount as u64 + }); + __bindgen_bitfield_unit.set(22usize, 9u8, { + let speakerPlacement: u32 = unsafe { ::std::mem::transmute(speakerPlacement) }; + speakerPlacement as u64 + }); + __bindgen_bitfield_unit.set(32usize, 2u8, { + let downmixInhibit: u32 = unsafe { ::std::mem::transmute(downmixInhibit) }; + downmixInhibit as u64 + }); + __bindgen_bitfield_unit.set(34usize, 3u8, { + let lfePlaybackLevel: u32 = unsafe { ::std::mem::transmute(lfePlaybackLevel) }; + lfePlaybackLevel as u64 + }); + __bindgen_bitfield_unit.set(37usize, 5u8, { + let levelShift: u32 = unsafe { ::std::mem::transmute(levelShift) }; + levelShift as u64 + }); + __bindgen_bitfield_unit.set(42usize, 2u8, { + let Future12: u32 = unsafe { ::std::mem::transmute(Future12) }; + Future12 as u64 + }); + __bindgen_bitfield_unit.set(44usize, 4u8, { + let Future2x: u32 = unsafe { ::std::mem::transmute(Future2x) }; + Future2x as u64 + }); + __bindgen_bitfield_unit.set(48usize, 4u8, { + let Future3x: u32 = unsafe { ::std::mem::transmute(Future3x) }; + Future3x as u64 + }); + __bindgen_bitfield_unit.set(52usize, 2u8, { + let Future52: u32 = unsafe { ::std::mem::transmute(Future52) }; + Future52 as u64 + }); + __bindgen_bitfield_unit.set(54usize, 9u8, { + let Future6: u32 = unsafe { ::std::mem::transmute(Future6) }; + Future6 as u64 + }); + __bindgen_bitfield_unit.set(64usize, 9u8, { + let Future7: u32 = unsafe { ::std::mem::transmute(Future7) }; + Future7 as u64 + }); + __bindgen_bitfield_unit.set(73usize, 9u8, { + let Future8: u32 = unsafe { ::std::mem::transmute(Future8) }; + Future8 as u64 + }); + __bindgen_bitfield_unit.set(82usize, 9u8, { + let Future9: u32 = unsafe { ::std::mem::transmute(Future9) }; + Future9 as u64 + }); + __bindgen_bitfield_unit.set(96usize, 9u8, { + let Future10: u32 = unsafe { ::std::mem::transmute(Future10) }; + Future10 as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct NV_INFOFRAME_DATA { + #[doc = "!< version of this structure"] + pub version: NvU32, + #[doc = "!< size of this structure"] + pub size: NvU16, + #[doc = "!< The actions to perform from NV_INFOFRAME_CMD"] + pub cmd: NvU8, + #[doc = "!< type of infoframe"] + pub type_: NvU8, + pub infoframe: NV_INFOFRAME_DATA__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union NV_INFOFRAME_DATA__bindgen_ty_1 { + #[doc = "!< This is NVIDIA-specific and corresponds to the property cmds and associated infoframe."] + pub property: NV_INFOFRAME_PROPERTY, + pub audio: NV_INFOFRAME_AUDIO, + pub video: NV_INFOFRAME_VIDEO, +} +pub const NV_COLOR_CMD_NV_COLOR_CMD_GET: NV_COLOR_CMD = 1; +pub const NV_COLOR_CMD_NV_COLOR_CMD_SET: NV_COLOR_CMD = 2; +pub const NV_COLOR_CMD_NV_COLOR_CMD_IS_SUPPORTED_COLOR: NV_COLOR_CMD = 3; +pub const NV_COLOR_CMD_NV_COLOR_CMD_GET_DEFAULT: NV_COLOR_CMD = 4; +pub type NV_COLOR_CMD = ::std::os::raw::c_int; +pub const NV_COLOR_FORMAT_NV_COLOR_FORMAT_RGB: NV_COLOR_FORMAT = 0; +pub const NV_COLOR_FORMAT_NV_COLOR_FORMAT_YUV422: NV_COLOR_FORMAT = 1; +pub const NV_COLOR_FORMAT_NV_COLOR_FORMAT_YUV444: NV_COLOR_FORMAT = 2; +pub const NV_COLOR_FORMAT_NV_COLOR_FORMAT_YUV420: NV_COLOR_FORMAT = 3; +pub const NV_COLOR_FORMAT_NV_COLOR_FORMAT_DEFAULT: NV_COLOR_FORMAT = 254; +pub const NV_COLOR_FORMAT_NV_COLOR_FORMAT_AUTO: NV_COLOR_FORMAT = 255; +#[doc = "! See Table 14 of CEA-861E. Not all of this is supported by the GPU."] +pub type NV_COLOR_FORMAT = ::std::os::raw::c_int; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_RGB: NV_COLOR_COLORIMETRY = 0; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_YCC601: NV_COLOR_COLORIMETRY = 1; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_YCC709: NV_COLOR_COLORIMETRY = 2; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_XVYCC601: NV_COLOR_COLORIMETRY = 3; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_XVYCC709: NV_COLOR_COLORIMETRY = 4; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_SYCC601: NV_COLOR_COLORIMETRY = 5; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_ADOBEYCC601: NV_COLOR_COLORIMETRY = 6; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_ADOBERGB: NV_COLOR_COLORIMETRY = 7; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_BT2020RGB: NV_COLOR_COLORIMETRY = 8; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_BT2020YCC: NV_COLOR_COLORIMETRY = 9; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_BT2020cYCC: NV_COLOR_COLORIMETRY = 10; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_DEFAULT: NV_COLOR_COLORIMETRY = 254; +pub const NV_COLOR_COLORIMETRY_NV_COLOR_COLORIMETRY_AUTO: NV_COLOR_COLORIMETRY = 255; +pub type NV_COLOR_COLORIMETRY = ::std::os::raw::c_int; +pub const _NV_DYNAMIC_RANGE_NV_DYNAMIC_RANGE_VESA: _NV_DYNAMIC_RANGE = 0; +pub const _NV_DYNAMIC_RANGE_NV_DYNAMIC_RANGE_CEA: _NV_DYNAMIC_RANGE = 1; +pub const _NV_DYNAMIC_RANGE_NV_DYNAMIC_RANGE_AUTO: _NV_DYNAMIC_RANGE = 255; +pub type _NV_DYNAMIC_RANGE = ::std::os::raw::c_int; +pub use self::_NV_DYNAMIC_RANGE as NV_DYNAMIC_RANGE; +pub const _NV_BPC_NV_BPC_DEFAULT: _NV_BPC = 0; +pub const _NV_BPC_NV_BPC_6: _NV_BPC = 1; +pub const _NV_BPC_NV_BPC_8: _NV_BPC = 2; +pub const _NV_BPC_NV_BPC_10: _NV_BPC = 3; +pub const _NV_BPC_NV_BPC_12: _NV_BPC = 4; +pub const _NV_BPC_NV_BPC_16: _NV_BPC = 5; +pub type _NV_BPC = ::std::os::raw::c_int; +pub use self::_NV_BPC as NV_BPC; +#[doc = "!< app/nvcpl make decision to select the desire color format"] +pub const _NV_COLOR_SELECTION_POLICY_NV_COLOR_SELECTION_POLICY_USER: _NV_COLOR_SELECTION_POLICY = 0; +#[doc = "!< driver/ OS make decision to select the best color format"] +pub const _NV_COLOR_SELECTION_POLICY_NV_COLOR_SELECTION_POLICY_BEST_QUALITY: + _NV_COLOR_SELECTION_POLICY = 1; +pub const _NV_COLOR_SELECTION_POLICY_NV_COLOR_SELECTION_POLICY_DEFAULT: _NV_COLOR_SELECTION_POLICY = + 1; +pub const _NV_COLOR_SELECTION_POLICY_NV_COLOR_SELECTION_POLICY_UNKNOWN: _NV_COLOR_SELECTION_POLICY = + 255; +pub type _NV_COLOR_SELECTION_POLICY = ::std::os::raw::c_int; +pub use self::_NV_COLOR_SELECTION_POLICY as NV_COLOR_SELECTION_POLICY; +pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_DEFAULT: _NV_DESKTOP_COLOR_DEPTH = 0; +pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_8BPC: _NV_DESKTOP_COLOR_DEPTH = 1; +pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_10BPC: _NV_DESKTOP_COLOR_DEPTH = 2; +pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_16BPC_FLOAT: _NV_DESKTOP_COLOR_DEPTH = 3; +pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_16BPC_FLOAT_WCG: _NV_DESKTOP_COLOR_DEPTH = + 4; +pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_16BPC_FLOAT_HDR: _NV_DESKTOP_COLOR_DEPTH = + 5; +pub const _NV_DESKTOP_COLOR_DEPTH_NV_DESKTOP_COLOR_DEPTH_MAX_VALUE: _NV_DESKTOP_COLOR_DEPTH = 5; +pub type _NV_DESKTOP_COLOR_DEPTH = ::std::os::raw::c_int; +pub use self::_NV_DESKTOP_COLOR_DEPTH as NV_DESKTOP_COLOR_DEPTH; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COLOR_DATA_V1 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Size of this structure"] + pub size: NvU16, + pub cmd: NvU8, + pub data: _NV_COLOR_DATA_V1__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COLOR_DATA_V1__bindgen_ty_1 { + #[doc = "!< One of NV_COLOR_FORMAT enum values."] + pub colorFormat: NvU8, + #[doc = "!< One of NV_COLOR_COLORIMETRY enum values."] + pub colorimetry: NvU8, +} +pub type NV_COLOR_DATA_V1 = _NV_COLOR_DATA_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COLOR_DATA_V2 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Size of this structure"] + pub size: NvU16, + pub cmd: NvU8, + pub data: _NV_COLOR_DATA_V2__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COLOR_DATA_V2__bindgen_ty_1 { + #[doc = "!< One of NV_COLOR_FORMAT enum values."] + pub colorFormat: NvU8, + #[doc = "!< One of NV_COLOR_COLORIMETRY enum values."] + pub colorimetry: NvU8, + #[doc = "!< One of NV_DYNAMIC_RANGE enum values."] + pub dynamicRange: NvU8, +} +pub type NV_COLOR_DATA_V2 = _NV_COLOR_DATA_V2; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COLOR_DATA_V3 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Size of this structure"] + pub size: NvU16, + pub cmd: NvU8, + pub data: _NV_COLOR_DATA_V3__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COLOR_DATA_V3__bindgen_ty_1 { + #[doc = "!< One of NV_COLOR_FORMAT enum values."] + pub colorFormat: NvU8, + #[doc = "!< One of NV_COLOR_COLORIMETRY enum values."] + pub colorimetry: NvU8, + #[doc = "!< One of NV_DYNAMIC_RANGE enum values."] + pub dynamicRange: NvU8, + #[doc = "!< One of NV_BPC enum values."] + pub bpc: NV_BPC, +} +pub type NV_COLOR_DATA_V3 = _NV_COLOR_DATA_V3; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COLOR_DATA_V4 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Size of this structure"] + pub size: NvU16, + pub cmd: NvU8, + pub data: _NV_COLOR_DATA_V4__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COLOR_DATA_V4__bindgen_ty_1 { + #[doc = "!< One of NV_COLOR_FORMAT enum values."] + pub colorFormat: NvU8, + #[doc = "!< One of NV_COLOR_COLORIMETRY enum values."] + pub colorimetry: NvU8, + #[doc = "!< One of NV_DYNAMIC_RANGE enum values."] + pub dynamicRange: NvU8, + #[doc = "!< One of NV_BPC enum values."] + pub bpc: NV_BPC, + #[doc = "!< One of the color selection policy"] + pub colorSelectionPolicy: NV_COLOR_SELECTION_POLICY, +} +pub type NV_COLOR_DATA_V4 = _NV_COLOR_DATA_V4; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COLOR_DATA_V5 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Size of this structure"] + pub size: NvU16, + pub cmd: NvU8, + pub data: _NV_COLOR_DATA_V5__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_COLOR_DATA_V5__bindgen_ty_1 { + #[doc = "!< One of NV_COLOR_FORMAT enum values."] + pub colorFormat: NvU8, + #[doc = "!< One of NV_COLOR_COLORIMETRY enum values."] + pub colorimetry: NvU8, + #[doc = "!< One of NV_DYNAMIC_RANGE enum values."] + pub dynamicRange: NvU8, + #[doc = "!< One of NV_BPC enum values."] + pub bpc: NV_BPC, + #[doc = "!< One of the color selection policy"] + pub colorSelectionPolicy: NV_COLOR_SELECTION_POLICY, + #[doc = "!< One of NV_DESKTOP_COLOR_DEPTH enum values."] + pub depth: NV_DESKTOP_COLOR_DEPTH, +} +pub type NV_COLOR_DATA_V5 = _NV_COLOR_DATA_V5; +pub type NV_COLOR_DATA = NV_COLOR_DATA_V5; +#[doc = "!< Tells the type of structure used to define the Static Metadata Descriptor block."] +pub const NV_STATIC_METADATA_DESCRIPTOR_ID_NV_STATIC_METADATA_TYPE_1: + NV_STATIC_METADATA_DESCRIPTOR_ID = 0; +#[doc = "! @}"] +pub type NV_STATIC_METADATA_DESCRIPTOR_ID = ::std::os::raw::c_int; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_CAPABILITIES_V1 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Static Metadata Descriptor Id (0 for static metadata type 1)"] + pub static_metadata_descriptor_id: NV_STATIC_METADATA_DESCRIPTOR_ID, + pub display_data: _NV_HDR_CAPABILITIES_V1__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_CAPABILITIES_V1__bindgen_ty_1 { + #[doc = "!< x coordinate of color primary 0 (e.g. Red) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x0: NvU16, + #[doc = "!< y coordinate of color primary 0 (e.g. Red) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y0: NvU16, + #[doc = "!< x coordinate of color primary 1 (e.g. Green) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x1: NvU16, + #[doc = "!< y coordinate of color primary 1 (e.g. Green) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y1: NvU16, + #[doc = "!< x coordinate of color primary 2 (e.g. Blue) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x2: NvU16, + #[doc = "!< y coordinate of color primary 2 (e.g. Blue) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y2: NvU16, + #[doc = "!< x coordinate of white point of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_x: NvU16, + #[doc = "!< y coordinate of white point of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_y: NvU16, + #[doc = "!< Maximum display luminance = desired max luminance of HDR content ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] + pub desired_content_max_luminance: NvU16, + #[doc = "!< Minimum display luminance = desired min luminance of HDR content ([0x0001-0xFFFF] = [1.0 - 6.55350] cd/m^2)"] + pub desired_content_min_luminance: NvU16, + #[doc = "!< Desired maximum Frame-Average Light Level (MaxFALL) of HDR content ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] + pub desired_content_max_frame_average_luminance: NvU16, +} +impl _NV_HDR_CAPABILITIES_V1 { + #[inline] + pub fn isST2084EotfSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isST2084EotfSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isST2084EotfSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isST2084EotfSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isTraditionalHdrGammaSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isTraditionalHdrGammaSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isTraditionalHdrGammaSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isTraditionalHdrGammaSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isEdrSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_isEdrSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isEdrSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isEdrSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn driverExpandDefaultHdrParameters(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_driverExpandDefaultHdrParameters(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn driverExpandDefaultHdrParameters_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_driverExpandDefaultHdrParameters_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isTraditionalSdrGammaSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_isTraditionalSdrGammaSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isTraditionalSdrGammaSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isTraditionalSdrGammaSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 27u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 27u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 27u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isST2084EotfSupported: NvU32, + isTraditionalHdrGammaSupported: NvU32, + isEdrSupported: NvU32, + driverExpandDefaultHdrParameters: NvU32, + isTraditionalSdrGammaSupported: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isST2084EotfSupported: u32 = + unsafe { ::std::mem::transmute(isST2084EotfSupported) }; + isST2084EotfSupported as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isTraditionalHdrGammaSupported: u32 = + unsafe { ::std::mem::transmute(isTraditionalHdrGammaSupported) }; + isTraditionalHdrGammaSupported as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let isEdrSupported: u32 = unsafe { ::std::mem::transmute(isEdrSupported) }; + isEdrSupported as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let driverExpandDefaultHdrParameters: u32 = + unsafe { ::std::mem::transmute(driverExpandDefaultHdrParameters) }; + driverExpandDefaultHdrParameters as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let isTraditionalSdrGammaSupported: u32 = + unsafe { ::std::mem::transmute(isTraditionalSdrGammaSupported) }; + isTraditionalSdrGammaSupported as u64 + }); + __bindgen_bitfield_unit.set(5usize, 27u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_HDR_CAPABILITIES_V1 = _NV_HDR_CAPABILITIES_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_CAPABILITIES_V2 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Static Metadata Descriptor Id (0 for static metadata type 1)"] + pub static_metadata_descriptor_id: NV_STATIC_METADATA_DESCRIPTOR_ID, + pub display_data: _NV_HDR_CAPABILITIES_V2__bindgen_ty_1, + pub dv_static_metadata: _NV_HDR_CAPABILITIES_V2__bindgen_ty_2, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_CAPABILITIES_V2__bindgen_ty_1 { + #[doc = "!< x coordinate of color primary 0 (e.g. Red) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x0: NvU16, + #[doc = "!< y coordinate of color primary 0 (e.g. Red) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y0: NvU16, + #[doc = "!< x coordinate of color primary 1 (e.g. Green) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x1: NvU16, + #[doc = "!< y coordinate of color primary 1 (e.g. Green) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y1: NvU16, + #[doc = "!< x coordinate of color primary 2 (e.g. Blue) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x2: NvU16, + #[doc = "!< y coordinate of color primary 2 (e.g. Blue) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y2: NvU16, + #[doc = "!< x coordinate of white point of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_x: NvU16, + #[doc = "!< y coordinate of white point of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_y: NvU16, + #[doc = "!< Maximum display luminance = desired max luminance of HDR content ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] + pub desired_content_max_luminance: NvU16, + #[doc = "!< Minimum display luminance = desired min luminance of HDR content ([0x0001-0xFFFF] = [1.0 - 6.55350] cd/m^2)"] + pub desired_content_min_luminance: NvU16, + #[doc = "!< Desired maximum Frame-Average Light Level (MaxFALL) of HDR content ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] + pub desired_content_max_frame_average_luminance: NvU16, +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_CAPABILITIES_V2__bindgen_ty_2 { + pub _bitfield_align_1: [u16; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Represents min luminance level of Sink"] + pub target_min_luminance: NvU16, + #[doc = "!< Represents max luminance level of sink"] + pub target_max_luminance: NvU16, + #[doc = "!< Red primary chromaticity coordinate x"] + pub cc_red_x: NvU16, + #[doc = "!< Red primary chromaticity coordinate y"] + pub cc_red_y: NvU16, + #[doc = "!< Green primary chromaticity coordinate x"] + pub cc_green_x: NvU16, + #[doc = "!< Green primary chromaticity coordinate Y"] + pub cc_green_y: NvU16, + #[doc = "!< Blue primary chromaticity coordinate x"] + pub cc_blue_x: NvU16, + #[doc = "!< Blue primary chromaticity coordinate y"] + pub cc_blue_y: NvU16, + #[doc = "!< White primary chromaticity coordinate x"] + pub cc_white_x: NvU16, + #[doc = "!< White primary chromaticity coordinate y"] + pub cc_white_y: NvU16, +} +impl _NV_HDR_CAPABILITIES_V2__bindgen_ty_2 { + #[inline] + pub fn VSVDB_version(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 3u8) as u32) } + } + #[inline] + pub fn set_VSVDB_version(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn VSVDB_version_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_VSVDB_version_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn dm_version(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 8u8) as u32) } + } + #[inline] + pub fn set_dm_version(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn dm_version_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_dm_version_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn supports_2160p60hz(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) } + } + #[inline] + pub fn set_supports_2160p60hz(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(11usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supports_2160p60hz_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 11usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_supports_2160p60hz_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 11usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn supports_YUV422_12bit(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) } + } + #[inline] + pub fn set_supports_YUV422_12bit(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(12usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supports_YUV422_12bit_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 12usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_supports_YUV422_12bit_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 12usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn supports_global_dimming(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) } + } + #[inline] + pub fn set_supports_global_dimming(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(13usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supports_global_dimming_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 13usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_supports_global_dimming_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 13usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn colorimetry(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) } + } + #[inline] + pub fn set_colorimetry(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(14usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn colorimetry_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 14usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_colorimetry_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 14usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn supports_backlight_control(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 2u8) as u32) } + } + #[inline] + pub fn set_supports_backlight_control(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(15usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn supports_backlight_control_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 15usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_supports_backlight_control_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 15usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn backlt_min_luma(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 2u8) as u32) } + } + #[inline] + pub fn set_backlt_min_luma(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(17usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn backlt_min_luma_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 17usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_backlt_min_luma_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 17usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn interface_supported_by_sink(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 2u8) as u32) } + } + #[inline] + pub fn set_interface_supported_by_sink(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(19usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn interface_supported_by_sink_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 19usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_interface_supported_by_sink_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 19usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn supports_10b_12b_444(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 2u8) as u32) } + } + #[inline] + pub fn set_supports_10b_12b_444(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(21usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn supports_10b_12b_444_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 21usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_supports_10b_12b_444_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 21usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 9u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(23usize, 9u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 23usize, + 9u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 23usize, + 9u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + VSVDB_version: NvU32, + dm_version: NvU32, + supports_2160p60hz: NvU32, + supports_YUV422_12bit: NvU32, + supports_global_dimming: NvU32, + colorimetry: NvU32, + supports_backlight_control: NvU32, + backlt_min_luma: NvU32, + interface_supported_by_sink: NvU32, + supports_10b_12b_444: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 3u8, { + let VSVDB_version: u32 = unsafe { ::std::mem::transmute(VSVDB_version) }; + VSVDB_version as u64 + }); + __bindgen_bitfield_unit.set(3usize, 8u8, { + let dm_version: u32 = unsafe { ::std::mem::transmute(dm_version) }; + dm_version as u64 + }); + __bindgen_bitfield_unit.set(11usize, 1u8, { + let supports_2160p60hz: u32 = unsafe { ::std::mem::transmute(supports_2160p60hz) }; + supports_2160p60hz as u64 + }); + __bindgen_bitfield_unit.set(12usize, 1u8, { + let supports_YUV422_12bit: u32 = + unsafe { ::std::mem::transmute(supports_YUV422_12bit) }; + supports_YUV422_12bit as u64 + }); + __bindgen_bitfield_unit.set(13usize, 1u8, { + let supports_global_dimming: u32 = + unsafe { ::std::mem::transmute(supports_global_dimming) }; + supports_global_dimming as u64 + }); + __bindgen_bitfield_unit.set(14usize, 1u8, { + let colorimetry: u32 = unsafe { ::std::mem::transmute(colorimetry) }; + colorimetry as u64 + }); + __bindgen_bitfield_unit.set(15usize, 2u8, { + let supports_backlight_control: u32 = + unsafe { ::std::mem::transmute(supports_backlight_control) }; + supports_backlight_control as u64 + }); + __bindgen_bitfield_unit.set(17usize, 2u8, { + let backlt_min_luma: u32 = unsafe { ::std::mem::transmute(backlt_min_luma) }; + backlt_min_luma as u64 + }); + __bindgen_bitfield_unit.set(19usize, 2u8, { + let interface_supported_by_sink: u32 = + unsafe { ::std::mem::transmute(interface_supported_by_sink) }; + interface_supported_by_sink as u64 + }); + __bindgen_bitfield_unit.set(21usize, 2u8, { + let supports_10b_12b_444: u32 = unsafe { ::std::mem::transmute(supports_10b_12b_444) }; + supports_10b_12b_444 as u64 + }); + __bindgen_bitfield_unit.set(23usize, 9u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +impl _NV_HDR_CAPABILITIES_V2 { + #[inline] + pub fn isST2084EotfSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isST2084EotfSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isST2084EotfSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isST2084EotfSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isTraditionalHdrGammaSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isTraditionalHdrGammaSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isTraditionalHdrGammaSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isTraditionalHdrGammaSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isEdrSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_isEdrSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isEdrSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isEdrSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn driverExpandDefaultHdrParameters(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_driverExpandDefaultHdrParameters(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn driverExpandDefaultHdrParameters_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_driverExpandDefaultHdrParameters_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isTraditionalSdrGammaSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_isTraditionalSdrGammaSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isTraditionalSdrGammaSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isTraditionalSdrGammaSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isDolbyVisionSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_isDolbyVisionSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isDolbyVisionSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isDolbyVisionSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 26u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 26u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 6usize, + 26u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 26u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isST2084EotfSupported: NvU32, + isTraditionalHdrGammaSupported: NvU32, + isEdrSupported: NvU32, + driverExpandDefaultHdrParameters: NvU32, + isTraditionalSdrGammaSupported: NvU32, + isDolbyVisionSupported: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isST2084EotfSupported: u32 = + unsafe { ::std::mem::transmute(isST2084EotfSupported) }; + isST2084EotfSupported as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isTraditionalHdrGammaSupported: u32 = + unsafe { ::std::mem::transmute(isTraditionalHdrGammaSupported) }; + isTraditionalHdrGammaSupported as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let isEdrSupported: u32 = unsafe { ::std::mem::transmute(isEdrSupported) }; + isEdrSupported as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let driverExpandDefaultHdrParameters: u32 = + unsafe { ::std::mem::transmute(driverExpandDefaultHdrParameters) }; + driverExpandDefaultHdrParameters as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let isTraditionalSdrGammaSupported: u32 = + unsafe { ::std::mem::transmute(isTraditionalSdrGammaSupported) }; + isTraditionalSdrGammaSupported as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let isDolbyVisionSupported: u32 = + unsafe { ::std::mem::transmute(isDolbyVisionSupported) }; + isDolbyVisionSupported as u64 + }); + __bindgen_bitfield_unit.set(6usize, 26u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_HDR_CAPABILITIES_V2 = _NV_HDR_CAPABILITIES_V2; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_CAPABILITIES_V3 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Static Metadata Descriptor Id (0 for static metadata type 1)"] + pub static_metadata_descriptor_id: NV_STATIC_METADATA_DESCRIPTOR_ID, + pub display_data: _NV_HDR_CAPABILITIES_V3__bindgen_ty_1, + pub dv_static_metadata: _NV_HDR_CAPABILITIES_V3__bindgen_ty_2, + pub hdr10plus_vsvdb: _NV_HDR_CAPABILITIES_V3__bindgen_ty_3, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_CAPABILITIES_V3__bindgen_ty_1 { + #[doc = "!< x coordinate of color primary 0 (e.g. Red) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x0: NvU16, + #[doc = "!< y coordinate of color primary 0 (e.g. Red) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y0: NvU16, + #[doc = "!< x coordinate of color primary 1 (e.g. Green) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x1: NvU16, + #[doc = "!< y coordinate of color primary 1 (e.g. Green) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y1: NvU16, + #[doc = "!< x coordinate of color primary 2 (e.g. Blue) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x2: NvU16, + #[doc = "!< y coordinate of color primary 2 (e.g. Blue) of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y2: NvU16, + #[doc = "!< x coordinate of white point of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_x: NvU16, + #[doc = "!< y coordinate of white point of the display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_y: NvU16, + #[doc = "!< Maximum display luminance = desired max luminance of HDR content ([0x0000-0xFFFF] = [0.0 - 65535.0] cd/m^2, in units of 1 cd/m^2)"] + pub desired_content_max_luminance: NvU16, + #[doc = "!< Minimum display luminance = desired min luminance of HDR content ([0x0000-0xFFFF] = [0.0 - 6.55350] cd/m^2, in units of 0.0001 cd/m^2)"] + pub desired_content_min_luminance: NvU16, + #[doc = "!< Desired maximum Frame-Average Light Level (MaxFALL) of HDR content ([0x0000-0xFFFF] = [0.0 - 65535.0] cd/m^2, in units of 1 cd/m^2)"] + pub desired_content_max_frame_average_luminance: NvU16, +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_CAPABILITIES_V3__bindgen_ty_2 { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Represents min luminance level of Sink"] + pub target_min_luminance: NvU16, + #[doc = "!< Represents max luminance level of sink"] + pub target_max_luminance: NvU16, + #[doc = "!< Red primary chromaticity coordinate x"] + pub cc_red_x: NvU16, + #[doc = "!< Red primary chromaticity coordinate y"] + pub cc_red_y: NvU16, + #[doc = "!< Green primary chromaticity coordinate x"] + pub cc_green_x: NvU16, + #[doc = "!< Green primary chromaticity coordinate Y"] + pub cc_green_y: NvU16, + #[doc = "!< Blue primary chromaticity coordinate x"] + pub cc_blue_x: NvU16, + #[doc = "!< Blue primary chromaticity coordinate y"] + pub cc_blue_y: NvU16, + #[doc = "!< White primary chromaticity coordinate x"] + pub cc_white_x: NvU16, + #[doc = "!< White primary chromaticity coordinate y"] + pub cc_white_y: NvU16, +} +impl _NV_HDR_CAPABILITIES_V3__bindgen_ty_2 { + #[inline] + pub fn VSVDB_version(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 3u8) as u32) } + } + #[inline] + pub fn set_VSVDB_version(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn VSVDB_version_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 3u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_VSVDB_version_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn dm_version(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 8u8) as u32) } + } + #[inline] + pub fn set_dm_version(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn dm_version_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_dm_version_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn supports_2160p60hz(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) } + } + #[inline] + pub fn set_supports_2160p60hz(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(11usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supports_2160p60hz_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 11usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_supports_2160p60hz_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 11usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn supports_YUV422_12bit(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) } + } + #[inline] + pub fn set_supports_YUV422_12bit(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(12usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supports_YUV422_12bit_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 12usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_supports_YUV422_12bit_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 12usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn supports_global_dimming(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) } + } + #[inline] + pub fn set_supports_global_dimming(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(13usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supports_global_dimming_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 13usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_supports_global_dimming_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 13usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn colorimetry(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) } + } + #[inline] + pub fn set_colorimetry(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(14usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn colorimetry_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 14usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_colorimetry_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 14usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn supports_backlight_control(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 2u8) as u32) } + } + #[inline] + pub fn set_supports_backlight_control(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(15usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn supports_backlight_control_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 15usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_supports_backlight_control_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 15usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn backlt_min_luma(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 2u8) as u32) } + } + #[inline] + pub fn set_backlt_min_luma(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(17usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn backlt_min_luma_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 17usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_backlt_min_luma_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 17usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn interface_supported_by_sink(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 2u8) as u32) } + } + #[inline] + pub fn set_interface_supported_by_sink(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(19usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn interface_supported_by_sink_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 19usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_interface_supported_by_sink_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 19usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn supports_10b_12b_444(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 2u8) as u32) } + } + #[inline] + pub fn set_supports_10b_12b_444(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(21usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn supports_10b_12b_444_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 21usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_supports_10b_12b_444_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 21usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn parity(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u32) } + } + #[inline] + pub fn set_parity(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(23usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn parity_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 23usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_parity_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 23usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(24usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 24usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 24usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + VSVDB_version: NvU32, + dm_version: NvU32, + supports_2160p60hz: NvU32, + supports_YUV422_12bit: NvU32, + supports_global_dimming: NvU32, + colorimetry: NvU32, + supports_backlight_control: NvU32, + backlt_min_luma: NvU32, + interface_supported_by_sink: NvU32, + supports_10b_12b_444: NvU32, + parity: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 3u8, { + let VSVDB_version: u32 = unsafe { ::std::mem::transmute(VSVDB_version) }; + VSVDB_version as u64 + }); + __bindgen_bitfield_unit.set(3usize, 8u8, { + let dm_version: u32 = unsafe { ::std::mem::transmute(dm_version) }; + dm_version as u64 + }); + __bindgen_bitfield_unit.set(11usize, 1u8, { + let supports_2160p60hz: u32 = unsafe { ::std::mem::transmute(supports_2160p60hz) }; + supports_2160p60hz as u64 + }); + __bindgen_bitfield_unit.set(12usize, 1u8, { + let supports_YUV422_12bit: u32 = + unsafe { ::std::mem::transmute(supports_YUV422_12bit) }; + supports_YUV422_12bit as u64 + }); + __bindgen_bitfield_unit.set(13usize, 1u8, { + let supports_global_dimming: u32 = + unsafe { ::std::mem::transmute(supports_global_dimming) }; + supports_global_dimming as u64 + }); + __bindgen_bitfield_unit.set(14usize, 1u8, { + let colorimetry: u32 = unsafe { ::std::mem::transmute(colorimetry) }; + colorimetry as u64 + }); + __bindgen_bitfield_unit.set(15usize, 2u8, { + let supports_backlight_control: u32 = + unsafe { ::std::mem::transmute(supports_backlight_control) }; + supports_backlight_control as u64 + }); + __bindgen_bitfield_unit.set(17usize, 2u8, { + let backlt_min_luma: u32 = unsafe { ::std::mem::transmute(backlt_min_luma) }; + backlt_min_luma as u64 + }); + __bindgen_bitfield_unit.set(19usize, 2u8, { + let interface_supported_by_sink: u32 = + unsafe { ::std::mem::transmute(interface_supported_by_sink) }; + interface_supported_by_sink as u64 + }); + __bindgen_bitfield_unit.set(21usize, 2u8, { + let supports_10b_12b_444: u32 = unsafe { ::std::mem::transmute(supports_10b_12b_444) }; + supports_10b_12b_444 as u64 + }); + __bindgen_bitfield_unit.set(23usize, 1u8, { + let parity: u32 = unsafe { ::std::mem::transmute(parity) }; + parity as u64 + }); + __bindgen_bitfield_unit.set(24usize, 8u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[repr(align(2))] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_CAPABILITIES_V3__bindgen_ty_3 { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>, +} +impl _NV_HDR_CAPABILITIES_V3__bindgen_ty_3 { + #[inline] + pub fn application_version(&self) -> NvU16 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u16) } + } + #[inline] + pub fn set_application_version(&mut self, val: NvU16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn application_version_raw(this: *const Self) -> NvU16 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 2u8, + ) as u16) + } + } + #[inline] + pub unsafe fn set_application_version_raw(this: *mut Self, val: NvU16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn full_frame_peak_luminance_index(&self) -> NvU16 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 2u8) as u16) } + } + #[inline] + pub fn set_full_frame_peak_luminance_index(&mut self, val: NvU16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn full_frame_peak_luminance_index_raw(this: *const Self) -> NvU16 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 2u8, + ) as u16) + } + } + #[inline] + pub unsafe fn set_full_frame_peak_luminance_index_raw(this: *mut Self, val: NvU16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn peak_luminance_index(&self) -> NvU16 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u16) } + } + #[inline] + pub fn set_peak_luminance_index(&mut self, val: NvU16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn peak_luminance_index_raw(this: *const Self) -> NvU16 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 4u8, + ) as u16) + } + } + #[inline] + pub unsafe fn set_peak_luminance_index_raw(this: *mut Self, val: NvU16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU16 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 8u8) as u16) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU16 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 8usize, + 8u8, + ) as u16) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU16) { + unsafe { + let val: u16 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 8usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + application_version: NvU16, + full_frame_peak_luminance_index: NvU16, + peak_luminance_index: NvU16, + reserved: NvU16, + ) -> __BindgenBitfieldUnit<[u8; 2usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 2u8, { + let application_version: u16 = unsafe { ::std::mem::transmute(application_version) }; + application_version as u64 + }); + __bindgen_bitfield_unit.set(2usize, 2u8, { + let full_frame_peak_luminance_index: u16 = + unsafe { ::std::mem::transmute(full_frame_peak_luminance_index) }; + full_frame_peak_luminance_index as u64 + }); + __bindgen_bitfield_unit.set(4usize, 4u8, { + let peak_luminance_index: u16 = unsafe { ::std::mem::transmute(peak_luminance_index) }; + peak_luminance_index as u64 + }); + __bindgen_bitfield_unit.set(8usize, 8u8, { + let reserved: u16 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +impl _NV_HDR_CAPABILITIES_V3 { + #[inline] + pub fn isST2084EotfSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isST2084EotfSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isST2084EotfSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isST2084EotfSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isTraditionalHdrGammaSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isTraditionalHdrGammaSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isTraditionalHdrGammaSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isTraditionalHdrGammaSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isEdrSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_isEdrSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isEdrSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isEdrSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn driverExpandDefaultHdrParameters(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_driverExpandDefaultHdrParameters(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn driverExpandDefaultHdrParameters_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_driverExpandDefaultHdrParameters_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isTraditionalSdrGammaSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_isTraditionalSdrGammaSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isTraditionalSdrGammaSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isTraditionalSdrGammaSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isDolbyVisionSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_isDolbyVisionSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isDolbyVisionSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isDolbyVisionSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isHdr10PlusSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } + } + #[inline] + pub fn set_isHdr10PlusSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isHdr10PlusSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 6usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isHdr10PlusSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isHdr10PlusGamingSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } + } + #[inline] + pub fn set_isHdr10PlusGamingSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isHdr10PlusGamingSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 7usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isHdr10PlusGamingSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 7usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isNvidiaCertifiedDisplay(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) } + } + #[inline] + pub fn set_isNvidiaCertifiedDisplay(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isNvidiaCertifiedDisplay_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 8usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isNvidiaCertifiedDisplay_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 8usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 23u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(9usize, 23u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 9usize, + 23u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 9usize, + 23u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isST2084EotfSupported: NvU32, + isTraditionalHdrGammaSupported: NvU32, + isEdrSupported: NvU32, + driverExpandDefaultHdrParameters: NvU32, + isTraditionalSdrGammaSupported: NvU32, + isDolbyVisionSupported: NvU32, + isHdr10PlusSupported: NvU32, + isHdr10PlusGamingSupported: NvU32, + isNvidiaCertifiedDisplay: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isST2084EotfSupported: u32 = + unsafe { ::std::mem::transmute(isST2084EotfSupported) }; + isST2084EotfSupported as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isTraditionalHdrGammaSupported: u32 = + unsafe { ::std::mem::transmute(isTraditionalHdrGammaSupported) }; + isTraditionalHdrGammaSupported as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let isEdrSupported: u32 = unsafe { ::std::mem::transmute(isEdrSupported) }; + isEdrSupported as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let driverExpandDefaultHdrParameters: u32 = + unsafe { ::std::mem::transmute(driverExpandDefaultHdrParameters) }; + driverExpandDefaultHdrParameters as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let isTraditionalSdrGammaSupported: u32 = + unsafe { ::std::mem::transmute(isTraditionalSdrGammaSupported) }; + isTraditionalSdrGammaSupported as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let isDolbyVisionSupported: u32 = + unsafe { ::std::mem::transmute(isDolbyVisionSupported) }; + isDolbyVisionSupported as u64 + }); + __bindgen_bitfield_unit.set(6usize, 1u8, { + let isHdr10PlusSupported: u32 = unsafe { ::std::mem::transmute(isHdr10PlusSupported) }; + isHdr10PlusSupported as u64 + }); + __bindgen_bitfield_unit.set(7usize, 1u8, { + let isHdr10PlusGamingSupported: u32 = + unsafe { ::std::mem::transmute(isHdr10PlusGamingSupported) }; + isHdr10PlusGamingSupported as u64 + }); + __bindgen_bitfield_unit.set(8usize, 1u8, { + let isNvidiaCertifiedDisplay: u32 = + unsafe { ::std::mem::transmute(isNvidiaCertifiedDisplay) }; + isNvidiaCertifiedDisplay as u64 + }); + __bindgen_bitfield_unit.set(9usize, 23u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_HDR_CAPABILITIES_V3 = _NV_HDR_CAPABILITIES_V3; +pub type NV_HDR_CAPABILITIES = NV_HDR_CAPABILITIES_V3; +#[doc = "!< Get current HDR output configuration"] +pub const NV_HDR_CMD_NV_HDR_CMD_GET: NV_HDR_CMD = 0; +#[doc = "!< Set HDR output configuration"] +pub const NV_HDR_CMD_NV_HDR_CMD_SET: NV_HDR_CMD = 1; +#[doc = "! @}"] +pub type NV_HDR_CMD = ::std::os::raw::c_int; +#[doc = "!< Turn off HDR"] +pub const NV_HDR_MODE_NV_HDR_MODE_OFF: NV_HDR_MODE = 0; +#[doc = "!< Source: CCCS [a.k.a FP16 scRGB, linear, sRGB primaries, [-65504,0, 65504] range, RGB(1,1,1) = 80nits] Output : UHDA HDR [a.k.a HDR10, RGB/YCC 10/12bpc ST2084(PQ) EOTF RGB(1,1,1) = 10000 nits, Rec2020 color primaries, ST2086 static HDR metadata]. This is the only supported production HDR mode."] +pub const NV_HDR_MODE_NV_HDR_MODE_UHDA: NV_HDR_MODE = 2; +#[doc = "!< Experimental mode only, not for production! Source: HDR10 RGB 10bpc Output: HDR10 RGB 10 bpc - signal UHDA HDR mode (PQ + Rec2020) to the sink but send source pixel values unmodified (no PQ or Rec2020 conversions) - assumes source is already in HDR10 format."] +pub const NV_HDR_MODE_NV_HDR_MODE_UHDA_PASSTHROUGH: NV_HDR_MODE = 5; +#[doc = "!< Experimental mode only, not for production! Source: RGB8 Dolby Vision encoded (12 bpc YCbCr422 packed into RGB8) Output: Dolby Vision encoded : Application is to encoded frames in DV format and embed DV dynamic metadata as described in Dolby Vision specification."] +pub const NV_HDR_MODE_NV_HDR_MODE_DOLBY_VISION: NV_HDR_MODE = 7; +#[doc = "!< Do not use! Internal test mode only, to be removed. Source: CCCS (a.k.a FP16 scRGB) Output : EDR (Extended Dynamic Range) - HDR content is tonemapped and gamut mapped to output on regular SDR display set to max luminance ( ~300 nits )."] +pub const NV_HDR_MODE_NV_HDR_MODE_EDR: NV_HDR_MODE = 3; +#[doc = "!< Do not use! Internal test mode only, to be removed. Source: any Output: SDR (Standard Dynamic Range), we continuously send SDR EOTF InfoFrame signaling, HDMI compliance testing."] +pub const NV_HDR_MODE_NV_HDR_MODE_SDR: NV_HDR_MODE = 4; +#[doc = "!< Do not use! Internal test mode only, to be removed. Source: CCCS (a.k.a FP16 scRGB) Output : notebook HDR"] +pub const NV_HDR_MODE_NV_HDR_MODE_UHDA_NB: NV_HDR_MODE = 6; +#[doc = "!< Do not use! Obsolete, to be removed. NV_HDR_MODE_UHDBD == NV_HDR_MODE_UHDA, reflects obsolete pre-UHDA naming convention."] +pub const NV_HDR_MODE_NV_HDR_MODE_UHDBD: NV_HDR_MODE = 2; +pub type NV_HDR_MODE = ::std::os::raw::c_int; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_COLOR_DATA_V1 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Command get/set"] + pub cmd: NV_HDR_CMD, + #[doc = "!< HDR mode"] + pub hdrMode: NV_HDR_MODE, + #[doc = "!< Static Metadata Descriptor Id (0 for static metadata type 1)"] + pub static_metadata_descriptor_id: NV_STATIC_METADATA_DESCRIPTOR_ID, + pub mastering_display_data: _NV_HDR_COLOR_DATA_V1__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_COLOR_DATA_V1__bindgen_ty_1 { + #[doc = "!< x coordinate of color primary 0 (e.g. Red) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x0: NvU16, + #[doc = "!< y coordinate of color primary 0 (e.g. Red) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y0: NvU16, + #[doc = "!< x coordinate of color primary 1 (e.g. Green) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x1: NvU16, + #[doc = "!< y coordinate of color primary 1 (e.g. Green) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y1: NvU16, + #[doc = "!< x coordinate of color primary 2 (e.g. Blue) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x2: NvU16, + #[doc = "!< y coordinate of color primary 2 (e.g. Blue) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y2: NvU16, + #[doc = "!< x coordinate of white point of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_x: NvU16, + #[doc = "!< y coordinate of white point of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_y: NvU16, + #[doc = "!< Maximum display mastering luminance ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] + pub max_display_mastering_luminance: NvU16, + #[doc = "!< Minimum display mastering luminance ([0x0001-0xFFFF] = [1.0 - 6.55350] cd/m^2)"] + pub min_display_mastering_luminance: NvU16, + #[doc = "!< Maximum Content Light level (MaxCLL) ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] + pub max_content_light_level: NvU16, + #[doc = "!< Maximum Frame-Average Light Level (MaxFALL) ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] + pub max_frame_average_light_level: NvU16, +} +pub type NV_HDR_COLOR_DATA_V1 = _NV_HDR_COLOR_DATA_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_COLOR_DATA_V2 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Command get/set"] + pub cmd: NV_HDR_CMD, + #[doc = "!< HDR mode"] + pub hdrMode: NV_HDR_MODE, + #[doc = "!< Static Metadata Descriptor Id (0 for static metadata type 1)"] + pub static_metadata_descriptor_id: NV_STATIC_METADATA_DESCRIPTOR_ID, + pub mastering_display_data: _NV_HDR_COLOR_DATA_V2__bindgen_ty_1, + #[doc = "!< Optional, One of NV_COLOR_FORMAT enum values, if set it will apply requested color format for HDR session"] + pub hdrColorFormat: NV_COLOR_FORMAT, + #[doc = "!< Optional, One of NV_DYNAMIC_RANGE enum values, if set it will apply requested dynamic range for HDR session"] + pub hdrDynamicRange: NV_DYNAMIC_RANGE, + #[doc = "!< Optional, One of NV_BPC enum values, if set it will apply requested color depth\n!< Dolby Vision mode: DV supports specific combinations of colorformat, dynamic range and bpc. Please refer Dolby Vision specification.\n!< If invalid or no combination is passed driver will force default combination of RGB format + full range + 8bpc.\n!< HDR mode: These fields are ignored in hdr mode"] + pub hdrBpc: NV_BPC, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_COLOR_DATA_V2__bindgen_ty_1 { + #[doc = "!< x coordinate of color primary 0 (e.g. Red) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x0: NvU16, + #[doc = "!< y coordinate of color primary 0 (e.g. Red) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y0: NvU16, + #[doc = "!< x coordinate of color primary 1 (e.g. Green) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x1: NvU16, + #[doc = "!< y coordinate of color primary 1 (e.g. Green) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y1: NvU16, + #[doc = "!< x coordinate of color primary 2 (e.g. Blue) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x2: NvU16, + #[doc = "!< y coordinate of color primary 2 (e.g. Blue) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y2: NvU16, + #[doc = "!< x coordinate of white point of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_x: NvU16, + #[doc = "!< y coordinate of white point of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_y: NvU16, + #[doc = "!< Maximum display mastering luminance ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] + pub max_display_mastering_luminance: NvU16, + #[doc = "!< Minimum display mastering luminance ([0x0001-0xFFFF] = [1.0 - 6.55350] cd/m^2)"] + pub min_display_mastering_luminance: NvU16, + #[doc = "!< Maximum Content Light level (MaxCLL) ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] + pub max_content_light_level: NvU16, + #[doc = "!< Maximum Frame-Average Light Level (MaxFALL) ([0x0001-0xFFFF] = [1.0 - 65535.0] cd/m^2)"] + pub max_frame_average_light_level: NvU16, +} +pub type NV_HDR_COLOR_DATA_V2 = _NV_HDR_COLOR_DATA_V2; +pub type NV_HDR_COLOR_DATA = NV_HDR_COLOR_DATA_V2; +#[doc = "!< sRGB IEC 61966-2-1:1999 == DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709"] +pub const _NV_COLORSPACE_TYPE_NV_COLORSPACE_sRGB: _NV_COLORSPACE_TYPE = 0; +#[doc = "!< FP16 linear with sRGB color primaries == DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709"] +pub const _NV_COLORSPACE_TYPE_NV_COLORSPACE_xRGB: _NV_COLORSPACE_TYPE = 1; +#[doc = "!< ITU-R Rec BT.2100 (HDR10) == DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020"] +pub const _NV_COLORSPACE_TYPE_NV_COLORSPACE_REC2100: _NV_COLORSPACE_TYPE = 12; +pub type _NV_COLORSPACE_TYPE = ::std::os::raw::c_int; +pub use self::_NV_COLORSPACE_TYPE as NV_COLORSPACE_TYPE; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_HDR_METADATA_V1 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< x coordinate of color primary 0 (e.g. Red) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x0: NvU16, + #[doc = "!< y coordinate of color primary 0 (e.g. Red) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y0: NvU16, + #[doc = "!< x coordinate of color primary 1 (e.g. Green) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x1: NvU16, + #[doc = "!< y coordinate of color primary 1 (e.g. Green) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y1: NvU16, + #[doc = "!< x coordinate of color primary 2 (e.g. Blue) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_x2: NvU16, + #[doc = "!< y coordinate of color primary 2 (e.g. Blue) of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayPrimary_y2: NvU16, + #[doc = "!< x coordinate of white point of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_x: NvU16, + #[doc = "!< y coordinate of white point of mastering display ([0x0000-0xC350] = [0.0 - 1.0])"] + pub displayWhitePoint_y: NvU16, + #[doc = "!< Maximum display mastering luminance ([0x0000-0xFFFF] = [0.0 - 65535.0] cd/m^2, in units of 1 cd/m^2)"] + pub max_display_mastering_luminance: NvU16, + #[doc = "!< Minimum display mastering luminance ([0x0000-0xFFFF] = [0.0 - 6.55350] cd/m^2, in units of 0.0001 cd/m^2)"] + pub min_display_mastering_luminance: NvU16, + #[doc = "!< Maximum Content Light level (MaxCLL) ([0x0000-0xFFFF] = [0.0 - 65535.0] cd/m^2, in units of 1 cd/m^2)"] + pub max_content_light_level: NvU16, + #[doc = "!< Maximum Frame-Average Light Level (MaxFALL) ([0x0000-0xFFFF] = [0.0 - 65535.0] cd/m^2, in units of 1 cd/m^2)"] + pub max_frame_average_light_level: NvU16, +} +pub type NV_HDR_METADATA_V1 = _NV_HDR_METADATA_V1; +pub type NV_HDR_METADATA = NV_HDR_METADATA_V1; +pub const _NV_DISPLAY_OUTPUT_MODE_NV_DISPLAY_OUTPUT_MODE_SDR: _NV_DISPLAY_OUTPUT_MODE = 0; +pub const _NV_DISPLAY_OUTPUT_MODE_NV_DISPLAY_OUTPUT_MODE_HDR10: _NV_DISPLAY_OUTPUT_MODE = 1; +pub const _NV_DISPLAY_OUTPUT_MODE_NV_DISPLAY_OUTPUT_MODE_HDR10PLUS_GAMING: _NV_DISPLAY_OUTPUT_MODE = + 2; +pub type _NV_DISPLAY_OUTPUT_MODE = ::std::os::raw::c_int; +pub use self::_NV_DISPLAY_OUTPUT_MODE as NV_DISPLAY_OUTPUT_MODE; +pub const _NV_HDR_TONEMAPPING_METHOD_NV_HDR_TONEMAPPING_APP: _NV_HDR_TONEMAPPING_METHOD = 0; +pub const _NV_HDR_TONEMAPPING_METHOD_NV_HDR_TONEMAPPING_GPU: _NV_HDR_TONEMAPPING_METHOD = 1; +pub type _NV_HDR_TONEMAPPING_METHOD = ::std::os::raw::c_int; +pub use self::_NV_HDR_TONEMAPPING_METHOD as NV_HDR_TONEMAPPING_METHOD; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_DISPLAY_COLORIMETRY_V1 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< min luminance, cd/m^2"] + pub min_luminance: f32, + #[doc = "!< max 100% frame luminance, cd/m^2"] + pub max_full_frame_luminance: f32, + #[doc = "!< max 10% frame luminance, cd/m^2"] + pub max_luminance: f32, + #[doc = "!< HDR brightness luminance scaling factor applied by GPU on output pixels"] + pub hdrBrightnessLuminanceScalingFactor: f32, + #[doc = "!< red primary chromaticity coordinate x"] + pub red_primary_x: f32, + #[doc = "!< red primary chromaticity coordinate y"] + pub red_primary_y: f32, + #[doc = "!< green primary chromaticity coordinate x"] + pub green_primary_x: f32, + #[doc = "!< green primary chromaticity coordinate y"] + pub green_primary_y: f32, + #[doc = "!< blue primary chromaticity coordinate x"] + pub blue_primary_x: f32, + #[doc = "!< blue primary chromaticity coordinate y"] + pub blue_primary_y: f32, + #[doc = "!< white point chromaticity coordinate x"] + pub white_point_x: f32, + #[doc = "!< white point chromaticity coordinate y"] + pub white_point_y: f32, +} +pub type NV_DISPLAY_COLORIMETRY_V1 = _NV_DISPLAY_COLORIMETRY_V1; +pub type NV_DISPLAY_COLORIMETRY = NV_DISPLAY_COLORIMETRY_V1; +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_DISP_GetTiming()."] +#[repr(C)] +#[repr(align(4))] +#[derive(Copy, Clone)] +pub struct NV_TIMING_FLAG { + pub _bitfield_align_1: [u16; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>, + pub __bindgen_anon_1: NV_TIMING_FLAG__bindgen_ty_1, + pub _bitfield_align_2: [u8; 0], + pub _bitfield_2: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 5usize], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union NV_TIMING_FLAG__bindgen_ty_1 { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>, +} +impl NV_TIMING_FLAG__bindgen_ty_1 { + #[inline] + pub fn tvFormat(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) } + } + #[inline] + pub fn set_tvFormat(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn tvFormat_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_tvFormat_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn ceaId(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 8u8) as u32) } + } + #[inline] + pub fn set_ceaId(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn ceaId_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 8usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_ceaId_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 8usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn nvPsfId(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 8u8) as u32) } + } + #[inline] + pub fn set_nvPsfId(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(16usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn nvPsfId_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 16usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_nvPsfId_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 16usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + tvFormat: NvU32, + ceaId: NvU32, + nvPsfId: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 3usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 8u8, { + let tvFormat: u32 = unsafe { ::std::mem::transmute(tvFormat) }; + tvFormat as u64 + }); + __bindgen_bitfield_unit.set(8usize, 8u8, { + let ceaId: u32 = unsafe { ::std::mem::transmute(ceaId) }; + ceaId as u64 + }); + __bindgen_bitfield_unit.set(16usize, 8u8, { + let nvPsfId: u32 = unsafe { ::std::mem::transmute(nvPsfId) }; + nvPsfId as u64 + }); + __bindgen_bitfield_unit + } +} +impl NV_TIMING_FLAG { + #[inline] + pub fn isInterlaced(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32) } + } + #[inline] + pub fn set_isInterlaced(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn isInterlaced_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 4u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isInterlaced_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved0(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 12u8) as u32) } + } + #[inline] + pub fn set_reserved0(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 12u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved0_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 12u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved0_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 12u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isInterlaced: NvU32, + reserved0: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 2usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 4u8, { + let isInterlaced: u32 = unsafe { ::std::mem::transmute(isInterlaced) }; + isInterlaced as u64 + }); + __bindgen_bitfield_unit.set(4usize, 12u8, { + let reserved0: u32 = unsafe { ::std::mem::transmute(reserved0) }; + reserved0 as u64 + }); + __bindgen_bitfield_unit + } + #[inline] + pub fn scaling(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 8u8) as u32) } + } + #[inline] + pub fn set_scaling(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_2.set(0usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn scaling_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_2), + 0usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_scaling_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 0usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_2(scaling: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 8u8, { + let scaling: u32 = unsafe { ::std::mem::transmute(scaling) }; + scaling as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_DISP_GetTiming()."] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_TIMING_INPUT { + #[doc = "!< (IN) structure version"] + pub version: NvU32, + #[doc = "!< Visible horizontal size"] + pub width: NvU32, + #[doc = "!< Visible vertical size"] + pub height: NvU32, + #[doc = "!< Timing refresh rate"] + pub rr: f32, + #[doc = "!< Flag containing additional info for timing calculation."] + pub flag: NV_TIMING_FLAG, + #[doc = "!< Timing type(formula) to use for calculating the timing"] + pub type_: NV_TIMING_OVERRIDE, +} +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_DISP_GetTiming()."] +pub type NV_TIMING_INPUT = _NV_TIMING_INPUT; +pub const NV_MONITOR_CAPS_TYPE_NV_MONITOR_CAPS_TYPE_HDMI_VSDB: NV_MONITOR_CAPS_TYPE = 4096; +pub const NV_MONITOR_CAPS_TYPE_NV_MONITOR_CAPS_TYPE_HDMI_VCDB: NV_MONITOR_CAPS_TYPE = 4097; +pub const NV_MONITOR_CAPS_TYPE_NV_MONITOR_CAPS_TYPE_GENERIC: NV_MONITOR_CAPS_TYPE = 4098; +#[doc = "! HDMI-related and extended CAPs"] +pub type NV_MONITOR_CAPS_TYPE = ::std::os::raw::c_int; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MONITOR_CAPS_VCDB { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, +} +impl _NV_MONITOR_CAPS_VCDB { + #[inline] + pub fn quantizationRangeYcc(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) } + } + #[inline] + pub fn set_quantizationRangeYcc(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn quantizationRangeYcc_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_quantizationRangeYcc_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn quantizationRangeRgb(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) } + } + #[inline] + pub fn set_quantizationRangeRgb(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn quantizationRangeRgb_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_quantizationRangeRgb_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn scanInfoPreferredVideoFormat(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 2u8) as u8) } + } + #[inline] + pub fn set_scanInfoPreferredVideoFormat(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn scanInfoPreferredVideoFormat_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 2u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_scanInfoPreferredVideoFormat_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn scanInfoITVideoFormats(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 2u8) as u8) } + } + #[inline] + pub fn set_scanInfoITVideoFormats(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn scanInfoITVideoFormats_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 2u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_scanInfoITVideoFormats_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn scanInfoCEVideoFormats(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 2u8) as u8) } + } + #[inline] + pub fn set_scanInfoCEVideoFormats(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn scanInfoCEVideoFormats_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 6usize, + 2u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_scanInfoCEVideoFormats_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + quantizationRangeYcc: NvU8, + quantizationRangeRgb: NvU8, + scanInfoPreferredVideoFormat: NvU8, + scanInfoITVideoFormats: NvU8, + scanInfoCEVideoFormats: NvU8, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let quantizationRangeYcc: u8 = unsafe { ::std::mem::transmute(quantizationRangeYcc) }; + quantizationRangeYcc as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let quantizationRangeRgb: u8 = unsafe { ::std::mem::transmute(quantizationRangeRgb) }; + quantizationRangeRgb as u64 + }); + __bindgen_bitfield_unit.set(2usize, 2u8, { + let scanInfoPreferredVideoFormat: u8 = + unsafe { ::std::mem::transmute(scanInfoPreferredVideoFormat) }; + scanInfoPreferredVideoFormat as u64 + }); + __bindgen_bitfield_unit.set(4usize, 2u8, { + let scanInfoITVideoFormats: u8 = + unsafe { ::std::mem::transmute(scanInfoITVideoFormats) }; + scanInfoITVideoFormats as u64 + }); + __bindgen_bitfield_unit.set(6usize, 2u8, { + let scanInfoCEVideoFormats: u8 = + unsafe { ::std::mem::transmute(scanInfoCEVideoFormats) }; + scanInfoCEVideoFormats as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_MONITOR_CAPS_VCDB = _NV_MONITOR_CAPS_VCDB; +#[doc = "! See NvAPI_DISP_GetMonitorCapabilities()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MONITOR_CAPS_VSDB { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>, + #[doc = "!< Bye 4"] + pub maxTmdsClock: NvU8, + pub _bitfield_align_2: [u8; 0], + pub _bitfield_2: __BindgenBitfieldUnit<[u8; 1usize]>, + #[doc = "!< Byte 6"] + pub videoLatency: NvU8, + #[doc = "!< Byte 7"] + pub audioLatency: NvU8, + #[doc = "!< Byte 8"] + pub interlacedVideoLatency: NvU8, + #[doc = "!< Byte 9"] + pub interlacedAudioLatency: NvU8, + pub _bitfield_align_3: [u8; 0], + pub _bitfield_3: __BindgenBitfieldUnit<[u8; 2usize]>, + #[doc = "!< Keeping maximum length for 3 bits"] + pub hdmi_vic: [NvU8; 7usize], + #[doc = "!< Keeping maximum length for 5 bits"] + pub hdmi_3d: [NvU8; 31usize], +} +impl _NV_MONITOR_CAPS_VSDB { + #[inline] + pub fn sourcePhysicalAddressB(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u8) } + } + #[inline] + pub fn set_sourcePhysicalAddressB(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn sourcePhysicalAddressB_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 4u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_sourcePhysicalAddressB_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn sourcePhysicalAddressA(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u8) } + } + #[inline] + pub fn set_sourcePhysicalAddressA(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn sourcePhysicalAddressA_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 4u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_sourcePhysicalAddressA_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn sourcePhysicalAddressD(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 4u8) as u8) } + } + #[inline] + pub fn set_sourcePhysicalAddressD(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn sourcePhysicalAddressD_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 8usize, + 4u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_sourcePhysicalAddressD_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 8usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn sourcePhysicalAddressC(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 4u8) as u8) } + } + #[inline] + pub fn set_sourcePhysicalAddressC(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(12usize, 4u8, val as u64) + } + } + #[inline] + pub unsafe fn sourcePhysicalAddressC_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 12usize, + 4u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_sourcePhysicalAddressC_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 12usize, + 4u8, + val as u64, + ) + } + } + #[inline] + pub fn supportDualDviOperation(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u8) } + } + #[inline] + pub fn set_supportDualDviOperation(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(16usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supportDualDviOperation_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 16usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_supportDualDviOperation_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 16usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved6(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 2u8) as u8) } + } + #[inline] + pub fn set_reserved6(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(17usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved6_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 17usize, + 2u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_reserved6_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 17usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn supportDeepColorYCbCr444(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u8) } + } + #[inline] + pub fn set_supportDeepColorYCbCr444(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(19usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supportDeepColorYCbCr444_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 19usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_supportDeepColorYCbCr444_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 19usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn supportDeepColor30bits(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u8) } + } + #[inline] + pub fn set_supportDeepColor30bits(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(20usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supportDeepColor30bits_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 20usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_supportDeepColor30bits_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 20usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn supportDeepColor36bits(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u8) } + } + #[inline] + pub fn set_supportDeepColor36bits(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(21usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supportDeepColor36bits_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 21usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_supportDeepColor36bits_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 21usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn supportDeepColor48bits(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u8) } + } + #[inline] + pub fn set_supportDeepColor48bits(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(22usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supportDeepColor48bits_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 22usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_supportDeepColor48bits_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 22usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn supportAI(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u8) } + } + #[inline] + pub fn set_supportAI(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(23usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supportAI_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 23usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_supportAI_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 23usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + sourcePhysicalAddressB: NvU8, + sourcePhysicalAddressA: NvU8, + sourcePhysicalAddressD: NvU8, + sourcePhysicalAddressC: NvU8, + supportDualDviOperation: NvU8, + reserved6: NvU8, + supportDeepColorYCbCr444: NvU8, + supportDeepColor30bits: NvU8, + supportDeepColor36bits: NvU8, + supportDeepColor48bits: NvU8, + supportAI: NvU8, + ) -> __BindgenBitfieldUnit<[u8; 3usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 4u8, { + let sourcePhysicalAddressB: u8 = + unsafe { ::std::mem::transmute(sourcePhysicalAddressB) }; + sourcePhysicalAddressB as u64 + }); + __bindgen_bitfield_unit.set(4usize, 4u8, { + let sourcePhysicalAddressA: u8 = + unsafe { ::std::mem::transmute(sourcePhysicalAddressA) }; + sourcePhysicalAddressA as u64 + }); + __bindgen_bitfield_unit.set(8usize, 4u8, { + let sourcePhysicalAddressD: u8 = + unsafe { ::std::mem::transmute(sourcePhysicalAddressD) }; + sourcePhysicalAddressD as u64 + }); + __bindgen_bitfield_unit.set(12usize, 4u8, { + let sourcePhysicalAddressC: u8 = + unsafe { ::std::mem::transmute(sourcePhysicalAddressC) }; + sourcePhysicalAddressC as u64 + }); + __bindgen_bitfield_unit.set(16usize, 1u8, { + let supportDualDviOperation: u8 = + unsafe { ::std::mem::transmute(supportDualDviOperation) }; + supportDualDviOperation as u64 + }); + __bindgen_bitfield_unit.set(17usize, 2u8, { + let reserved6: u8 = unsafe { ::std::mem::transmute(reserved6) }; + reserved6 as u64 + }); + __bindgen_bitfield_unit.set(19usize, 1u8, { + let supportDeepColorYCbCr444: u8 = + unsafe { ::std::mem::transmute(supportDeepColorYCbCr444) }; + supportDeepColorYCbCr444 as u64 + }); + __bindgen_bitfield_unit.set(20usize, 1u8, { + let supportDeepColor30bits: u8 = + unsafe { ::std::mem::transmute(supportDeepColor30bits) }; + supportDeepColor30bits as u64 + }); + __bindgen_bitfield_unit.set(21usize, 1u8, { + let supportDeepColor36bits: u8 = + unsafe { ::std::mem::transmute(supportDeepColor36bits) }; + supportDeepColor36bits as u64 + }); + __bindgen_bitfield_unit.set(22usize, 1u8, { + let supportDeepColor48bits: u8 = + unsafe { ::std::mem::transmute(supportDeepColor48bits) }; + supportDeepColor48bits as u64 + }); + __bindgen_bitfield_unit.set(23usize, 1u8, { + let supportAI: u8 = unsafe { ::std::mem::transmute(supportAI) }; + supportAI as u64 + }); + __bindgen_bitfield_unit + } + #[inline] + pub fn cnc0SupportGraphicsTextContent(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 1u8) as u8) } + } + #[inline] + pub fn set_cnc0SupportGraphicsTextContent(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_2.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn cnc0SupportGraphicsTextContent_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_2), + 0usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_cnc0SupportGraphicsTextContent_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn cnc1SupportPhotoContent(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(1usize, 1u8) as u8) } + } + #[inline] + pub fn set_cnc1SupportPhotoContent(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_2.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn cnc1SupportPhotoContent_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_2), + 1usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_cnc1SupportPhotoContent_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn cnc2SupportCinemaContent(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(2usize, 1u8) as u8) } + } + #[inline] + pub fn set_cnc2SupportCinemaContent(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_2.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn cnc2SupportCinemaContent_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_2), + 2usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_cnc2SupportCinemaContent_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn cnc3SupportGameContent(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(3usize, 1u8) as u8) } + } + #[inline] + pub fn set_cnc3SupportGameContent(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_2.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn cnc3SupportGameContent_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_2), + 3usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_cnc3SupportGameContent_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved8(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(4usize, 1u8) as u8) } + } + #[inline] + pub fn set_reserved8(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_2.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved8_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_2), + 4usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_reserved8_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn hasVicEntries(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(5usize, 1u8) as u8) } + } + #[inline] + pub fn set_hasVicEntries(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_2.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn hasVicEntries_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_2), + 5usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_hasVicEntries_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn hasInterlacedLatencyField(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(6usize, 1u8) as u8) } + } + #[inline] + pub fn set_hasInterlacedLatencyField(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_2.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn hasInterlacedLatencyField_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_2), + 6usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_hasInterlacedLatencyField_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 6usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn hasLatencyField(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_2.get(7usize, 1u8) as u8) } + } + #[inline] + pub fn set_hasLatencyField(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_2.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn hasLatencyField_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_2), + 7usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_hasLatencyField_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_2), + 7usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_2( + cnc0SupportGraphicsTextContent: NvU8, + cnc1SupportPhotoContent: NvU8, + cnc2SupportCinemaContent: NvU8, + cnc3SupportGameContent: NvU8, + reserved8: NvU8, + hasVicEntries: NvU8, + hasInterlacedLatencyField: NvU8, + hasLatencyField: NvU8, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let cnc0SupportGraphicsTextContent: u8 = + unsafe { ::std::mem::transmute(cnc0SupportGraphicsTextContent) }; + cnc0SupportGraphicsTextContent as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let cnc1SupportPhotoContent: u8 = + unsafe { ::std::mem::transmute(cnc1SupportPhotoContent) }; + cnc1SupportPhotoContent as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let cnc2SupportCinemaContent: u8 = + unsafe { ::std::mem::transmute(cnc2SupportCinemaContent) }; + cnc2SupportCinemaContent as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let cnc3SupportGameContent: u8 = + unsafe { ::std::mem::transmute(cnc3SupportGameContent) }; + cnc3SupportGameContent as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let reserved8: u8 = unsafe { ::std::mem::transmute(reserved8) }; + reserved8 as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let hasVicEntries: u8 = unsafe { ::std::mem::transmute(hasVicEntries) }; + hasVicEntries as u64 + }); + __bindgen_bitfield_unit.set(6usize, 1u8, { + let hasInterlacedLatencyField: u8 = + unsafe { ::std::mem::transmute(hasInterlacedLatencyField) }; + hasInterlacedLatencyField as u64 + }); + __bindgen_bitfield_unit.set(7usize, 1u8, { + let hasLatencyField: u8 = unsafe { ::std::mem::transmute(hasLatencyField) }; + hasLatencyField as u64 + }); + __bindgen_bitfield_unit + } + #[inline] + pub fn reserved13(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_3.get(0usize, 7u8) as u8) } + } + #[inline] + pub fn set_reserved13(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_3.set(0usize, 7u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved13_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_3), + 0usize, + 7u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_reserved13_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_3), + 0usize, + 7u8, + val as u64, + ) + } + } + #[inline] + pub fn has3dEntries(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_3.get(7usize, 1u8) as u8) } + } + #[inline] + pub fn set_has3dEntries(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_3.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn has3dEntries_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_3), + 7usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_has3dEntries_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_3), + 7usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn hdmi3dLength(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_3.get(8usize, 5u8) as u8) } + } + #[inline] + pub fn set_hdmi3dLength(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_3.set(8usize, 5u8, val as u64) + } + } + #[inline] + pub unsafe fn hdmi3dLength_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_3), + 8usize, + 5u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_hdmi3dLength_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_3), + 8usize, + 5u8, + val as u64, + ) + } + } + #[inline] + pub fn hdmiVicLength(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_3.get(13usize, 3u8) as u8) } + } + #[inline] + pub fn set_hdmiVicLength(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_3.set(13usize, 3u8, val as u64) + } + } + #[inline] + pub unsafe fn hdmiVicLength_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_3), + 13usize, + 3u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_hdmiVicLength_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_3), + 13usize, + 3u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_3( + reserved13: NvU8, + has3dEntries: NvU8, + hdmi3dLength: NvU8, + hdmiVicLength: NvU8, + ) -> __BindgenBitfieldUnit<[u8; 2usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 7u8, { + let reserved13: u8 = unsafe { ::std::mem::transmute(reserved13) }; + reserved13 as u64 + }); + __bindgen_bitfield_unit.set(7usize, 1u8, { + let has3dEntries: u8 = unsafe { ::std::mem::transmute(has3dEntries) }; + has3dEntries as u64 + }); + __bindgen_bitfield_unit.set(8usize, 5u8, { + let hdmi3dLength: u8 = unsafe { ::std::mem::transmute(hdmi3dLength) }; + hdmi3dLength as u64 + }); + __bindgen_bitfield_unit.set(13usize, 3u8, { + let hdmiVicLength: u8 = unsafe { ::std::mem::transmute(hdmiVicLength) }; + hdmiVicLength as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! See NvAPI_DISP_GetMonitorCapabilities()."] +pub type NV_MONITOR_CAPS_VSDB = _NV_MONITOR_CAPS_VSDB; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MONITOR_CAPS_GENERIC { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, +} +impl _NV_MONITOR_CAPS_GENERIC { + #[inline] + pub fn supportVRR(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) } + } + #[inline] + pub fn set_supportVRR(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supportVRR_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_supportVRR_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn supportULMB(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) } + } + #[inline] + pub fn set_supportULMB(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supportULMB_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_supportULMB_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isTrueGsync(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) } + } + #[inline] + pub fn set_isTrueGsync(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isTrueGsync_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_isTrueGsync_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isRLACapable(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) } + } + #[inline] + pub fn set_isRLACapable(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isRLACapable_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_isRLACapable_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn currentlyCapableOfVRR(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) } + } + #[inline] + pub fn set_currentlyCapableOfVRR(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn currentlyCapableOfVRR_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_currentlyCapableOfVRR_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn isBasicVRR(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) } + } + #[inline] + pub fn set_isBasicVRR(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isBasicVRR_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_isBasicVRR_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 2u8) as u8) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 6usize, + 2u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + supportVRR: NvU8, + supportULMB: NvU8, + isTrueGsync: NvU8, + isRLACapable: NvU8, + currentlyCapableOfVRR: NvU8, + isBasicVRR: NvU8, + reserved: NvU8, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let supportVRR: u8 = unsafe { ::std::mem::transmute(supportVRR) }; + supportVRR as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let supportULMB: u8 = unsafe { ::std::mem::transmute(supportULMB) }; + supportULMB as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let isTrueGsync: u8 = unsafe { ::std::mem::transmute(isTrueGsync) }; + isTrueGsync as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let isRLACapable: u8 = unsafe { ::std::mem::transmute(isRLACapable) }; + isRLACapable as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let currentlyCapableOfVRR: u8 = unsafe { ::std::mem::transmute(currentlyCapableOfVRR) }; + currentlyCapableOfVRR as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let isBasicVRR: u8 = unsafe { ::std::mem::transmute(isBasicVRR) }; + isBasicVRR as u64 + }); + __bindgen_bitfield_unit.set(6usize, 2u8, { + let reserved: u8 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_MONITOR_CAPS_GENERIC = _NV_MONITOR_CAPS_GENERIC; +#[doc = "! See NvAPI_DISP_GetMonitorCapabilities()."] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _NV_MONITOR_CAPABILITIES_V1 { + pub version: NvU32, + pub size: NvU16, + pub infoType: NvU32, + #[doc = "!< Out: VGA, TV, DVI, HDMI, DP"] + pub connectorType: NvU32, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub data: _NV_MONITOR_CAPABILITIES_V1__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union _NV_MONITOR_CAPABILITIES_V1__bindgen_ty_1 { + pub vsdb: NV_MONITOR_CAPS_VSDB, + pub vcdb: NV_MONITOR_CAPS_VCDB, + pub caps: NV_MONITOR_CAPS_GENERIC, +} +impl _NV_MONITOR_CAPABILITIES_V1 { + #[inline] + pub fn bIsValidInfo(&self) -> NvU8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) } + } + #[inline] + pub fn set_bIsValidInfo(&mut self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsValidInfo_raw(this: *const Self) -> NvU8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_bIsValidInfo_raw(this: *mut Self, val: NvU8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1(bIsValidInfo: NvU8) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsValidInfo: u8 = unsafe { ::std::mem::transmute(bIsValidInfo) }; + bIsValidInfo as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! See NvAPI_DISP_GetMonitorCapabilities()."] +pub type NV_MONITOR_CAPABILITIES_V1 = _NV_MONITOR_CAPABILITIES_V1; +#[doc = "! See NvAPI_DISP_GetMonitorCapabilities()."] +pub type NV_MONITOR_CAPABILITIES = NV_MONITOR_CAPABILITIES_V1; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MONITOR_COLOR_DATA { + pub version: NvU32, + #[doc = "!< One of the supported color formats"] + pub colorFormat: NV_DP_COLOR_FORMAT, + #[doc = "!< One of the supported bit depths"] + pub backendBitDepths: NV_DP_BPC, +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_MONITOR_COLOR_CAPS_V1 = _NV_MONITOR_COLOR_DATA; +#[doc = "! \\ingroup dispcontrol"] +pub type NV_MONITOR_COLOR_CAPS = NV_MONITOR_COLOR_CAPS_V1; +#[doc = "! \\ingroup dispcontrol\n! Used in NvAPI_DISP_EnumCustomDisplay() and NvAPI_DISP_TryCustomDisplay()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_CUSTOM_DISPLAY { + pub version: NvU32, + #[doc = "!< Source surface(source mode) width"] + pub width: NvU32, + #[doc = "!< Source surface(source mode) height"] + pub height: NvU32, + #[doc = "!< Source surface color depth.\"0\" means all 8/16/32bpp"] + pub depth: NvU32, + #[doc = "!< Color format (optional)"] + pub colorFormat: NV_FORMAT, + #[doc = "!< For multimon support, should be set to (0,0,1.0,1.0) for now."] + pub srcPartition: NV_VIEWPORTF, + #[doc = "!< Horizontal scaling ratio"] + pub xRatio: f32, + #[doc = "!< Vertical scaling ratio"] + pub yRatio: f32, + #[doc = "!< Timing used to program TMDS/DAC/LVDS/HDMI/TVEncoder, etc."] + pub timing: NV_TIMING, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +impl NV_CUSTOM_DISPLAY { + #[inline] + pub fn hwModeSetOnly(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_hwModeSetOnly(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn hwModeSetOnly_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_hwModeSetOnly_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1(hwModeSetOnly: NvU32) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let hwModeSetOnly: u32 = unsafe { ::std::mem::transmute(hwModeSetOnly) }; + hwModeSetOnly as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup dispcontrol\n! @{"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_EDID_DATA_V1 { + #[doc = "!< Structure version."] + pub version: NvU32, + #[doc = "!< Pointer to EDID data."] + pub pEDID: *mut NvU8, + #[doc = "!< Size of EDID data."] + pub sizeOfEDID: NvU32, +} +#[doc = "! \\ingroup dispcontrol\n! @{"] +pub type NV_EDID_DATA_V1 = _NV_EDID_DATA_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_EDID_DATA_V2 { + #[doc = "!< Structure version."] + pub version: NvU32, + #[doc = "!< Pointer to EDID data."] + pub pEDID: *mut NvU8, + #[doc = "!< Size of EDID data."] + pub sizeOfEDID: NvU32, + #[doc = "!< Reserved for future use."] + pub reserved: [NvU32; 8usize], +} +pub type NV_EDID_DATA_V2 = _NV_EDID_DATA_V2; +pub type NV_EDID_DATA = NV_EDID_DATA_V2; +#[doc = "! @}"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GET_ADAPTIVE_SYNC_DATA_V1 { + #[doc = "!< [in] structure version"] + pub version: NvU32, + #[doc = "!< [out] maximum frame interval in micro seconds as set previously using NvAPI_DISP_SetAdaptiveSyncData function."] + pub maxFrameInterval: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< [out] Number of times the last flip was shown on the screen"] + pub lastFlipRefreshCount: NvU32, + #[doc = "!< [out] Timestamp for the lastest flip on the screen"] + pub lastFlipTimeStamp: NvU64, + #[doc = "!< reserved for future use."] + pub reservedEx: [NvU32; 4usize], +} +impl _NV_GET_ADAPTIVE_SYNC_DATA_V1 { + #[inline] + pub fn bDisableAdaptiveSync(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bDisableAdaptiveSync(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bDisableAdaptiveSync_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bDisableAdaptiveSync_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bDisableFrameSplitting(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bDisableFrameSplitting(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bDisableFrameSplitting_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bDisableFrameSplitting_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 30u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 30u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 30u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bDisableAdaptiveSync: NvU32, + bDisableFrameSplitting: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bDisableAdaptiveSync: u32 = unsafe { ::std::mem::transmute(bDisableAdaptiveSync) }; + bDisableAdaptiveSync as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bDisableFrameSplitting: u32 = + unsafe { ::std::mem::transmute(bDisableFrameSplitting) }; + bDisableFrameSplitting as u64 + }); + __bindgen_bitfield_unit.set(2usize, 30u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! @}"] +pub type NV_GET_ADAPTIVE_SYNC_DATA_V1 = _NV_GET_ADAPTIVE_SYNC_DATA_V1; +#[doc = "! @}"] +pub type NV_GET_ADAPTIVE_SYNC_DATA = NV_GET_ADAPTIVE_SYNC_DATA_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_SET_ADAPTIVE_SYNC_DATA_V1 { + #[doc = "!< [in] structure version"] + pub version: NvU32, + #[doc = "!< [in] deprecated, please use maxFrameIntervalNs instead\n!< If maxFrameInterval is sent as 0, default values from EDID will be used."] + pub maxFrameInterval: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Ensure the alignment is 8 bytes and reserve it for future use."] + pub reserved1: NvU32, + #[doc = "!< [in] maximum frame interval in nano seconds.\n!< If maxFrameIntervalNs is sent as 0, default values from EDID will be used."] + pub maxFrameIntervalNs: NvU64, + #[doc = "!< reserved for future use."] + pub reservedEx: [NvU32; 4usize], +} +impl _NV_SET_ADAPTIVE_SYNC_DATA_V1 { + #[inline] + pub fn bDisableAdaptiveSync(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bDisableAdaptiveSync(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bDisableAdaptiveSync_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bDisableAdaptiveSync_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bDisableFrameSplitting(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bDisableFrameSplitting(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bDisableFrameSplitting_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bDisableFrameSplitting_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 30u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 30u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 30u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bDisableAdaptiveSync: NvU32, + bDisableFrameSplitting: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bDisableAdaptiveSync: u32 = unsafe { ::std::mem::transmute(bDisableAdaptiveSync) }; + bDisableAdaptiveSync as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bDisableFrameSplitting: u32 = + unsafe { ::std::mem::transmute(bDisableFrameSplitting) }; + bDisableFrameSplitting as u64 + }); + __bindgen_bitfield_unit.set(2usize, 30u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_SET_ADAPTIVE_SYNC_DATA_V1 = _NV_SET_ADAPTIVE_SYNC_DATA_V1; +pub type NV_SET_ADAPTIVE_SYNC_DATA = NV_SET_ADAPTIVE_SYNC_DATA_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GET_VIRTUAL_REFRESH_RATE_DATA_V1 { + #[doc = "!< [in] structure version"] + pub version: NvU32, + #[doc = "!< [out] frame interval in micro seconds if Virtual RR is currently applied"] + pub frameIntervalUs: NvU32, + #[doc = "!< [out] Refresh Rate * 1000"] + pub rrx1k: NvU32, + #[doc = "!< [out] If the content is Gaming"] + pub bIsGamingVrr: NvU32, + #[doc = "!< reserved for future use."] + pub reservedEx: [NvU32; 6usize], +} +pub type NV_GET_VIRTUAL_REFRESH_RATE_DATA_V1 = _NV_GET_VIRTUAL_REFRESH_RATE_DATA_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GET_VIRTUAL_REFRESH_RATE_DATA_V2 { + #[doc = "!< [in] structure version"] + pub version: NvU32, + #[doc = "!< [out] frame interval in micro seconds if Virtual RR is currently applied. This variable is deprecated in V2 and should not be used."] + pub frameIntervalUs: NvU32, + #[doc = "!< [out] Refresh Rate * 1000"] + pub rrx1k: NvU32, + #[doc = "!< [out] If the content is Gaming"] + pub bIsGamingVrr: NvU32, + #[doc = "!< [out] frame interval in nano seconds if Virtual RR is currently applied"] + pub frameIntervalNs: NvU64, + #[doc = "!< reserved for future use."] + pub reservedEx: [NvU32; 4usize], +} +pub type NV_GET_VIRTUAL_REFRESH_RATE_DATA_V2 = _NV_GET_VIRTUAL_REFRESH_RATE_DATA_V2; +pub type NV_GET_VIRTUAL_REFRESH_RATE_DATA = NV_GET_VIRTUAL_REFRESH_RATE_DATA_V2; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_SET_VIRTUAL_REFRESH_RATE_DATA_V1 { + #[doc = "!< [in] structure version"] + pub version: NvU32, + #[doc = "!< [in] frame interval in micro seconds if Virtual RR is currently applied"] + pub frameIntervalUs: NvU32, + #[doc = "!< [in] Refresh Rate * 1000"] + pub rrx1k: NvU32, + #[doc = "!< [in] If the content is Gaming"] + pub bIsGamingVrr: NvU32, + #[doc = "!< reserved for future use."] + pub reservedEx: [NvU32; 6usize], +} +pub type NV_SET_VIRTUAL_REFRESH_RATE_DATA_V1 = _NV_SET_VIRTUAL_REFRESH_RATE_DATA_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_SET_VIRTUAL_REFRESH_RATE_DATA_V2 { + #[doc = "!< [in] structure version"] + pub version: NvU32, + #[doc = "!< [in] frame interval in micro seconds if Virtual RR is currently applied. This variable is deprecated in V2 and should not be used."] + pub frameIntervalUs: NvU32, + #[doc = "!< [in] Refresh Rate * 1000"] + pub rrx1k: NvU32, + #[doc = "!< [in] If the content is Gaming"] + pub bIsGamingVrr: NvU32, + #[doc = "!< [in] frame interval in nano seconds if Virtual RR is currently applied"] + pub frameIntervalNs: NvU64, + #[doc = "!< reserved for future use."] + pub reservedEx: [NvU32; 4usize], +} +pub type NV_SET_VIRTUAL_REFRESH_RATE_DATA_V2 = _NV_SET_VIRTUAL_REFRESH_RATE_DATA_V2; +pub type NV_SET_VIRTUAL_REFRESH_RATE_DATA = NV_SET_VIRTUAL_REFRESH_RATE_DATA_V2; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_SET_PREFERRED_STEREO_DISPLAY_V1 { + #[doc = "!< [in] Structure version"] + pub version: NvU32, + #[doc = "!< [in] Monitor Identifier to be set"] + pub displayId: NvU32, + #[doc = "!< Reserved for future use without adding versioning"] + pub reserved: NvU32, +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_SET_PREFERRED_STEREO_DISPLAY = NV_SET_PREFERRED_STEREO_DISPLAY_V1; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_GET_PREFERRED_STEREO_DISPLAY_V1 { + #[doc = "!< [in] Structure version"] + pub version: NvU32, + #[doc = "!< [out] The queried stereo display"] + pub displayId: NvU32, + #[doc = "!< Reserved for future use without adding versioning"] + pub reserved: NvU32, +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_GET_PREFERRED_STEREO_DISPLAY = NV_GET_PREFERRED_STEREO_DISPLAY_V1; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_DISPLAY_ID_INFO_DATA_V1 { + #[doc = "!< [in] Structure version"] + pub version: NvU32, + #[doc = "!< [out] Locally unique ID (LUID) of the display adapter on which the given display is present."] + pub adapterId: LUID, + #[doc = "!< [out] The target identifier of the given display. This is also called AdapterRelativeId."] + pub targetId: NvU32, + #[doc = "!< Reserved for future use."] + pub reserved: [NvU32; 4usize], +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_DISPLAY_ID_INFO_DATA_V1 = _NV_DISPLAY_ID_INFO_DATA_V1; +#[doc = "! \\ingroup dispcontrol"] +pub type NV_DISPLAY_ID_INFO_DATA = NV_DISPLAY_ID_INFO_DATA_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_TARGET_INFO_DATA_V1 { + #[doc = "!< [in] Structure version"] + pub version: NvU32, + #[doc = "!< [in] Locally unique ID (LUID) of the display adapter on which the target is present."] + pub adapterId: LUID, + #[doc = "!< [in] The target identifier. This is also called AdapterRelativeId."] + pub targetId: NvU32, + #[doc = "!< [out] An array of displayIds corresponding to the input adapterId and targetId.\n!< If the input (targetId, adapterId) pair is a display grid (Mosaic/Surround),\n!< then the output contains the displayId of every display that is part of the display grid.\n!< Otherwise, it contains exactly one displayId.\n!< These displayId values are unique to this (targetId, adapterId) pair."] + pub displayId: [NvU32; 128usize], + #[doc = "!< [out] The number of displays returned in displayId array."] + pub displayIdCount: NvU32, + #[doc = "!< Reserved for future use."] + pub reserved: [NvU32; 4usize], +} +pub type NV_TARGET_INFO_DATA_V1 = _NV_TARGET_INFO_DATA_V1; +pub type NV_TARGET_INFO_DATA = NV_TARGET_INFO_DATA_V1; +#[doc = "! \\ingroup dispcontrol"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GET_VRR_INFO_V1 { + #[doc = "!< [in] Structure version"] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Reserved for future use"] + pub reservedEx: [NvU32; 4usize], +} +impl _NV_GET_VRR_INFO_V1 { + #[inline] + pub fn bIsVRREnabled(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsVRREnabled(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsVRREnabled_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsVRREnabled_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsVRRPossible(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsVRRPossible(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsVRRPossible_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsVRRPossible_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsVRRRequested(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsVRRRequested(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsVRRRequested_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsVRRRequested_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsVRRIndicatorEnabled(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsVRRIndicatorEnabled(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsVRRIndicatorEnabled_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsVRRIndicatorEnabled_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsDisplayInVRRMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsDisplayInVRRMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsDisplayInVRRMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsDisplayInVRRMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 27u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 27u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 27u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsVRREnabled: NvU32, + bIsVRRPossible: NvU32, + bIsVRRRequested: NvU32, + bIsVRRIndicatorEnabled: NvU32, + bIsDisplayInVRRMode: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsVRREnabled: u32 = unsafe { ::std::mem::transmute(bIsVRREnabled) }; + bIsVRREnabled as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bIsVRRPossible: u32 = unsafe { ::std::mem::transmute(bIsVRRPossible) }; + bIsVRRPossible as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let bIsVRRRequested: u32 = unsafe { ::std::mem::transmute(bIsVRRRequested) }; + bIsVRRRequested as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let bIsVRRIndicatorEnabled: u32 = + unsafe { ::std::mem::transmute(bIsVRRIndicatorEnabled) }; + bIsVRRIndicatorEnabled as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let bIsDisplayInVRRMode: u32 = unsafe { ::std::mem::transmute(bIsDisplayInVRRMode) }; + bIsDisplayInVRRMode as u64 + }); + __bindgen_bitfield_unit.set(5usize, 27u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! \\ingroup dispcontrol"] +pub type NV_GET_VRR_INFO_V1 = _NV_GET_VRR_INFO_V1; +#[doc = "! \\ingroup dispcontrol"] +pub type NV_GET_VRR_INFO = NV_GET_VRR_INFO_V1; +#[doc = "! This structure defines the topology details."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_MOSAIC_TOPO_DETAILS { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Logical GPU for this topology"] + pub hLogicalGPU: NvLogicalGpuHandle, + #[doc = "!< 0 means topology is valid with the current hardware."] + pub validityMask: NvU32, + #[doc = "!< Number of displays in a row"] + pub rowCount: NvU32, + #[doc = "!< Number of displays in a column"] + pub colCount: NvU32, + pub gpuLayout: [[NV_MOSAIC_TOPO_DETAILS__bindgen_ty_1; 8usize]; 8usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_MOSAIC_TOPO_DETAILS__bindgen_ty_1 { + #[doc = "!< Physical GPU to be used in the topology (0 if GPU missing)"] + pub hPhysicalGPU: NvPhysicalGpuHandle, + #[doc = "!< Connected display target (0 if no display connected)"] + pub displayOutputId: NvU32, + #[doc = "!< Pixels of overlap on left of target: (+overlap, -gap)"] + pub overlapX: NvS32, + #[doc = "!< Pixels of overlap on top of target: (+overlap, -gap)"] + pub overlapY: NvS32, +} +#[doc = "!< All mosaic topologies"] +pub const NV_MOSAIC_TOPO_TYPE_NV_MOSAIC_TOPO_TYPE_ALL: NV_MOSAIC_TOPO_TYPE = 0; +#[doc = "!< Basic Mosaic topologies"] +pub const NV_MOSAIC_TOPO_TYPE_NV_MOSAIC_TOPO_TYPE_BASIC: NV_MOSAIC_TOPO_TYPE = 1; +#[doc = "!< Passive Stereo topologies"] +pub const NV_MOSAIC_TOPO_TYPE_NV_MOSAIC_TOPO_TYPE_PASSIVE_STEREO: NV_MOSAIC_TOPO_TYPE = 2; +#[doc = "!< Not supported at this time"] +pub const NV_MOSAIC_TOPO_TYPE_NV_MOSAIC_TOPO_TYPE_SCALED_CLONE: NV_MOSAIC_TOPO_TYPE = 3; +#[doc = "!< Not supported at this time"] +pub const NV_MOSAIC_TOPO_TYPE_NV_MOSAIC_TOPO_TYPE_PASSIVE_STEREO_SCALED_CLONE: NV_MOSAIC_TOPO_TYPE = + 4; +#[doc = "!< Always leave this at end of the enum"] +pub const NV_MOSAIC_TOPO_TYPE_NV_MOSAIC_TOPO_TYPE_MAX: NV_MOSAIC_TOPO_TYPE = 5; +#[doc = "! These values refer to the different types of Mosaic topologies that are possible. When\n! getting the supported Mosaic topologies, you can specify one of these types to narrow down\n! the returned list to only those that match the given type."] +pub type NV_MOSAIC_TOPO_TYPE = ::std::os::raw::c_int; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_NONE: NV_MOSAIC_TOPO = 0; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_BEGIN_BASIC: NV_MOSAIC_TOPO = 1; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x2_BASIC: NV_MOSAIC_TOPO = 1; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_2x1_BASIC: NV_MOSAIC_TOPO = 2; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x3_BASIC: NV_MOSAIC_TOPO = 3; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_3x1_BASIC: NV_MOSAIC_TOPO = 4; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x4_BASIC: NV_MOSAIC_TOPO = 5; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_4x1_BASIC: NV_MOSAIC_TOPO = 6; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_2x2_BASIC: NV_MOSAIC_TOPO = 7; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_2x3_BASIC: NV_MOSAIC_TOPO = 8; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_2x4_BASIC: NV_MOSAIC_TOPO = 9; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_3x2_BASIC: NV_MOSAIC_TOPO = 10; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_4x2_BASIC: NV_MOSAIC_TOPO = 11; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x5_BASIC: NV_MOSAIC_TOPO = 12; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x6_BASIC: NV_MOSAIC_TOPO = 13; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_7x1_BASIC: NV_MOSAIC_TOPO = 14; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_END_BASIC: NV_MOSAIC_TOPO = 23; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_BEGIN_PASSIVE_STEREO: NV_MOSAIC_TOPO = 24; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x2_PASSIVE_STEREO: NV_MOSAIC_TOPO = 24; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_2x1_PASSIVE_STEREO: NV_MOSAIC_TOPO = 25; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x3_PASSIVE_STEREO: NV_MOSAIC_TOPO = 26; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_3x1_PASSIVE_STEREO: NV_MOSAIC_TOPO = 27; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_1x4_PASSIVE_STEREO: NV_MOSAIC_TOPO = 28; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_4x1_PASSIVE_STEREO: NV_MOSAIC_TOPO = 29; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_2x2_PASSIVE_STEREO: NV_MOSAIC_TOPO = 30; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_END_PASSIVE_STEREO: NV_MOSAIC_TOPO = 34; +pub const NV_MOSAIC_TOPO_NV_MOSAIC_TOPO_MAX: NV_MOSAIC_TOPO = 35; +#[doc = "! This is a complete list of supported Mosaic topologies.\n!\n! Using a \"Basic\" topology combines multiple monitors to create a single desktop.\n!\n! Using a \"Passive\" topology combines multiples monitors to create a passive stereo desktop.\n! In passive stereo, two identical topologies combine - one topology is used for the right eye and the other identical //! topology (targeting different displays) is used for the left eye. \\n\n! NOTE: common\\inc\\nvEscDef.h shadows a couple PASSIVE_STEREO enums. If this\n! enum list changes and effects the value of NV_MOSAIC_TOPO_BEGIN_PASSIVE_STEREO\n! please update the corresponding value in nvEscDef.h"] +pub type NV_MOSAIC_TOPO = ::std::os::raw::c_int; +#[doc = "! This is a \"topology brief\" structure. It tells you what you need to know about\n! a topology at a high level. A list of these is returned when you query for the\n! supported Mosaic information.\n!\n! If you need more detailed information about the topology, call\n! NvAPI_Mosaic_GetTopoGroup() with the topology value from this structure."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_MOSAIC_TOPO_BRIEF { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< The topology"] + pub topo: NV_MOSAIC_TOPO, + #[doc = "!< 1 if topo is enabled, else 0"] + pub enabled: NvU32, + #[doc = "!< 1 if topo *can* be enabled, else 0"] + pub isPossible: NvU32, +} +#[doc = "! Basic per-display settings that are used in setting/getting the Mosaic mode"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MOSAIC_DISPLAY_SETTING_V1 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Per-display width"] + pub width: NvU32, + #[doc = "!< Per-display height"] + pub height: NvU32, + #[doc = "!< Bits per pixel"] + pub bpp: NvU32, + #[doc = "!< Display frequency"] + pub freq: NvU32, +} +#[doc = "! Basic per-display settings that are used in setting/getting the Mosaic mode"] +pub type NV_MOSAIC_DISPLAY_SETTING_V1 = _NV_MOSAIC_DISPLAY_SETTING_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_MOSAIC_DISPLAY_SETTING_V2 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Per-display width"] + pub width: NvU32, + #[doc = "!< Per-display height"] + pub height: NvU32, + #[doc = "!< Bits per pixel"] + pub bpp: NvU32, + #[doc = "!< Display frequency"] + pub freq: NvU32, + #[doc = "!< Display frequency in x1k"] + pub rrx1k: NvU32, +} +pub type NV_MOSAIC_DISPLAY_SETTING = NV_MOSAIC_DISPLAY_SETTING_V2; +#[doc = "! This structure is used to contain a list of supported Mosaic topologies\n! along with the display settings that can be used."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MOSAIC_SUPPORTED_TOPO_INFO_V1 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Number of topologies in below array"] + pub topoBriefsCount: NvU32, + #[doc = "!< List of supported topologies with only brief details"] + pub topoBriefs: [NV_MOSAIC_TOPO_BRIEF; 35usize], + #[doc = "!< Number of display settings in below array"] + pub displaySettingsCount: NvU32, + #[doc = "!< List of per display settings possible"] + pub displaySettings: [NV_MOSAIC_DISPLAY_SETTING_V1; 40usize], +} +#[doc = "! This structure is used to contain a list of supported Mosaic topologies\n! along with the display settings that can be used."] +pub type NV_MOSAIC_SUPPORTED_TOPO_INFO_V1 = _NV_MOSAIC_SUPPORTED_TOPO_INFO_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MOSAIC_SUPPORTED_TOPO_INFO_V2 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Number of topologies in below array"] + pub topoBriefsCount: NvU32, + #[doc = "!< List of supported topologies with only brief details"] + pub topoBriefs: [NV_MOSAIC_TOPO_BRIEF; 35usize], + #[doc = "!< Number of display settings in below array"] + pub displaySettingsCount: NvU32, + #[doc = "!< List of per display settings possible"] + pub displaySettings: [NV_MOSAIC_DISPLAY_SETTING_V2; 40usize], +} +pub type NV_MOSAIC_SUPPORTED_TOPO_INFO_V2 = _NV_MOSAIC_SUPPORTED_TOPO_INFO_V2; +pub type NV_MOSAIC_SUPPORTED_TOPO_INFO = NV_MOSAIC_SUPPORTED_TOPO_INFO_V2; +#[doc = "! This structure defines a group of topologies that work together to create one\n! overall layout. All of the supported topologies are represented with this\n! structure.\n!\n! For example, a 'Passive Stereo' topology would be represented with this\n! structure, and would have separate topology details for the left and right eyes.\n! The count would be 2. A 'Basic' topology is also represented by this structure,\n! with a count of 1.\n!\n! The structure is primarily used internally, but is exposed to applications in a\n! read-only fashion because there are some details in it that might be useful\n! (like the number of rows/cols, or connected display information). A user can\n! get the filled-in structure by calling NvAPI_Mosaic_GetTopoGroup().\n!\n! You can then look at the detailed values within the structure. There are no\n! entrypoints which take this structure as input (effectively making it read-only)."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_MOSAIC_TOPO_GROUP { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< The brief details of this topo"] + pub brief: NV_MOSAIC_TOPO_BRIEF, + #[doc = "!< Number of topos in array below"] + pub count: NvU32, + pub topos: [NV_MOSAIC_TOPO_DETAILS; 2usize], +} +#[doc = "! \\ingroup mosaicapi\n! @{"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MOSAIC_GRID_TOPO_DISPLAY_V1 { + #[doc = "!< DisplayID of the display"] + pub displayId: NvU32, + #[doc = "!< (+overlap, -gap)"] + pub overlapX: NvS32, + #[doc = "!< (+overlap, -gap)"] + pub overlapY: NvS32, + #[doc = "!< Rotation of display"] + pub rotation: NV_ROTATE, + #[doc = "!< Reserved, must be 0"] + pub cloneGroup: NvU32, +} +#[doc = "! \\ingroup mosaicapi\n! @{"] +pub type NV_MOSAIC_GRID_TOPO_DISPLAY_V1 = _NV_MOSAIC_GRID_TOPO_DISPLAY_V1; +#[doc = "!< No pixel shift will be applied to this display."] +pub const _NV_PIXEL_SHIFT_TYPE_NV_PIXEL_SHIFT_TYPE_NO_PIXEL_SHIFT: _NV_PIXEL_SHIFT_TYPE = 0; +#[doc = "!< This display will be used to scanout top left pixels in 2x2 PixelShift configuration"] +pub const _NV_PIXEL_SHIFT_TYPE_NV_PIXEL_SHIFT_TYPE_2x2_TOP_LEFT_PIXELS: _NV_PIXEL_SHIFT_TYPE = 1; +#[doc = "!< This display will be used to scanout bottom right pixels in 2x2 PixelShift configuration"] +pub const _NV_PIXEL_SHIFT_TYPE_NV_PIXEL_SHIFT_TYPE_2x2_BOTTOM_RIGHT_PIXELS: _NV_PIXEL_SHIFT_TYPE = + 2; +#[doc = "!< This display will be used to scanout top right pixels in 2x2 PixelShift configuration"] +pub const _NV_PIXEL_SHIFT_TYPE_NV_PIXEL_SHIFT_TYPE_2x2_TOP_RIGHT_PIXELS: _NV_PIXEL_SHIFT_TYPE = 4; +#[doc = "!< This display will be used to scanout bottom left pixels in 2x2 PixelShift configuration"] +pub const _NV_PIXEL_SHIFT_TYPE_NV_PIXEL_SHIFT_TYPE_2x2_BOTTOM_LEFT_PIXELS: _NV_PIXEL_SHIFT_TYPE = 8; +pub type _NV_PIXEL_SHIFT_TYPE = ::std::os::raw::c_int; +pub use self::_NV_PIXEL_SHIFT_TYPE as NV_PIXEL_SHIFT_TYPE; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MOSAIC_GRID_TOPO_DISPLAY_V2 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< DisplayID of the display"] + pub displayId: NvU32, + #[doc = "!< (+overlap, -gap)"] + pub overlapX: NvS32, + #[doc = "!< (+overlap, -gap)"] + pub overlapY: NvS32, + #[doc = "!< Rotation of display"] + pub rotation: NV_ROTATE, + #[doc = "!< Reserved, must be 0"] + pub cloneGroup: NvU32, + #[doc = "!< Type of the pixel shift enabled display"] + pub pixelShiftType: NV_PIXEL_SHIFT_TYPE, +} +pub type NV_MOSAIC_GRID_TOPO_DISPLAY_V2 = _NV_MOSAIC_GRID_TOPO_DISPLAY_V2; +#[doc = "! \\ingroup mosaicapi\n! @{"] +pub type NV_MOSAIC_GRID_TOPO_DISPLAY = NV_MOSAIC_GRID_TOPO_DISPLAY_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MOSAIC_GRID_TOPO_V1 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Number of rows"] + pub rows: NvU32, + #[doc = "!< Number of columns"] + pub columns: NvU32, + #[doc = "!< Number of display details"] + pub displayCount: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Displays are done as [(row * columns) + column]"] + pub displays: [NV_MOSAIC_GRID_TOPO_DISPLAY_V1; 64usize], + #[doc = "!< Display settings"] + pub displaySettings: NV_MOSAIC_DISPLAY_SETTING_V1, +} +impl _NV_MOSAIC_GRID_TOPO_V1 { + #[inline] + pub fn applyWithBezelCorrect(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_applyWithBezelCorrect(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn applyWithBezelCorrect_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_applyWithBezelCorrect_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn immersiveGaming(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_immersiveGaming(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn immersiveGaming_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_immersiveGaming_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn baseMosaic(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_baseMosaic(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn baseMosaic_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_baseMosaic_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn driverReloadAllowed(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_driverReloadAllowed(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn driverReloadAllowed_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_driverReloadAllowed_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn acceleratePrimaryDisplay(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_acceleratePrimaryDisplay(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn acceleratePrimaryDisplay_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_acceleratePrimaryDisplay_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 27u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 27u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 27u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + applyWithBezelCorrect: NvU32, + immersiveGaming: NvU32, + baseMosaic: NvU32, + driverReloadAllowed: NvU32, + acceleratePrimaryDisplay: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let applyWithBezelCorrect: u32 = + unsafe { ::std::mem::transmute(applyWithBezelCorrect) }; + applyWithBezelCorrect as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let immersiveGaming: u32 = unsafe { ::std::mem::transmute(immersiveGaming) }; + immersiveGaming as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let baseMosaic: u32 = unsafe { ::std::mem::transmute(baseMosaic) }; + baseMosaic as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let driverReloadAllowed: u32 = unsafe { ::std::mem::transmute(driverReloadAllowed) }; + driverReloadAllowed as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let acceleratePrimaryDisplay: u32 = + unsafe { ::std::mem::transmute(acceleratePrimaryDisplay) }; + acceleratePrimaryDisplay as u64 + }); + __bindgen_bitfield_unit.set(5usize, 27u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_MOSAIC_GRID_TOPO_V1 = _NV_MOSAIC_GRID_TOPO_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MOSAIC_GRID_TOPO_V2 { + #[doc = "!< Version of this structure"] + pub version: NvU32, + #[doc = "!< Number of rows"] + pub rows: NvU32, + #[doc = "!< Number of columns"] + pub columns: NvU32, + #[doc = "!< Number of display details"] + pub displayCount: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Displays are done as [(row * columns) + column]"] + pub displays: [NV_MOSAIC_GRID_TOPO_DISPLAY_V2; 64usize], + #[doc = "!< Display settings"] + pub displaySettings: NV_MOSAIC_DISPLAY_SETTING_V1, +} +impl _NV_MOSAIC_GRID_TOPO_V2 { + #[inline] + pub fn applyWithBezelCorrect(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_applyWithBezelCorrect(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn applyWithBezelCorrect_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_applyWithBezelCorrect_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn immersiveGaming(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_immersiveGaming(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn immersiveGaming_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_immersiveGaming_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn baseMosaic(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_baseMosaic(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn baseMosaic_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_baseMosaic_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn driverReloadAllowed(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_driverReloadAllowed(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn driverReloadAllowed_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_driverReloadAllowed_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn acceleratePrimaryDisplay(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_acceleratePrimaryDisplay(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn acceleratePrimaryDisplay_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_acceleratePrimaryDisplay_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn pixelShift(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_pixelShift(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn pixelShift_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_pixelShift_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 26u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 26u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 6usize, + 26u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 6usize, + 26u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + applyWithBezelCorrect: NvU32, + immersiveGaming: NvU32, + baseMosaic: NvU32, + driverReloadAllowed: NvU32, + acceleratePrimaryDisplay: NvU32, + pixelShift: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let applyWithBezelCorrect: u32 = + unsafe { ::std::mem::transmute(applyWithBezelCorrect) }; + applyWithBezelCorrect as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let immersiveGaming: u32 = unsafe { ::std::mem::transmute(immersiveGaming) }; + immersiveGaming as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let baseMosaic: u32 = unsafe { ::std::mem::transmute(baseMosaic) }; + baseMosaic as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let driverReloadAllowed: u32 = unsafe { ::std::mem::transmute(driverReloadAllowed) }; + driverReloadAllowed as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let acceleratePrimaryDisplay: u32 = + unsafe { ::std::mem::transmute(acceleratePrimaryDisplay) }; + acceleratePrimaryDisplay as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let pixelShift: u32 = unsafe { ::std::mem::transmute(pixelShift) }; + pixelShift as u64 + }); + __bindgen_bitfield_unit.set(6usize, 26u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_MOSAIC_GRID_TOPO_V2 = _NV_MOSAIC_GRID_TOPO_V2; +pub type NV_MOSAIC_GRID_TOPO = NV_MOSAIC_GRID_TOPO_V2; +#[doc = "! \\ingroup mosaicapi"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_MOSAIC_DISPLAY_TOPO_STATUS { + pub version: NvU32, + #[doc = "!< (OUT) Any of the NV_MOSAIC_DISPLAYTOPO_ERROR_* flags."] + pub errorFlags: NvU32, + #[doc = "!< (OUT) Any of the NV_MOSAIC_DISPLAYTOPO_WARNING_* flags."] + pub warningFlags: NvU32, + #[doc = "!< (OUT) The number of valid entries in the displays array."] + pub displayCount: NvU32, + pub displays: [NV_MOSAIC_DISPLAY_TOPO_STATUS__bindgen_ty_1; 128usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_MOSAIC_DISPLAY_TOPO_STATUS__bindgen_ty_1 { + #[doc = "!< (OUT) The DisplayID of this display."] + pub displayId: NvU32, + #[doc = "!< (OUT) Any of the NV_MOSAIC_DISPLAYCAPS_PROBLEM_* flags."] + pub errorFlags: NvU32, + #[doc = "!< (OUT) Any of the NV_MOSAIC_DISPLAYTOPO_WARNING_* flags."] + pub warningFlags: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl NV_MOSAIC_DISPLAY_TOPO_STATUS__bindgen_ty_1 { + #[inline] + pub fn supportsRotation(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_supportsRotation(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn supportsRotation_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_supportsRotation_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + supportsRotation: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let supportsRotation: u32 = unsafe { ::std::mem::transmute(supportsRotation) }; + supportsRotation as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! Used in NvAPI_GetCurrentMosaicTopology() and NvAPI_SetCurrentMosaicTopology()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_MOSAIC_TOPOLOGY { + #[doc = "!< Version number of the mosaic topology"] + pub version: NvU32, + #[doc = "!< Horizontal display count"] + pub rowCount: NvU32, + #[doc = "!< Vertical display count"] + pub colCount: NvU32, + pub gpuLayout: [[NV_MOSAIC_TOPOLOGY__bindgen_ty_1; 8usize]; 8usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_MOSAIC_TOPOLOGY__bindgen_ty_1 { + #[doc = "!< Physical GPU to be used in the topology"] + pub hPhysicalGPU: NvPhysicalGpuHandle, + #[doc = "!< Connected display target"] + pub displayOutputId: NvU32, + #[doc = "!< Pixels of overlap on the left of target: (+overlap, -gap)"] + pub overlapX: NvS32, + #[doc = "!< Pixels of overlap on the top of target: (+overlap, -gap)"] + pub overlapY: NvS32, +} +#[doc = "! Used in NvAPI_GetSupportedMosaicTopologies()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NV_MOSAIC_SUPPORTED_TOPOLOGIES { + pub version: NvU32, + #[doc = "!< Count of valid topologies"] + pub totalCount: NvU32, + #[doc = "!< Maximum number of topologies"] + pub topos: [NV_MOSAIC_TOPOLOGY; 16usize], +} +#[doc = "! Used in NvAPI_GSync_QueryCapabilities()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GSYNC_CAPABILITIES_V1 { + #[doc = "!< Version of the structure"] + pub version: NvU32, + #[doc = "!< Board ID"] + pub boardId: NvU32, + #[doc = "!< FPGA Revision"] + pub revision: NvU32, + #[doc = "!< Capabilities of the Sync board. Reserved for future use"] + pub capFlags: NvU32, +} +#[doc = "! Used in NvAPI_GSync_QueryCapabilities()."] +pub type NV_GSYNC_CAPABILITIES_V1 = _NV_GSYNC_CAPABILITIES_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GSYNC_CAPABILITIES_V2 { + #[doc = "!< Version of the structure"] + pub version: NvU32, + #[doc = "!< Board ID"] + pub boardId: NvU32, + #[doc = "!< FPGA major revision"] + pub revision: NvU32, + #[doc = "!< Capabilities of the Sync board. Reserved for future use"] + pub capFlags: NvU32, + #[doc = "!< FPGA minor revision"] + pub extendedRevision: NvU32, +} +pub type NV_GSYNC_CAPABILITIES_V2 = _NV_GSYNC_CAPABILITIES_V2; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GSYNC_CAPABILITIES_V3 { + #[doc = "!< Version of the structure"] + pub version: NvU32, + #[doc = "!< Board ID"] + pub boardId: NvU32, + #[doc = "!< FPGA major revision"] + pub revision: NvU32, + #[doc = "!< Capabilities of the Sync board. Reserved for future use"] + pub capFlags: NvU32, + #[doc = "!< FPGA minor revision"] + pub extendedRevision: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< This parameter returns the maximum possible value that can be programmed\n!< for multiplying / dividing house sync. Only valid if bIsMulDivSupported is set to 1."] + pub maxMulDivValue: NvU32, +} +impl _NV_GSYNC_CAPABILITIES_V3 { + #[inline] + pub fn bIsMulDivSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsMulDivSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsMulDivSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsMulDivSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsMulDivSupported: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsMulDivSupported: u32 = unsafe { ::std::mem::transmute(bIsMulDivSupported) }; + bIsMulDivSupported as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_GSYNC_CAPABILITIES_V3 = _NV_GSYNC_CAPABILITIES_V3; +pub type NV_GSYNC_CAPABILITIES = NV_GSYNC_CAPABILITIES_V3; +pub const _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_NONE: + _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR = 0; +pub const _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_PRIMARY: + _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR = 1; +pub const _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_SECONDARY: + _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR = 2; +pub const _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_TERTIARY: + _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR = 3; +pub const _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_QUARTERNARY: + _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR = 4; +#[doc = "! Connector values for a GPU. Used in NV_GSYNC_GPU."] +pub type _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR = ::std::os::raw::c_int; +#[doc = "! Connector values for a GPU. Used in NV_GSYNC_GPU."] +pub use self::_NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR as NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR; +pub const _NVAPI_GSYNC_DISPLAY_SYNC_STATE_NVAPI_GSYNC_DISPLAY_SYNC_STATE_UNSYNCED: + _NVAPI_GSYNC_DISPLAY_SYNC_STATE = 0; +pub const _NVAPI_GSYNC_DISPLAY_SYNC_STATE_NVAPI_GSYNC_DISPLAY_SYNC_STATE_SLAVE: + _NVAPI_GSYNC_DISPLAY_SYNC_STATE = 1; +pub const _NVAPI_GSYNC_DISPLAY_SYNC_STATE_NVAPI_GSYNC_DISPLAY_SYNC_STATE_MASTER: + _NVAPI_GSYNC_DISPLAY_SYNC_STATE = 2; +#[doc = "! Display sync states. Used in NV_GSYNC_DISPLAY."] +pub type _NVAPI_GSYNC_DISPLAY_SYNC_STATE = ::std::os::raw::c_int; +#[doc = "! Display sync states. Used in NV_GSYNC_DISPLAY."] +pub use self::_NVAPI_GSYNC_DISPLAY_SYNC_STATE as NVAPI_GSYNC_DISPLAY_SYNC_STATE; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GSYNC_GPU { + #[doc = "!< Version of the structure"] + pub version: NvU32, + #[doc = "!< GPU handle"] + pub hPhysicalGpu: NvPhysicalGpuHandle, + #[doc = "!< Indicates which connector on the device the GPU is connected to."] + pub connector: NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR, + #[doc = "!< GPU through which hPhysicalGpu is connected to the Sync device (if not directly connected)\n!< - this is NULL otherwise"] + pub hProxyPhysicalGpu: NvPhysicalGpuHandle, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + pub __bindgen_padding_0: u32, +} +impl _NV_GSYNC_GPU { + #[inline] + pub fn isSynced(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isSynced(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isSynced_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isSynced_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1(isSynced: NvU32, reserved: NvU32) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isSynced: u32 = unsafe { ::std::mem::transmute(isSynced) }; + isSynced as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_GSYNC_GPU = _NV_GSYNC_GPU; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GSYNC_DISPLAY { + #[doc = "!< Version of the structure"] + pub version: NvU32, + #[doc = "!< display identifier for displays.The GPU to which it is connected, can be retireved from NvAPI_SYS_GetPhysicalGpuFromDisplayId"] + pub displayId: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Is this display slave/master\n!< (Retrieved with topology or set by caller for enable/disable sync)"] + pub syncState: NVAPI_GSYNC_DISPLAY_SYNC_STATE, +} +impl _NV_GSYNC_DISPLAY { + #[inline] + pub fn isMasterable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_isMasterable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn isMasterable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_isMasterable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + isMasterable: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let isMasterable: u32 = unsafe { ::std::mem::transmute(isMasterable) }; + isMasterable as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_GSYNC_DISPLAY = _NV_GSYNC_DISPLAY; +pub const _NVAPI_GSYNC_POLARITY_NVAPI_GSYNC_POLARITY_RISING_EDGE: _NVAPI_GSYNC_POLARITY = 0; +pub const _NVAPI_GSYNC_POLARITY_NVAPI_GSYNC_POLARITY_FALLING_EDGE: _NVAPI_GSYNC_POLARITY = 1; +pub const _NVAPI_GSYNC_POLARITY_NVAPI_GSYNC_POLARITY_BOTH_EDGES: _NVAPI_GSYNC_POLARITY = 2; +#[doc = "! Source signal edge to be used for output pulse. See NV_GSYNC_CONTROL_PARAMS."] +pub type _NVAPI_GSYNC_POLARITY = ::std::os::raw::c_int; +#[doc = "! Source signal edge to be used for output pulse. See NV_GSYNC_CONTROL_PARAMS."] +pub use self::_NVAPI_GSYNC_POLARITY as NVAPI_GSYNC_POLARITY; +pub const _NVAPI_GSYNC_VIDEO_MODE_NVAPI_GSYNC_VIDEO_MODE_NONE: _NVAPI_GSYNC_VIDEO_MODE = 0; +pub const _NVAPI_GSYNC_VIDEO_MODE_NVAPI_GSYNC_VIDEO_MODE_TTL: _NVAPI_GSYNC_VIDEO_MODE = 1; +pub const _NVAPI_GSYNC_VIDEO_MODE_NVAPI_GSYNC_VIDEO_MODE_NTSCPALSECAM: _NVAPI_GSYNC_VIDEO_MODE = 2; +pub const _NVAPI_GSYNC_VIDEO_MODE_NVAPI_GSYNC_VIDEO_MODE_HDTV: _NVAPI_GSYNC_VIDEO_MODE = 3; +pub const _NVAPI_GSYNC_VIDEO_MODE_NVAPI_GSYNC_VIDEO_MODE_COMPOSITE: _NVAPI_GSYNC_VIDEO_MODE = 4; +#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] +pub type _NVAPI_GSYNC_VIDEO_MODE = ::std::os::raw::c_int; +#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] +pub use self::_NVAPI_GSYNC_VIDEO_MODE as NVAPI_GSYNC_VIDEO_MODE; +pub const _NVAPI_GSYNC_SYNC_SOURCE_NVAPI_GSYNC_SYNC_SOURCE_VSYNC: _NVAPI_GSYNC_SYNC_SOURCE = 0; +pub const _NVAPI_GSYNC_SYNC_SOURCE_NVAPI_GSYNC_SYNC_SOURCE_HOUSESYNC: _NVAPI_GSYNC_SYNC_SOURCE = 1; +#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] +pub type _NVAPI_GSYNC_SYNC_SOURCE = ::std::os::raw::c_int; +#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] +pub use self::_NVAPI_GSYNC_SYNC_SOURCE as NVAPI_GSYNC_SYNC_SOURCE; +#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GSYNC_DELAY { + #[doc = "!< Version of the structure"] + pub version: NvU32, + #[doc = "!< delay to be induced in number of horizontal lines."] + pub numLines: NvU32, + #[doc = "!< delay to be induced in number of pixels."] + pub numPixels: NvU32, + #[doc = "!< maximum number of lines supported at current display mode to induce delay. Updated by NvAPI_GSync_GetControlParameters(). Read only."] + pub maxLines: NvU32, + #[doc = "!< minimum number of pixels required at current display mode to induce delay. Updated by NvAPI_GSync_GetControlParameters(). Read only."] + pub minPixels: NvU32, +} +#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] +pub type NV_GSYNC_DELAY = _NV_GSYNC_DELAY; +#[doc = "! Used in NvAPI_GSync_GetControlParameters() and NvAPI_GSync_SetControlParameters()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GSYNC_CONTROL_PARAMS_V1 { + #[doc = "!< Version of the structure"] + pub version: NvU32, + #[doc = "!< Leading edge / Falling edge / both"] + pub polarity: NVAPI_GSYNC_POLARITY, + #[doc = "!< None, TTL, NTSCPALSECAM, HDTV"] + pub vmode: NVAPI_GSYNC_VIDEO_MODE, + #[doc = "!< Number of pulses to wait between framelock signal generation"] + pub interval: NvU32, + #[doc = "!< VSync/House sync"] + pub source: NVAPI_GSYNC_SYNC_SOURCE, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< The time delay between the frame sync signal and the GPUs signal."] + pub syncSkew: NV_GSYNC_DELAY, + #[doc = "!< Sync start delay for master."] + pub startupDelay: NV_GSYNC_DELAY, +} +impl _NV_GSYNC_CONTROL_PARAMS_V1 { + #[inline] + pub fn interlaceMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_interlaceMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn interlaceMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_interlaceMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn syncSourceIsOutput(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_syncSourceIsOutput(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn syncSourceIsOutput_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_syncSourceIsOutput_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 30u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 30u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 30u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + interlaceMode: NvU32, + syncSourceIsOutput: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let interlaceMode: u32 = unsafe { ::std::mem::transmute(interlaceMode) }; + interlaceMode as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let syncSourceIsOutput: u32 = unsafe { ::std::mem::transmute(syncSourceIsOutput) }; + syncSourceIsOutput as u64 + }); + __bindgen_bitfield_unit.set(2usize, 30u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! Used in NvAPI_GSync_GetControlParameters() and NvAPI_GSync_SetControlParameters()."] +pub type NV_GSYNC_CONTROL_PARAMS_V1 = _NV_GSYNC_CONTROL_PARAMS_V1; +pub const _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE_NVAPI_GSYNC_UNDEFINED_MODE: + _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE = 0; +pub const _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE_NVAPI_GSYNC_MULTIPLY_MODE: + _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE = 1; +pub const _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE_NVAPI_GSYNC_DIVIDE_MODE: + _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE = 2; +#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] +pub type _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE = ::std::os::raw::c_int; +#[doc = "! Used in NV_GSYNC_CONTROL_PARAMS."] +pub use self::_NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE as NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GSYNC_CONTROL_PARAMS_V2 { + #[doc = "!< Version of the structure"] + pub version: NvU32, + #[doc = "!< Leading edge / Falling edge / both"] + pub polarity: NVAPI_GSYNC_POLARITY, + #[doc = "!< None, TTL, NTSCPALSECAM, HDTV"] + pub vmode: NVAPI_GSYNC_VIDEO_MODE, + #[doc = "!< Number of pulses to wait between framelock signal generation"] + pub interval: NvU32, + #[doc = "!< VSync/House sync"] + pub source: NVAPI_GSYNC_SYNC_SOURCE, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< The time delay between the frame sync signal and the GPUs signal."] + pub syncSkew: NV_GSYNC_DELAY, + #[doc = "!< Sync start delay for master."] + pub startupDelay: NV_GSYNC_DELAY, + #[doc = "!< Indicates multiplier/divider mode for the housesync signal.\n!< While setting multiplyDivideMode, source needs to be set as NVAPI_GSYNC_SYNC_SOURCE_HOUSESYNC."] + pub multiplyDivideMode: NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE, + #[doc = "!< Indicates the multiplier/divider value for the housesync signal. Only supported if bIsMulDivSupported field of the structure NV_GSYNC_CAPABILITIES is set to 1.\n!< The maximum supported value for this field can be obtained from maxMulDivValue field of the structure NV_GSYNC_CAPABILITIES."] + pub multiplyDivideValue: NvU8, +} +impl _NV_GSYNC_CONTROL_PARAMS_V2 { + #[inline] + pub fn interlaceMode(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_interlaceMode(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn interlaceMode_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_interlaceMode_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn syncSourceIsOutput(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_syncSourceIsOutput(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn syncSourceIsOutput_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_syncSourceIsOutput_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 30u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 30u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 30u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + interlaceMode: NvU32, + syncSourceIsOutput: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let interlaceMode: u32 = unsafe { ::std::mem::transmute(interlaceMode) }; + interlaceMode as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let syncSourceIsOutput: u32 = unsafe { ::std::mem::transmute(syncSourceIsOutput) }; + syncSourceIsOutput as u64 + }); + __bindgen_bitfield_unit.set(2usize, 30u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_GSYNC_CONTROL_PARAMS_V2 = _NV_GSYNC_CONTROL_PARAMS_V2; +pub type NV_GSYNC_CONTROL_PARAMS = NV_GSYNC_CONTROL_PARAMS_V2; +#[doc = "! Used in NvAPI_GSync_GetSyncStatus()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GSYNC_STATUS { + #[doc = "!< Version of the structure"] + pub version: NvU32, + #[doc = "!< Is timing in sync?"] + pub bIsSynced: NvU32, + #[doc = "!< Does the phase of the timing signal from the GPU = the phase of the master sync signal?"] + pub bIsStereoSynced: NvU32, + #[doc = "!< Is the sync signal available?"] + pub bIsSyncSignalAvailable: NvU32, +} +#[doc = "! Used in NvAPI_GSync_GetSyncStatus()."] +pub type NV_GSYNC_STATUS = _NV_GSYNC_STATUS; +pub const _NVAPI_GSYNC_RJ45_IO_NVAPI_GSYNC_RJ45_OUTPUT: _NVAPI_GSYNC_RJ45_IO = 0; +pub const _NVAPI_GSYNC_RJ45_IO_NVAPI_GSYNC_RJ45_INPUT: _NVAPI_GSYNC_RJ45_IO = 1; +#[doc = "!< This field is used to notify that the framelock is not actually present."] +pub const _NVAPI_GSYNC_RJ45_IO_NVAPI_GSYNC_RJ45_UNUSED: _NVAPI_GSYNC_RJ45_IO = 2; +#[doc = "! Used in NV_GSYNC_STATUS_PARAMS."] +pub type _NVAPI_GSYNC_RJ45_IO = ::std::os::raw::c_int; +#[doc = "! Used in NV_GSYNC_STATUS_PARAMS."] +pub use self::_NVAPI_GSYNC_RJ45_IO as NVAPI_GSYNC_RJ45_IO; +#[doc = "! \\ingroup gsyncapi\n! Used in NvAPI_GSync_GetStatusParameters()."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GSYNC_STATUS_PARAMS_V1 { + pub version: NvU32, + #[doc = "!< The refresh rate"] + pub refreshRate: NvU32, + #[doc = "!< Configured as input / output"] + pub RJ45_IO: [NVAPI_GSYNC_RJ45_IO; 2usize], + #[doc = "!< Connected to ethernet hub? [ERRONEOUSLY CONNECTED!]"] + pub RJ45_Ethernet: [NvU32; 2usize], + #[doc = "!< Incoming house sync frequency in Hz"] + pub houseSyncIncoming: NvU32, + #[doc = "!< Is house sync connected?"] + pub bHouseSync: NvU32, +} +#[doc = "! \\ingroup gsyncapi\n! Used in NvAPI_GSync_GetStatusParameters()."] +pub type NV_GSYNC_STATUS_PARAMS_V1 = _NV_GSYNC_STATUS_PARAMS_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GSYNC_STATUS_PARAMS_V2 { + pub version: NvU32, + #[doc = "!< The refresh rate"] + pub refreshRate: NvU32, + #[doc = "!< Configured as input / output"] + pub RJ45_IO: [NVAPI_GSYNC_RJ45_IO; 2usize], + #[doc = "!< Connected to ethernet hub? [ERRONEOUSLY CONNECTED!]"] + pub RJ45_Ethernet: [NvU32; 2usize], + #[doc = "!< Incoming house sync frequency in Hz"] + pub houseSyncIncoming: NvU32, + #[doc = "!< Is house sync connected?"] + pub bHouseSync: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl _NV_GSYNC_STATUS_PARAMS_V2 { + #[inline] + pub fn bInternalSlave(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bInternalSlave(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bInternalSlave_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bInternalSlave_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bInternalSlave: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bInternalSlave: u32 = unsafe { ::std::mem::transmute(bInternalSlave) }; + bInternalSlave as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_GSYNC_STATUS_PARAMS_V2 = _NV_GSYNC_STATUS_PARAMS_V2; +pub type NV_GSYNC_STATUS_PARAMS = NV_GSYNC_STATUS_PARAMS_V2; +pub const _NV_RESOLVE_MODE_NV_RESOLVE_MODE_SAMPLE_0: _NV_RESOLVE_MODE = 0; +#[doc = "! \\ingroup dx\n! Valid modes for NvAPI_D3D11_ResolveSubresourceRegion() and NvAPI_D3D12_ResolveSubresourceRegion"] +pub type _NV_RESOLVE_MODE = ::std::os::raw::c_int; +#[doc = "! \\ingroup dx\n! Valid modes for NvAPI_D3D11_ResolveSubresourceRegion() and NvAPI_D3D12_ResolveSubresourceRegion"] +pub use self::_NV_RESOLVE_MODE as NV_RESOLVE_MODE; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of Single Pass Stereo HW feature\n! \\ingroup dx"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V1 { + pub version: NvU32, + pub bSinglePassStereoSupported: NvU32, +} +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of Single Pass Stereo HW feature\n! \\ingroup dx"] +pub type NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V1 = + _NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V2 { + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl _NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V2 { + #[inline] + pub fn bSinglePassStereoSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bSinglePassStereoSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bSinglePassStereoSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bSinglePassStereoSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bSinglePassStereoXYZWSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bSinglePassStereoXYZWSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bSinglePassStereoXYZWSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bSinglePassStereoXYZWSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 30u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 30u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 30u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bSinglePassStereoSupported: NvU32, + bSinglePassStereoXYZWSupported: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bSinglePassStereoSupported: u32 = + unsafe { ::std::mem::transmute(bSinglePassStereoSupported) }; + bSinglePassStereoSupported as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bSinglePassStereoXYZWSupported: u32 = + unsafe { ::std::mem::transmute(bSinglePassStereoXYZWSupported) }; + bSinglePassStereoXYZWSupported as u64 + }); + __bindgen_bitfield_unit.set(2usize, 30u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V2 = + _NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V2; +pub type NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS = NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V2; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of MultiView HW feature\n! \\ingroup dx"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_QUERY_MULTIVIEW_SUPPORT_PARAMS_V1 { + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl _NV_QUERY_MULTIVIEW_SUPPORT_PARAMS_V1 { + #[inline] + pub fn bMultiViewSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bMultiViewSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bMultiViewSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bMultiViewSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bSinglePassStereoSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bSinglePassStereoSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bSinglePassStereoSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bSinglePassStereoSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bSinglePassStereoXYZWSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_bSinglePassStereoXYZWSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bSinglePassStereoXYZWSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bSinglePassStereoXYZWSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 29u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 29u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 29u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 29u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bMultiViewSupported: NvU32, + bSinglePassStereoSupported: NvU32, + bSinglePassStereoXYZWSupported: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bMultiViewSupported: u32 = unsafe { ::std::mem::transmute(bMultiViewSupported) }; + bMultiViewSupported as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bSinglePassStereoSupported: u32 = + unsafe { ::std::mem::transmute(bSinglePassStereoSupported) }; + bSinglePassStereoSupported as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let bSinglePassStereoXYZWSupported: u32 = + unsafe { ::std::mem::transmute(bSinglePassStereoXYZWSupported) }; + bSinglePassStereoXYZWSupported as u64 + }); + __bindgen_bitfield_unit.set(3usize, 29u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of MultiView HW feature\n! \\ingroup dx"] +pub type NV_QUERY_MULTIVIEW_SUPPORT_PARAMS_V1 = _NV_QUERY_MULTIVIEW_SUPPORT_PARAMS_V1; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of MultiView HW feature\n! \\ingroup dx"] +pub type NV_QUERY_MULTIVIEW_SUPPORT_PARAMS = NV_QUERY_MULTIVIEW_SUPPORT_PARAMS_V1; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used for setting the Mode for MultiView HW Feature.\n! \\ingroup dx"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MULTIVIEW_PARAMS_V1 { + pub version: NvU32, + pub numViews: NvU32, + pub renderTargetIndexOffset: [NvU32; 4usize], + pub independentViewportMaskEnable: NvU8, +} +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used for setting the Mode for MultiView HW Feature.\n! \\ingroup dx"] +pub type NV_MULTIVIEW_PARAMS_V1 = _NV_MULTIVIEW_PARAMS_V1; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used for setting the Mode for MultiView HW Feature.\n! \\ingroup dx"] +pub type NV_MULTIVIEW_PARAMS = NV_MULTIVIEW_PARAMS_V1; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of Lens Matched Shading HW feature\n! \\ingroup dx"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_QUERY_MODIFIED_W_SUPPORT_PARAMS { + pub version: NvU32, + pub bModifiedWSupported: NvU32, +} +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of Lens Matched Shading HW feature\n! \\ingroup dx"] +pub type NV_QUERY_MODIFIED_W_SUPPORT_PARAMS_V1 = _NV_QUERY_MODIFIED_W_SUPPORT_PARAMS; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to query the support of Lens Matched Shading HW feature\n! \\ingroup dx"] +pub type NV_QUERY_MODIFIED_W_SUPPORT_PARAMS = NV_QUERY_MODIFIED_W_SUPPORT_PARAMS_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MODIFIED_W_COEFFICIENTS { + pub fA: f32, + pub fB: f32, + pub fAReserved: f32, + pub fBReserved: f32, + pub fReserved: [f32; 2usize], +} +pub type NV_MODIFIED_W_COEFFICIENTS = _NV_MODIFIED_W_COEFFICIENTS; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_MODIFIED_W_PARAMS { + pub version: NvU32, + pub numEntries: NvU32, + pub modifiedWCoefficients: [NV_MODIFIED_W_COEFFICIENTS; 16usize], + pub id: NvU32, + pub reserved: [NvU32; 16usize], +} +pub type NV_MODIFIED_W_PARAMS_V1 = _NV_MODIFIED_W_PARAMS; +pub type NV_MODIFIED_W_PARAMS = NV_MODIFIED_W_PARAMS_V1; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to get sleep status\n! \\ingroup dx"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GET_SLEEP_STATUS_PARAMS { + #[doc = "!< (IN) Structure version"] + pub version: NvU32, + #[doc = "!< (OUT) Is low latency mode enabled?"] + pub bLowLatencyMode: NvBool, + #[doc = "!< (OUT) Is fullscreen VRR enabled?"] + pub bFsVrr: NvBool, + #[doc = "!< (OUT) Is Control Panel overriding VSYNC ON?"] + pub bCplVsyncOn: NvBool, + #[doc = "!< (OUT) Latest sleep interval in microseconds."] + pub sleepIntervalUs: NvU32, + #[doc = "!< (OUT) Is NvAPI_D3D_Sleep() being called?"] + pub bUseGameSleep: NvBool, + #[doc = "!< (OUT) Is in fullscreen/iFlip mode?"] + pub bFullscreenIFlip: NvBool, + #[doc = "!< (OUT) Latest Frame Generation multiplier used."] + pub fgMultiplier: NvU8, + #[doc = "!< (IN) Reserved. Must be set to 0s."] + pub rsvd: [NvU8; 119usize], +} +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to get sleep status\n! \\ingroup dx"] +pub type NV_GET_SLEEP_STATUS_PARAMS_V1 = _NV_GET_SLEEP_STATUS_PARAMS; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to get sleep status\n! \\ingroup dx"] +pub type NV_GET_SLEEP_STATUS_PARAMS = NV_GET_SLEEP_STATUS_PARAMS_V1; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to set sleep mode\n! \\ingroup dx"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_SET_SLEEP_MODE_PARAMS { + #[doc = "!< (IN) Structure version"] + pub version: NvU32, + #[doc = "!< (IN) Low latency mode enable/disable."] + pub bLowLatencyMode: NvBool, + #[doc = "!< (IN) Request maximum GPU clock frequency regardless of workload."] + pub bLowLatencyBoost: NvBool, + #[doc = "!< (IN) Minimum frame interval in microseconds. 0 = no frame rate limit."] + pub minimumIntervalUs: NvU32, + #[doc = "!< (IN) Allow latency markers to be used for runtime optimizations."] + pub bUseMarkersToOptimize: NvBool, + #[doc = "!< (IN) Consider all submission overlaps (both in between frames and within each frame)."] + pub bUseMinQueueTime: NvBool, + #[doc = "!< (IN) Reserved. Must be set to 0s."] + pub rsvd: [NvU8; 30usize], +} +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to set sleep mode\n! \\ingroup dx"] +pub type NV_SET_SLEEP_MODE_PARAMS_V1 = _NV_SET_SLEEP_MODE_PARAMS; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to set sleep mode\n! \\ingroup dx"] +pub type NV_SET_SLEEP_MODE_PARAMS = NV_SET_SLEEP_MODE_PARAMS_V1; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to send Reflex Sync data to UMD\n! \\ingroup dx"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_SET_REFLEX_SYNC_PARAMS { + #[doc = "!< (IN) Structure version"] + pub version: NvU32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< (IN) Interval between VBLANKs in microseconds. (0 means N/A)"] + pub vblankIntervalUs: NvU32, + #[doc = "!< (IN) Amount of time in the completed frame queue. Can be negative. (0 means N/A)"] + pub timeInQueueUs: NvS32, + #[doc = "!< (IN) Target amount of time in the completed frame queue. (0 means N/A)"] + pub timeInQueueUsTarget: NvU32, + #[doc = "!< (IN) Specify the frame generation multipler to use. (0 means driver should auto-detect)"] + pub fgMultiplier: NvU8, + #[doc = "!< (IN) Reserved. Must be set to 0s."] + pub rsvd: [NvU8; 27usize], +} +impl _NV_SET_REFLEX_SYNC_PARAMS { + #[inline] + pub fn bEnable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bEnable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bEnable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bEnable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bDisable(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bDisable(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bDisable_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bDisable_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn flagsRsvd(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } + } + #[inline] + pub fn set_flagsRsvd(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 30u8, val as u64) + } + } + #[inline] + pub unsafe fn flagsRsvd_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 30u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_flagsRsvd_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 30u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bEnable: NvU32, + bDisable: NvU32, + flagsRsvd: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bEnable: u32 = unsafe { ::std::mem::transmute(bEnable) }; + bEnable as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bDisable: u32 = unsafe { ::std::mem::transmute(bDisable) }; + bDisable as u64 + }); + __bindgen_bitfield_unit.set(2usize, 30u8, { + let flagsRsvd: u32 = unsafe { ::std::mem::transmute(flagsRsvd) }; + flagsRsvd as u64 + }); + __bindgen_bitfield_unit + } +} +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to send Reflex Sync data to UMD\n! \\ingroup dx"] +pub type NV_SET_REFLEX_SYNC_PARAMS_V1 = _NV_SET_REFLEX_SYNC_PARAMS; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to send Reflex Sync data to UMD\n! \\ingroup dx"] +pub type NV_SET_REFLEX_SYNC_PARAMS = NV_SET_REFLEX_SYNC_PARAMS_V1; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to get latency report.\n! \\ingroup dx"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LATENCY_RESULT_PARAMS { + #[doc = "!< (IN) Structure version"] + pub version: NvU32, + pub frameReport: [_NV_LATENCY_RESULT_PARAMS_FrameReport; 64usize], + pub rsvd: [NvU8; 32usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LATENCY_RESULT_PARAMS_FrameReport { + #[doc = "!< (OUT)"] + pub frameID: NvU64, + #[doc = "!< (OUT)"] + pub inputSampleTime: NvU64, + #[doc = "!< (OUT)"] + pub simStartTime: NvU64, + #[doc = "!< (OUT)"] + pub simEndTime: NvU64, + #[doc = "!< (OUT)"] + pub renderSubmitStartTime: NvU64, + #[doc = "!< (OUT)"] + pub renderSubmitEndTime: NvU64, + #[doc = "!< (OUT)"] + pub presentStartTime: NvU64, + #[doc = "!< (OUT)"] + pub presentEndTime: NvU64, + #[doc = "!< (OUT)"] + pub driverStartTime: NvU64, + #[doc = "!< (OUT)"] + pub driverEndTime: NvU64, + #[doc = "!< (OUT)"] + pub osRenderQueueStartTime: NvU64, + #[doc = "!< (OUT)"] + pub osRenderQueueEndTime: NvU64, + #[doc = "!< (OUT)"] + pub gpuRenderStartTime: NvU64, + #[doc = "!< (OUT)"] + pub gpuRenderEndTime: NvU64, + #[doc = "!< (OUT) Difference between gpuRenderStartTime and gpuRenderEndTime, excluding the idles in between, in microseconds."] + pub gpuActiveRenderTimeUs: NvU32, + #[doc = "!< (OUT) Difference between previous and current frame's gpuRenderEndTime, in microseconds."] + pub gpuFrameTimeUs: NvU32, + #[doc = "!< (OUT)"] + pub cameraConstructedTime: NvU64, + #[doc = "!< (OUT) Cross adapter copy time in microseconds."] + pub crossAdapterCopyTimeUs: NvU32, + #[doc = "!< (OUT) Frame generation time in microseconds."] + pub aiFrameTimeUs: NvU32, + pub rsvd: [NvU8; 104usize], +} +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to get latency report.\n! \\ingroup dx"] +pub type NV_LATENCY_RESULT_PARAMS_V1 = _NV_LATENCY_RESULT_PARAMS; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used to get latency report.\n! \\ingroup dx"] +pub type NV_LATENCY_RESULT_PARAMS = NV_LATENCY_RESULT_PARAMS_V1; +pub const NV_LATENCY_MARKER_TYPE_SIMULATION_START: NV_LATENCY_MARKER_TYPE = 0; +pub const NV_LATENCY_MARKER_TYPE_SIMULATION_END: NV_LATENCY_MARKER_TYPE = 1; +pub const NV_LATENCY_MARKER_TYPE_RENDERSUBMIT_START: NV_LATENCY_MARKER_TYPE = 2; +pub const NV_LATENCY_MARKER_TYPE_RENDERSUBMIT_END: NV_LATENCY_MARKER_TYPE = 3; +pub const NV_LATENCY_MARKER_TYPE_PRESENT_START: NV_LATENCY_MARKER_TYPE = 4; +pub const NV_LATENCY_MARKER_TYPE_PRESENT_END: NV_LATENCY_MARKER_TYPE = 5; +pub const NV_LATENCY_MARKER_TYPE_INPUT_SAMPLE: NV_LATENCY_MARKER_TYPE = 6; +pub const NV_LATENCY_MARKER_TYPE_TRIGGER_FLASH: NV_LATENCY_MARKER_TYPE = 7; +pub const NV_LATENCY_MARKER_TYPE_PC_LATENCY_PING: NV_LATENCY_MARKER_TYPE = 8; +pub const NV_LATENCY_MARKER_TYPE_OUT_OF_BAND_RENDERSUBMIT_START: NV_LATENCY_MARKER_TYPE = 9; +pub const NV_LATENCY_MARKER_TYPE_OUT_OF_BAND_RENDERSUBMIT_END: NV_LATENCY_MARKER_TYPE = 10; +pub const NV_LATENCY_MARKER_TYPE_OUT_OF_BAND_PRESENT_START: NV_LATENCY_MARKER_TYPE = 11; +pub const NV_LATENCY_MARKER_TYPE_OUT_OF_BAND_PRESENT_END: NV_LATENCY_MARKER_TYPE = 12; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used define latency marker type\n! \\ingroup dx"] +pub type NV_LATENCY_MARKER_TYPE = ::std::os::raw::c_int; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used set latency markers\n! \\ingroup dx"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LATENCY_MARKER_PARAMS { + #[doc = "!< (IN) Structure version"] + pub version: NvU32, + pub frameID: NvU64, + pub markerType: NV_LATENCY_MARKER_TYPE, + pub rsvd0: NvU64, + pub rsvd: [NvU8; 56usize], +} +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used set latency markers\n! \\ingroup dx"] +pub type NV_LATENCY_MARKER_PARAMS_V1 = _NV_LATENCY_MARKER_PARAMS; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used set latency markers\n! \\ingroup dx"] +pub type NV_LATENCY_MARKER_PARAMS = NV_LATENCY_MARKER_PARAMS_V1; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used in NvAPI_D3D12_SetAsyncFrameMarker and NvAPI_D3D11_SetAsyncFrameMarker\n! \\ingroup dx"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_ASYNC_FRAME_MARKER_PARAMS_V1 { + #[doc = "!< (IN) Structure version"] + pub version: NvU32, + pub frameID: NvU64, + pub markerType: NV_LATENCY_MARKER_TYPE, + pub presentFrameID: NvU64, + pub vendorInternal: NvBool, + pub rsvd: [NvU8; 55usize], +} +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used in NvAPI_D3D12_SetAsyncFrameMarker and NvAPI_D3D11_SetAsyncFrameMarker\n! \\ingroup dx"] +pub type NV_ASYNC_FRAME_MARKER_PARAMS_V1 = _NV_ASYNC_FRAME_MARKER_PARAMS_V1; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used in NvAPI_D3D12_SetAsyncFrameMarker and NvAPI_D3D11_SetAsyncFrameMarker\n! \\ingroup dx"] +pub type NV_ASYNC_FRAME_MARKER_PARAMS = NV_ASYNC_FRAME_MARKER_PARAMS_V1; +pub const NV_OUT_OF_BAND_CQ_TYPE_OUT_OF_BAND_RENDER: NV_OUT_OF_BAND_CQ_TYPE = 0; +pub const NV_OUT_OF_BAND_CQ_TYPE_OUT_OF_BAND_PRESENT: NV_OUT_OF_BAND_CQ_TYPE = 1; +pub const NV_OUT_OF_BAND_CQ_TYPE_OUT_OF_BAND_IGNORE: NV_OUT_OF_BAND_CQ_TYPE = 2; +pub const NV_OUT_OF_BAND_CQ_TYPE_OUT_OF_BAND_RENDER_PRESENT: NV_OUT_OF_BAND_CQ_TYPE = 3; +#[doc = "! SUPPORTED OS: Windows 10 and higher\n!\n! Used in NvAPI_D3D12_NotifyOutOfBandCommandQueue\n! \\ingroup dx"] +pub type NV_OUT_OF_BAND_CQ_TYPE = ::std::os::raw::c_int; +pub const _NV_D3D12_WORKSTATION_FEATURE_TYPE_NV_D3D12_WORKSTATION_FEATURE_TYPE_PRESENT_BARRIER: + _NV_D3D12_WORKSTATION_FEATURE_TYPE = 1; +pub const _NV_D3D12_WORKSTATION_FEATURE_TYPE_NV_D3D12_WORKSTATION_FEATURE_TYPE_RDMA_BAR1_SUPPORT: + _NV_D3D12_WORKSTATION_FEATURE_TYPE = 2; +#[doc = "! \\ingroup DX"] +pub type _NV_D3D12_WORKSTATION_FEATURE_TYPE = ::std::os::raw::c_int; +#[doc = "! \\ingroup DX"] +pub use self::_NV_D3D12_WORKSTATION_FEATURE_TYPE as NV_D3D12_WORKSTATION_FEATURE_TYPE; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_D3D12_WORKSTATION_FEATURE_RDMA_PROPERTIES { + pub rdmaHeapSize: NvU64, +} +pub type NV_D3D12_WORKSTATION_FEATURE_RDMA_PROPERTIES = + _NV_D3D12_WORKSTATION_FEATURE_RDMA_PROPERTIES; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_INITIALIZED: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 1; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_ENABLED: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 2; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_DLL_EXISTS: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 4; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_DLL_LOADED: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 8; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_DLL_SELECTED: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 16; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_PRESET: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 32; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_PERF_MODE: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 64; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_SCALING_RATIO: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 128; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_OPTIMAL_SETTINGS: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 256; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_CREATED: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 512; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_EVALUATE: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 1024; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_FG_MODE: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 8192; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_SR_DLAA_MODE: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 16384; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_FG_MULTI_FRAME: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 32768; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_ERR_FAILED: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 65536; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_ERR_DENIED: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 131072; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_ERR_DRS: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 262144; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_ERR_NOT_FOUND: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 524288; +pub const NV_NGX_DLSS_OVERRIDE_BITFIELD_NV_NGX_DLSS_OVERRIDE_FLAG_ERR_DLL_LOAD: + NV_NGX_DLSS_OVERRIDE_BITFIELD = 1048576; +pub type NV_NGX_DLSS_OVERRIDE_BITFIELD = ::std::os::raw::c_int; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_NGX_DLSS_OVERRIDE_GET_STATE_PARAMS_V1 { + #[doc = "!< [in] Structure version"] + pub version: NvU32, + #[doc = "!< [in] Process Identifier"] + pub processIdentifier: NvU32, + #[doc = "!< [out] Feedback bits for Super Resolution"] + pub feedbackMaskSR: NvU64, + #[doc = "!< [out] Feedback bits for Ray Reconstruction"] + pub feedbackMaskRR: NvU64, + #[doc = "!< [out] Feedback bits for Frame Generation"] + pub feedbackMaskFG: NvU64, + #[doc = "!< [out] Scaling Ratio"] + pub scalingRatio: NvF32, + #[doc = "!< [out] Performance Mode"] + pub performanceMode: NvU32, + #[doc = "!< [out] Render Preset for SR/RR"] + pub renderPreset: NvU32, + #[doc = "!< [out] FG Override Frame Count Target"] + pub frameGenerationCount: NvU32, + #[doc = "!< [out] Render Preset for FG"] + pub frameGenerationPreset: NvU32, + #[doc = "!< [out] Frame Generation Mode"] + pub frameGenerationMode: NvU32, + #[doc = "!< Reserved for future use. Must be zero."] + pub reserved: [NvU32; 2usize], +} +pub type NV_NGX_DLSS_OVERRIDE_GET_STATE_PARAMS_V1 = _NV_NGX_DLSS_OVERRIDE_GET_STATE_PARAMS_V1; +pub type NV_NGX_DLSS_OVERRIDE_GET_STATE_PARAMS = NV_NGX_DLSS_OVERRIDE_GET_STATE_PARAMS_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_NGX_DLSS_OVERRIDE_SET_STATE_PARAMS_V1 { + #[doc = "!< [in] Structure version"] + pub version: NvU32, + #[doc = "!< [in] Process identifier of caller"] + pub processIdentifier: NvU32, + #[doc = "!< [in] DLSS feature ID"] + pub feature: NvU32, + #[doc = "!< [in] Feedback bits for DLSS feature"] + pub feedbackMask: NvU64, + #[doc = "!< Reserved for future use. Must be zero."] + pub reserved: [NvU64; 4usize], +} +pub type NV_NGX_DLSS_OVERRIDE_SET_STATE_PARAMS_V1 = _NV_NGX_DLSS_OVERRIDE_SET_STATE_PARAMS_V1; +pub type NV_NGX_DLSS_OVERRIDE_SET_STATE_PARAMS = NV_NGX_DLSS_OVERRIDE_SET_STATE_PARAMS_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct NVVIOTOPOLOGYTARGET { + #[doc = "!< Handle to Physical GPU (This could be NULL for GVI device if its not binded)"] + pub hPhysicalGpu: NvPhysicalGpuHandle, + #[doc = "!, +} +impl _NV_DISPLAY_DRIVER_INFO { + #[inline] + pub fn bIsDCHDriver(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsDCHDriver(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsDCHDriver_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsDCHDriver_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsNVIDIAStudioPackage(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsNVIDIAStudioPackage(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsNVIDIAStudioPackage_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsNVIDIAStudioPackage_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsNVIDIAGameReadyPackage(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsNVIDIAGameReadyPackage(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsNVIDIAGameReadyPackage_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsNVIDIAGameReadyPackage_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsNVIDIARTXProductionBranchPackage(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsNVIDIARTXProductionBranchPackage(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsNVIDIARTXProductionBranchPackage_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsNVIDIARTXProductionBranchPackage_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsNVIDIARTXNewFeatureBranchPackage(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsNVIDIARTXNewFeatureBranchPackage(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsNVIDIARTXNewFeatureBranchPackage_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsNVIDIARTXNewFeatureBranchPackage_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 27u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 27u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 27u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsDCHDriver: NvU32, + bIsNVIDIAStudioPackage: NvU32, + bIsNVIDIAGameReadyPackage: NvU32, + bIsNVIDIARTXProductionBranchPackage: NvU32, + bIsNVIDIARTXNewFeatureBranchPackage: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsDCHDriver: u32 = unsafe { ::std::mem::transmute(bIsDCHDriver) }; + bIsDCHDriver as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bIsNVIDIAStudioPackage: u32 = + unsafe { ::std::mem::transmute(bIsNVIDIAStudioPackage) }; + bIsNVIDIAStudioPackage as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let bIsNVIDIAGameReadyPackage: u32 = + unsafe { ::std::mem::transmute(bIsNVIDIAGameReadyPackage) }; + bIsNVIDIAGameReadyPackage as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let bIsNVIDIARTXProductionBranchPackage: u32 = + unsafe { ::std::mem::transmute(bIsNVIDIARTXProductionBranchPackage) }; + bIsNVIDIARTXProductionBranchPackage as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let bIsNVIDIARTXNewFeatureBranchPackage: u32 = + unsafe { ::std::mem::transmute(bIsNVIDIARTXNewFeatureBranchPackage) }; + bIsNVIDIARTXNewFeatureBranchPackage as u64 + }); + __bindgen_bitfield_unit.set(5usize, 27u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_DISPLAY_DRIVER_INFO_V1 = _NV_DISPLAY_DRIVER_INFO; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_DISPLAY_DRIVER_INFO_V2 { + #[doc = "!< Structure Version."] + pub version: NvU32, + #[doc = "!< Contains the driver version after successful return."] + pub driverVersion: NvU32, + #[doc = "!< Contains the driver-branch string after successful return."] + pub szBuildBranch: NvAPI_ShortString, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< (OUT) Contains the driver base branch string after successful return."] + pub szBuildBaseBranch: NvAPI_ShortString, + #[doc = "!< Reserved for future use"] + pub reservedEx: NvU32, +} +impl _NV_DISPLAY_DRIVER_INFO_V2 { + #[inline] + pub fn bIsDCHDriver(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsDCHDriver(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsDCHDriver_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsDCHDriver_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsNVIDIAStudioPackage(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsNVIDIAStudioPackage(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsNVIDIAStudioPackage_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsNVIDIAStudioPackage_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsNVIDIAGameReadyPackage(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsNVIDIAGameReadyPackage(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsNVIDIAGameReadyPackage_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsNVIDIAGameReadyPackage_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsNVIDIARTXProductionBranchPackage(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsNVIDIARTXProductionBranchPackage(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsNVIDIARTXProductionBranchPackage_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsNVIDIARTXProductionBranchPackage_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn bIsNVIDIARTXNewFeatureBranchPackage(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_bIsNVIDIARTXNewFeatureBranchPackage(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bIsNVIDIARTXNewFeatureBranchPackage_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bIsNVIDIARTXNewFeatureBranchPackage_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 27u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 27u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 27u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bIsDCHDriver: NvU32, + bIsNVIDIAStudioPackage: NvU32, + bIsNVIDIAGameReadyPackage: NvU32, + bIsNVIDIARTXProductionBranchPackage: NvU32, + bIsNVIDIARTXNewFeatureBranchPackage: NvU32, + reserved: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bIsDCHDriver: u32 = unsafe { ::std::mem::transmute(bIsDCHDriver) }; + bIsDCHDriver as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bIsNVIDIAStudioPackage: u32 = + unsafe { ::std::mem::transmute(bIsNVIDIAStudioPackage) }; + bIsNVIDIAStudioPackage as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let bIsNVIDIAGameReadyPackage: u32 = + unsafe { ::std::mem::transmute(bIsNVIDIAGameReadyPackage) }; + bIsNVIDIAGameReadyPackage as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let bIsNVIDIARTXProductionBranchPackage: u32 = + unsafe { ::std::mem::transmute(bIsNVIDIARTXProductionBranchPackage) }; + bIsNVIDIARTXProductionBranchPackage as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let bIsNVIDIARTXNewFeatureBranchPackage: u32 = + unsafe { ::std::mem::transmute(bIsNVIDIARTXNewFeatureBranchPackage) }; + bIsNVIDIARTXNewFeatureBranchPackage as u64 + }); + __bindgen_bitfield_unit.set(5usize, 27u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_DISPLAY_DRIVER_INFO_V2 = _NV_DISPLAY_DRIVER_INFO_V2; +pub type NV_DISPLAY_DRIVER_INFO = NV_DISPLAY_DRIVER_INFO_V2; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_PHYSICAL_GPU_HANDLE_DATA { + pub hPhysicalGpu: NvPhysicalGpuHandle, + pub adapterType: NV_ADAPTER_TYPE, + pub reserved2: [NvU32; 4usize], +} +pub type NV_PHYSICAL_GPU_HANDLE_DATA = _NV_PHYSICAL_GPU_HANDLE_DATA; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_PHYSICAL_GPUS { + pub version: NvU32, + pub gpuHandleData: [NV_PHYSICAL_GPU_HANDLE_DATA; 64usize], + pub gpuHandleCount: NvU32, + pub reserved: [NvU32; 4usize], +} +pub type NV_PHYSICAL_GPUS_V1 = _NV_PHYSICAL_GPUS; +pub type NV_PHYSICAL_GPUS = NV_PHYSICAL_GPUS_V1; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LOGICAL_GPU_HANDLE_DATA { + pub hLogicalGpu: NvLogicalGpuHandle, + pub adapterType: NV_ADAPTER_TYPE, + pub reserved: [NvU32; 4usize], +} +pub type NV_LOGICAL_GPU_HANDLE_DATA = _NV_LOGICAL_GPU_HANDLE_DATA; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_LOGICAL_GPUS { + pub version: NvU32, + pub gpuHandleData: [NV_LOGICAL_GPU_HANDLE_DATA; 64usize], + pub gpuHandleCount: NvU32, + pub reserved: [NvU32; 4usize], +} +pub type NV_LOGICAL_GPUS_V1 = _NV_LOGICAL_GPUS; +pub type NV_LOGICAL_GPUS = NV_LOGICAL_GPUS_V1; +pub const _NV_NGX_DRIVER_FEATURE_ID_NV_NGX_DRIVER_FEATURE_ID_SET_FLIP_CONFIG_V2: + _NV_NGX_DRIVER_FEATURE_ID = 3423695; +pub type _NV_NGX_DRIVER_FEATURE_ID = ::std::os::raw::c_int; +pub use self::_NV_NGX_DRIVER_FEATURE_ID as NV_NGX_DRIVER_FEATURE_ID; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_NGX_DRIVER_FEATURE_SUPPORT_INFO { + #[doc = "!< [IN] Feature ID to query"] + pub featureId: NV_NGX_DRIVER_FEATURE_ID, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + #[doc = "!< Reserved for future use"] + pub reserved2: [NvU32; 2usize], +} +impl _NV_NGX_DRIVER_FEATURE_SUPPORT_INFO { + #[inline] + pub fn bSupported(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_bSupported(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn bSupported_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_bSupported_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved1(&self) -> NvU32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_reserved1(&mut self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved1_raw(this: *const Self) -> NvU32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved1_raw(this: *mut Self, val: NvU32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + bSupported: NvU32, + reserved1: NvU32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let bSupported: u32 = unsafe { ::std::mem::transmute(bSupported) }; + bSupported as u64 + }); + __bindgen_bitfield_unit.set(1usize, 31u8, { + let reserved1: u32 = unsafe { ::std::mem::transmute(reserved1) }; + reserved1 as u64 + }); + __bindgen_bitfield_unit + } +} +pub type NV_NGX_DRIVER_FEATURE_SUPPORT_INFO = _NV_NGX_DRIVER_FEATURE_SUPPORT_INFO; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_NGX_GET_DRIVER_FEATURE_SUPPORT_PARAMS_V1 { + #[doc = "!< [IN] Structure version"] + pub version: NvU32, + #[doc = "!< [IN] Number of features to query (must be <= NVAPI_MAX_NGX_FEATURES_PER_QUERY)"] + pub featureCount: NvU32, + #[doc = "!< [INOUT] Feature query array"] + pub featureSupportInfo: [NV_NGX_DRIVER_FEATURE_SUPPORT_INFO; 16usize], + #[doc = "!< Reserved for future use"] + pub reserved: [NvU32; 6usize], +} +pub type NV_NGX_GET_DRIVER_FEATURE_SUPPORT_PARAMS_V1 = _NV_NGX_GET_DRIVER_FEATURE_SUPPORT_PARAMS_V1; +pub type NV_NGX_GET_DRIVER_FEATURE_SUPPORT_PARAMS = NV_NGX_GET_DRIVER_FEATURE_SUPPORT_PARAMS_V1; +#[doc = " Callback settings common to all client callbacks."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1 { + #[doc = " [in] Generic callback parameter which will be passed to the callback."] + pub pCallbackParam: *mut ::std::os::raw::c_void, + #[doc = " Reserved bytes for future expansion."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Callback settings common to all client callbacks."] +pub type NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1 = _NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1; +#[doc = " Callback settings common to all client callbacks."] +pub type NV_GPU_CLIENT_CALLBACK_SETTINGS_SUPER_V1 = NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1; +#[doc = " Callback settings common to all periodic client callbacks."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_PERIODIC_CALLBACK_SETTINGS_SUPER_V1 { + #[doc = " [in] Super class data."] + pub super_: NV_GPU_CLIENT_CALLBACK_SETTINGS_SUPER_V1, + #[doc = " [in] Minimum interval at which callback will be called.\n\n The callback may be invoked slower than this interval if underlying\n sampling rate does not align precisely to the provided period."] + pub callbackPeriodms: NvU32, + #[doc = " Reserved bytes for future expansion."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Callback settings common to all periodic client callbacks."] +pub type NV_GPU_CLIENT_PERIODIC_CALLBACK_SETTINGS_SUPER_V1 = + _NV_GPU_CLIENT_PERIODIC_CALLBACK_SETTINGS_SUPER_V1; +#[doc = " Callback data common to all client callbacks."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_CALLBACK_DATA_SUPER_V1 { + #[doc = " [out] Generic callback parameter which was passed in at registration time."] + pub pCallbackParam: *mut ::std::os::raw::c_void, + #[doc = " Reserved bytes for future expansion."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Callback data common to all client callbacks."] +pub type NV_GPU_CLIENT_CALLBACK_DATA_SUPER_V1 = _NV_GPU_CLIENT_CALLBACK_DATA_SUPER_V1; +pub const _NV_GPU_CLIENT_UTIL_DOMAIN_ID_NV_GPU_CLIENT_UTIL_DOMAIN_GRAPHICS: + _NV_GPU_CLIENT_UTIL_DOMAIN_ID = 0; +pub const _NV_GPU_CLIENT_UTIL_DOMAIN_ID_NV_GPU_CLIENT_UTIL_DOMAIN_FRAME_BUFFER: + _NV_GPU_CLIENT_UTIL_DOMAIN_ID = 1; +pub const _NV_GPU_CLIENT_UTIL_DOMAIN_ID_NV_GPU_CLIENT_UTIL_DOMAIN_VIDEO: + _NV_GPU_CLIENT_UTIL_DOMAIN_ID = 2; +#[doc = " Reserved for future use."] +pub const _NV_GPU_CLIENT_UTIL_DOMAIN_ID_NV_GPU_CLIENT_UTIL_DOMAIN_RSVD: + _NV_GPU_CLIENT_UTIL_DOMAIN_ID = 3; +#[doc = " Enumeration of different utilization domains"] +pub type _NV_GPU_CLIENT_UTIL_DOMAIN_ID = ::std::os::raw::c_int; +#[doc = " Enumeration of different utilization domains"] +pub use self::_NV_GPU_CLIENT_UTIL_DOMAIN_ID as NV_GPU_CLIENT_UTIL_DOMAIN_ID; +#[doc = " Data specific to a single utilization domain."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_UTILIZATION_DATA_V1 { + #[doc = " [out] Utilization domain identifier."] + pub utilId: NV_GPU_CLIENT_UTIL_DOMAIN_ID, + #[doc = " [out] Percentage of time where the domain is considered busy since the\n last sample. Units of percent*100; i.e. 5000 = 50%."] + pub utilizationPercent: NvU32, + #[doc = " Reserved bytes for future expansion."] + pub rsvd: [NvU8; 61usize], +} +#[doc = " Data specific to a single utilization domain."] +pub type NV_GPU_CLIENT_UTILIZATION_DATA_V1 = _NV_GPU_CLIENT_UTILIZATION_DATA_V1; +#[doc = " Data passed back to callback registered with\n @ref NvAPI_GPU_ClientRegisterForUtilizationSampleUpdates."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_CALLBACK_UTILIZATION_DATA_V1 { + #[doc = " [out] Super struct."] + pub super_: NV_GPU_CLIENT_CALLBACK_DATA_SUPER_V1, + #[doc = " [out] Number of valid entries in `utils` array."] + pub numUtils: NvU32, + #[doc = " [out] Time at which data was collected. Represented as elapsed\n microseconds since 00:00:00 UTC on January 1, 1970."] + pub timestamp: NvU64, + #[doc = " Reserved bytes for future expansion."] + pub rsvd: [NvU8; 64usize], + #[doc = " [out] Status data for each utilization domain."] + pub utils: [NV_GPU_CLIENT_UTILIZATION_DATA_V1; 4usize], +} +#[doc = " Data passed back to callback registered with\n @ref NvAPI_GPU_ClientRegisterForUtilizationSampleUpdates."] +pub type NV_GPU_CLIENT_CALLBACK_UTILIZATION_DATA_V1 = _NV_GPU_CLIENT_CALLBACK_UTILIZATION_DATA_V1; +#[doc = " Function prototype for a periodic utilization data callback that will be registered with NvAPI."] +pub type NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_V1 = ::std::option::Option< + unsafe extern "C" fn( + hPhysicalGpu: NvPhysicalGpuHandle, + pData: *mut NV_GPU_CLIENT_CALLBACK_UTILIZATION_DATA_V1, + ), +>; +#[doc = " Data required to register a periodic callback for utilization data."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_SETTINGS_V1 { + #[doc = " [in] Structure Version, must always be first."] + pub version: NvU32, + #[doc = " [in] Generic callback settings. Some data within will be passed to the\n callback when invoked."] + pub super_: NV_GPU_CLIENT_PERIODIC_CALLBACK_SETTINGS_SUPER_V1, + #[doc = " [in] Callback. Pass in NULL or nullptr to indicate request to unregister."] + pub callback: NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_V1, + #[doc = " Reserved bytes for future expansion."] + pub rsvd: [NvU8; 64usize], +} +#[doc = " Data required to register a periodic callback for utilization data."] +pub type NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_SETTINGS_V1 = + _NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_SETTINGS_V1; +#[doc = " Data required to register a periodic callback for utilization data."] +pub type NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_SETTINGS = + NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_SETTINGS_V1; +pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_INVALID: _NV_RISE_CONTENT_TYPE = 0; +pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_TEXT: _NV_RISE_CONTENT_TYPE = 1; +pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_GRAPH: _NV_RISE_CONTENT_TYPE = 2; +pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_CUSTOM_BEHAVIOR: _NV_RISE_CONTENT_TYPE = 3; +pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_CUSTOM_BEHAVIOR_RESULT: _NV_RISE_CONTENT_TYPE = + 4; +pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_INSTALLING: _NV_RISE_CONTENT_TYPE = 5; +pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_PROGRESS_UPDATE: _NV_RISE_CONTENT_TYPE = 6; +pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_READY: _NV_RISE_CONTENT_TYPE = 7; +pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_DOWNLOAD_REQUEST: _NV_RISE_CONTENT_TYPE = 8; +pub const _NV_RISE_CONTENT_TYPE_NV_RISE_CONTENT_TYPE_UPDATE_INFO: _NV_RISE_CONTENT_TYPE = 9; +#[doc = " Enumeration of different RISE content types."] +pub type _NV_RISE_CONTENT_TYPE = ::std::os::raw::c_int; +#[doc = " Enumeration of different RISE content types."] +pub use self::_NV_RISE_CONTENT_TYPE as NV_RISE_CONTENT_TYPE; +#[doc = " Data passed back to callback."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_RISE_CALLBACK_DATA_V1 { + #[doc = " Super struct."] + pub super_: NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1, + #[doc = " RISE type of content"] + pub contentType: NV_RISE_CONTENT_TYPE, + #[doc = " RISE content."] + pub content: NvAPI_String, + #[doc = " Is this the last in the batch?"] + pub completed: NvBool, +} +#[doc = " Data passed back to callback."] +pub type NV_RISE_CALLBACK_DATA_V1 = _NV_RISE_CALLBACK_DATA_V1; +#[doc = " Callback for RISE update callbacks."] +pub type NV_RISE_CALLBACK_V1 = + ::std::option::Option; +#[doc = " Data required to register an update callback from the RISE."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_RISE_CALLBACK_SETTINGS_V1 { + #[doc = " [in] Structure Version, must always be first."] + pub version: NvU32, + #[doc = " [in] Generic callback parameter which will be passed to the callback."] + pub super_: NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1, + #[doc = " [in] Callback. Pass in NULL or nullptr to indicate request to unregister."] + pub callback: NV_RISE_CALLBACK_V1, + #[doc = " Reserved, must be set to zero by client."] + pub reserved: [NvU8; 32usize], +} +#[doc = " Data required to register an update callback from the RISE."] +pub type NV_RISE_CALLBACK_SETTINGS_V1 = _NV_RISE_CALLBACK_SETTINGS_V1; +#[doc = " Data required to register an update callback from the RISE."] +pub type NV_RISE_CALLBACK_SETTINGS = NV_RISE_CALLBACK_SETTINGS_V1; +#[doc = " Request contents sent to RISE."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_REQUEST_RISE_SETTINGS_V1 { + #[doc = " [in] Structure Version, must always be first."] + pub version: NvU32, + #[doc = " RISE type of content"] + pub contentType: NV_RISE_CONTENT_TYPE, + #[doc = " RISE request content."] + pub content: NvAPI_String, + #[doc = " Is the request fully sent?"] + pub completed: NvBool, + #[doc = " Reserved, must be set to zero by client."] + pub reserved: [NvU8; 32usize], +} +#[doc = " Request contents sent to RISE."] +pub type NV_REQUEST_RISE_SETTINGS_V1 = _NV_REQUEST_RISE_SETTINGS_V1; +#[doc = " Request contents sent to RISE."] +pub type NV_REQUEST_RISE_SETTINGS = NV_REQUEST_RISE_SETTINGS_V1; +#[doc = " Request contents sent to RISE."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _NV_UNINSTALL_RISE_SETTINGS_V1 { + #[doc = " [in] Structure Version, must always be first."] + pub version: NvU32, + #[doc = " Reserved, must be set to zero by client."] + pub reserved: [NvU8; 32usize], +} +#[doc = " Request contents sent to RISE."] +pub type NV_UNINSTALL_RISE_SETTINGS_V1 = _NV_UNINSTALL_RISE_SETTINGS_V1; +#[doc = " Request contents sent to RISE."] +pub type NV_UNINSTALL_RISE_SETTINGS = NV_UNINSTALL_RISE_SETTINGS_V1; From 86cb104a6b5c9ead52f3184d6dd5d320617de6a3 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Sun, 5 Jul 2026 21:23:39 -0700 Subject: [PATCH 77/85] Remove unused dependencies --- Cargo.lock | 351 ++++----------------------------- dark_api/Cargo.toml | 2 +- zluda32/Cargo.toml | 12 +- zluda64_server/Cargo.toml | 8 +- zluda_common/src/os_win.rs | 2 +- zluda_server_common/Cargo.toml | 5 +- zluda_windows/src/lib.rs | 2 +- 7 files changed, 44 insertions(+), 338 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index bc6775e3e..074515af5 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -114,15 +114,6 @@ version = "4.7.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de" -[[package]] -name = "atomic-polyfill" -version = "1.0.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8cf2bce30dfe09ef0bfaef228b9d414faaf7e563035494d7fe092dba54b300f4" -dependencies = [ - "critical-section", -] - [[package]] name = "autocfg" version = "1.4.0" @@ -135,26 +126,6 @@ version = "0.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3a8241f3ebb85c056b509d4327ad0358fbbba6ffb340bf388f26350aeda225b1" -[[package]] -name = "bincode" -version = "2.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "36eaf5d7b090263e8150820482d5d93cd964a81e4019913c972f4edcc6edb740" -dependencies = [ - "bincode_derive", - "serde", - "unty", -] - -[[package]] -name = "bincode_derive" -version = "2.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bf95709a440f45e986983918d0e8a1f30a9b1df04918fc828670606804ac3c09" -dependencies = [ - "virtue", -] - [[package]] name = "bindgen" version = "0.70.1" @@ -201,30 +172,6 @@ version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7" -[[package]] -name = "bitcode" -version = "0.6.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0a6ed1b54d8dc333e7be604d00fa9262f4635485ffea923647b6521a5fff045d" -dependencies = [ - "arrayvec", - "bitcode_derive", - "bytemuck", - "glam", - "serde", -] - -[[package]] -name = "bitcode_derive" -version = "0.6.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "238b90427dfad9da4a9abd60f3ec1cdee6b80454bde49ed37f1781dd8e9dc7f9" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.117", -] - [[package]] name = "bitflags" version = "1.3.2" @@ -516,15 +463,6 @@ dependencies = [ "cc", ] -[[package]] -name = "cobs" -version = "0.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0fa961b519f0b462e3a3b4a34b64d119eeaca1d59af726fe450bbba07a9fc0a1" -dependencies = [ - "thiserror 2.0.12", -] - [[package]] name = "compiler" version = "0.0.0" @@ -555,9 +493,9 @@ dependencies = [ [[package]] name = "compio-buf" -version = "0.8.1" +version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a00d719dbd8c602ab0d25d219cbc6b517008858de7a8d6c51b4dc95aefff4dce" +checksum = "b51a2c35873865376ed4cdb6cfeb602b6cf569815f017ddd7bd8f86ad49b34c7" dependencies = [ "arrayvec", "bytes", @@ -741,21 +679,6 @@ dependencies = [ "cfg-if", ] -[[package]] -name = "critical-section" -version = "1.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "790eea4361631c5e7d22598ecd5723ff611904e3344ce8720784c93e3d83d40b" - -[[package]] -name = "crossbeam-channel" -version = "0.5.15" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2" -dependencies = [ - "crossbeam-utils", -] - [[package]] name = "crossbeam-deque" version = "0.8.6" @@ -815,7 +738,7 @@ dependencies = [ "libloading", "owo-colors", "rand 0.10.1", - "windows 0.62.2", + "windows", "zluda_windows", ] @@ -1188,18 +1111,6 @@ dependencies = [ "winreg", ] -[[package]] -name = "embedded-io" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ef1a6892d9eef45c8fa6b9e0086428a2cca8491aca8f787c534a3d6d0bcb3ced" - -[[package]] -name = "embedded-io" -version = "0.6.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "edd0f118536f44f5ccd48bcb8b111bdc3de888b58c74639dfb034a357d0f206d" - [[package]] name = "encode_unicode" version = "1.0.0" @@ -1258,7 +1169,7 @@ version = "0.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7223ae2d2f179b803433d9c830478527e92b8117eab39460edae7f1614d9fb73" dependencies = [ - "heapless 0.8.0", + "heapless", "serde", ] @@ -1532,8 +1443,8 @@ dependencies = [ "libc", "log", "rustversion", - "windows-link 0.2.1", - "windows-result 0.4.1", + "windows-link", + "windows-result", ] [[package]] @@ -2396,12 +2307,6 @@ dependencies = [ "gix-validate 0.9.4", ] -[[package]] -name = "glam" -version = "0.32.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f70749695b063ecbf6b62949ccccde2e733ec3ecbbd71d467dca4e5c6c97cca0" - [[package]] name = "glob" version = "0.3.1" @@ -2434,15 +2339,6 @@ dependencies = [ "zerocopy", ] -[[package]] -name = "hash32" -version = "0.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b0c35f58762feb77d74ebe43bdbc3210f09be9fe6742234d573bacc26ed92b67" -dependencies = [ - "byteorder", -] - [[package]] name = "hash32" version = "0.3.1" @@ -2484,27 +2380,13 @@ dependencies = [ "serde_core", ] -[[package]] -name = "heapless" -version = "0.7.17" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cdc6457c0eb62c71aac4bc17216026d8410337c4126773b9c5daba343f17964f" -dependencies = [ - "atomic-polyfill", - "hash32 0.2.1", - "rustc_version", - "serde", - "spin", - "stable_deref_trait", -] - [[package]] name = "heapless" version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0bfb9eb618601c89945a70e254898da93b13be0388091d42117462b265bb3fad" dependencies = [ - "hash32 0.3.1", + "hash32", "stable_deref_trait", ] @@ -2726,9 +2608,9 @@ dependencies = [ [[package]] name = "io-uring" -version = "0.7.11" +version = "0.7.13" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fdd7bddefd0a8833b88a4b68f90dae22c7450d11b354198baee3874fd811b344" +checksum = "9080b15e63775b9a2ac7dca720f7050a8b955e092ea0f6020a4a80f69998cdc0" dependencies = [ "bitflags 2.11.1", "cfg-if", @@ -2746,25 +2628,6 @@ dependencies = [ "rustix 1.1.4", ] -[[package]] -name = "ipc-channel" -version = "0.21.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a441490012d80e9aea75fb27503df8e87e9557dcfc6fe4244dde86bfc12e94e3" -dependencies = [ - "crossbeam-channel", - "libc", - "mio", - "postcard", - "rand 0.9.2", - "rustc-hash 2.1.2", - "serde_core", - "tempfile", - "thiserror 2.0.12", - "uuid", - "windows 0.61.3", -] - [[package]] name = "is-terminal" version = "0.4.17" @@ -3133,17 +2996,6 @@ dependencies = [ "adler2", ] -[[package]] -name = "mio" -version = "1.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "50b7e5b27aa02a74bac8c3f23f448f8d87ff11f92d3aac1a6ed369ee08cc56c1" -dependencies = [ - "libc", - "wasi 0.11.1+wasi-snapshot-preview1", - "windows-sys 0.61.2", -] - [[package]] name = "miopen-sys" version = "0.0.0" @@ -3366,12 +3218,6 @@ version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d" -[[package]] -name = "orderly-allocator" -version = "0.2.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "801f8900aedd8c4060d155f0c8e0269e011ddd0e061bf56a87e5d9ddba3ce995" - [[package]] name = "os_pipe" version = "1.2.3" @@ -3496,19 +3342,6 @@ dependencies = [ "portable-atomic", ] -[[package]] -name = "postcard" -version = "1.1.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6764c3b5dd454e283a30e6dfe78e9b31096d9e32036b5d1eaac7a6119ccb9a24" -dependencies = [ - "cobs", - "embedded-io 0.4.0", - "embedded-io 0.6.1", - "heapless 0.7.17", - "serde", -] - [[package]] name = "potential_utf" version = "0.1.2" @@ -4362,9 +4195,9 @@ dependencies = [ [[package]] name = "synchrony" -version = "0.1.7" +version = "0.1.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c174d82fd56da8214ec095cfe4568e59e5ccb49d060e70c2f98e3ba352b23e45" +checksum = "416090a4d8f6358526df5f9f65dfe28750b8b7bfd1fd8a5620f483fc4a75722c" dependencies = [ "futures-util", "loom", @@ -4721,12 +4554,6 @@ version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "323402cff2dd658f39ca17c789b502021b3f18707c91cdf22e3838e1b4023817" -[[package]] -name = "unty" -version = "0.0.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6d49784317cd0d1ee7ec5c716dd598ec5b4483ea832a2dced265471cc0f690ae" - [[package]] name = "unwrap_or" version = "1.0.1" @@ -4756,7 +4583,6 @@ version = "1.18.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2f87b8aa10b915a06587d0dec516c282ff295b475d94abf425d62b57710070a2" dependencies = [ - "getrandom 0.3.3", "js-sys", "wasm-bindgen", ] @@ -4817,12 +4643,6 @@ version = "0.9.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" -[[package]] -name = "virtue" -version = "0.0.18" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "051eb1abcf10076295e815102942cc58f9d5e3b4560e46e53c21e8ff6f3af7b1" - [[package]] name = "vswhom" version = "0.1.0" @@ -5026,38 +4846,16 @@ version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" -[[package]] -name = "windows" -version = "0.61.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9babd3a767a4c1aef6900409f85f5d53ce2544ccdfaa86dad48c91782c6d6893" -dependencies = [ - "windows-collections 0.2.0", - "windows-core 0.61.2", - "windows-future 0.2.1", - "windows-link 0.1.3", - "windows-numerics 0.2.0", -] - [[package]] name = "windows" version = "0.62.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "527fadee13e0c05939a6a05d5bd6eec6cd2e3dbd648b9f8e447c6518133d8580" dependencies = [ - "windows-collections 0.3.2", - "windows-core 0.62.2", - "windows-future 0.3.2", - "windows-numerics 0.3.1", -] - -[[package]] -name = "windows-collections" -version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3beeceb5e5cfd9eb1d76b381630e82c4241ccd0d27f1a39ed41b2760b255c5e8" -dependencies = [ - "windows-core 0.61.2", + "windows-collections", + "windows-core", + "windows-future", + "windows-numerics", ] [[package]] @@ -5066,20 +4864,7 @@ version = "0.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "23b2d95af1a8a14a3c7367e1ed4fc9c20e0a26e79551b1454d72583c97cc6610" dependencies = [ - "windows-core 0.62.2", -] - -[[package]] -name = "windows-core" -version = "0.61.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3" -dependencies = [ - "windows-implement", - "windows-interface", - "windows-link 0.1.3", - "windows-result 0.3.4", - "windows-strings 0.4.2", + "windows-core", ] [[package]] @@ -5090,20 +4875,9 @@ checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb" dependencies = [ "windows-implement", "windows-interface", - "windows-link 0.2.1", - "windows-result 0.4.1", - "windows-strings 0.5.1", -] - -[[package]] -name = "windows-future" -version = "0.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fc6a41e98427b19fe4b73c550f060b59fa592d7d686537eebf9385621bfbad8e" -dependencies = [ - "windows-core 0.61.2", - "windows-link 0.1.3", - "windows-threading 0.1.0", + "windows-link", + "windows-result", + "windows-strings", ] [[package]] @@ -5112,9 +4886,9 @@ version = "0.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e1d6f90251fe18a279739e78025bd6ddc52a7e22f921070ccdc67dde84c605cb" dependencies = [ - "windows-core 0.62.2", - "windows-link 0.2.1", - "windows-threading 0.2.1", + "windows-core", + "windows-link", + "windows-threading", ] [[package]] @@ -5139,45 +4913,20 @@ dependencies = [ "syn 2.0.117", ] -[[package]] -name = "windows-link" -version = "0.1.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a" - [[package]] name = "windows-link" version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" -[[package]] -name = "windows-numerics" -version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9150af68066c4c5c07ddc0ce30421554771e528bde427614c61038bc2c92c2b1" -dependencies = [ - "windows-core 0.61.2", - "windows-link 0.1.3", -] - [[package]] name = "windows-numerics" version = "0.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6e2e40844ac143cdb44aead537bbf727de9b044e107a0f1220392177d15b0f26" dependencies = [ - "windows-core 0.62.2", - "windows-link 0.2.1", -] - -[[package]] -name = "windows-result" -version = "0.3.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6" -dependencies = [ - "windows-link 0.1.3", + "windows-core", + "windows-link", ] [[package]] @@ -5186,16 +4935,7 @@ version = "0.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5" dependencies = [ - "windows-link 0.2.1", -] - -[[package]] -name = "windows-strings" -version = "0.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57" -dependencies = [ - "windows-link 0.1.3", + "windows-link", ] [[package]] @@ -5204,7 +4944,7 @@ version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091" dependencies = [ - "windows-link 0.2.1", + "windows-link", ] [[package]] @@ -5231,7 +4971,7 @@ version = "0.61.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" dependencies = [ - "windows-link 0.2.1", + "windows-link", ] [[package]] @@ -5250,22 +4990,13 @@ dependencies = [ "windows_x86_64_msvc", ] -[[package]] -name = "windows-threading" -version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b66463ad2e0ea3bbf808b7f1d371311c80e115c0b71d60efc142cafbcfb057a6" -dependencies = [ - "windows-link 0.1.3", -] - [[package]] name = "windows-threading" version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3949bd5b99cafdf1c7ca86b43ca564028dfe27d66958f2470940f73d86d75b37" dependencies = [ - "windows-link 0.2.1", + "windows-link", ] [[package]] @@ -5634,7 +5365,7 @@ dependencies = [ "serde_json", "tempfile", "vergen-gix", - "windows 0.62.2", + "windows", "zluda_cache", "zluda_common", "zluda_windows", @@ -5644,21 +5375,16 @@ dependencies = [ name = "zluda32" version = "0.0.0" dependencies = [ - "bincode", - "bitcode", "cuda_macros", "cuda_types", "dark_api", - "ipc-channel", "libc", "paste", - "postcard", "rand 0.10.1", "rkyv", "rustc-hash 2.1.2", "unwrap_or", - "widestring", - "windows 0.62.2", + "windows", "zluda_common", "zluda_server_common", "zluda_windows", @@ -5668,12 +5394,10 @@ dependencies = [ name = "zluda64_server" version = "0.0.0" dependencies = [ - "bincode", "compio", "cuda_macros", "cuda_types", "dark_api", - "orderly-allocator", "range-alloc", "rkyv", "rustc-hash 2.1.2", @@ -5792,7 +5516,7 @@ dependencies = [ "paste", "rand 0.9.2", "rand_chacha", - "windows 0.62.2", + "windows", "zluda_common", "zluda_dnn", "zluda_windows", @@ -5816,8 +5540,8 @@ dependencies = [ "rustc-hash 2.1.2", "tempfile", "widestring", - "windows 0.62.2", - "windows-core 0.62.2", + "windows", + "windows-core", "zluda_ml", "zluda_redirect", "zluda_trace", @@ -5861,7 +5585,7 @@ dependencies = [ "rustc-hash 2.1.2", "unwrap_or", "widestring", - "windows 0.62.2", + "windows", "windows-sys 0.61.2", "winnow 0.6.20", "zluda_windows", @@ -5871,13 +5595,10 @@ dependencies = [ name = "zluda_server_common" version = "0.0.0" dependencies = [ - "bincode", - "bitcode", "cuda_macros", "cuda_types", "dark_api", "paste", - "postcard", "rkyv", "strum", "strum_macros", @@ -5918,7 +5639,7 @@ dependencies = [ "regex", "rustc-hash 2.1.2", "unwrap_or", - "windows 0.62.2", + "windows", "zluda_common", "zluda_trace_common", "zstd-safe", @@ -6049,7 +5770,7 @@ dependencies = [ "trie-hard", "uuid", "widestring", - "windows 0.62.2", + "windows", ] [[package]] diff --git a/dark_api/Cargo.toml b/dark_api/Cargo.toml index c5c65bb82..6b5452566 100644 --- a/dark_api/Cargo.toml +++ b/dark_api/Cargo.toml @@ -12,4 +12,4 @@ bit-vec = "0.8.0" cglue = "0.3.5" lz4-sys = "1.9" zstd-safe = { version = "7.2.4", features = ["std"] } -rkyv = "0.8.15" +rkyv = "0.8" diff --git a/zluda32/Cargo.toml b/zluda32/Cargo.toml index b64dd8ec7..767f38cfa 100644 --- a/zluda32/Cargo.toml +++ b/zluda32/Cargo.toml @@ -16,7 +16,6 @@ zluda_windows = { path = "../zluda_windows" } zluda_server_common = { path = "../zluda_server_common" } dark_api = { path = "../dark_api" } paste = "1.0" -ipc-channel = "^0.21.0" windows = { version = "0.62.2", features = [ "Win32_Foundation", "Win32_Storage_FileSystem", @@ -24,17 +23,8 @@ windows = { version = "0.62.2", features = [ "Win32_System_Pipes", "Win32_Security", ] } -# windows-sys = { version = "0.61.2", features = [ -# "Win32_Foundation", -# "Win32_System_Pipes", -# "Win32_Storage_FileSystem", -# ] } rand = "0.10.1" -widestring = "1.2.1" -bitcode = "0.6.9" -postcard = "1.1.3" -bincode = "2.0.1" -rkyv = "0.8.15" +rkyv = "0.8" unwrap_or = "1.0.1" rustc-hash = "2.0.0" libc = "0.2" diff --git a/zluda64_server/Cargo.toml b/zluda64_server/Cargo.toml index 69be4b5e9..193c9bfb1 100644 --- a/zluda64_server/Cargo.toml +++ b/zluda64_server/Cargo.toml @@ -14,13 +14,11 @@ cuda_macros = { path = "../cuda_macros" } zluda_server_common = { path = "../zluda_server_common" } dark_api = { path = "../dark_api" } windows-sys = { version = "0.61.2", features = ["Win32_Foundation"] } -compio = { version = "0.18.0", features = ["macros", "fs"] } +compio = { version = "0.18", features = ["macros", "fs"] } slab = "0.4.12" -bincode = "2.0.1" -rkyv = "0.8.15" -orderly-allocator = "0.2.2" -range-alloc = "0.1.5" +rkyv = "0.8" rustc-hash = "2.0.0" +range-alloc = "0.1.5" [package.metadata.zluda] windows_only = true diff --git a/zluda_common/src/os_win.rs b/zluda_common/src/os_win.rs index 05d8c74d8..10a1a1463 100644 --- a/zluda_common/src/os_win.rs +++ b/zluda_common/src/os_win.rs @@ -1,5 +1,5 @@ use std::path::PathBuf; pub fn self_path() -> Option { - zluda_windows::get_module_path_for_function(self_path as usize).map(PathBuf::from) + zluda_windows::get_module_path_for_function(self_path as *const () as usize).map(PathBuf::from) } diff --git a/zluda_server_common/Cargo.toml b/zluda_server_common/Cargo.toml index c1b9de263..def02f849 100644 --- a/zluda_server_common/Cargo.toml +++ b/zluda_server_common/Cargo.toml @@ -8,10 +8,7 @@ edition = "2021" dark_api = { path = "../dark_api" } cuda_types = { path = "../cuda_types" } cuda_macros = { path = "../cuda_macros" } -bitcode = "0.6.9" paste = "1" -postcard = "1.1.3" -bincode = "2.0.1" -rkyv = "0.8.15" +rkyv = "0.8" strum = "0.28" strum_macros = "0.28" diff --git a/zluda_windows/src/lib.rs b/zluda_windows/src/lib.rs index 26ba82846..1a293a94d 100644 --- a/zluda_windows/src/lib.rs +++ b/zluda_windows/src/lib.rs @@ -534,7 +534,7 @@ pub unsafe fn delay_load_check( } pub unsafe fn try_load_from_self_dir(libname: &str) -> Option { - let path = get_module_path_for_function(try_load_from_self_dir as usize)?; + let path = get_module_path_for_function(try_load_from_self_dir as *const () as usize)?; let mut path_buf = PathBuf::from(path); path_buf.pop(); path_buf.push(libname); From 4f66550d208b2826648685e09effa6510f358a7c Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Sun, 5 Jul 2026 21:27:33 -0700 Subject: [PATCH 78/85] More deps cleanup --- Cargo.lock | 16 +++++++++++++--- cuda_check/Cargo.toml | 2 +- zluda32/Cargo.toml | 2 +- zluda_dnn9/Cargo.toml | 4 ++-- 4 files changed, 17 insertions(+), 7 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 074515af5..d9f983c1c 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3620,7 +3620,7 @@ version = "0.9.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1" dependencies = [ - "rand_chacha", + "rand_chacha 0.9.0", "rand_core 0.9.5", ] @@ -3645,6 +3645,16 @@ dependencies = [ "rand_core 0.9.5", ] +[[package]] +name = "rand_chacha" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3e6af7f3e25ded52c41df4e0b1af2d047e45896c2f3281792ed68a1c243daedb" +dependencies = [ + "ppv-lite86", + "rand_core 0.10.0", +] + [[package]] name = "rand_core" version = "0.9.5" @@ -5514,8 +5524,8 @@ dependencies = [ "half", "libloading", "paste", - "rand 0.9.2", - "rand_chacha", + "rand 0.10.1", + "rand_chacha 0.10.0", "windows", "zluda_common", "zluda_dnn", diff --git a/cuda_check/Cargo.toml b/cuda_check/Cargo.toml index baefa150c..0b771f548 100644 --- a/cuda_check/Cargo.toml +++ b/cuda_check/Cargo.toml @@ -13,7 +13,7 @@ cuda_types = { path = "../cuda_types" } zluda_windows = { path = "../zluda_windows" } bpaf = { version = "0.9.19", features = ["derive", "bright-color"] } owo-colors = { version = "4", features = ["supports-colors"] } -rand = "0.10.1" +rand = "0.10" libloading = "0.8" [target.'cfg(windows)'.dependencies] diff --git a/zluda32/Cargo.toml b/zluda32/Cargo.toml index 767f38cfa..0685339eb 100644 --- a/zluda32/Cargo.toml +++ b/zluda32/Cargo.toml @@ -23,7 +23,7 @@ windows = { version = "0.62.2", features = [ "Win32_System_Pipes", "Win32_Security", ] } -rand = "0.10.1" +rand = "0.10" rkyv = "0.8" unwrap_or = "1.0.1" rustc-hash = "2.0.0" diff --git a/zluda_dnn9/Cargo.toml b/zluda_dnn9/Cargo.toml index 4abf2e331..508a99b7c 100644 --- a/zluda_dnn9/Cargo.toml +++ b/zluda_dnn9/Cargo.toml @@ -24,8 +24,8 @@ paste = "1.0" libloading = "0.8" candle-core = "0.9.2" half = { version = "2.7", features = ["rand_distr"] } -rand = { version = "0.9.2" } -rand_chacha = { version = "0.9" } +rand = { version = "0.10" } +rand_chacha = { version = "0.10" } [target.'cfg(windows)'.dependencies] zluda_windows = { path = "../zluda_windows" } From dff396b07237882a12d2e4212c12aa1da1d55458 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Sun, 5 Jul 2026 21:58:05 -0700 Subject: [PATCH 79/85] Don't build windows crates for tests --- .github/workflows/pr_master.yml | 6 +++++- .github/workflows/push_master.yml | 6 +++++- 2 files changed, 10 insertions(+), 2 deletions(-) diff --git a/.github/workflows/pr_master.yml b/.github/workflows/pr_master.yml index b7cd4c7c1..f5a355801 100644 --- a/.github/workflows/pr_master.yml +++ b/.github/workflows/pr_master.yml @@ -121,7 +121,11 @@ jobs: --exclude cuda_macros \ --exclude ptx_parser_macros \ --exclude zluda_inject \ - --exclude zluda_redirect + --exclude zluda_redirect \ + --exclude zluda32 \ + --exclude zluda64_server \ + --exclude nvapi \ + --exclude nvapi_trace mkdir -p target/amdgpu bash .github/workflows/move_tests.sh target/tests amdgpu strip target/amdgpu/* diff --git a/.github/workflows/push_master.yml b/.github/workflows/push_master.yml index eac12a07f..e821e446c 100644 --- a/.github/workflows/push_master.yml +++ b/.github/workflows/push_master.yml @@ -138,7 +138,11 @@ jobs: --exclude cuda_macros \ --exclude ptx_parser_macros \ --exclude zluda_inject \ - --exclude zluda_redirect + --exclude zluda_redirect \ + --exclude zluda32 \ + --exclude zluda64_server \ + --exclude nvapi \ + --exclude nvapi_trace mkdir -p target/amdgpu bash .github/workflows/move_tests.sh target/tests amdgpu strip target/amdgpu/* From a2ac5adc87e266b6753cd831e1a76a02377020ef Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Sun, 5 Jul 2026 22:25:52 -0700 Subject: [PATCH 80/85] Downgrade rand for half --- Cargo.lock | 246 +++--------------------------------------- cuda_check/Cargo.toml | 2 +- zluda32/Cargo.toml | 2 +- zluda_dnn9/Cargo.toml | 4 +- 4 files changed, 17 insertions(+), 237 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index d9f983c1c..30af03a85 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -323,7 +323,7 @@ dependencies = [ "memmap2", "num-traits", "num_cpus", - "rand 0.9.2", + "rand", "rand_distr", "rayon", "safetensors", @@ -426,17 +426,6 @@ dependencies = [ "syn 1.0.109", ] -[[package]] -name = "chacha20" -version = "0.10.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6f8d983286843e49675a4b7a2d174efe136dc93a18d69130dd18198a6c167601" -dependencies = [ - "cfg-if", - "cpufeatures 0.3.0", - "rand_core 0.10.0", -] - [[package]] name = "clang-sys" version = "1.8.1" @@ -661,15 +650,6 @@ dependencies = [ "libc", ] -[[package]] -name = "cpufeatures" -version = "0.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b2a41393f66f16b0823bb79094d54ac5fbd34ab292ddafb9a0456ac9f87d201" -dependencies = [ - "libc", -] - [[package]] name = "crc32fast" version = "1.5.0" @@ -737,7 +717,7 @@ dependencies = [ "cuda_types", "libloading", "owo-colors", - "rand 0.10.1", + "rand", "windows", "zluda_windows", ] @@ -1222,7 +1202,7 @@ checksum = "719a903cc23e4a89e87962c2a80fdb45cdaad0983a89bd150bb57b4c8571a7d5" dependencies = [ "half", "num-traits", - "rand 0.9.2", + "rand", "rand_distr", ] @@ -1476,24 +1456,10 @@ checksum = "26145e563e54f2cadc477553f1ec5ee650b00862f0a58bcd12cbdc5f0ea2d2f4" dependencies = [ "cfg-if", "libc", - "r-efi 5.3.0", + "r-efi", "wasi 0.14.2+wasi-0.2.4", ] -[[package]] -name = "getrandom" -version = "0.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0de51e6874e94e7bf76d726fc5d13ba782deca734ff60d5bb2fb2607c7406555" -dependencies = [ - "cfg-if", - "libc", - "r-efi 6.0.0", - "rand_core 0.10.0", - "wasip2", - "wasip3", -] - [[package]] name = "gix" version = "0.71.0" @@ -2334,7 +2300,7 @@ dependencies = [ "cfg-if", "crunchy", "num-traits", - "rand 0.9.2", + "rand", "rand_distr", "zerocopy", ] @@ -2527,12 +2493,6 @@ dependencies = [ "zerovec", ] -[[package]] -name = "id-arena" -version = "2.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954" - [[package]] name = "ident_case" version = "1.0.1" @@ -2577,7 +2537,6 @@ checksum = "8c9c992b02b5b4c94ea26e32fe5bccb7aa7d9f390ab5c1221ff895bc7ea8b652" dependencies = [ "equivalent", "hashbrown 0.15.2", - "serde", ] [[package]] @@ -2743,12 +2702,6 @@ version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe" -[[package]] -name = "leb128fmt" -version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2" - [[package]] name = "libc" version = "0.2.184" @@ -3599,12 +3552,6 @@ version = "5.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f" -[[package]] -name = "r-efi" -version = "6.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf" - [[package]] name = "rancor" version = "0.1.1" @@ -3620,19 +3567,8 @@ version = "0.9.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1" dependencies = [ - "rand_chacha 0.9.0", - "rand_core 0.9.5", -] - -[[package]] -name = "rand" -version = "0.10.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d2e8e8bcc7961af1fdac401278c6a831614941f6164ee3bf4ce61b7edb162207" -dependencies = [ - "chacha20", - "getrandom 0.4.2", - "rand_core 0.10.0", + "rand_chacha", + "rand_core", ] [[package]] @@ -3642,17 +3578,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb" dependencies = [ "ppv-lite86", - "rand_core 0.9.5", -] - -[[package]] -name = "rand_chacha" -version = "0.10.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3e6af7f3e25ded52c41df4e0b1af2d047e45896c2f3281792ed68a1c243daedb" -dependencies = [ - "ppv-lite86", - "rand_core 0.10.0", + "rand_core", ] [[package]] @@ -3664,12 +3590,6 @@ dependencies = [ "getrandom 0.3.3", ] -[[package]] -name = "rand_core" -version = "0.10.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0c8d0fd677905edcbeedbf2edb6494d676f0e98d54d5cf9bda0b061cb8fb8aba" - [[package]] name = "rand_distr" version = "0.5.1" @@ -3677,7 +3597,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6a8615d50dcf34fa31f7ab52692afec947c4dd0ab803cc87cb3b0b4570ff7463" dependencies = [ "num-traits", - "rand 0.9.2", + "rand", ] [[package]] @@ -4026,7 +3946,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba" dependencies = [ "cfg-if", - "cpufeatures 0.2.17", + "cpufeatures", "digest", ] @@ -4698,24 +4618,6 @@ dependencies = [ "wit-bindgen-rt", ] -[[package]] -name = "wasip2" -version = "1.0.2+wasi-0.2.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9517f9239f02c069db75e65f174b3da828fe5f5b945c4dd26bd25d89c03ebcf5" -dependencies = [ - "wit-bindgen", -] - -[[package]] -name = "wasip3" -version = "0.4.0+wasi-0.3.0-rc-2026-01-06" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5" -dependencies = [ - "wit-bindgen", -] - [[package]] name = "wasm-bindgen" version = "0.2.104" @@ -4775,40 +4677,6 @@ dependencies = [ "unicode-ident", ] -[[package]] -name = "wasm-encoder" -version = "0.244.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319" -dependencies = [ - "leb128fmt", - "wasmparser", -] - -[[package]] -name = "wasm-metadata" -version = "0.244.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909" -dependencies = [ - "anyhow", - "indexmap", - "wasm-encoder", - "wasmparser", -] - -[[package]] -name = "wasmparser" -version = "0.244.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe" -dependencies = [ - "bitflags 2.11.1", - "hashbrown 0.15.2", - "indexmap", - "semver", -] - [[package]] name = "web-time" version = "1.1.0" @@ -5085,26 +4953,6 @@ dependencies = [ "windows-sys 0.59.0", ] -[[package]] -name = "wit-bindgen" -version = "0.51.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5" -dependencies = [ - "wit-bindgen-rust-macro", -] - -[[package]] -name = "wit-bindgen-core" -version = "0.51.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc" -dependencies = [ - "anyhow", - "heck", - "wit-parser", -] - [[package]] name = "wit-bindgen-rt" version = "0.39.0" @@ -5114,74 +4962,6 @@ dependencies = [ "bitflags 2.11.1", ] -[[package]] -name = "wit-bindgen-rust" -version = "0.51.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21" -dependencies = [ - "anyhow", - "heck", - "indexmap", - "prettyplease", - "syn 2.0.117", - "wasm-metadata", - "wit-bindgen-core", - "wit-component", -] - -[[package]] -name = "wit-bindgen-rust-macro" -version = "0.51.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0c0f9bfd77e6a48eccf51359e3ae77140a7f50b1e2ebfe62422d8afdaffab17a" -dependencies = [ - "anyhow", - "prettyplease", - "proc-macro2", - "quote", - "syn 2.0.117", - "wit-bindgen-core", - "wit-bindgen-rust", -] - -[[package]] -name = "wit-component" -version = "0.244.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2" -dependencies = [ - "anyhow", - "bitflags 2.11.1", - "indexmap", - "log", - "serde", - "serde_derive", - "serde_json", - "wasm-encoder", - "wasm-metadata", - "wasmparser", - "wit-parser", -] - -[[package]] -name = "wit-parser" -version = "0.244.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736" -dependencies = [ - "anyhow", - "id-arena", - "indexmap", - "log", - "semver", - "serde", - "serde_derive", - "serde_json", - "unicode-xid", - "wasmparser", -] - [[package]] name = "writeable" version = "0.6.1" @@ -5390,7 +5170,7 @@ dependencies = [ "dark_api", "libc", "paste", - "rand 0.10.1", + "rand", "rkyv", "rustc-hash 2.1.2", "unwrap_or", @@ -5524,8 +5304,8 @@ dependencies = [ "half", "libloading", "paste", - "rand 0.10.1", - "rand_chacha 0.10.0", + "rand", + "rand_chacha", "windows", "zluda_common", "zluda_dnn", diff --git a/cuda_check/Cargo.toml b/cuda_check/Cargo.toml index 0b771f548..2c29cf7aa 100644 --- a/cuda_check/Cargo.toml +++ b/cuda_check/Cargo.toml @@ -13,7 +13,7 @@ cuda_types = { path = "../cuda_types" } zluda_windows = { path = "../zluda_windows" } bpaf = { version = "0.9.19", features = ["derive", "bright-color"] } owo-colors = { version = "4", features = ["supports-colors"] } -rand = "0.10" +rand = "0.9" libloading = "0.8" [target.'cfg(windows)'.dependencies] diff --git a/zluda32/Cargo.toml b/zluda32/Cargo.toml index 0685339eb..52bbd1aca 100644 --- a/zluda32/Cargo.toml +++ b/zluda32/Cargo.toml @@ -23,7 +23,7 @@ windows = { version = "0.62.2", features = [ "Win32_System_Pipes", "Win32_Security", ] } -rand = "0.10" +rand = "0.9" rkyv = "0.8" unwrap_or = "1.0.1" rustc-hash = "2.0.0" diff --git a/zluda_dnn9/Cargo.toml b/zluda_dnn9/Cargo.toml index 508a99b7c..535f9d33d 100644 --- a/zluda_dnn9/Cargo.toml +++ b/zluda_dnn9/Cargo.toml @@ -24,8 +24,8 @@ paste = "1.0" libloading = "0.8" candle-core = "0.9.2" half = { version = "2.7", features = ["rand_distr"] } -rand = { version = "0.10" } -rand_chacha = { version = "0.10" } +rand = { version = "0.9" } +rand_chacha = { version = "0.9" } [target.'cfg(windows)'.dependencies] zluda_windows = { path = "../zluda_windows" } From 2b6a7ed37a6e018a1e2147804c59bc6f083c8050 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Mon, 6 Jul 2026 21:54:39 -0700 Subject: [PATCH 81/85] Use relative startup path and package 32 on build --- .github/workflows/pr_master.yml | 2 ++ .github/workflows/push_master.yml | 2 ++ zluda32/src/ipc.rs | 21 +++++++++++---------- 3 files changed, 15 insertions(+), 10 deletions(-) diff --git a/.github/workflows/pr_master.yml b/.github/workflows/pr_master.yml index f5a355801..e75f66176 100644 --- a/.github/workflows/pr_master.yml +++ b/.github/workflows/pr_master.yml @@ -83,6 +83,8 @@ jobs: run: | cargo xtask zip --profile ${{ env.CARGO_PROFILE }} Expand-Archive -Path target/${{ env.CARGO_PROFILE }}/zluda.zip -DestinationPath target/${{ env.CARGO_PROFILE }}/zluda + cargo xtask zip --profile ${{ env.CARGO_PROFILE }} --target=i686-pc-windows-msvc + Expand-Archive -Path target/i686-pc-windows-msvc/${{ env.CARGO_PROFILE }}/zluda.zip -DestinationPath target/${{ env.CARGO_PROFILE }}/zluda/32 - name: Set revision hash run: echo "SHORT_SHA=$("${{ github.sha }}".SubString(0, 7))" >> $env:GITHUB_ENV - name: Upload diff --git a/.github/workflows/push_master.yml b/.github/workflows/push_master.yml index e821e446c..a166bcc7d 100644 --- a/.github/workflows/push_master.yml +++ b/.github/workflows/push_master.yml @@ -81,6 +81,8 @@ jobs: run: | cargo xtask zip --profile ${{ env.CARGO_PROFILE }} Expand-Archive -Path target/${{ env.CARGO_PROFILE }}/zluda.zip -DestinationPath target/${{ env.CARGO_PROFILE }}/zluda + cargo xtask zip --profile ${{ env.CARGO_PROFILE }} --target=i686-pc-windows-msvc + Expand-Archive -Path target/i686-pc-windows-msvc/${{ env.CARGO_PROFILE }}/zluda.zip -DestinationPath target/${{ env.CARGO_PROFILE }}/zluda/32 - name: Set revision hash run: echo "SHORT_SHA=$("${{ github.sha }}".SubString(0, 7))" >> $env:GITHUB_ENV - name: Upload diff --git a/zluda32/src/ipc.rs b/zluda32/src/ipc.rs index f4435c113..b7a1ec6ef 100644 --- a/zluda32/src/ipc.rs +++ b/zluda32/src/ipc.rs @@ -17,15 +17,6 @@ use windows::Win32::Foundation::*; use windows::Win32::System::Pipes::*; use zluda_server_common::Opcode; -fn server_path() -> &'static str { - if cfg!(debug_assertions) { - r"C:\dev\ZLUDA\target\debug\zluda64_server.exe" - } else { - //"zluda64_server.exe" - r"C:\dev\ZLUDA\target\release\zluda64_server.exe" - } -} - pub(crate) struct Server { pipe: std::fs::File, _child: Child, @@ -60,7 +51,17 @@ impl Server { )? .0, ); - let child = Command::new(server_path()) + let mut server_path = zluda_common::os::self_path().ok_or(Error::new( + E_FAIL, + "Could not get path to the executing module", + ))?; + server_path.pop(); + if cfg!(debug_assertions) { + server_path.push("../../debug/zluda64_server.exe"); + } else { + server_path.push("../zluda64_server.exe"); + } + let child = Command::new(server_path) .arg(&pipe_path[..pipe_path.len() - 1]) .stdin(Stdio::null()) .stdout(Stdio::null()) From 57f4ffbd5f731eb87a44b9ab334e1c854cf64987 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Mon, 6 Jul 2026 23:51:19 -0700 Subject: [PATCH 82/85] Fix paths, honor env var in 32 bit nvcuda.dll --- .github/workflows/pr_master.yml | 1 + .github/workflows/push_master.yml | 1 + zluda32/src/ipc.rs | 35 +++++++++++++++++++------------ 3 files changed, 24 insertions(+), 13 deletions(-) diff --git a/.github/workflows/pr_master.yml b/.github/workflows/pr_master.yml index e75f66176..90cd03a89 100644 --- a/.github/workflows/pr_master.yml +++ b/.github/workflows/pr_master.yml @@ -85,6 +85,7 @@ jobs: Expand-Archive -Path target/${{ env.CARGO_PROFILE }}/zluda.zip -DestinationPath target/${{ env.CARGO_PROFILE }}/zluda cargo xtask zip --profile ${{ env.CARGO_PROFILE }} --target=i686-pc-windows-msvc Expand-Archive -Path target/i686-pc-windows-msvc/${{ env.CARGO_PROFILE }}/zluda.zip -DestinationPath target/${{ env.CARGO_PROFILE }}/zluda/32 + Move-Item -Path target/${{ env.CARGO_PROFILE }}/zluda/32/zluda -Destination target/${{ env.CARGO_PROFILE }}/zluda/zluda/32 - name: Set revision hash run: echo "SHORT_SHA=$("${{ github.sha }}".SubString(0, 7))" >> $env:GITHUB_ENV - name: Upload diff --git a/.github/workflows/push_master.yml b/.github/workflows/push_master.yml index a166bcc7d..0eb15d302 100644 --- a/.github/workflows/push_master.yml +++ b/.github/workflows/push_master.yml @@ -83,6 +83,7 @@ jobs: Expand-Archive -Path target/${{ env.CARGO_PROFILE }}/zluda.zip -DestinationPath target/${{ env.CARGO_PROFILE }}/zluda cargo xtask zip --profile ${{ env.CARGO_PROFILE }} --target=i686-pc-windows-msvc Expand-Archive -Path target/i686-pc-windows-msvc/${{ env.CARGO_PROFILE }}/zluda.zip -DestinationPath target/${{ env.CARGO_PROFILE }}/zluda/32 + Move-Item -Path target/${{ env.CARGO_PROFILE }}/zluda/32/zluda -Destination target/${{ env.CARGO_PROFILE }}/zluda/zluda/32 - name: Set revision hash run: echo "SHORT_SHA=$("${{ github.sha }}".SubString(0, 7))" >> $env:GITHUB_ENV - name: Upload diff --git a/zluda32/src/ipc.rs b/zluda32/src/ipc.rs index b7a1ec6ef..b675b24c7 100644 --- a/zluda32/src/ipc.rs +++ b/zluda32/src/ipc.rs @@ -8,10 +8,10 @@ use rkyv::util::AlignedVec; use rkyv::{Archive, Deserialize, Portable, Serialize}; use std::io::{Read, Write}; use std::os::windows::io::{AsHandle, AsRawHandle, FromRawHandle}; -// use rkyv::util::AlignedVec; -use std::mem; +use std::path::PathBuf; use std::num::NonZeroU32; use std::process::{Child, Command, Stdio}; +use std::{env, mem}; use windows::core::{Error, PCSTR}; use windows::Win32::Foundation::*; use windows::Win32::System::Pipes::*; @@ -51,22 +51,31 @@ impl Server { )? .0, ); - let mut server_path = zluda_common::os::self_path().ok_or(Error::new( + let mut primary_path = zluda_common::os::self_path().ok_or(Error::new( E_FAIL, "Could not get path to the executing module", ))?; - server_path.pop(); + primary_path.pop(); if cfg!(debug_assertions) { - server_path.push("../../debug/zluda64_server.exe"); + primary_path.push("../../debug/zluda64_server.exe"); } else { - server_path.push("../zluda64_server.exe"); - } - let child = Command::new(server_path) - .arg(&pipe_path[..pipe_path.len() - 1]) - .stdin(Stdio::null()) - .stdout(Stdio::null()) - .stderr(Stdio::null()) - .spawn()?; + primary_path.push("../zluda64_server.exe"); + }; + let fallback_path = env::var("ZLUDA64_PATH").ok().map(PathBuf::from); + let spawn_server = |path: &PathBuf| { + Command::new(path) + .arg(&pipe_path[..pipe_path.len() - 1]) + .stdin(Stdio::null()) + .stdout(Stdio::null()) + .stderr(Stdio::null()) + .current_dir(path.parent().unwrap()) + .spawn() + }; + let child = match (spawn_server(&primary_path), fallback_path) { + (Ok(c), _) => c, + (Err(_), Some(fallback_path)) => spawn_server(&fallback_path)?, + (Err(e), None) => return Err(e.into()), + }; zluda_windows::kill_child_on_process_exit(child.as_handle().as_raw_handle())?; match ConnectNamedPipe(HANDLE(pipe.as_raw_handle()), None) { Ok(_) => Ok(Server::new(pipe, child)), From f5f328dac101523b589007a5ae4492b6fd63e5a3 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Mon, 6 Jul 2026 23:53:04 -0700 Subject: [PATCH 83/85] Formatting --- zluda32/src/ipc.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/zluda32/src/ipc.rs b/zluda32/src/ipc.rs index b675b24c7..0892d96a9 100644 --- a/zluda32/src/ipc.rs +++ b/zluda32/src/ipc.rs @@ -7,9 +7,9 @@ use rkyv::ser::allocator::ArenaHandle; use rkyv::util::AlignedVec; use rkyv::{Archive, Deserialize, Portable, Serialize}; use std::io::{Read, Write}; +use std::num::NonZeroU32; use std::os::windows::io::{AsHandle, AsRawHandle, FromRawHandle}; use std::path::PathBuf; -use std::num::NonZeroU32; use std::process::{Child, Command, Stdio}; use std::{env, mem}; use windows::core::{Error, PCSTR}; From 1b67de23bb906fe31e7b919984484fd2cd4a0237 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Tue, 7 Jul 2026 18:11:55 -0700 Subject: [PATCH 84/85] Address review comments --- zluda32/src/ipc.rs | 3 --- zluda64_server/src/main.rs | 23 ++++++++++++++++++----- 2 files changed, 18 insertions(+), 8 deletions(-) diff --git a/zluda32/src/ipc.rs b/zluda32/src/ipc.rs index 0892d96a9..833bf5807 100644 --- a/zluda32/src/ipc.rs +++ b/zluda32/src/ipc.rs @@ -23,9 +23,6 @@ pub(crate) struct Server { buffer: AlignedVec, } -unsafe impl Sync for Server {} -unsafe impl Send for Server {} - impl Server { fn new(pipe: std::fs::File, child: Child) -> Self { Self { diff --git a/zluda64_server/src/main.rs b/zluda64_server/src/main.rs index 41339e8ee..0078c71a6 100644 --- a/zluda64_server/src/main.rs +++ b/zluda64_server/src/main.rs @@ -58,11 +58,23 @@ impl HandlePool { if id == 0 { return Ok(ptr::null_mut()); } + let idx = id.checked_sub(Self::OFFSET).ok_or(CUerror::INVALID_VALUE)? as usize; self.handles - .get((id - Self::OFFSET) as usize) + .get(idx) .map(|&handle| handle as *mut T) .ok_or(CUerror::INVALID_VALUE) } + + fn remove(&mut self, id: u32) -> Result<*mut T, CUerror> { + if id == 0 { + return Err(CUerror::INVALID_VALUE); + } + let idx = id.checked_sub(Self::OFFSET).ok_or(CUerror::INVALID_VALUE)? as usize; + self.handles + .try_remove(idx) + .map(|handle| handle as *mut T) + .ok_or(CUerror::INVALID_VALUE) + } } struct ModuleLaunchData { @@ -219,11 +231,12 @@ impl Allocator { } fn free(&mut self, start: u32) -> Result<(), CUerror> { + let start_in_units = start / Allocator::ALLOCATION_UNIT; let end = self .allocation_ends - .remove(&(start / Allocator::ALLOCATION_UNIT)) + .remove(&start_in_units) .ok_or(CUerror::INVALID_VALUE)?; - self.allocator.free_range(start..end); + self.allocator.free_range(start_in_units..end); Ok(()) } @@ -652,7 +665,7 @@ fn cu_event_destroy_v2( input: &ArchivedcuEventDestroy_v2In, ) -> Result { let event = input.hEvent.to_native(); - let cu_event = state.handles.get(event)?; + let cu_event = state.handles.remove(event)?; unsafe { cuEventDestroy_v2(cu_event) }?; Ok(cuEventDestroy_v2Out {}) } @@ -662,7 +675,7 @@ fn cu_stream_destroy_v2( input: &ArchivedcuStreamDestroy_v2In, ) -> Result { let stream = input.hStream.to_native(); - let cu_stream = CUstream(state.handles.get(stream)?); + let cu_stream = CUstream(state.handles.remove(stream)?); unsafe { cuStreamDestroy_v2(cu_stream) }?; Ok(cuStreamDestroy_v2Out {}) } From 509e8adacbe0ee9847c3b6b00cd4986766d698d0 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Tue, 7 Jul 2026 21:41:12 -0700 Subject: [PATCH 85/85] Document PhysX --- docs/src/SUMMARY.md | 1 + docs/src/physx32.md | 63 +++++++++++++++++++++++++++++++++++++++ docs/src/steam.jpg | Bin 0 -> 55347 bytes docs/src/steam_trace.jpg | Bin 0 -> 55567 bytes 4 files changed, 64 insertions(+) create mode 100644 docs/src/physx32.md create mode 100644 docs/src/steam.jpg create mode 100644 docs/src/steam_trace.jpg diff --git a/docs/src/SUMMARY.md b/docs/src/SUMMARY.md index 8f1daf799..a13ae2eea 100644 --- a/docs/src/SUMMARY.md +++ b/docs/src/SUMMARY.md @@ -10,6 +10,7 @@ - [Precompiling (slow start)](./precompiling.md) # Applications + - [PhysX (32 bit)](./physx32.md) - [llama.cpp](./llama_cpp.md) # For developers diff --git a/docs/src/physx32.md b/docs/src/physx32.md new file mode 100644 index 000000000..8fb7829c6 --- /dev/null +++ b/docs/src/physx32.md @@ -0,0 +1,63 @@ +# PhysX (32 bit) + +ZLUDA has a limited implementation of 32-bit CUDA tailored for PhysX. +There are three ways to use it: + +* Steam game + + Open the game's "Properties" and enter the following in "Launch Options": + + `"\32\zluda.exe" -- %command%` + + ![](steam.jpg) + +* Using launcher directly + + Open a command prompt and launch the game with 32-bit `zluda.exe`: + + `\32\zluda.exe -- ` + +* System install + + + This is not a recommended way to load ZLUDA. Use it only if nothing else works. + + + * Copy `nvapi.dll` and `nvcuda.dll` from the `32` directory to `C:\Windows\SysWOW64` (requires Administrator permissions) + * Set the `ZLUDA64_PATH` environment variable to the ZLUDA directory (it must contain `zluda64_server.exe`) + +## Known Issues + +* Reinitializing PhysX might fail. Changing in-game PhysX settings can crash or hang the game. + +## Troubleshooting + +If your game does not work, try collecting a trace. + +* When using a launcher (through Steam or directly) + + Add the `--zluda-trace` option to `zluda.exe`. + If you have access to an NVIDIA GPU, you can also collect a trace on NVIDIA with `--nvidia-trace`. + + ![](steam_trace.jpg) + +* When using a system install + + + This is not a recommended way to load ZLUDA. Use it only if nothing else works. + + + * Copy `nvapi.dll` and `nvcuda.dll` from `32\trace` to `C:\Windows\SysWOW64` + * Set environment variable `ZLUDA_NVAPI_LIB` to the full path to `32\nvapi.dll` + * Set environment variable `ZLUDA_CUDA_LIB` to the full path to `32\nvcuda.dll` + +Read more about traces [here](troubleshooting.md). + +## Supported games + +ZLUDA was tested with: +* Mirror's Edge +* Alice: Madness Returns +* Mafia II (Classic) + +Most games should work. If your game does not work, see the [Troubleshooting](#troubleshooting) section above. \ No newline at end of file diff --git a/docs/src/steam.jpg b/docs/src/steam.jpg new file mode 100644 index 0000000000000000000000000000000000000000..bf2fdc90af97a21951742cd22f739ccc98d469d9 GIT binary patch literal 55347 zcmeFZ2UJtf+AkbLK&guKsse%_p!6OQX(A#Zy+j41L_q013IY-1ob8-EXb$1UBqFGkfM~^P8Dxo(bs(X%=+uj)t}d zh>VO3^bq&~ktRTDAo5eEe*FTU)4(sq848NirzxnZs3_0SQq$7XP}9)R(KDW-qd!ki zLvxPh-1!Sk%*@QR46JM{Ol*uy%uK&3AtMLgIZbhvg5oR_9St4R|MG|Q6?Fd0DKqjr zK0Cf&@ij186)M@fxR0E|0 zfqc;E^AwDiZm3dT(0@dA`8kus%ec%le78y)nGO1}{F0B|g3nU3u(Gjp2wV{qx+*Ls zEh8%@ub_5YT|-k#`;OrQBV!X&GjkhTyC?Pzj!y0#o?hNQzJ4LELc_veN5JC~-Xun7R3d#iiwy)ivDq z&hFm+0sipl7hhx`^559{le2%~>pZ~Msne&)PgDKki|mv)aFL%sO>yZ4C8Mf7)uZPZ zE=#;T!*nYyv$XLnpQHhn`LSC+H4DEKMgaGVwZC!p?=cqqKjQ39#{SONIEa><3{W2V zc@P+cjg2IMIO|kB=S1p7?hKVk9dl~lki4~M8`n;&Lw}Phib1cl2aI{-lSd4*vLS)U z7fGPGLUa@-EYh=buOW>DTF@wlua(C2!J3+JCMUGx?L?|h5~x+51fsdn3fq;0^5S{L zNg!s+6DBgCPzw$M6zcu0(EXrGKKXk%na{9IB7`VheI!Kwyv}>hK035B|i5Jb>hGgpfc_3N%}InUH#nYxAqHU&NR)8GPnuAY6km#~!}l%OJ4n{7y1w zYsRh=6pX)~Oaj46{NUH9)Br|UfmF%$-&3=REaH*i75fnw_R-%M+ha1N5C5k`O`vWT zSYIzd=4{h1*4Bi`GfAM(=(*k_4(b1W(;ashjNPb!fG7KL7M z9))4;WC2+LtdKx#fVjs>V6)#{0bWwB{xDI1;LRGYgLh=08TcEifUp3u*hhg^pd%y@ z*5=oHmcvYD6g|nmlBo#YeltYcCjj+;CbrmO4^yRk3GBLn&`l)OSya6|fR`$i>;U>* zY61GMqVa`bj03)x7`EvRh`|tsGwRY;e`C1@#yI-?O7#a)-C?)~8Q6+CKu~I4f4sIN zl=V&QZ`B3-Lpo5MPbV>K>aW#VeE<_g8Q5Wc6D5F}ezBJDPrO@p13Zik!kT(<$tQF* z%S75w01x?qB0tRY9&!E?6EoQII-rlJJ*oba2YdXlM&1A5p;6aT#0l4W z*?13A_Ie3y-GG7&U`?Gk*a@Ba?+PqR&5FEOtDuKBvlauasK^4aqA0+Mc(G-5fJLbp zR{_kk0}5PP0W{GQOJvcDM6WoGpntOpz?xtz8HXv-NCMm6^e_K6{X?*&b*8YTKRcB+ zz&k^$Ch>{$AD{!6eI&(LL(oN^k9)W)CBGp?N`UX2&1j2xDG5}y3K)G;){9zMhL`{? zKYWN0c>h=sutT7gR}(FoM4O{LA|+67tFb5(#Td{{&gQ+=BeZ*h3A70WM=(ZWw3pB> zEl!|GAV7KG*I1vR30F99B+$F*Y!c|D8!TFoAW(w=o=1R={L%mxZQFn6n^?Eu9OCKT z2ml0F0Iu3n0`!X0YfuNo(`fvN-7n+G0~(S6=u@@WBAkWcasX;lO-Z1Sh~LUMGi?NK z3<8N6zY>3YaWEW?Lai1ao!0<IlR!5%^#DNTCxJNH z0Jde&7#SSv3Duq+zz@(LbAdYNTVT7_oigy8zvN*0_CD*AWrCmzKkv?UC-iTLngl^> z08}!=jYy!cV}Jyke@PIAQN)R#&?+E_l)q#7+2sh>%Hv@)RsjIB&-ow4y0`Fp0f1=L zSP+0T27be-z&Y3v+ny_dJ{cgOm_vxB+@E-1>jHos?M1LzkH5iGhEE1DOc}5ma)83Q zB1-tFjcI_?gBB8K_r}@`p8FT30%T1CG-t*d17!VDY~wGo&=?gQ_=MIEO{DrAug@Mt zkU%Ro!+`YvMwkOY*!=v=1>VDVsNc!>#LMLqT>}gSV2d#@zOdz&s2HL=_t#6DG}pZa z@q-NTz4B30G}r>r6vy{p#x2zwv6nDv+yLI+CV}QP3H;;jClsz|EFh@1@?ZGk2#i3w z#jrl}6$R1*d~~;xvQ+?N_1_Y~G~$%5szu zNs#s~v9@+Hk->IAJ^3vdg=U|ga#PB!!`2}b|7lG{Z3;}|a&?5@xVnZv#VZO>qRZ^9=mXwo5 z*W8i@mc!zn?_6DZ=F=1O;q(l{W317KsjbNESK*O*pHXjJ>jIu%f0TAxf_@`llGgK+ z7?eFluw~|)BWnbIN^~oM{bWJb;5|7#Uhqv|tN&EaHpINyown!EdzRb$X^DJ%=uBji z$m-S^EzMWEswB|8>#!A6Zr7a0K*BJO{=E9xd2ZiZg=8?fal{vfX<5+1@_I@e0?hQi z9G_|u$CRbK(8ZMYh9+Hdx?Gs0g@Q@{?kTv?$A9OdjfN3TVPDa?w#E%;66hLu7BWyK z9G5yNlm$OaEtK`*|Mn$Q!OONrWDhf~n8nOU(3a*$Qx}EdggXa_xY*^!=g)k$aM$B2x^Ym)@Exa-gMl<_03z_ zd{ssl+d1h=!3K&(53n&WVt~$kb|n6pI|;<&jV3&E30vm}TMk7~cO^yiuSzo?bh+O;DaookIHLjs|*FJ{M@4c6mg(Py%kEI^z zops{vrPH0=-F0KPY*MksSU1<11u;{#yyC0NyaJ&QI1ly5@hq#3iZ%>#*K{Fy_V1RZ zouYp8d~F#`QI7q8r6r}IKXQ&~94!t9uH%->87vFn(#mFGP$ zXBNtSFNe>&gIRIc$pnSkhP{kd_gf>#^=08qBE_~0OaqiNH(krVF4VpHsOWtm!}_HC za<%`aW|P7~63e)Kxcxv$`nHspY^<=-?b(ooH+~+3^|DVo#?gu9aZ#y`SEi;iM2EA> z{jKsw+PP`xk_3=8_Y909UB34(S#~IP`b+x@+Q75wliPWC`|3pVAr=+{g}VCk;OjHv z+P-d=*>7sEXs{~njMo9PA&q0o_m6z{*F`c=VPN~JRFBWIG5nSR)xFFe(Vb2YbA|5Q zxu-bs-ohdOfP5Po)u)`TBznaWQ8k*?W9^9hTI!4HxNaIEM%8 z;3(R%^P%53waTK6suV9uD1zz=s77~~eh}!K^8y~mHjjR0_c*9&%6wwgfBjlrNcubW z-uqBC+b;zJnHIN;wAEd+T{`Ne?)6M;c<9MC->SEiL`%!CDrB(kESRQ;rncL zlCxV(_zWW~;!}c5c)>(nfwNDttAtiZMqRNFmpysk&RuL(6BNuyP_A{oW`U1UtbPPH zev26cFTQ7Qmvgz<8x&lFY5r1!I6kZ4G~oDYZ_!b1En%tFTnafkmwXQ6sFq%5#}KZO zG*F+L4NcbcS1ifj<`C(hXiV`$H=mq3^1l-MAj9mKxl{6s0NEQRku-)H1&|M7i^~Ug z3tO2P=SM9w7$sW*a^Usp$n~bBecNoYV)32Rm zZS4hWu>G{f65|A>(%i(ndItC(tNtwPjrF2JIiA^3^p!mjd4JCmPK@00QtAbU{9r#~ zUrJjdeYPuhdR25$?}owp{qm}J3_dyUt@KLo2Nty`*~}vRF$b?*D#RIASyOmQot{g7 z*u8R~lyX>I{@%%^ zMK^TI@D0ms=RPt$n`#aKPbH%|{-WTgdp;*)%<%6CKB^@92I#Q56X%*xQ?+wqhd!jesLwDbz_`2b!l!@fIKZzB=A zGe-ioOpzN^CoNsQR8u~H6r))i73X_BgiOhlx%M>3ILfm_iQKy1tYf!|sOul3>;1(| z#Z%X1YkLv3b%5mCX@Z}e!Q+k@2}-!onXgk2%xP9@j{b&AlkKhoxs%(y3r&3|*}XhA zwN$1fcT48Z(nPuGAu@hc?FYGXW`u@dz%6z|L7j`hgspj799I5n+W2HThy>#EetM{4 zy_JlhcAWCmE%L0mAG3zm9kGn&IBffXg8LNuV=g zIhSJ1gSQ6(`tfywHhwCfjs^p1;Z|#^^b?lO2;05= zrM9M_&dl`A&jQ77MWtEew_j&NT^6EH(pQDrEpo*ZOd#QNTqQkv+0PI2?1@3)ZAKel zF0kDebHFKVRWQ(L&aH7MFJ?qK>rTNP6YgwlyyOeG!^01nGdj+#rotU%>=&NA4Pr4T zc1i@8VFiN&bg}LC2Y+V418G`N zvj_>aDxE6`evYb%hxoY?;CY-Q_gyv5>MS8#hX}+hxQN>IEVvNp|K^1Z!VZ1(algY( z0wrsqcgd{Dt(P%l&oL+0VS~kxU$X*7x}FP0^26c`Co-^;GsEWP1v>@6a&**$_@u~C zNMzJSg%59|+NY$LW4?+&mZY<+bX75qzy9f_ebKp-D`7N>V_R5cxbcb6Hop5lYSGzT zw@7i-A7NFcX9wl6mKDo>=jQLV$?AV)cnVQu>}Rzx`l0t}NP9Z79-O5?Ach3`R#o#^ z#4GIVS@=^BS<_A%rH1DBKxlGh8P@A1!f`w|FOr9-CH^S!qe4JwbZVnbydrIyH&QXH zUfzDsUO-+yqfg1gk=E;VMjIdIrXx_<=Dusdgh8Y4 z6HYJk>6UF0gaMj*v-af~pKmv1o%!U}CqB=PO8VyE71f|3(TXjy3WzytjpY-%tmw;h zNmI3H$5Fd&^55o!ik<8|p=QH*XSHPp9jB}N$f})1ASw-)7rq| zovXEN2W2MZCd$C1;bLE%VLrrif}mbkR-S$xJyu}v_E_%bnKepIF5Glo39((TYVevM zYKS=Md)>wzy6>e|{>F#1mm$ODUGbVo0_VFrk6eRXp#qhH-lB%&1f7AA@_uLMXY7wV zF&qyHJ6bI?GRut1oz6BK)c;JXtUqCBoK~#FB46f)iA2}bIF(MdQ??z>Q)f0jwRv-< z&E2X6%n~3=6@{Qc^o~ifA@bf&stNYGi-bMRx5V|zwF_2?GzuYg7+QQLrR4^KW3M^) z?;h?A5MN_jpZ#QDl^@Dq^mVuH4$Mh*iG)s%+UGk4$zXfKRk+4hdTl*dw*+KaN7kj1 znq*EhQ#28NG-2gtM?MwI1Cte~wIDY9HL>rh3nBu3G#0N-t0h^nHL>$BVKC#J9|x}H zs^;tG`uefg*sQb0@mk~rI9#MgT-SBD_IL)Hbcy$ zG%M>Zw^(uM23DNZ_(8U4F=E(TS?_B~URa%+)cQ)DU4dhn*l69LZc)wM=ECTYB@B1d zGIDQuqUn4>T58%Vq=BXNS!>}Z3?dNpB3*a4s9D`WR|Xa zvfFHr&!)LYk-rS~qc9^RMeUJ5hmU~eKQS@xLDV$Hy7gFy*mnRc7jNTaU~P67k4f)WPRg~7 zVqU6r%MDKWYG>4yF|g!j^pta zksf?hAD{3&+1TVi*$@r#(>H4qrn9i~7fUGuH{V(~99){3fM|N+*MedLH1QZL^}O9iS5HVmq?EBFej3??j9JeDDWOw&Yo8rm9Eva-iYOgLA60$T%BRm%lV+57N3 z3vJk}w&0;d;K3YnLbkDi6)%4*%}c$OZGnTlSVkqA4A2#0H`FVxck`y;Uh#+7QRuk2 ze?uDJVmD=v6$y7nN88*9e)w|C+2t5{L2OcV{+i6lMB>e>rI&4QJtNy*q`s$hF&?`8 z9UjzeZLlubz2hiet6twVh)T9ip7K6e?>kPO1#ik?cbaDCNFYaUuocd_P@M3vN+c8J zqW0W7&CkY@Dx0P%T*jXoBNk6~-Af=j*T z{&|tQB-bcAdWws6IvgtIp7uN=%ArVGox164?Gt^V5$m@zQi%E)qF0%B=x`>UvkAA%!rh6hg)< zJnGOkC#gU?AQwtB_xqd$7w!V4!T**wd7w*{@kU(#uM^8LqOHTC^q5d>0>5P55XiCwUF#e&R zo<$yx0`P4kyQf#QZa#B^d~CmiTif@CMfKr>+8dLO0%yiWMG>#eb3eZdK4U~q`(2** z#^F7Bc_iYSKuBah&P8OlO3FsO0%<2MIzBAw$19TF%nG*Qx@NnVIPf-epBpK(i9iH$ zmaS<&!ZzRfjEjXowJS|9t12zCD1t)dM|4{*EG}NxR;Ho~Ru~m5o^~)-?@qNQ$kz<= z2}Hoxh!`bY)H5@U>sm@M^Oao&7QDYU&NcFhiojd*wWMQb6gllC|I@MgpJCtaLsqC% z(jYM$-~Ig^FX3`W;r1pXi&GX|=>~Bflp4xfT-3X`;p@Af;XdlRQp=vl1+dNzi@Cat zTBwDNMdtj&OA!T;_glYb-@86~&_9|03G2UiyaRKSMrVg40V1s2p%Qel@G;u zy~avoZywK{3@E?%)zak7$9!KqK)f}6_PI}0P#8T|7pn3rpHO$L2{LXePSis~SG4kGhLEGN7-VJX3#Zfq*OIclzqwYh;E2MhK* z(bMg}f;|~|D_fl5Ch!*R z{umdphl!fcec}XROlWHW4S96C8u>dLv%ebYiTkXBV!teV<_p_q8ttZXv|r-dqC}{X zUIGMa=TJ00*|3kREV=3^8h~7EN`IPn$8fpdpmr%e`E7Omu&461+`z}hov?E%OlD(v zHNBAvxw`7h6*18D=X~1?S?dZV~Di0+z?`x>bwoPBcW<&*e zLOsS?hhs8W(&98doylF`4>xXJjG84Us7#I|THjrNP;l$IYr06{mt4DUZ0XI?oyT?XVkxkx2j^WeoJf6+kOmR^Q z!DAggDqB2DU(ELal}~6Vf4%xqt$5Ps(_YExEaDnvR8#innVkzm-k4Zr3SX;$d!8IO zT7#DK9dohyIUgzy0!K!TD^!{V63rfER7NG}67K1uW@ZlJ12Yzw^woVd>wv$Yzh3{% zP^->_$M{B^sct`U3~;sX_Y+y>)$kcqi=Wucl{ZZ6`>kUq)3# zj64$OzOtjg?o7jXJ>31?}f#`LW zcW;UG>!qI+eG<=}?eHlYuH=$yX3BL=bw%})!OR2YUs65=uPOwHCm;=ZzAY-PA2;zBd4y+WUR`v%RN1;coFX)@}sipQ)x>()4oj3j*XbR z#=sa(hQ+%0fM7eur>mw6)#=FJVH`@<-~lhY zo>iE5s&oDC`|s=Z=XRb*1wNJpy1sP`?A(@(vfdf#OU^gilqH%6@s8vV|9b|!pIHSWS(pM0F&z_)e$Vw7R>xuQ?IoqFICGEhY|iu%H|D1s?jSWups)~J zxkF{jgDO9x;SY!u(_1bTbSjPpr>)@W(65ltS?;leg8b^$?UDlmKiax$L_sIDb5Czq zIZ_Mnjh#ET!Xkt9Ld;Og{*9f*I!JDVS#4MEeX4hCb9Ch{D-oAM+?F|So=TksJj&@z zXuQ8@dUY;7sI$e*=iWS|DxU7ik(Fg)=qI@GEAcU7nfofYyeZ^+ppA&2Yxt7R76t2S z`l9j&gHo8BalL(?*kq?m4!8a9ID>1wtXf!><$I<3R!E=6~DE!fQgS!ADz4_Jy=~T{{OfJHZ~asj1a4xK~yAWuRgw z*L?2Gdy32_HZ++AWd-&&5#(OGY|d64B?vS+Bk!aRwQeJo@;ope62*BuWWGJvHHKf# z@!`8Sk3W>Wqa#9fB`=pwN5x^?7IE-sYr{@j9(^p2r>?98F`3Rcz0zx*R&o=FF}a z--({2r_jw1t=WO>kU-$RyrQ7zRlR!KCwfl!Kx{T3)^<(?Y9|g@IA`N$?YW2w|1XHW zt3TIwrk>*249Bis*k>PwfrDmN1&X}agZHmDe85a>YW!q( zre@@iL-HAvi3ma7&W80+igfRSBdo7rN1`2bSIsLbS-etG)~{cqF2qe0`aZsopE~fF z_|Py6YlpE1SmCaG=TwFnge{F+9bZv%e&p(akfdejQsZz9xUeImCpZ$JzPo)QezZ#T zJMZNU13KFhIu}_&V8jH*K3+jgWFNr zpA_J0lrQOvuvMB^lZZOSJd5=spzH1`s~HA6CeBscz0!7rm+(!63$wZ=flgnP7i=V4 z!X31$Q1lm9AUKUHgL~RElKLzilaeJY6uG!c8syB5>Pk>x=W|B|+1e=?bzGJ83`Cz*CsgPL_KZ`jtN|V?W^uGJnmJI< z6(5T2#C+(S!o!-2GS%jOc-A^A-W~LaHq=jAB1p}#KdzCzU#u_p%^5d)>P#bBPY(iX z@|7bxFFdbeuuhq~#ai}rpZF|x1etHuDp1#2)h;r5#s?u z14_Je&R*hSryQlk8Dkk5UB#-s%hqH}Tov57xMy$S&%d?&@=eiq2l<+p!GnR0I8dc> zF1!nc9aw*3ah|{00kPn5O*Z3aQCvbV*C>tee76?~q%~Agy;axAt*Os}8nV7?(^W(E zHQ|z*TpaQKt)0P_Ms+502*WnwrTS6nB4p)SatVJrOq6f>E7^zqQ!$_w3Uz6r?~F;6 z=7+VKdj`iuZN2Fbcz-R?t!gsmxWRsKn_!A-3K~RXOAN+f7&@z`4t$Mh8@0zkY@n?D z5u*Msq;5yyphq}863g0XEm}9Yr>ijY9Xk_Nr&{;}|H%ajjfs`h#;inp3Ojq$6n2VXVepzigFV$+W+P zbFywj5-gMiqN=dsZ4PN+$aLuUiPYk#OZGNT&++8EB}z!TGevLcWPH31k`cm_gMtBe;PcuhVKgO^s7C zWx}?lQfBf-W@#@rCUuzKADgPC#Z{=Cxk;t?+}ay6Gp;iy`)UKR>482^CnMPEZi0n1^t+Y29XPFCCBurO%&nW3*PGq)>YjCVl;+LyO()}Hri#Lba zKO{}rxS7_TJ1hJ`=&Ski{kK=g6?5YE#sa@@9ymJoO?{V0ZRjR)R3W`{YoR5@9e5xR zg>#NIf}omd<(Rp(M|XK&mr-uY!`L*Ctk3R_fmaA8@l`;IDi|Iy2Ye< zW=IM_bu&X}X#V(iCZt6R*FvwhKsOjZe#Y{)PaAYekJcyE5NrS15RlS21K@%rR0)o!B8ce@5HXuH1asg^*qyKZ&!t;YgrJg5k$WAJcZ^>NHh|DdarN zL3im8`{U+H@VNlwwGyV_-13ClPnUCv2H3zYt^m3QqIfwN=#bO~+OT+eGKA_V;r*J-%5+hiYC7e%>MN(xbgw<4OVvqL&)x1z7U8 zJyFQ*@O9P$Wbzk+6W$%0-Nd08C1s(5V7QB;e7#PeHsXDh*p}@rti^b{CdSm5Vlp@N z#yO@JWRJRmtyabbit()FGj%s> zLHzMNn%yTTkkxdQW&1nkG91&LSYv5<&6bI=r!>MAln++q39g=D@Y%7#mSjA)$(;#I z8kze!eq>5`H{&s~(M@CbHm;)fnVkFr$Ga;DOCtpItAwCr?ILGH2EB&Bn0DuMU4id{B`7{eNiH*ALn|y=C>FycYCG04W0-5WOj7l5ye%d&MB!jv zO%H3K4`QC4+kCu^adwg-fins8Ef|@YDY=3MW;{xXZhn)`GC_Y>Du0vz3ACQw2KsJ0 zO2sH);h}plqWLOcy{=q`M)$g_m9tBO->a#qk*PYQzxS|XQ1}--^s6-kJ`)3@#)qh5 z=~FYSN2F;2?~Tt})y8xnoHrR=Z!CIwN1Fs$JTcvr<5P03YJ`RRB}c0;PpRcO?yRI= zDj%WGhGI4~wso|51_W(=Y^zV%J)OVQV43$kZJYNz*vY@+X`P7kY`2Nw@x5r};m$R` zq+}cWx~^bJYV(^M=UMt%!X{0tuY3WvuE*8pc=A+|rQ2%H2VU!XdfU&r82VJ;b?fD} zqI1-tXE{OR3>V3}uez()(<%CGPyB4C+}ghSv>J_YJviL&+v}xY1yf5;$zn=Al0dYK zz`UhICrkHf%_1gjL@G&o=gron-DQvCcKdHZ`st!8XsRGKAMs`m?iu(({}U^S!O-QD zd8;85jqhw_RgHgu1>kAq)H=0w#W3p4b+Yb&`8ZRfHy$l>SL@jrm&d|#7Itfs2H0Apv9PpQJzDdut<3dRZh~-uLp3jqBA2 z`IG7K0@3P#Exg5^_u#zC66gfkkE|iqnY`Y-c1=mG(0tX~{{G;lnj}SwN`p^6 zYHwnLDP@JI*tX1uMW-f558SORzwb=m+vJb`=GN1)5bqy<&q?@l3jA(?)Pw^N@R$ii zPTu?qXM%4k)yGGE3BVe!WWd`$Ro#4_+O-s7*2dQ*h z+0%@d+#BhL9bcDAdrLHbJS&k2qq$*FvXPTgI|dBU7E1vptPi2{+wHUpwNY=2s~oL@ zst$SYpr@n{z#HK<&QL5^Ck1qR)I?U&(x%|eoo|vP5a>4Y6++w@#p#(c;#2bIQDQtR zeUATm>jNM#!?zp{mF^8!QokC0t1h*ts&3rW;_fpx8TlVSxME&i=!*wy&P{SZ4YDA1 zZ^@xV#0q;|j%OBvteV)y<%8^r!#@iIIU8bD*C(I>y_H2Gt>)_Cua(4$9sLTkSCcE< zEv&9(cr>jTHSUk=>e?Y!Q<5_Fk99Q$*4kaRDw-AQO!p?~Z$OxXreIZ&FeQOmEBmiO zBQlsjEhM#_g*%dosGLko9iuP#9tsUcafZM{C#i{YIr1|E$y)j7R)}* z`k<9f&V(9KjZkO0|Co6rg@N#5ck5^$Sly~J&wFm9oF#!Gcs`Io*8M&F|U*#OMmN@HHNAEoTxI(-4_IP!>9h9&6Y5I=m*hg0#& z1lPUuoK&=ns;$1#fv_vNc>%Xa2)y&$oGlRgk+BL9ZcdYdy5|A~NsXIrW3Xw1`98P%;F+As{RP3Fs=lpHb{ ztpUf@F%&p{SA7qN7wSl3 z#dK}09=HnSjBkt|SECh0{7#7EnFM*9eZ(H;CRh{OP+kQ2!C2*0sSr@EBtZ=uQxC)O z-tFImP(#)j=7xt&jtyG|9c4znHld8y;w&4bpjWk-w?kuO87ZM%L4pJmUFcWhwJ=x4 zRTj(C`Pw&8^3Nm^Cs7v6ve(JoH<56~6p)eItlr6bwLI>h%t z$p6fV6HSd+|G&;TwNk5Y@GBzk6AXVq0s%`b@gsW@C>FMtPm{IDtn>Fez<*Z!Q7p2; zNc`^w|ML2a|1|U;(fwgd|35PZRrW&2IApgMIBh@zt?QrUl0bKXlSErY6q$#`_UOP{ zA#UM}{p1s1Xm3X!4Z$2?gJ1#>g^9Rn#p>|aR}HvzV)&NVZ(1?sXTfQkfLMe5!g2bP zpni^}alVk+*th;B5u+#{81bfp>xn<$wEYN=NM^M7Q5QM!`tXq7ZW&4Wv3S$I6|~Me z;T!=`xyy)`n+z<>APDg8ZjwN8;G^NP_|L`N<03Rf#@Hjkd+{yf#0iW6PG97?5+VTT z$mT?o|`x)hXfm!6lBkqU39trBSv<3V&>B4RB1N762V84H6HTe9x0W zy;3AlgSrZwhW%eAgY4sY2|Ien3;KU%9|@7A--hjUgSX-|f6p{r`AGTq%6NXy)ysPE zpGyCQsQ)9=e=;fNK#%J8s^4k%uOuH|aorMJf;GM9>)qxffzp9JrvSLpYZ7QV1vYcJ z0$lclxE*9q5F&P@9(NpOU_VMp68^}Iy$n8F$~gFjVAyz%uFC)>Bh-JEr=tbn;J57T zZ?Qz*ypwGawLcn*{j)r|8u<5Ip}#lZ_eW#df4uNNq3+E@i-r=4P}tpCG;y6F#_zoT zeM$jffBB6`CH{A8RR^$@8YjHJ#Q^(8{(H0+nLeKu*F6MqhS6f?XoCbgI$wx_{xw+p zysA3$n#z^_Vo`z>c7Scec|L6G&LIDn=u7v@C9COsZtSr9)U)2xwrchEA^_MMp_3>( z2H7ToBs=qw&N%yE!iAhEpH$0{xnY|s2(z{0b;lzvBu;R}XewSwM4>7`l0733;@eCEhN zI)2e>k01`~NS9R)q?=~|nfX-BjYf-$du-l2&_yK;2&7EtR}5y~>dTu+nisYpe`T$w z6tgD{32$J+g2R9?rsNUXl-&Ked^1(&pz@ZO0wJ$h_J~U0yk^MGLmL-)?|zkI~oW1)_ob?xGQUrPl3@fa#cQiI`o=0zgza@>fQ(# z{Vp$!kITrhTBOO)=7LY0C&vBsc)&t?vQ=rxilr23y(hW)@?j z?XN0o-zSX=MCph$C&zuJG>a986|BFi@*u<8wGrLd?=-%Ro=aZy4Q1X>LloS=NZX>>Wsa{T%D_2G{BuZRJa}RdFfxp7Sy;6V!u97(rpZ5ek zU`L378@B1~W|1m0!DLXudHPXrhtS~xJuEy%lRq`q2ymJcGWH&t=KxzVUr8Y8lPdvZ z>VbTLSP{&00umqFC@ULuC8N!pHGFwk%ylkh%HvSX2DQ_r!yfhRoSnwpm>eJZ#TXZG zusJ7wq*qhcFMRA17C8S~OtkfH?cMjS{z2d6>)&=GYLj?vN6pIw5X31x63E#mco|hY zv2+MKnbAqDz$> z*Sh#>NA57@mNPOr-}$PXCuC`Kg~qf1k#Q(^6#Bn#TK3fcFm8fA1}@Tor@=%^wq>x@ z31+U#WF6=<)SJ49c15$rX(_oFuz9SVDb#tN6J;-bPt5gG9=W>zRD0uk1~Y!9x#2=J zb~!YF*3+y+38AMpY&*<*{#K9i?PCwj1B`D|#@*QvgXVqrfdDnvoV6OkXx-j0L0t{# ziNS$3)VmzsVdH3PdOODU^qpFb2Wi_>4)=~yr0qLLcV=9Ud3eOQhczO~2ZCtYiu$ULD@ZY=E8~sE8KZ z*-+sfSZt`PmA#%_n_HKx`0fg!+T`o}8A*5%3<5i3Z*$W9b(9}67Bm)b`>J&EC8n68f9kypyZ%x5g-+R4+x4@^6v0r$a{QG>+sAp_ z67<4`HP!wzokWJi8*lZ^`|wUb5A-T)N+DGdw%gVs&&)7y5>Tc#_!r-l8TjNWEA#Gn zTHH5r_?~NOpgrVuw<8PTltg~F&fm2{-R&F5`_<3;KNeNDLfSN`xGoqu*|DCL>-2cQ zpT{h;(KTg5G$n!u%8N9CZzf0r$Lw*j?c44e}fkiY0t> zP;daIt784$B#`X`tuJX$iU7RV>HRz20|C9c%O_rcJDtPQ8tO+Gfy*!$xK{Ccx!*(g z@s6fdidT02c`sW@}R|EUm02m zH?2xizuzyo9jkL$`h7|fjbAffVhNoX~XN?tt20mRl8uG>IxVr;$ACp` zqmA0=r>Wx~9NEBKa&c7;MqC24MTxQ5Q{u1rURdAizmv}&dMD=_%T1$0!IDV;q?~qY zgvut4h!qgGjhBumFvw`ZBtB$rcqU@^FhRf1LnPYRhjH538NoKKRrG=_o@g2XqIpFZ zv&T}8yESi$UF?a3W;&!W=Pva3dW~DvW=~c;+?cBWAw&_;M8PiI+OK9Z$&w1VY5&VZ z?*HYXcH#Y05=a!xu>Qd5kGq?qov1a1jCR+}P1bv5!vSY8y7$(a?}pzAF-%wNcPqV} z%IBK2aAj7$r^~*|X?sn`53uTy;(mvp{u%|xhR~Y&@Yfepn~2O7=yN{;LyU&9%Mx8& zz8cZ+$$kiZc3<{8v-aX!oaJV3yH(J7Yr|FCg>lEGgBEj12k+;_2ELBuYFq-@oZGxl z@3?8R3&u3}IOKju4dymjq0f6+p=V+7D#*zBjIc{s>(aut@!qgsK2sicXTGkoKJiP# zi%D8a9|b@3j$vQyT&C+e2MC{rcibKFx&Lw*gaPkjvCz-i++Eyhcd6c=@4{_9(IsaJ zqcHXd7fMz6ZFzaKBE+6-jS>Mj7e8_P<0PX#fa&DGiVyO918{hu#H#6Xn>sMA)Rr?= ztKc8W<2fS|CxzQX>Wio2UVS~qBre1hADQ+NzMDZ!@Wi$yU|xIHyPIK0s^*|Dx{ln| z#TC{Fgk%LB^{oTipk5R?=n1dl<@su4!b;Y2Ljye|fp_O|_?JN|Fu>+`dIDd`E zT{(z?(co>&hk*UujW5!hw;C54VnDU`?Yp+e;(SaTI%(%#i>!#^3nK*S{xPJOka9Oa(ykuOX1^wduYQpURAVq=DPsHg|_eO(t}Zt zIu4(?QOSK%fKUhBfUGd${Z-Qs?hJS+UKQ`EQV5M2eSSAtU$~RG<$2|DbX^YbMOq0x zIppQzyWpK+@K&bg_#uRTNh>$MV&?Fh-hvVI)%keCX20&Eb{j5Hf4bfy zc~rDb#G9No)k~@mwP`i)J~T=CgURg8>%bZm2s~~Gl^P!da0NY-Zd3wvGhhnB?^i#% z$vWr1#fZ1D`cgS4fW{JYy$dZ8XhM^q5roy#FXX<5%~DLf97;zmv0jjF*}n6YGA{C* zf^FI`tfH9&QZ^(WF$MlE&H`=z_%T+miNFH_tovjE^|;fZcJS_}ktGWosV7&J@Q zzK9>apPDI(*4!bhSSS7VytW+)brI*AU&X1O(@fgEIKA{P#tA;DavCSR9-^+oGptc& z*v0X@EP0dS`G;xisUPhD#%&2$*EWT=L?lG@<4k@(T(rA({LU4zmH>FFo0(C_XSt@G zNjobS$;hlq-o}QDk+(P|R{Y`}x}% WPeN%kkE=P1kvrWSijiPZBfNYGU{EQunz< zbcYD&@_E?!e!%;ww(gT>?lHlsgWJRg3=ERD=6k}7$oEmR8jvb-zIUuX^t56k&6hQq zC0>)Znw`_~1t(uRovS0TRP(G3xQc)tg~nv&{P;1Z>FX-m9a(Jh@>9(9{LPmGx?}9C zTPcdsP6Jl=#NcZI+_UTfkUXcO5GaRBq)qN?-PX38ClkkQ!Y^;@S1ZNdsm&!w5Ql~l z&WOEr&Q5uhj+OXk<$cRKyH5)e$q}rJ%fem7T5_k|bwz3~S#jwy_rsdVN~YI1>NxJj z<*(m&EU%NCG&AeC{AobL!r_t|rLVN%U2IT2Vzo*k=0lc~>``Fl?E|mMcx@(AcEt~> zG%tIvWNK@>i&kCz^dSl^l$HO_z(T3<_kc>s-=mPVx_>hJ153T6jPSie>1(WXWQxz+ zN2Sg>bUTSC9&70R%v*3E_9q+{9CFaqNI4X5ZL))FGUBp-&!WlJfcN~K53aB!t_5kl z_)oF_2;~1m7DAtSm76JuiK5>aSp9T~j7u>bk~#h!=-;|NE=5KHF^Vc?9D2q6+J==7 z6XY#|eKXi0)`E$zoDil%5zZPb>7RZbMIX2(GHudkoZ|eUYhPii9`yt7?`*^M#!C20 zMsK9Y&5#U9myP^ob|ht1SP5bs{|SBHTwCX83fy-@qlGh^bW~xC88qxeeuB|<=B*{w zw3Uc*Xf^!kx_rUakn5$_XNvI7A2D>kZBcyqT+9h)%g7+-H>p)o!6DBFV|*HGgBr;U z724&A2J&|LQKP~Aw}G8O7j7Hs6uc>pFSfTP^KoC2Ufw3|l?=|de=!Ic4DuVY9 zS{Ri#Mz5S}W36&j`eI~e3exuz8_;fbuL*}&$n9ELb_Uw}^6oQ)^T~85NZx(ybGM%? z-RxE+X2?CwBv{`F2FvIM*QOG_Ego?3LjNE3-ZQGHe%%*EK~aiykdD%%ORs{cbOAx6 z7ZDLcq_K9LWS0?t?!NpfPt`e0T2Qa zFTaqj(|j4CcU*Hs|4?@=RucV*p|P_TZhOXEKJMevgTB=rx<8NtaU*ly&r$Bx9Z zZ9SF(zp=<4cgiLD<)c-%pN^JWb^BV(#677p?T*VoJ5W-awu7j|Z8x~L&pNIB=hTJ#%cmx3_s z8iM;^&L_CYT?xhkGkT8KJ8`7-ne39EpNsgu6cG6 z*{6K(;LHq2b#ZE4%*=TM*{>f!3g_ql`=uEmRS^LJ{{J^n$N%c*{8WQ}5pW2}pr-OH{yVkZMD@?|cuGHA4nufc-K-^8>}t=ngtJH-cwgfcSPv<_Sq2b!JeZwxil z=UA{&?awmLhMJN|4{(twbAYOrx0z3_75u{;W|MH2TPn;~(p2ciAmBykD4bnEUjQ(? zZfrO1M!nVB^OzL_M~sI*GogJKP)L}Pom&q}9$8Z7{jiwHa}U#-XL1{$ysS|A8F-N0 zD?7=7=|uRdp>B<{PND@AgMc{je{b*lo`eIvXrY8} zUjE&SKIH#!;mN?AhW;(31ImV91m$J80izP8|LD?8~pH%Jg z9M3{*jyAZiCDnsW&sc@??z>ikpukP}YD-cJdV|g=qnNL!;p9r`3pmk@=S!@z?_>+?W=_XT)dNx44!AaPv^OTKMWt8n6lIra7 zAop;ivvW#|nm|Z8Gmr(Jtp@?gV0P1H3snolxzlI0Lfo}K-ZOZRd{0k$9%e}J?qTV! z%~DH2skxef3Fu^6vPg0vjw>i|m?PHZEIlKuiI{PSH}jL;NZ*Ok#WJ+xQxW(F5-0(KAc|SchRid|KqqId3VV zuizRMxE=TmfP zeN>@+g`g>a#63KG9y)94?gQ-rVxEhZOA!i?SEc|~t-?&%miXi()SEs#QH}C&y(W=L z{e4jKjWsDoUgj8qky@qqa;)Rk$`8KzC^805Yc|AmpAYFIA3lp`0?lcCjJff2hcwJd zrj-c!(fo z`rwVLr;lxM_dc@@V?>gsoLJ>d2Y*Kx$6DDotYQFkX0`UF9EMLs?jshzPCBrY;@B5^ z{jCF_MOItMOa{pUZ&EGBn=>ZDSor*<{f z2r0yjE+^Vf$B0z)+Ez&3RH3ul=ZIk#?m2`{$re4zE5{KGVoM)>bSgST_%yV?gy_!0 zA>#Nb_xM2-Oo4ua#q$eY6(D=9b*XWzXID7gi!n2o?XNL=ZAgG7slLxa7Gk1!2m84c zo8MtnH};e!L-$#%e&)+ibM^Qdhmw#Q4x?_-Nq3XnF~^C1AW4qczI1e}PCB>1*Ig== zU9yP;w=lslRv&7rrOL{5-<(twfTWBJCy>=`5|&`4ecBIM|=F$!YR7q;`U@R3+sdedc1E#u;tk6mT z)yhIiWo#@8kuR?050L-s_by@nUksFwayvDFD-qfdv)@!goh-+(ojiqu> zY$kOXVRu0)KWo(`X3>*J1O8$@1IRJk3pTXo9|N*DRvS`t z>}Y&S_WZtInt;68G}l0MwUZBH(kQ#|1j&ONOAYgckges`l+>u7pcA=tqZ55&b2A6h zJJCySd5H1G`%3rL6>HOJBEfx^C$Qtwy#cOKSjD2>F9IvCo*IWN(wg}Qx$rQjWu|A9 z+Du#f`r`^Rl~ZPOePr)$FPlhl=@7+VJ>aKElWC=6c#mhq%Bx{RzI=?Z(ytp66q&90 zED4rhuT8#f0RxBzoFyWB?QtEv952r{u&ZTe7MocwMJcrB5KB1l_zI@7k zYiA$MAFKtv(aoP!&;^bb=wdRg&BH<;jhN|b*qF&{`4Bx9jQqZ&Kf=h)-x+|Hf0bsI zHvy=7BNmG<-UDdSGDN;-7Fi3;MxcUiL)ufMP)*aW){bF{c8STuyXGRe;}_tRYYoQZ zkj=g>HCuGbV_hBZPm+k6QEGXA_KBJ z99h^{(HCXWD=8@FEJwktsl8RL8`Zo5Nkqi+A-%g=U`+WzH~v(=7L5!qtNr*v__emS zP@eeo=TqmY&zk8@Zy5|ZAJ`}D?w#N~U_hOWh_j^`Nc`ZhtQ+X5JY!_~MS!aWfUZ!@ z-m-vymlS=$DP3;_V8tq9ak1=_&>f92MEZ+E6<>xnrRdb2)-0NNu&;1No=VfRQdo2@BGefN zqK(=+7tZn$vRvS&CVUEs7LOi?4@#$WwR(8aCH<8EZnJPui{ zre0Z0yFJ~Cj-|z;*aR@DAxmZ4{z418OzgA|haE;ia%LTpqgBL%-iI1u6lsjTXVbwt zU~+^5ln&PYfMH2*^vHR4mZ!~QLkRad@W*h3C8de~Y*$@_EZKF}9*4Ck-fCYHk&J>0 zJkfH6?Sb?k*{ggio{j;SZx@LdLl4v15TuIN{CUu~s+M($EO3t};5IC$`A;TzMwcps z7!CMu;4c<~?li5(2~>>YG|=0RF5_^deoOP$=CCE|X`Sc6#vsz-2Zf;~(?VQT?*_l8 z6WqU@m~QkD%WzVGkq%K{2QQ`#Q9z8k<+P(aW;TbhIa(JspuNuI1D#`(n8v!yxvM!W z5-+{oavx2fw#YpFK#WzY<3+>7-Gq_Z?6?7WdQT3i)^}Cy#Zj&Uj^LrWajBL)`zEtS zjqT>+mRxxYGhh?q6S&+3;Z3&#$Drg#&Y|qAIIYEuYqlR%>maXTk#@qvf^oTN(roJb zD_4D58MzKE7cXpZdYJHb3U-KYyX6gJE&ENZk;c!`)zPw=k72=lr>|>bYhtCjUA$kr zK;iC(N?jF^OcmX_Y+HJ*+?*_T~9FVu}2J<=enW&OVM`PRY_&G3{?s~{zZiD!bcsi{l6^d z%T$m+)D~Zy`?CU)A^r~%HLAuH3|iQl(6imu4}K{6$cAm&LO<70-h6ZwHp|J#8-(S% z(0PF9+>gkV#R96ITc&j-z*G@X_av3hoLF0^QDrualx**OM5&CbAJoy&C10*U`E_N= zj4N=vB+K!J)c_m5xzJov_6EJuo2syvi@2eC)vptX{XJV5WhaDGUA$lxa+Yq6J{NUb zb+OvlB=X2{&5pP8Hp^k##mMKISyWlKAh45I?5=ZxJ#3DpaYTW;MBB&Hx_tKQm{VN0 zp`C%p6_?5TxL)5la6%o{3hliJ$glS=&POWH6k@YF+3t^)?v>-TZdC~(CUcu!#Yeof ziXXoXWsq54+q8UMhDT;{PxzZHQBW0xDe&ey0LOXvFI(gVlUkISe7z##fk(+{s|51Y zqGN3Q&>MkMa}wy3@FQ)7jZC_U{UZT)a4s0tow&Xw=WpCzs=rTgja95*UNZV#;q&*e z>ok<)W#?uqAk$zWIpdMiv1!+>75p)&Rdbo}#mv!7MQVUICWId9I$w{1^SLiKt3AOq z4~6aOvl^Ol)ki#v2{Vk!XnN>%W+Wd$9FxI~Y#j=2p~o&S1qkR@!@xdA0z$eSEzA?g zQxe-I`JZUGR1cGhti8f`<%i5&5BAD11)Zj+9clZ-4(xB5YMPPro!$%woM{chb4o(r zrt5Y&(;Wx>mLqrbF3XN*A9qRnu2n4{h#)aqA4#@VK{X&CdJiC|NwHsxHcJ-zW3N0ZqK)53 zoKM@oN6Yv+3vYVIv6CfB=S$>a@eW?d-xwJv0U3l+W8Y5;Eq5kk%%)UUm7S@{1YOHD zNMyG(Ru0W=DFIdikE65)5R01puP*!i)6chT{t94l7y#fy#h)>{<>P<6q9?BI0{DoW&%z@T@8mjNi6^ctSxn-D;rFwbm4X1u}= z4}kLl8EZaTx;dZ}NxaWJ;?cir)X78kDe zJC-6pcLN0|D8QyxA0(LRw1ttn@S5>j+M47Mb(Y?MJ&IS zXjlIpRI4F_dRXj>=#-Zg!tr}p7=Rkxv5gnc5(Wi=7{fRvczENL&mQVyc>zwr(NYCB zGawbL`HMh))|ZA)qQZG=V0zqi2)TaV)`Lk09mRO>%8_US6#N$(Y|5 zDiv2<%eCCrqAQL^7R_RFS+Mt=9h``ie)WF=#oh1^gRV_Fxb0zN)4RrFlza} z?uF`yOu97rXL5JUSFWnwT&vc1+yzc~!O%1b2b9k=2DVzX;w#dTp?dm!;^BycWFAQF58xPN&p)8>jXhLRv%`wF~7ny=nosx3fyesA`H7FoJY8gc9B^sp`dDO;CJGwp8N* zrQZ;rc0ie0*dt9t*TW^$7novlPm)JISzm=PL2|XD6A%LTiSj8lVYSF(%rAljX!1%A zfQG0D$4xENwcNnaofNninAtPsb$@-^##<9PsG7|4fRMwyNO7qOJcrX-o>Gln?w!{k zep}0#3u^Qi__{^?lt(3090-G!~Q2HwMBS)ELj#U zWDq4?o%pP_TCJtNE>fIRGoF0TSP$ug`t*yyp<$Q#Q48kUsM)0Q$%iDeQ19YJWkOjl z@4JnDBG(~3I#q~jSoJ~Ke!NY+o}g^}i;yenE99+gHwLeRGa<#aw*C6qx&wI|zLRfL z#Cx8f)SF9c#-T9pQxC^E3o+6ipSUsRsLZeVGaIH)QL+=Oqc6jI6QsxS*eJ@ROVTh|u$^$_uJ+%B} z1eZl0+mF=T8*p0i`ErvsjMuG_kl(Fk>>`al!pOAlbCHB*itii6Zfp8sE&{0qItJ3H z#BR|6+v6FYxe2Lb%fJBPmVNQ+OYMCrAjnr3uWtLc|5~|?h5$Xro)GMxMXE!?Bty75J$0iRQeP)30Pb?^{_b*`CzO-|7KSaTeo%D*U5g1cuf9(0V}9ug!f2>8#oV zZn^$bfjY%)o4m+D9aT1w^|nr2?TW#>LJ-S0MdSV34~ZYS_m(U#swOgo?{e3}51jUD zItt5H8q0EBRl7)gs9-j0bq`75RQ)cwB*C+aoMr<7B1yE}Co6M5V4|p}nLgWhOM(k$ zj-OGiKKn&rhkGdZY;+FA=r|!A%4WaIl`8Re?@3aS$MeMYN|w~v^2G+nT^lGycz(U& z_!VLtzMuMwK(EC4{8SO2Q6qU|L8yu@P2KyHjSqMWc?1676xAzK&0U}Ps;AnUq}6%8 zk9d`C9mNymTm&E+Qll#Phw^&}+Y28WirjnL6qQMFn=^Ggfjy!R(C@kNbNcer6uoV& z*rywu-^H@h^C?Ko2%~JSRv%H2L8d#zW*&t8VK2;ikRJ)H9%A_rH~BizE%PBKXE1-J z{Eby8n6;^V_w?|N%LF9Hx$ti-3WrBCD}~Roo7L8(f}5H)OWz7R9v!!Y4X=W-DejnX zJt_ck2tpxyTdqbD`|nMyM4m6?+7#(|L%V)o~BB39sW--k=LY-{zt7YA0rUTd`{cJ~a!#2b)V~nwgVZq~Mw|e-XGgR6v;9 zQkfxH(O#}!EP5O{E}jaURNSv8U>7{|)4bfz@>1Md5B-MKEr_MtN~URpy63C-(A7w1 zq3G+Z2@BuS-0LhS6zTmmWGQydW`2WBehdH+wTu#{U6zRH`W&_@AoVpfDf)wZf`SI@ zy92p;ggVnWeR%)Su~gq>O?dc~uv=Zx%#pz9DciNDu9Gh?FJkdT@CxJ@cZbQ^aO
~bVX&(9zUswT3>s7RPNq3$6AHCo>Q#l zaY_a9^~{Bh^pJ{VZsZa~s<(1|TdjI0=89^n7gEr2TtrY4I=U-1EYa&hq^2J`Glg+y zX!ae-Up2rL6L@W>uGT2sfQ)wdMp}XD@=>eG7VY-NV)0>y`ki9&ZA6qHK_^Cgfa$vJ z=L<06?zAuu&f{9g=kWnU;B$Wj&GYsHtS4N2*@PNt5UWXF7rL9eCY_Ez5nr_uyhpU0 z5zd0PABSH9Y9tg>mS7{HB8yGtw=Mm4w3r^(#w9}OeeQexp#)Ly&pxo;cWA~(FE^_S z^yXEE-f4=Ic@s7(Wc?`O;^(!e*E-w}f-;XElx20wYp^EYST%x$jW5<~nS6yTJ*&DN zeUMwoBFeZu!~-l-W>9)*plA!I=U}a&B__bJbOy*yEHs<}No>4EvA^O^oU|RZ)Jh8q z%>{gjE@M!0#*6jNHILq~fs%iCYfw|3ET`n(AzA-7gJoJLtVl_(n7+=8piso51h20a8pN+v}IS__B5A z5uwp9f@?!K1O@ihcvkxZNe_z$wWNu5egPnEB+72wkt62kYB1+?19e}*r&lBknOEA% z!Hdx`(E*<2(6^w&`CO(K1D#sr?OnA=H+lbXPWySHurN_$s6?4P+S2|q5~7NZbxW?+ zVmr{G@Uc>unsd+<2I(64ABCb7ctjk za9*J#s>n15)LgAg0FY&h`@w<4P7C`615-@&*QPCjQZT)i5BbOdBkWycN{p2D=Rg9o z#T25fl*m@B`@)8Tb+J|6Sf0>Z!MVLBS`lABF5kZrC1iX^SQd1DM?tjIc;hAZqjSM! zjLh&|DmWj9nU&nVdHI|etCk42z!xuN6$}l-f$Raq>0&q4vmjovJGz=nI40`;_ukGD zz9WuEFl%Vj<&N)V-nw&>F0fe`9`=izFd?wQP{j-=p~J=Ede~8uqpn_kLsRm|#COt) z$|(nWq*xEO=!q1hVc0 zcl_wyxe^uqB|U0-m!ZcuN;r9V7eR#LQIpUl?b}=B} zC_~V)kGs-J(XT--Bw6Jp-HYopucH#&k%W1Uv!G1H<`E;E`r0sidO8@jf>%CN$d@+* zUv1xddp62-q}ns~8l=N&>>)!Nv&+e!%tfec}&ejZlMpHF1jc#F#+C9?4n?f(<$C zvXfeQ2XT80%6N$U5BF}^wLQI00$Qs{SG=SLRuALu^XH-{V%8J()I!{6r+TbK=ZS}| z5|Ly;dXm#)AlrQVdyEw$BULhrAv?@^igu98%-#peuHJDtyNLor_Pe0@Xklai@L7zS9q| zLQ3&R1#bbcgfPt>1>Zr4GkQ^VZnDr>Vn4$4{pf&On2B9|@Sc$!tY3>HDZ255D9Yo( z;R}{PDoy-^)ab78<|(p>dNCbS5};bP`-?zveR}lq7mVQ_3eXDhMhXMf;2c-&$Sc3~ z7;^p8^i(+EBQ*I6!Qe zwVN#MJ%MCntsl#N=kQGPrN<%FyHuGe7Tjk;0>>eacoQphILL^JJgf}jbUh86op$E9 z`-D%S6d6mx`-$@xfk%oQOpA;^e{Ob{T1+TPmEOxMI!8&M=nXH~jm-^FUDiSBF5ClSJk3^B$64St`detaHW(()Xzoba$>-Nu-!_<*Ql{Nla&AJtWs zJf$ti@yNEx9uMm1N=(S#e4Sx@cF_;Fg7SzQgXPx{V}I`dCxMps)3FODpRI)}PZRt7 zuGN+Cq+Km90KIH`CLj?tieA5kxEu6yC5B%>B;41ayF<5rjJzvuOwt~8&@Q8;o_w-> zSFUBmn0+sqbCf9Y#oh2FL2tSDyF}7LKtSb0y(gft41%_By1X#UEWT3w6J$jxghL1m zHE}g01%lnfGNhjR0_T!<51L*9?Wm6z^upUVr)+!aFT(fE7aWd%Z=;6?M;DP zk>}#Zk0t2C7S3E}G`ZtdJH~?xm4YJ?i-@q~#-Y&HO^tQ%YPb{w!_S$PuWt*NB)tgC zsMfy4y>}*N+zm?YAI8xwlM_A+_%;~tt0xginzkn%+%Lkb!6vDEi87d`ClhT2BTC1Gz zR^qe|Ql1mNv`w&Qe%3u}JAE3sw#LcoI^S%GR3Kd3eqOP8BIW=^`5I=CpVikVD{-HG zQjUH35JE!%@Wz_v(&PPAV>R)E#y`yh{+LXxL;kP_A}5gI#l5~(u4N!{Dl)fMRA_7* zbK(y1K!rA<%BF*~V#O@s2kN4h<;8|td&`Lii>A(brX7_!W1^enw zFC_@QD1DUuX+uX-=OCV5NI0cnk4#di)rZUo7@kxiiud3bJdzzgD8OL! z&m}YK)UQT62co6?Q3Jh#Y8!h~kIeT7EqxtLJx;GH;(lFKjCD$0Sx0n8vW%hwN&!O3 zv85Fc6b%(Qq?|H&XV`Lq$%I(e?(mG{)^kOb8zBZz#T&`&l>YLslaudfKV}Itev*xP z6V%&g|M|eiCg?jQgzg(RCLe(QG3bm6{$Q9ufW&9N*Hv(UtYjk%xqmLCC-Dc?;G5qg zFn=CFMU*U5@MU(%zX;rbEN1Zf`s(JF0g-mpb%krM1?{vo4-Hc%mQDvF4FVFnqn3BZa=I%`!;`XOJ#23#u9?>{-oJI-6-amu zv2W5ROHI^aa=oOLz_oT}MiARxu97nK<575kz-v_*=rk4(9fqTBrt3|@m=10|%q#$- zF@5oX)4AaXu88+^MsWmtU*5U=P`jFfbO9{)nqw}JXMiGf8+y)rApd$9VjG|m^&X}Q zRJ33NmNFjgnSJ)CPtdrvW=ux;<@_#X$q|78JGvCE1?&RzxLAhYwyDTU#Nmk&mYU%l zmH|Mq{v7NFvc3X^fQ_i_lGXWjAb5lzew!tc)Aq8 zKNjeT_@&?e$>%2w_`pBY1Z(VDbKd{9jRF65b)!7zAMX8!U#{33`imgz&t32={QsB# zGN%#iy~Hd4D(4wJc}&g73f~x{B};ramo#XkA~&`zFq)8()3EmH0Qbgch>K5Xb+$PE2Mx?I+9h4o$n0kWXdQj|H2tY z`hn{4V@8s%5rpy@8+`w8Yc()YR_u`g_~}6RlDuSnoXNAADKgifdAzaVJhz(cja9p` z#>;KZG*1VMZXM}i=Qkhc(VrmI_+Vhj%mbNYY^2iSeZWrr8nB2VL;6f&pS^m9HY{q5MVlI4fws203$sR z__`%PE#!R%U?oo%i^l=iI$vnsJC9+&2dMobxMH=!zRd&71m$rk`ZWOZg#oG?;egG& z0Q=<`fGUs3!P8IxhVq6=7l-VC)$5CUIa@MTXUFWgYtT4o>F4=N;uk=c6(~cB&Et63 z1c7N<3O!v@!rzU>K2R-#!Un}rmo6SGnSL1QEOXK>g`Oz`$w-2D0?vSuS}KKP;Au37aelJqYS1VC}2msCb5Ez$GeC{vw#}!GAD4IA7@h zdfTv5m84JWNHOPQ$$01L*$an5x5V7NX-9-#iEm|vGx`+wPGac%7&wPNq+6ofV`Edo zaEvN#PXNFYqne?CS1#v&kG>f%1JE}x#PQUh&=L?m;E;YSAqNd{KB6F>G=r%2{}^%f zWG++dVgg *ur^71_?mNPC@ti1burHnk*Bcs}j&CgKclwFVIazKjNY$FUd^ZcvRp zn(n09cFw!3&>Gu)yR-Ci(wegIY`sm%)x|YNL#Ei&sD1t>$ZG)-vu#q}0Hv9McrrYN z++c6z-le-LObQ~xi7A=*u+IHjrbUg;{NfuEJZqdG);n(be}ZU5}k)y2VYrGHKB&h_DI;BY)4c zBiY(J`I{&AwTQe;jFUCkOi08QoCvPzHC?6}&G#RFvq}|!WgVZh*{Jx5LE6*m*rgh-zSD}KoXkF|4hZt_7}lB ze~F3H^KzKbfyrhd+laG&2EPD=&8}YM+AU7f({%q8aT~6ENw%-(#CDW{QOn)>h6(2O zc>4*tbVGYgK6Is~WHA0!(P-B&w>Cp9uW%>;^Nj%z6c5>(a(vQ((wO>UPB(06e)*axeSc z@0Xb5e;9U}p8p3{yI9rP9gdX-2zDw%mp(9jSW*UX4Cnk!b+$@?ZaA7M{pVoiA0m*h zJm6-2#G=|p{rnl%eXHY>f|Y0`3j1nEiq)vZN6_8KWRu)&{pzp&{X_ z>$s$zjw&`qj3WPKK3TG_(?tWS|xvSdn5a{yb z(k8d-GPidW9_K@zE29}Y`-Q~2ipsPLK@(8hmT?6eTQAh7V90C1;hAqmbD%8MDV0s^TTE%@bcnr?}{a~r-kBg1hZA9)I7v)E~t z8<0@@o276gmK?p{_Gw*+BtiQYcSD5OqsRVRoMKlQWb|jN&8V=W9jKP@Qjn+x*7?Om zEd>e0M_9@)n(EK-5VWINHc%xo{esQrrnk(-D{cWPM9Amqg@*66)d{y%mS?4z?@;B=k zP`0oSa|2{9@K{n6KZ*4p$ij4$vLPQ>6m>j&A3=!Z`5NfbM z=E_ohSJ{tm-(5&3r07BSuTUj#IKV(a*!@8N%zpo1-lb{#(gK>1vf;{h`!W+}RftXQ ze~O_GEyF&V*b+#Ixp+SECYo^(mJkpU*s4KAg^a0}>2j%rJU44>9^F|SKE7Fge4}O9 z&Y88OCPfrCui$XqB2aDRwSU1+{4)Ci;S}YSIx9d2Wr>GGS(j5E_QBbyaL3)cB z4{|kqzLPO!YSe1c`qBr~CL`)Em7Oagx1dk4QzMM(aoMk@Sw8bJCjuh+`)mrDNaR9Ke@XJW8 znZ?zU<(&gCW;0<3?BvsDciXc5wxAqR(guCeB?tJ)AWLzQC9@kY*Fl~#g4}-g?Uzd< zp(xRL-pF&aR;K36ugh8QE%|CO<>9#y@RQ*$qx+>5o}bEiYCh8?dmJ!^)F<@@Y~|?$ zz7o~Lk&pVbFJcx3UO6*-$aCb`<69Y1FtY2V7OV&*}}3pioNP-W)Z97*?SRH|O|=C2Emxg?2mxgy#)IUW}XV zR0`^=G>0rSd~fVyV{m;1Crj7ghTahN7~oW$5cJph0!9fJ1bTD<_HW!_0)FpkcR!h{ z&~TupVRX~)bim)j+YkIzu|^AL*Nd_@fra3hx%rk^v*o7#>@Z@aEUx!44{1Q2vQ6cJ zdx#mELaHvkzZ4o4=C4u)dBjc+b=;|B5;{&dlrq$L|MXP#=Vh`2B3YR*kaqn6U$a%y ztpBJlbfsdorHMB82w?{`$e2$qIjZUdu~!3D!8H@rDD0^6c#Y?{V@;Xnsp{dXqijJy zd@p8zMSfYRd*#)G?Zj_bm1PSX{qfS8EE2HX49a43YK~Q0H+j`MN#mMvb~+n{=~2ap z)Q129!UQh6D5UlnK0L9+oMB{MhoR4UuvR2T&3RC^R1cyivg0-aIWPO$5W-SA>KvDU z=VUSFSP#G~AU5JH0FF;Kfwehb@83EI5rJ!Cna#TTU9y(fwnJ|XW^-|Xv6rwn}vUE(z zN%b3pN9;W=ioQ0bqoy@j1p6gAoNOKu|5*0*&&m26pb|iXuIMt9doo80!>~tqtc(ps zz#pX`^&P05Mw~MFQ|1oc73Yi26T0}RnJ!B7&Y`Dc^C&B{F6-7?Pb+$RzQXdd(gCh> zr>}HdAboS=Hu9QpaFvwR_{UEA58Ku`f~q66fwQ5IPfHQhLMP?+MG+{s;=rvIzY@zg zp-2Qt>zKP5VliG*W~MbREcwTXF5MR9 zsr$I&eud*RYl4W_!|Mlu77O)^U2kxY(3#QYI3+Z1m_!!U2I_Uywm04vta!hAEHrX} zRuHK);x|dGi`0e5*jYOmH^v=yh;2$cTYaJmu_Y< zjRUTY)81Kyrp8)Aa5GgikH|bD!o=hwo_*?SYA1$27^3wInMvd1#T=baPZk`zPlE6Ja($^(d z3Fw|e3bfJ|p3IRr(}7$e-`4t$U!)2|gw`1HSn~~cuB;j_^jBszM-1unHCf~WC#XzB zMYdN{rAo8NrH^k}vt^x;Vn7oXy7ZCamdX-o1^LzqitOuC-`ol6ypk{(b4?>q-{z2H z)$;!P#;lG3cD1pJT5_qAd4pdB`hwivK+;nUmhMdUF*adM@$>qFN?kb45HrRg%_fP2 z1IM!)g!ZOuu_v$LDW;79n(C~yLa<5g>9@&Z*Tt`PHz^Yt^&RugZB}5JH!sabn_`MI z02ZeZv;uo0yOCLhX0tAnB}F?0sFAO3mlSW)4EPG?@O~vpA-!c(XTuqzoYSeuJL*{` zH-{Q(my-&Tc*?jhu~}hh5+)i(Go${FX6XBu70({pZVz9j)=OtoG$Ev%c~?qCyKMYO z&LdU?RRF8=)L1cBwYj2oi*Y>W)|F+M)YA?NcV&!FN_gPVWnRTh8*R_i(fGCc&{^*r z7LV2kNP}N^+sN>81kLzUVY0E0pSFxiB4{jl!%NHWO3g87O^8~~iC%k?Fe$|(6MPn> zx%gSneZY6EOexr-f)>24g7kPm*lEdCHNI0O>8I^6+qsw@w7cH$ITu>3B}e++I*HKb zd%mlV=8(<+ZluvlDa&(QaG7T|E8yJW^bFeSHH=8j#hNUu*J6)&(P8k^nfT9%+Kyt@ zZo`0Hts2bL%Kz0D-Ed2RM9cbNnhvJ^ZNsfHsq{ww{3Q;};^bJTg`1v)oF!Lgj4H53 zn)SnQ(q#%_3&`lh*v{0t4EwhvV052T^02x3s0s5I{1e+#;z=%)*Ft>i%s9>!v^aF# z(tdj>O<;%?geP?5U)HN?(V#aN;wmhdbqOkR9(ej_97Wd%{ri_{}WR zwBV|NZw2#}DZU53YLgk{`z|#-gkHy;8Oy1N=wZb9%9l(>12_v6d@ zwYvfhL2VoIO#3;PsR~b0rQ$t{H2tML-LL2P1UOfi3^|^V`swnD-GAZ3?wwgr$`<%# z#h0NYmI*|-h|`hoA8O3BS* z3(|JP4G(hp9+YG32f@8#nN`H7!eeIP6xspjng^Zwjw&b?T&Z%$mBe@h7z}y{Mt^f2 z`~KXoJl5(7!XoACx}p$Pv>bbvf^w)t*M^Ac!HS{c%lO{r)F;&ZZ3nhhjMP%QP09p| z5zpI@V=wd$*_^z})`io#BxEawge?ai>Iid)odI<0V zogskUeueRGdQ!iV{D+P$K>e4l8BpmM0zj`!C5E-mXC!k##n28YYDK>&5)?p;;6>+9 zAk>TUoGrzVOML2*&- zv5O~GpT1m{T{#?Ov7i+aa>_z0^#yeJ&Rs&y0M*Wm!6rO?;I{HbI}wLK0io%dLQt^9S8!QgCQmN9y$~AJ6-l+s~?MY%{$X`?xcb#B|i7 zgtcAA^Z~)n4TQ?+wc~~=;>dEqtjKloNIf+Dw92ZcUeP|DYWSgS_x<%cfc`w8)O~5W zxBo0f4^V$KCD)w0QL*dH5!d4_$a&Lc`ZZa#4aYaJki>XPZxv~vUWruZb_D#U&N2qV zyV9DNn_oh$?Vp2~vb%YQ*~XIxp4w0~5_x*M4hwfhi zJ4S+F*Wkuvw>Z!MUge5%Tc=*qAgSoDeMOd_fxKDp^>O@^0*{i&n&XA{mDo@Bc zQ2M~Qu=jLAKOQMPS&BWQTV?;9{oGWxTwDaWA=KpJ_~uu@Msy7l;1~XH0@S6y1*l)C zt;fwQ9{;Dks>BrbC;b=*%mMoG2tYV)zT3a>rl4>d)bCin;pT82mMJN3aeF{)R*Oo% zRTwz=RF)m=?*gjs)=gDwM@HH?fYaCYGS`CeQIWSoBI#=6$6e7K4}bK&en#e6EoJcf z8d3a^4p_)vvZVPkBLU?7&C)WvAAEJXAz_i3+fuUIM4g!Emg`ehN4hGJV4U*xFv%hb zA)N;-0JuZBbcO!X6<^Kli$RuYfEIMA=QlNqO|gD28b)8g{NO|WM;WQ8;}>GmVE1lu zWaM@0VWY5+qR-AtOrBGTx@5=?D^iZ{Ugq|S9#}^Z%d9LFjsQGMzIXqE0evMNICb_@ zU>S}|Baz7eF7>Z3?w3)}9{mWZjiKv=dEZBMJDNQHv3Ny(G%6Fvv?)n(6C$sVXlP35 zB>ASxso5rCO+e3;?mC)!;49Eq_AW_t5YAs;moVCU@uMk{&suE5wmzLjKvm4md|>aA z0w7epXK1rJx)0QIc9d}1?C4;u06vTzmk|zZ#}y*k)#stm^BXA(9?&vIyGs&Kz`=vZ zcuK2l(4QSZS*8*|=14%>Nf#>4Z$l5f*zr8@mPo~~R`_6UEb;kpGW2JD$~@*n~bmrJ!KP#(}bqw;Ay71RB-)JKV#^ z5i0_I03to>7r`S*!!n2Yzt0V*f2jarc)P&Pq-~3`9zxP;O-K&(Y%}a+IN7A2#x15a zh$s^%69gVmi(3k*@Cn=6UD_kJNY$X*IhPc^qj1|d^K|&z@bg*3iB3lLR2S!iku&-c zQm?sE_t2L;#0o1*U(hMhM_}hr(sJ|p$LvuGvS81g&AOfC!BqJKg$4sVnTQ8HqXMIm z=R<;?V% z>)i*Hb;Lg0W0f3^vVD?EV;gz)+!_o{D=$0T!Wh}Upaa8-wt0mR1^8EytA_LERx5r5 zUF1$(iY)AuQ@tVjn2R><70vsv=sOtLLuRa-F_tuDiuW*KWy=Ef!jj;mjIu>~v>Gi{ z8?9(mToH>yVGdU&!M5=@p9$=e`)BzFK;6~gUqP<_HN+Z7AN?P!`Wqe|i&Ova_@%|; z|Ab!xgmH)|0R8OWx;TI8XPf@#aTu@scS!)?+j;>BQ`rHN1(Ey^_UEd6kw31>u#gU@1T7SUR5hZ`EA~RFhf0M-jmSs5I#+*g%RX zy#%C*h^R=YAw%yV(rW+}9D0!=U0Udo8UaI;UZgka9R#Ge5R&+=GdsJp^VZpU=k41! z%Q+nKeI%TZd;j;||NY-z(S;_O=DB&wZE#t>IA2=TUkIBIIN#dzGEzQ0>MuzdH+PsuEMkYROG^b( zYfmFL)owN4FIm^vX3BXX-U;x zCN1~H-URz5Ve?~bNz|7kZJL6Hp|A10i}lmKT-+Jr^#vV>2JW4=fuI-fogdc}D9*T`M0uR% zdMASsBy>0nFzzqKWmr@Rr^Gq!6)z45-aZ%W`Y=F6^ma%6)%W|p)ZFO1jno*MsV3*$?iDy_E7PgomM`3t0X>o->joY$D2%Qkj`)>m?){( zQ`S6e%%X9%1#| zKUq&#kEr*Oj-j)?q>phX&$&fJWC%WnlW5!Ch z7j0LZwycpuqn2OEjAI$y>}=;_GTr7VY7FCMj-2-EP_lCO5n4(IZqc!wYCUCbd?MpZ zv`xES3=w`qI-G7^2-T%5@_*dm=BkR~_t6rMYpMs`` zTL(JGfv~&V+=b^t^mM)|7vst3&!{YF$Mh4V5;f3$MH8xh+il10QgAPfcZ*C=cYC_kF}&|#M_Nh zk1apdCbdY2ye8&{P8c5W?&BIAOIfQNdoUsk54s6r!?RVI^QqZZdj{+#)!{1DV>bLO z^N=XYYftWa#XOW^oHN(yfypcX^a)x1foNI$UwCJ^~t7+b1_w8}o11b@wM%l|c zx5}(K8d^qrxuY`9MYfC9jq_B1+N@`-tA{y(Yr?Xpa9r|ffmQT~%8?r5Qqh+sIWhWz z5FT-hqXKElP#&|i*sGsaHvAGAeofHsoau}A zGv_8F@4MajFz6$^VVV+XUi~ozh7xMjSMVit$bO*&r^*=RT90H5@he%~7<8mw*Df4s z$yrrXl7iDKQ(q{Rq-tp^2wHA#{!)KPpQ#peYeWtAIs-O3+F)(X-ffCHY+gY_FJI{)zuE0`NoJ)esp|!n zcoT`xfoN}AWP3Qzs2jQ-rRBv>F?#jX4vr=zp_}y=WKZxv zc|@qY9JDMYmnU!UIfF4tf+HhiexRDh*h4qkP%otHcJaICqwCgnhvQcp2Ml+Acqqko=1`np z=fqwS*EC}mV|EIYQYUs*}KjlcBb=qVai5?nZArLFUv4hh&mKTcRWLPq?1HBySB$6ObpFou7?;_ zZiPTBPw(@+Z9pSlg?Nu)MONb%vSij|`>$Oy!c_L!trX1h6pyNsU$eUtc>in&Tkc8e zFb}N)un3x~c^<8C9^>JK;}jDbe()@3Iyz;eOLsba?dmAaF)}vaW8BB5eJ(D;htUb# z4hF&1*0wB-4BB%vk#GE5QEZ3LRw(PwCzZL7(1_WZ^*c)>_#DZ8m8;i>UEMuXdx!65dl#AvuK9pH(W;Cv|FFgk&SCT zdfYx7{jgPIq4)WwSB26Vb(ALJPlhSy6y$u#irVL6zN=B@f1%{?@d^iji4c};KKaJM zC>$L$_}~e&`t8PRf5+Z)o=~l@wG}%OpVeUO-l=xWOF5=`FOqKB zRByc%oDADX(t12lHz%o(D)uSVU4*Qi5w*+Pyl%noFW2ok>RhVMwyMh1;xx5|sO!bX zw^Un_JMkco7(d-^HyOui==IuXlvH<@pU`VL)f~GuTy?wo&_(~qD6%69p9V7w+=|-j zu}u7YJIrO(w#?4FuP)S-1h6W_ahS)|EOFBohjr;WOfE<-BcJN`mUZIfGxf&k?pF4i z^*wvDh=2W7&+%e~(fQfPmKMqwqv|j*?x1#vTk4e*jmhjrn`b|f3Dz@N)rGcVj4aR^9+5G>f7;*_ z*X0y)4oZ|&u0@UdI(naUqzS$}NWgMpTbbnhQZ|RXoer|AD;3?&okG9jdD9xBZ|cY9 zFVT;sc5}i7z*K-2y_tv$-8iv*git<)&S~`a^w4?@e38%)a1=LnDOM4tS65MLDQLbX zo=TLb-6IE#j)@ccu5}|Lp1h%6qw4gBVT_yHLT_QK-BXXubEN}4?C+TlL0U$(5!d-1 z!CkPzh(7PYy2P#j-eD_-eDA~@47Z^^d*(^O- z%uw#5$vAaXRlNk8;2UvNgPHkS1`^6qzI1=-jX`#)wQPgXT$Q|kuaz5-XX}v%VJ$KpHp(m-J zh=@1=FjxnqJ$4%mgaf{Xa2=bQsb$&H9y17~dm!Rc&?5c5EV}La%c-Xof|(p?+nE*X zVbz}Y)D1PkIqF9mpyEd5kuh!N77vde6BBFF=e)Bk5HKh~lWaS65P<1%Q8jg77#q(j zxE*(@^KyL6!;!V)r{?a>KSXlJ9(}7$@0RU(0&zHzTG1q0<&Dmf$F1y!N&2m$zK?0C zeByUs=S#{g`nVFXXP|k@rHB|TS3w zh8y#Vh8Hmb;aNbtY8@A3zCj;lpgN~~((J};EdWr;JSML+-9d5WXe|?633fp)V+a_Q z`W8@vIQLJAZ@*WV`|j^hc0X_G6FUjjir;F}8!Uibk&260#O|zs+B6ThC3Occ^w;*H z77t7%I)xL6e#$J^K6PQFly6K3Z@+pDP>d|!n6~EB-=r!2SbNUBz=l_A|$oDGc|JM5k zy=jQ%6M&+CviRmLM}6=7PL`B`tP5#e0M_szy2J`ybCf*fkX_J z0Xz}v?B8AHyvh_6=d-%bSnLxt5@Q~5l#6*kT=-s*wX#I}{#P>OkC1JyM~fk#fsTF; zaQ)l+|EX>iH8^XfinzK2jq({@;Yj-$oiVJTkmV0RO$k(u1z29}?n zvzLX?Rm8J6oq}P-^`=^?UIk_+PeD0{ z2(M?kkq$B!H<;pp>eo@^Z0Sw7Rh+Tl2i|ux7fP4Li(IYH$ZT^*z;9y7)nJb_RHWDZ zZL0LW>;KU42Y2%l>plYyOkr|#JRI9osCTr3kxLNu+`Mfdee%x@hkkj_ zf9h2KiQ_0P(baGgRCn^SKRF$^HNvW>`aBM_ns#>f{7B5B6FA>pvuE#VWfJ2Bx)Rv4jgIl$pR`29cLR{g&vqJI$w zIew)OMZK6{mbE*v!YBWQJAIZ!y4k( zYlXg&i5d8Ug|(*Lv-6pkrnmi+8Y6dtY~+w^8m$~l(2pz%n|y$bhb5 zG9x4z0JJX(CM@myPUaNt9*|^4K0{)3dLgry&B4JA)BZqg*X%BSxGAX{Mkv3sWbvlo zb6aXPXgh;cSX0i2#_!;R)D?7deFEbj7+^0GJb|QQ-t#ql4uYlQ#{A8fm71Lb=@?dA z+%lAN_3{CBpu9M|VpFOyXom_iv+fPaa=8xv%_>CIRmME{>n#}|!g38V3GXT4?ezll z=lOgr9#GWqr!(pxn}T3JwZTbx#w+@8SbJD-p>)+fhGDNM5ZhmL zS#j-+1m2MX?94g>qXk5rK*wpi!wRe!KDse5Y~Rc3nILxSfONcz#K4cKV)2CB_>hBg z01pa^APX2ML#EXh@27i=OKup3l}qRvAP?C*0S+E)A=`S7`U}4-wz>?7i1p4#Y00>y z*UUw)_A`O5#0~nEg8ft*wuy9TbRBvC4q`4YAW7Q@(BsDeq_B09=|TZ`x*F_A)0S! z06!H(p%cex(4?-U9dnHvyRLg8Ti{QfuHCv>8UFGL>dh*k2grOSTRlFzV~^YBToc`7 zpx;ur=$R#eu_e^DZ!{q@4qsPKxPnTzLG%mE5SC`a=BAVQgcQ@aF@T_*`ASAMr)|9> zW0hVLQF;&u*=fniSRNjU`}V|~&@CDJ^qNADfObxQtD5xOCDle`DA{1kC9C)TjF zXKn(RzB<%y!N+Cprq^TwimyK?emG+jwX}fOP0Kbzr&iE13nZHs}D_ zl#}lOV*BGaDNd=SP8=efaEPdJFyXgOWY`lwDDQBaA<2R)vIhIH7n!ux0*q84>xZVU zq1thr?A>rc4k5`Q7PGRYvtc|ko9!3Dx1U+M;kFCcSz zx{x(&=UJ(pj@YITWSt6++{2R3^6)O}kUr;iJ419CZ4t#dFghupp@#{yFF&KQ2&UkZ z7KmjKSY5hrrwmd!=~kvXt=YD+npYefEl}pdCzDwhVN&y6f#DAf`m;cJgTV7Kbz`#( zgN)dxJ(-T_fdg2BZ;nPm>K!k<4Zl3FJ+J{pj__yr!4d*L=mbB+7zBSTYeg!sW!?*> z=o1Gtiyx*EEs-7k@>?!J#B0GMY29pTFl|mm?+dd{HT#%#!!yS(fZWf6&2(obPAA!%Ru9vCFT%k`3k0VH`>F zj^2nu{>S$#w+b0{I%|Ox6!Q-RYu9Nsp%PJr*yd6lcBeeQ5u51D9-Cq9aP5RMy-;R2 zIdO>WT#OV4?Y)31?u~%>s>WP5FL8@5SbcGW)twdedD&6yC867$WX>o(FqXpS@wBtN zT{4tl01na;9RX}sp+!Bl*$dg3LbYy&-Z1J^1zICgm-Z6kQ=Jl$u87~QaINTm&Kd|M zoo>3b`$~poDTTwOCo@)Tw)j$iWb%_NKw+2Z$1|-@5Iu?1Ud|hoB;|=SU&%h*1H)9Q NTv=3b#rW&ce*r1rf9L=J literal 0 HcmV?d00001 diff --git a/docs/src/steam_trace.jpg b/docs/src/steam_trace.jpg new file mode 100644 index 0000000000000000000000000000000000000000..302efd6106c971b9e1808dcb7a288c58fd7eadaf GIT binary patch literal 55567 zcmeFZ2UJtf+AkbLK&guKsse%_p!6OQX(A#Zy+j41L_q013IY-1ob8-EXb$1UBqFGkfM~^P8Dxo(bs(X%=+uj)t}d zh>VO3^bq&~ktRTDAo5eEe*FTU)4(sq848NirzxnZs3_0SQq$7XP}9)R(KDW-qd!ki zLvxPh-1!Sk%*@QR46JM{Ol*uy%uK&3AtMLgIZbhvg5oR_9St4R|MG|Q6?Fd0DKqjr zK0Cf&@ij186)M@fxR0E|0 zfqc;E^AwDiZm3dT(0@dA`8kus%ec%le78y)nGO1}{F0B|g3nU3u(Gjp2wV{qx+*Ls zEh8%@ub_5YT|-k#`;OrQBV!X&GjkhTyC?Pzj!y0#o?hNQzJ4LELc_veN5JC~-Xun7R3d#iiwy)ivDq z&hFm+0sipl7hhx`^559{le2%~>pZ~Msne&)PgDKki|mv)aFL%sO>yZ4C8Mf7)uZPZ zE=#;T!*nYyv$XLnpQHhn`LSC+H4DEKMgaGVwZC!p?=cqqKjQ39#{SONIEa><3{W2V zc@P+cjg2IMIO|kB=S1p7?hKVk9dl~lki4~M8`n;&Lw}Phib1cl2aI{-lSd4*vLS)U z7fGPGLUa@-EYh=buOW>DTF@wlua(C2!J3+JCMUGx?L?|h5~x+51fsdn3fq;0^5S{L zNg!s+6DBgCPzw$M6zcu0(EXrGKKXk%na{9IB7`VheI!Kwyv}>hK035B|i5Jb>hGgpfc_3N%}InUH#nYxAqHU&NR)8GPnuAY6km#~!}l%OJ4n{7y1w zYsRh=6pX)~Oaj46{NUH9)Br|UfmF%$-&3=REaH*i75fnw_R-%M+ha1N5C5k`O`vWT zSYIzd=4{h1*4Bi`GfAM(=(*k_4(b1W(;ashjNPb!fG7KL7M z9))4;WC2+LtdKx#fVjs>V6)#{0bWwB{xDI1;LRGYgLh=08TcEifUp3u*hhg^pd%y@ z*5=oHmcvYD6g|nmlBo#YeltYcCjj+;CbrmO4^yRk3GBLn&`l)OSya6|fR`$i>;U>* zY61GMqVa`bj03)x7`EvRh`|tsGwRY;e`C1@#yI-?O7#a)-C?)~8Q6+CKu~I4f4sIN zl=V&QZ`B3-Lpo5MPbV>K>aW#VeE<_g8Q5Wc6D5F}ezBJDPrO@p13Zik!kT(<$tQF* z%S75w01x?qB0tRY9&!E?6EoQII-rlJJ*oba2YdXlM&1A5p;6aT#0l4W z*?13A_Ie3y-GG7&U`?Gk*a@Ba?+PqR&5FEOtDuKBvlauasK^4aqA0+Mc(G-5fJLbp zR{_kk0}5PP0W{GQOJvcDM6WoGpntOpz?xtz8HXv-NCMm6^e_K6{X?*&b*8YTKRcB+ zz&k^$Ch>{$AD{!6eI&(LL(oN^k9)W)CBGp?N`UX2&1j2xDG5}y3K)G;){9zMhL`{? zKYWN0c>h=sutT7gR}(FoM4O{LA|+67tFb5(#Td{{&gQ+=BeZ*h3A70WM=(ZWw3pB> zEl!|GAV7KG*I1vR30F99B+$F*Y!c|D8!TFoAW(w=o=1R={L%mxZQFn6n^?Eu9OCKT z2ml0F0Iu3n0`!X0YfuNo(`fvN-7n+G0~(S6=u@@WBAkWcasX;lO-Z1Sh~LUMGi?NK z3<8N6zY>3YaWEW?Lai1ao!0<IlR!5%^#DNTCxJNH z0Jde&7#SSv3Duq+zz@(LbAdYNTVT7_oigy8zvN*0_CD*AWrCmzKkv?UC-iTLngl^> z08}!=jYy!cV}Jyke@PIAQN)R#&?+E_l)q#7+2sh>%Hv@)RsjIB&-ow4y0`Fp0f1=L zSP+0T27be-z&Y3v+ny_dJ{cgOm_vxB+@E-1>jHos?M1LzkH5iGhEE1DOc}5ma)83Q zB1-tFjcI_?gBB8K_r}@`p8FT30%T1CG-t*d17!VDY~wGo&=?gQ_=MIEO{DrAug@Mt zkU%Ro!+`YvMwkOY*!=v=1>VDVsNc!>#LMLqT>}gSV2d#@zOdz&s2HL=_t#6DG}pZa z@q-NTz4B30G}r>r6vy{p#x2zwv6nDv+yLI+CV}QP3H;;jClsz|EFh@1@?ZGk2#i3w z#jrl}6$R1*d~~;xvQ+?N_1_Y~G~$%5szu zNs#s~v9@+Hk->IAJ^3vdg=U|ga#PB!!`2}b|7lG{Z3;}|a&?5@xVnZv#VZO>qRZ^9=mXwo5 z*W8i@mc!zn?_6DZ=F=1O;q(l{W317KsjbNESK*O*pHXjJ>jIu%f0TAxf_@`llGgK+ z7?eFluw~|)BWnbIN^~oM{bWJb;5|7#Uhqv|tN&EaHpINyown!EdzRb$X^DJ%=uBji z$m-S^EzMWEswB|8>#!A6Zr7a0K*BJO{=E9xd2ZiZg=8?fal{vfX<5+1@_I@e0?hQi z9G_|u$CRbK(8ZMYh9+Hdx?Gs0g@Q@{?kTv?$A9OdjfN3TVPDa?w#E%;66hLu7BWyK z9G5yNlm$OaEtK`*|Mn$Q!OONrWDhf~n8nOU(3a*$Qx}EdggXa_xY*^!=g)k$aM$B2x^Ym)@Exa-gMl<_03z_ zd{ssl+d1h=!3K&(53n&WVt~$kb|n6pI|;<&jV3&E30vm}TMk7~cO^yiuSzo?bh+O;DaookIHLjs|*FJ{M@4c6mg(Py%kEI^z zops{vrPH0=-F0KPY*MksSU1<11u;{#yyC0NyaJ&QI1ly5@hq#3iZ%>#*K{Fy_V1RZ zouYp8d~F#`QI7q8r6r}IKXQ&~94!t9uH%->87vFn(#mFGP$ zXBNtSFNe>&gIRIc$pnSkhP{kd_gf>#^=08qBE_~0OaqiNH(krVF4VpHsOWtm!}_HC za<%`aW|P7~63e)Kxcxv$`nHspY^<=-?b(ooH+~+3^|DVo#?gu9aZ#y`SEi;iM2EA> z{jKsw+PP`xk_3=8_Y909UB34(S#~IP`b+x@+Q75wliPWC`|3pVAr=+{g}VCk;OjHv z+P-d=*>7sEXs{~njMo9PA&q0o_m6z{*F`c=VPN~JRFBWIG5nSR)xFFe(Vb2YbA|5Q zxu-bs-ohdOfP5Po)u)`TBznaWQ8k*?W9^9hTI!4HxNaIEM%8 z;3(R%^P%53waTK6suV9uD1zz=s77~~eh}!K^8y~mHjjR0_c*9&%6wwgfBjlrNcubW z-uqBC+b;zJnHIN;wAEd+T{`Ne?)6M;c<9MC->SEiL`%!CDrB(kESRQ;rncL zlCxV(_zWW~;!}c5c)>(nfwNDttAtiZMqRNFmpysk&RuL(6BNuyP_A{oW`U1UtbPPH zev26cFTQ7Qmvgz<8x&lFY5r1!I6kZ4G~oDYZ_!b1En%tFTnafkmwXQ6sFq%5#}KZO zG*F+L4NcbcS1ifj<`C(hXiV`$H=mq3^1l-MAj9mKxl{6s0NEQRku-)H1&|M7i^~Ug z3tO2P=SM9w7$sW*a^Usp$n~bBecNoYV)32Rm zZS4hWu>G{f65|A>(%i(ndItC(tNtwPjrF2JIiA^3^p!mjd4JCmPK@00QtAbU{9r#~ zUrJjdeYPuhdR25$?}owp{qm}J3_dyUt@KLo2Nty`*~}vRF$b?*D#RIASyOmQot{g7 z*u8R~lyX>I{@%%^ zMK^TI@D0ms=RPt$n`#aKPbH%|{-WTgdp;*)%<%6CKB^@92I#Q56X%*xQ?+wqhd!jesLwDbz_`2b!l!@fIKZzB=A zGe-ioOpzN^CoNsQR8u~H6r))i73X_BgiOhlx%M>3ILfm_iQKy1tYf!|sOul3>;1(| z#Z%X1YkLv3b%5mCX@Z}e!Q+k@2}-!onXgk2%xP9@j{b&AlkKhoxs%(y3r&3|*}XhA zwN$1fcT48Z(nPuGAu@hc?FYGXW`u@dz%6z|L7j`hgspj799I5n+W2HThy>#EetM{4 zy_JlhcAWCmE%L0mAG3zm9kGn&IBffXg8LNuV=g zIhSJ1gSQ6(`tfywHhwCfjs^p1;Z|#^^b?lO2;05= zrM9M_&dl`A&jQ77MWtEew_j&NT^6EH(pQDrEpo*ZOd#QNTqQkv+0PI2?1@3)ZAKel zF0kDebHFKVRWQ(L&aH7MFJ?qK>rTNP6YgwlyyOeG!^01nGdj+#rotU%>=&NA4Pr4T zc1i@8VFiN&bg}LC2Y+V418G`N zvj_>aDxE6`evYb%hxoY?;CY-Q_gyv5>MS8#hX}+hxQN>IEVvNp|K^1Z!VZ1(algY( z0wrsqcgd{Dt(P%l&oL+0VS~kxU$X*7x}FP0^26c`Co-^;GsEWP1v>@6a&**$_@u~C zNMzJSg%59|+NY$LW4?+&mZY<+bX75qzy9f_ebKp-D`7N>V_R5cxbcb6Hop5lYSGzT zw@7i-A7NFcX9wl6mKDo>=jQLV$?AV)cnVQu>}Rzx`l0t}NP9Z79-O5?Ach3`R#o#^ z#4GIVS@=^BS<_A%rH1DBKxlGh8P@A1!f`w|FOr9-CH^S!qe4JwbZVnbydrIyH&QXH zUfzDsUO-+yqfg1gk=E;VMjIdIrXx_<=Dusdgh8Y4 z6HYJk>6UF0gaMj*v-af~pKmv1o%!U}CqB=PO8VyE71f|3(TXjy3WzytjpY-%tmw;h zNmI3H$5Fd&^55o!ik<8|p=QH*XSHPp9jB}N$f})1ASw-)7rq| zovXEN2W2MZCd$C1;bLE%VLrrif}mbkR-S$xJyu}v_E_%bnKepIF5Glo39((TYVevM zYKS=Md)>wzy6>e|{>F#1mm$ODUGbVo0_VFrk6eRXp#qhH-lB%&1f7AA@_uLMXY7wV zF&qyHJ6bI?GRut1oz6BK)c;JXtUqCBoK~#FB46f)iA2}bIF(MdQ??z>Q)f0jwRv-< z&E2X6%n~3=6@{Qc^o~ifA@bf&stNYGi-bMRx5V|zwF_2?GzuYg7+QQLrR4^KW3M^) z?;h?A5MN_jpZ#QDl^@Dq^mVuH4$Mh*iG)s%+UGk4$zXfKRk+4hdTl*dw*+KaN7kj1 znq*EhQ#28NG-2gtM?MwI1Cte~wIDY9HL>rh3nBu3G#0N-t0h^nHL>$BVKC#J9|x}H zs^;tG`uefg*sQb0@mk~rI9#MgT-SBD_IL)Hbcy$ zG%M>Zw^(uM23DNZ_(8U4F=E(TS?_B~URa%+)cQ)DU4dhn*l69LZc)wM=ECTYB@B1d zGIDQuqUn4>T58%Vq=BXNS!>}Z3?dNpB3*a4s9D`WR|Xa zvfFHr&!)LYk-rS~qc9^RMeUJ5hmU~eKQS@xLDV$Hy7gFy*mnRc7jNTaU~P67k4f)WPRg~7 zVqU6r%MDKWYG>4yF|g!j^pta zksf?hAD{3&+1TVi*$@r#(>H4qrn9i~7fUGuH{V(~99){3fM|N+*MedLH1QZL^}O9iS5HVmq?EBFej3??j9JeDDWOw&Yo8rm9Eva-iYOgLA60$T%BRm%lV+57N3 z3vJk}w&0;d;K3YnLbkDi6)%4*%}c$OZGnTlSVkqA4A2#0H`FVxck`y;Uh#+7QRuk2 ze?uDJVmD=v6$y7nN88*9e)w|C+2t5{L2OcV{+i6lMB>e>rI&4QJtNy*q`s$hF&?`8 z9UjzeZLlubz2hiet6twVh)T9ip7K6e?>kPO1#ik?cbaDCNFYaUuocd_P@M3vN+c8J zqW0W7&CkY@Dx0P%T*jXoBNk6~-Af=j*T z{&|tQB-bcAdWws6IvgtIp7uN=%ArVGox164?Gt^V5$m@zQi%E)qF0%B=x`>UvkAA%!rh6hg)< zJnGOkC#gU?AQwtB_xqd$7w!V4!T**wd7w*{@kU(#uM^8LqOHTC^q5d>0>5P55XiCwUF#e&R zo<$yx0`P4kyQf#QZa#B^d~CmiTif@CMfKr>+8dLO0%yiWMG>#eb3eZdK4U~q`(2** z#^F7Bc_iYSKuBah&P8OlO3FsO0%<2MIzBAw$19TF%nG*Qx@NnVIPf-epBpK(i9iH$ zmaS<&!ZzRfjEjXowJS|9t12zCD1t)dM|4{*EG}NxR;Ho~Ru~m5o^~)-?@qNQ$kz<= z2}Hoxh!`bY)H5@U>sm@M^Oao&7QDYU&NcFhiojd*wWMQb6gllC|I@MgpJCtaLsqC% z(jYM$-~Ig^FX3`W;r1pXi&GX|=>~Bflp4xfT-3X`;p@Af;XdlRQp=vl1+dNzi@Cat zTBwDNMdtj&OA!T;_glYb-@86~&_9|03G2UiyaRKSMrVg40V1s2p%Qel@G;u zy~avoZywK{3@E?%)zak7$9!KqK)f}6_PI}0P#8T|7pn3rpHO$L2{LXePSis~SG4kGhLEGN7-VJX3#Zfq*OIclzqwYh;E2MhK* z(bMg}f;|~|D_fl5Ch!*R z{umdphl!fcec}XROlWHW4S96C8u>dLv%ebYiTkXBV!teV<_p_q8ttZXv|r-dqC}{X zUIGMa=TJ00*|3kREV=3^8h~7EN`IPn$8fpdpmr%e`E7Omu&461+`z}hov?E%OlD(v zHNBAvxw`7h6*18D=X~1?S?dZV~Di0+z?`x>bwoPBcW<&*e zLOsS?hhs8W(&98doylF`4>xXJjG84Us7#I|THjrNP;l$IYr06{mt4DUZ0XI?oyT?XVkxkx2j^WeoJf6+kOmR^Q z!DAggDqB2DU(ELal}~6Vf4%xqt$5Ps(_YExEaDnvR8#innVkzm-k4Zr3SX;$d!8IO zT7#DK9dohyIUgzy0!K!TD^!{V63rfER7NG}67K1uW@ZlJ12Yzw^woVd>wv$Yzh3{% zP^->_$M{B^sct`U3~;sX_Y+y>)$kcqi=Wucl{ZZ6`>kUq)3# zj64$OzOtjg?o7jXJ>31?}f#`LW zcW;UG>!qI+eG<=}?eHlYuH=$yX3BL=bw%})!OR2YUs65=uPOwHCm;=ZzAY-PA2;zBd4y+WUR`v%RN1;coFX)@}sipQ)x>()4oj3j*XbR z#=sa(hQ+%0fM7eur>mw6)#=FJVH`@<-~lhY zo>iE5s&oDC`|s=Z=XRb*1wNJpy1sP`?A(@(vfdf#OU^gilqH%6@s8vV|9b|!pIHSWS(pM0F&z_)e$Vw7R>xuQ?IoqFICGEhY|iu%H|D1s?jSWups)~J zxkF{jgDO9x;SY!u(_1bTbSjPpr>)@W(65ltS?;leg8b^$?UDlmKiax$L_sIDb5Czq zIZ_Mnjh#ET!Xkt9Ld;Og{*9f*I!JDVS#4MEeX4hCb9Ch{D-oAM+?F|So=TksJj&@z zXuQ8@dUY;7sI$e*=iWS|DxU7ik(Fg)=qI@GEAcU7nfofYyeZ^+ppA&2Yxt7R76t2S z`l9j&gHo8BalL(?*kq?m4!8a9ID>1wtXf!><$I<3R!E=6~DE!fQgS!ADz4_Jy=~T{{OfJHZ~asj1a4xK~yAWuRgw z*L?2Gdy32_HZ++AWd-&&5#(OGY|d64B?vS+Bk!aRwQeJo@;ope62*BuWWGJvHHKf# z@!`8Sk3W>Wqa#9fB`=pwN5x^?7IE-sYr{@j9(^p2r>?98F`3Rcz0zx*R&o=FF}a z--({2r_jw1t=WO>kU-$RyrQ7zRlR!KCwfl!Kx{T3)^<(?Y9|g@IA`N$?YW2w|1XHW zt3TIwrk>*249Bis*k>PwfrDmN1&X}agZHmDe85a>YW!q( zre@@iL-HAvi3ma7&W80+igfRSBdo7rN1`2bSIsLbS-etG)~{cqF2qe0`aZsopE~fF z_|Py6YlpE1SmCaG=TwFnge{F+9bZv%e&p(akfdejQsZz9xUeImCpZ$JzPo)QezZ#T zJMZNU13KFhIu}_&V8jH*K3+jgWFNr zpA_J0lrQOvuvMB^lZZOSJd5=spzH1`s~HA6CeBscz0!7rm+(!63$wZ=flgnP7i=V4 z!X31$Q1lm9AUKUHgL~RElKLzilaeJY6uG!c8syB5>Pk>x=W|B|+1e=?bzGJ83`Cz*CsgPL_KZ`jtN|V?W^uGJnmJI< z6(5T2#C+(S!o!-2GS%jOc-A^A-W~LaHq=jAB1p}#KdzCzU#u_p%^5d)>P#bBPY(iX z@|7bxFFdbeuuhq~#ai}rpZF|x1etHuDp1#2)h;r5#s?u z14_Je&R*hSryQlk8Dkk5UB#-s%hqH}Tov57xMy$S&%d?&@=eiq2l<+p!GnR0I8dc> zF1!nc9aw*3ah|{00kPn5O*Z3aQCvbV*C>tee76?~q%~Agy;axAt*Os}8nV7?(^W(E zHQ|z*TpaQKt)0P_Ms+502*WnwrTS6nB4p)SatVJrOq6f>E7^zqQ!$_w3Uz6r?~F;6 z=7+VKdj`iuZN2Fbcz-R?t!gsmxWRsKn_!A-3K~RXOAN+f7&@z`4t$Mh8@0zkY@n?D z5u*Msq;5yyphq}863g0XEm}9Yr>ijY9Xk_Nr&{;}|H%ajjfs`h#;inp3Ojq$6n2VXVepzigFV$+W+P zbFywj5-gMiqN=dsZ4PN+$aLuUiPYk#OZGNT&++8EB}z!TGevLcWPH31k`cm_gMtBe;PcuhVKgO^s7C zWx}?lQfBf-W@#@rCUuzKADgPC#Z{=Cxk;t?+}ay6Gp;iy`)UKR>482^CnMPEZi0n1^t+Y29XPFCCBurO%&nW3*PGq)>YjCVl;+LyO()}Hri#Lba zKO{}rxS7_TJ1hJ`=&Ski{kK=g6?5YE#sa@@9ymJoO?{V0ZRjR)R3W`{YoR5@9e5xR zg>#NIf}omd<(Rp(M|XK&mr-uY!`L*Ctk3R_fmaA8@l`;IDi|Iy2Ye< zW=IM_bu&X}X#V(iCZt6R*FvwhKsOjZe#Y{)PaAYekJcyE5NrS15RlS21K@%rR0)o!B8ce@5HXuH1asg^*qyKZ&!t;YgrJg5k$WAJcZ^>NHh|DdarN zL3im8`{U+H@VNlwwGyV_-13ClPnUCv2H3zYt^m3QqIfwN=#bO~+OT+eGKA_V;r*J-%5+hiYC7e%>MN(xbgw<4OVvqL&)x1z7U8 zJyFQ*@O9P$Wbzk+6W$%0-Nd08C1s(5V7QB;e7#PeHsXDh*p}@rti^b{CdSm5Vlp@N z#yO@JWRJRmtyabbit()FGj%s> zLHzMNn%yTTkkxdQW&1nkG91&LSYv5<&6bI=r!>MAln++q39g=D@Y%7#mSjA)$(;#I z8kze!eq>5`H{&s~(M@CbHm;)fnVkFr$Ga;DOCtpItAwCr?ILGH2EB&Bn0DuMU4id{B`7{eNiH*ALn|y=C>FycYCG04W0-5WOj7l5ye%d&MB!jv zO%H3K4`QC4+kCu^adwg-fins8Ef|@YDY=3MW;{xXZhn)`GC_Y>Du0vz3ACQw2KsJ0 zO2sH);h}plqWLOcy{=q`M)$g_m9tBO->a#qk*PYQzxS|XQ1}--^s6-kJ`)3@#)qh5 z=~FYSN2F;2?~Tt})y8xnoHrR=Z!CIwN1Fs$JTcvr<5P03YJ`RRB}c0;PpRcO?yRI= zDj%WGhGI4~wso|51_W(=Y^zV%J)OVQV43$kZJYNz*vY@+X`P7kY`2Nw@x5r};m$R` zq+}cWx~^bJYV(^M=UMt%!X{0tuY3WvuE*8pc=A+|rQ2%H2VU!XdfU&r82VJ;b?fD} zqI1-tXE{OR3>V3}uez()(<%CGPyB4C+}ghSv>J_YJviL&+v}xY1yf5;$zn=Al0dYK zz`UhICrkHf%_1gjL@G&o=gron-DQvCcKdHZ`st!8XsRGKAMs`m?iu(({}U^S!O-QD zd8;85jqhw_RgHgu1>kAq)H=0w#W3p4b+Yb&`8ZRfHy$l>SL@jrm&d|#7Itfs2H0Apv9PpQJzDdut<3dRZh~-uLp3jqBA2 z`IG7K0@3P#Exg5^_u#zC66gfkkE|iqnY`Y-c1=mG(0tX~{{G;lnj}SwN`p^6 zYHwnLDP@JI*tX1uMW-f558SORzwb=m+vJb`=GN1)5bqy<&q?@l3jA(?)Pw^N@R$ii zPTu?qXM%4k)yGGE3BVe!WWd`$Ro#4_+O-s7*2dQ*h z+0%@d+#BhL9bcDAdrLHbJS&k2qq$*FvXPTgI|dBU7E1vptPi2{+wHUpwNY=2s~oL@ zst$SYpr@n{z#HK<&QL5^Ck1qR)I?U&(x%|eoo|vP5a>4Y6++w@#p#(c;#2bIQDQtR zeUATm>jNM#!?zp{mF^8!QokC0t1h*ts&3rW;_fpx8TlVSxME&i=!*wy&P{SZ4YDA1 zZ^@xV#0q;|j%OBvteV)y<%8^r!#@iIIU8bD*C(I>y_H2Gt>)_Cua(4$9sLTkSCcE< zEv&9(cr>jTHSUk=>e?Y!Q<5_Fk99Q$*4kaRDw-AQO!p?~Z$OxXreIZ&FeQOmEBmiO zBQlsjEhM#_g*%dosGLko9iuP#9tsUcafZM{C#i{YIr1|E$y)j7R)}* z`k<9f&V(9KjZkO0|Co6rg@N#5ck5^$Sly~J&wFm9oF#!Gcs`Io*8M&F|U*#OMmN@HHNAEoTxI(-4_IP!>9h9&6Y5I=m*hg0#& z1lPUuoK&=ns;$1#fv_vNc>%Xa2)y&$oGlRgk+BL9ZcdYdy5|A~NsXIrW3Xw1`98P%;F+As{RP3Fs=lpHb{ ztpUf@F%&p{SA7qN7wSl3 z#dK}09=HnSjBkt|SECh0{7#7EnFM*9eZ(H;CRh{OP+kQ2!C2*0sSr@EBtZ=uQxC)O z-tFImP(#)j=7xt&jtyG|9c4znHld8y;w&4bpjWk-w?kuO87ZM%L4pJmUFcWhwJ=x4 zRTj(C`Pw&8^3Nm^Cs7v6ve(JoH<56~6p)eItlr6bwLI>h%t z$p6fV6HSd+|G&;TwNk5Y@GBzk6AXVq0s%`b@gsW@C>FMtPm{IDtn>Fez<*Z!Q7p2; zNc`^w|ML2a|1|U;(fwgd|35PZRrW&2IApgMIBh@zt?QrUl0bKXlSErY6q$#`_UOP{ zA#UM}{p1s1Xm3X!4Z$2?gJ1#>g^9Rn#p>|aR}HvzV)&NVZ(1?sXTfQkfLMe5!g2bP zpni^}alVk+*th;B5u+#{81bfp>xn<$wEYN=NM^M7Q5QM!`tXq7ZW&4Wv3S$I6|~Me z;T!=`xyy)`n+z<>APDg8ZjwN8;G^NP_|L`N<03Rf#@Hjkd+{yf#0iW6PG97?5+VTT z$mT?o|`x)hXfm!6lBkqU39trBSv<3V&>B4RB1N762V84H6HTe9x0W zy;3AlgSrZwhW%eAgY4sY2|Ien3;KU%9|@7A--hjUgSX-|f6p{r`AGTq%6NXy)ysPE zpGyCQsQ)9=e=;fNK#%J8s^4k%uOuH|aorMJf;GM9>)qxffzp9JrvSLpYZ7QV1vYcJ z0$lclxE*9q5F&P@9(NpOU_VMp68^}Iy$n8F$~gFjVAyz%uFC)>Bh-JEr=tbn;J57T zZ?Qz*ypwGawLcn*{j)r|8u<5Ip}#lZ_eW#df4uNNq3+E@i-r=4P}tpCG;y6F#_zoT zeM$jffBB6`CH{A8RR^$@8YjHJ#Q^(8{(H0+nLeKu*F6MqhS6f?XoCbgI$wx_{xw+p zysA3$n#z^_Vo`z>c7Scec|L6G&LIDn=u7v@C9COsZtSr9)U)2xwrchEA^_MMp_3>( z2H7ToBs=qw&N%yE!iAhEpH$0{xnY|s2(z{0b;lzvBu;R}XewSwM4>7`l0733;@eCEhN zI)2e>k01`~NS9R)q?=~|nfX-BjYf-$du-l2&_yK;2&7EtR}5y~>dTu+nisYpe`T$w z6tgD{32$J+g2R9?rsNUXl-&Ked^1(&pz@ZO0wJ$h_J~U0yk^MGLmL-)?|zkI~oW1)_ob?xGQUrPl3@fa#cQiI`o=0zgza@>fQ(# z{Vp$!kITrhTBOO)=7LY0C&vBsc)&t?vQ=rxilr23y(hW)@?j z?XN0o-zSX=MCph$C&zuJG>a986|BFi@*u<8wGrLd?=-%Ro=aZy4Q1X>LloS=NZX>>Wsa{T%D_2G{BuZRJa}RdFfxp7Sy;6V!u97(rpZ5ek zU`L378@B1~W|1m0!DLXudHPXrhtS~xJuEy%lRq`q2ymJcGWH&t=KxzVUr8Y8lPdvZ z>VbTLSP{&00umqFC@ULuC8N!pHGFwk%ylkh%HvSX2DQ_r!yfhRoSnwpm>eJZ#TXZG zusJ7wq*qhcFMRA17C8S~OtkfH?cMjS{z2d6>)&=GYLj?vN6pIw5X31x63E#mco|hY zv2+MKnbAqDz$> z*Sh#>NA57@mNPOr-}$PXCuC`Kg~qf1k#Q(^6#Bn#TK3fcFm8fA1}@Tor@=%^wq>x@ z31+U#WF6=<)SJ49c15$rX(_oFuz9SVDb#tN6J;-bPt5gG9=W>zRD0uk1~Y!9x#2=J zb~!YF*3+y+38AMpY&*<*{#K9i?PCwj1B`D|#@*QvgXVqrfdDnvoV6OkXx-j0L0t{# ziNS$3)VmzsVdH3PdOODU^qpFb2Wi_>4)=~yr0qLLcV=9Ud3eOQhczO~2ZCtYiu$ULD@ZY=E8~sE8KZ z*-+sfSZt`PmA#%_n_HKx`0fg!+T`o}8A*5%3<5i3Z*$W9b(9}67Bm)b`>J&EC8n68f9kypyZ%x5g-+R4+x4@^6v0r$a{QG>+sAp_ z67<4`HP!wzokWJi8*lZ^`|wUb5A-T)N+DGdw%gVs&&)7y5>Tc#_!r-l8TjNWEA#Gn zTHH5r_?~NOpgrVuw<8PTltg~F&fm2{-R&F5`_<3;KNeNDLfSN`xGoqu*|DCL>-2cQ zpT{h;(KTg5G$n!u%8N9CZzf0r$Lw*j?c44e}fkiY0t> zP;daIt784$B#`X`tuJX$iU7RV>HRz20|C9c%O_rcJDtPQ8tO+Gfy*!$xK{Ccx!*(g z@s6fdidT02c`sW@}R|EUm02m zH?2xizuzyo9jkL$`h7|fjbAffVhNoX~XN?tt20mRl8uG>IxVr;$ACp` zqmA0=r>Wx~9NEBKa&c7;MqC24MTxQ5Q{u1rURdAizmv}&dMD=_%T1$0!IDV;q?~qY zgvut4h!qgGjhBumFvw`ZBtB$rcqU@^FhRf1LnPYRhjH538NoKKRrG=_o@g2XqIpFZ zv&T}8yESi$UF?a3W;&!W=Pva3dW~DvW=~c;+?cBWAw&_;M8PiI+OK9Z$&w1VY5&VZ z?*HYXcH#Y05=a!xu>Qd5kGq?qov1a1jCR+}P1bv5!vSY8y7$(a?}pzAF-%wNcPqV} z%IBK2aAj7$r^~*|X?sn`53uTy;(mvp{u%|xhR~Y&@Yfepn~2O7=yN{;LyU&9%Mx8& zz8cZ+$$kiZc3<{8v-aX!oaJV3yH(J7Yr|FCg>lEGgBEj12k+;_2ELBuYFq-@oZGxl z@3?8R3&u3}IOKju4dymjq0f6+p=V+7D#*zBjIc{s>(aut@!qgsK2sicXTGkoKJiP# zi%D8a9|b@3j$vQyT&C+e2MC{rcibKFx&Lw*gaPkjvCz-i++Eyhcd6c=@4{_9(IsaJ zqcHXd7fMz6ZFzaKBE+6-jS>Mj7e8_P<0PX#fa&DGiVyO918{hu#H#6Xn>sMA)Rr?= ztKc8W<2fS|CxzQX>Wio2UVS~qBre1hADQ+NzMDZ!@Wi$yU|xIHyPIK0s^*|Dx{ln| z#TC{Fgk%LB^{oTipk5R?=n1dl<@su4!b;Y2Ljye|fp_O|_?JN|Fu>+`dIDd`E zT{(z?(co>&hk*UujW5!hw;C54VnDU`?Yp+e;(SaTI%(%#i>!#^3nK*S{xPJOka9Oa(ykuOX1^wduYQpURAVq=DPsHg|_eO(t}Zt zIu4(?QOSK%fKUhBfUGd${Z-Qs?hJS+UKQ`EQV5M2eSSAtU$~RG<$2|DbX^YbMOq0x zIppQzyWpK+@K&bg_#uRTNh>$MV&?Fh-hvVI)%keCX20&Eb{j5Hf4bfy zc~rDb#G9No)k~@mwP`i)J~T=CgURg8>%bZm2s~~Gl^P!da0NY-Zd3wvGhhnB?^i#% z$vWr1#fZ1D`cgS4fW{JYy$dZ8XhM^q5roy#FXX<5%~DLf97;zmv0jjF*}n6YGA{C* zf^FI`tfH9&QZ^(WF$MlE&H`=z_%T+miNFH_tovjE^|;fZcJS_}ktGWosV7&J@Q zzK9>apPDI(*4!bhSSS7VytW+)brI*AU&X1O(@fgEIKA{P#tA;DavCSR9-^+oGptc& z*v0X@EP0dS`G;xisUPhD#%&2$*EWT=L?lG@<4k@(T(rA({LU4zmH>FFo0(C_XSt@G zNjobS$;hlq-o}QDk+(P|R{Y`}x}% WPeN%kkE=P1kvrWSijiPZBfNYGU{EQunz< zbcYD&@_E?!e!%;ww(gT>?lHlsgWJRg3=ERD=6k}7$oEmR8jvb-zIUuX^t56k&6hQq zC0>)Znw`_~1t(uRovS0TRP(G3xQc)tg~nv&{P;1Z>FX-m9a(Jh@>9(9{LPmGx?}9C zTPcdsP6Jl=#NcZI+_UTfkUXcO5GaRBq)qN?-PX38ClkkQ!Y^;@S1ZNdsm&!w5Ql~l z&WOEr&Q5uhj+OXk<$cRKyH5)e$q}rJ%fem7T5_k|bwz3~S#jwy_rsdVN~YI1>NxJj z<*(m&EU%NCG&AeC{AobL!r_t|rLVN%U2IT2Vzo*k=0lc~>``Fl?E|mMcx@(AcEt~> zG%tIvWNK@>i&kCz^dSl^l$HO_z(T3<_kc>s-=mPVx_>hJ153T6jPSie>1(WXWQxz+ zN2Sg>bUTSC9&70R%v*3E_9q+{9CFaqNI4X5ZL))FGUBp-&!WlJfcN~K53aB!t_5kl z_)oF_2;~1m7DAtSm76JuiK5>aSp9T~j7u>bk~#h!=-;|NE=5KHF^Vc?9D2q6+J==7 z6XY#|eKXi0)`E$zoDil%5zZPb>7RZbMIX2(GHudkoZ|eUYhPii9`yt7?`*^M#!C20 zMsK9Y&5#U9myP^ob|ht1SP5bs{|SBHTwCX83fy-@qlGh^bW~xC88qxeeuB|<=B*{w zw3Uc*Xf^!kx_rUakn5$_XNvI7A2D>kZBcyqT+9h)%g7+-H>p)o!6DBFV|*HGgBr;U z724&A2J&|LQKP~Aw}G8O7j7Hs6uc>pFSfTP^KoC2Ufw3|l?=|de=!Ic4DuVY9 zS{Ri#Mz5S}W36&j`eI~e3exuz8_;fbuL*}&$n9ELb_Uw}^6oQ)^T~85NZx(ybGM%? z-RxE+X2?CwBv{`F2FvIM*QOG_Ego?3LjNE3-aD$vcH0+45kWx^=^X_GqzTfisB{4V zsiCP9A%tE+je_(J0!meSuL&JOFCsM*=@39VgdQN|JMXvF-S@1u$6kBvbH_gS-f_nF z2mgdOA-wN1pJ&ebD>J}i)nDjz>@Yf_4D01{$ELTyAiLR zLx`o?d(HX&72_ASst2BF-rwv-H>seI6Ba&DYkk(GEhtTUW>^YZ&T;rV+J?!w zAmk04;4zrv#Uuo0m~GLEma|Yq9lx$0FaOp!<`IHuu1R>-9WU@@FH?%-n&BH65L2l7 z`DsMIBG2JD2xxV2Xk5-Mcmdt7pFj&|p|d4K|TPLz5N(5{WKxKDzx?Go4%{jDD0y8EPA7h8)zCw!Ft zR~i@pvLfQih99$$f#rEK(JXXotrNfNK9<|WbWE?m&o*_84-5)sV0hOyc>M`*+i(0` zp=P3o1sftp$~+q2CBNLkMJ7!C${JoE?_7)K@cT^0q0Zz=OxMzsXvU%7Wv3{dZ9%_3 zu)IjN8+W4|boSimMZjSbp|6aoKlm3Crex>V*CmgkRk_2LGavFC^yL}T1Cp23yS}g8 z$#}}{aCFX8gvn1_rR1C2TUdQ8ca-lZ99Zo_`l!s1Pq6&L@X3D!>cIbRpRUhoDDV`` z6!0x8e?CR;JOA#57lZd32DTIq?>78FP+o=`G%R8KpO18dhi@T2R2u`qe_U=Nbt0Me zPSq^W@hHURXo727Q{BmQjFdPYd}t&17_cc*V@_&@PdSJ=MQM$dd9V;F9#E(1hV3|> zfDOIBMKPCpt5Hkyat1rM*`gxK_$wAMQ+UGN?*cNLvj-^r?emP-Pk0iLedhfM{*x>5 zgBw1xn=tU$i3~_a@{2hA3&B=zjP{%<^ScDCN6ATmb(4u%JuBee;3#O(b;in~gkt5H zqC9^-#5LOJ+OJMFq=t>nX;L|!r3c?02kutCp!1rKhl%*LJSB# zJT2XQhi)w>HC5p=wmY2_D-v6Z7=fvr;$<% z{Gzppwt{n%?`8;eK}B1L-}wojvn!POWB_Mzz>9kWajt>7Jw@#c=2Okv(~3vc46R6U z)>P-K^-~7-7urqxA$jo4i?DeUH*Z)cQ1e{2UI|gyd1mrqRVqM=*2Jf$!Cti4i7I!G z*5Qeis-He4ll&HE;AV>98$&33l4hBxQIxCpmS+f@Rd0ytxfs?;K6(|;Xt$sd8AI}N zhcv`dvhBuHq@UcuX%1$#D}LL=%3z9$--&c~p~svdKIC>|;4Kykojw|0C2U^NW^_5% zZgLiyRL;i5!`r&JXP-%nAuLH_>bQ4@TvNPLapX7)&ICiu8-x0)=Shr2h<^q@ z<^LYjZ5pp7IMy_Ca9LV`oqO~UrL%(vVBm}0No-A9CKaY-0a1cYLTE(##@;ozs})a` znBG-aA*2v7yqau38^58X)4qD!rV5kQu|QmRz_oz%F4>};@yvmM?O4-CpPdO06TS={ zD7kU}=`eA8lw16e(m{c4f|=f>wi3|2*0@qT(XlO@?K=RON)5n4Rt5x^+cl5b$%2gK z?_+m{5v*$sPyf4LdwjzcB~fF?O|`wHS(lXPK* zuf0+zyJ8gzY-OxFun33Oh?kXV+niPu*ohk&OitCbi<*NK_Nl`euHDuZ>*toeeK=32 zUB@b4U7h%{r5Vnc@ZtjeP%uwhl#r5;-c{bzWjN0rhH2OWaMlfz8r zpr3vrA!5eKR?F?!@{;NnohN2@YkVmN`UkGzNRew%+M9gcn5A!8*k!WMC~~=@R4(C z{Wo*vkjPx>3extHRA%0yTg0q4j|%+FbPlj%elG|qTQ!WmCqnJF!kwMik1pC$U^)S8 zaV$2(7uYcPlME9f{~)mN?1kHBk-`_lq(eg- zR~TPaYBFx^>rTi@R!)N!`pG`fuNaGSYTbyxe)xzYO|p%K?h~E?E2Dx9`W6{xp<6r7 zFEkJTDh8HWMj<`;4cFXe(>{=PfY%|LeCF=h~qcX(TW3;U7%goC} z%a>f_JNwO#0ySVHJ&%$Ky1~(W-HZl^JS^~9Y{vQ`-UEW#1FLY7z5j*E`Pkt z+cZ$#B;f9iTrR%+1h7TRkog{2WUW*i0kYN&X)mV);7z+4I|eD5CB{!5m>Z8CclKva)4scdKt{Jp4D|M5;lhi5NmoHRUvf6--ACw>V;Lmgsn5ob*L}a+2 zm8PaZ-jms{XHL^!)zcjv=nOdI-Y4zuo#Nc<0G#XwM{5hv_`zRWf32hRih=PD0$e3P zbcLz+mHGdhrKmoKM7<%v6|0QJ#j@Rn?Wm0-)Af&(eCXO0qEma@vZxlpK7tu}_KD`d z)Cx2qrB9EZjx_OF>a*P9wq#DX%;W*5QpH01{WrfwuBBT~7o3Uq;fb&>po{2`=v-v5 z6V8r0YVSfY%TvI7>CrvHm(b`Z(Sz|H)9<=i=;2;oeUatM6Y7vN*kAs+Na5&_MK`-) zQWpY1kF$CazTQmtyS7#X^;OS}Rr~j@RnXR6RU*pRx}bn5Nb}f3)WNQkd8lzdjt&Fq#G~G7vN>a%zFr06 zlOA8P3O-cC!J5x?REC@Kd~*C~v5Z*^aP463Hj^OxO!iT_SNM4|dk@-sY07aV*>lf> z)@tspE~nAYwqata@iVM^2g*U{GA=)XrCmlg>ZhajC_8CTrx>b=c*yHWO@tziq3?V) zPz!tqX%C~R>ye{F>!6OEcIO|qyKe~Kz6Sgp4Ku%M>^I+C+aN`D)1}w`cNBMxkFiij zK?VNCN`>{I#OLfaUL_BR|3UR-;^pwuw00z^Jdxi+40+Xx_6;-K^U3CS%xC#8CLf~E zl^+>iKO(_jE`Pk=v>wM-fx@X_wx3i$Ehg(qg&7VB=W<&Z-YX zKhg;v()!h& zP@~#*%Smglj2Q?xgn0R`cJ1&c+X3USJI7AJY%Dm9R0q;w5c29FF0VY_xfo9rJso_S4DsS8vBBwU-owkQwOY;EmBr) zxrIr2LRMy(jj=bIAXR@cLNpdJ_v>5FM8wmrr}Xqg+Ju=zJOw+;v?p5lMlr1UhATJ& zUT1K=u{faY&%3f8%6j|Ytoy|QTkJ7i=7o0f06N-Mvnr{~nyyOL+pmbwP4KwW%J17s zzGTI1sLHbbg&zxG8R93Gs8%&0`?{622{YeQBllC@TPkGJ8uqpJ?yYCn>*hHaxIbcf zFSX>5UHf5~Qdq$CbIYW*1PB#ARS!~$%*o$NaAhWg2(gZ?XLl86>W8$nwC}7`%=mU^ zN>0dfIVVeVhrodY-&9~BDSLxf!KNz2av3+wQ)87t?B~(OAT=qV?Ce=*CT;Et@xH9p zsEySm63x4VYk|<`ZI;(<7fIF5L+egsvAa$M@9P$r8^>h1N;JJa-jvUOA9sxF zF|d8@e$DyUV_ct495|sCYk~1v2JF`dmKP&rsS2@KU968$rF-Q#4e}}h9!TfizHQwp_@!|-lebUkNx*S(+8Tk( zJ>hZIM=+9r=><_tO6aks>_#TdgdJ zs#Z-wMrvWc0y+y8kTx1C9iMgCTE(A`TC|i2Ud|oglD`M&#so0K-52Xo&Ae_aEh;Y# zT82Y*by*BRob_SPVnPg}GMb)xo*T-95yxb3O|=aNw$fr((Efb7HFaR`V?F`x&Q_+$ zlWEayzaOeQyL&e`}bo1x`{uP}ks*Y|Z zNL;WJY`Y22At)E?w^-nxO(9R_|L)Pu0~FJie=ny0+4ki>dhI{8f_bI-H*bqS{Vo1~ z_G4HJ^@DYV0*&!M9j~qdj#snG7==pr1=!k*&=tY!zAb z!WR#a^8p)cUTT^J0E#5u=NfY#*fs28qzFMGs0OR+CiXJ8QaRcZZ!vv(rr0U<%4KuV zS%1e|Xk<5lkAebhVi7LNM58GeUM!;QUbU~?q;v;8r`ssm#-3r_&zd(aELzSj#oT?s*B|YGzG`# z3N9wVDp>sw0-1RqDqhhFr>()+36tTe{UfM6Ei`q#tp-{v@M!HATCUk7-G1NldX=4| zDam;GSQn<3wLTkw;Bh)E^LZs$Cqqz4k4J5AsWpX^b}OalTEtne*2&g_#JGdlJ~8xg zSaZ^S34`tN*L>@XU6G*8Dk1_Xu{>YC+|)dYjRilZqE#QE&J5)W(@fICAY8{rJ9b-Fx{^DVe9>FjH4yD9 zY>-wJvZk)4Ibz|QRwkIXSL9Kp<&!#gM*@tp^Ap`IWeP(Zh&HKtvy&FNM!&>4YY^Hg z^sxrI0U`HXvtb1O74B9xkl#)b&*@OF#;)Y@>1ugMJ)M{M=GT(!)@EMv`OS0_YDsQfpP(%eWJXUN@TnTABcXrA&$=K-phI}Lqc25B*&+@ zp*W-JPe_I z8ZGtkrbE>|9{2n7jt(MAQR619W$1aR#_5J&{*hzwHoEWOX5ftl&u{Alw&RE1QpKm^ zdua)mIKZioG*_tb?JkZNwj@+z*1{xyvPk%z^_E71N60vW6JoHfT?=B!`B41ywP=hn z8^2c+JK=Y!Rs91@j#^~rX~LYjw}h9;n{k6fGlMb7oVUR%VY5|7AawWoJp7Gio?TKk< zxL0>JK4`v2$yvaAL^B(;bX~FBU-sR~$HM*q%zz6Nt*~gisq^y3JNjpND>AAqQ^X4; z?Pwu}=WiioPv(>wRSX+Z3EuAnUDr6>1;278!ei9r?9|I7eAWB`OXZVQ-8MA5h1dO( zf5hoF)ZmB3ZIH$M;;dS+N#5@Kta>2*=kuTeoyznY_VfOZ^*C_mL2@Wfc zqi5CMG7tIM**T;8Mb!(pdqjwDP|oCQ3{&O(&T@wcawd1onarNol0M*n?)5`Iu7o0^ z6(eUa=c#=Uny|+gc`5Uim41>wf$u(<3w!_V!U!5=HAw;wF?EC>_=wK}slC-<#B7Gh z6G)l%z3R2AfHJkGGC{MVJzc(;^+MP$U-F$+Jgz5T<3IORzuM38l;2tpuEuH?#L{df zQ?|^?ta92=(IAASv$h+jCjW->Dt@&D@*032)!E2apsBKR*S9uZZX8{Q5tk_Q{DHxpm zMyt`QTfH*mQcI&HP|{93TXpkfIY_r@Onllud5Cuxdrj359mDXw4y8-Y6Wc=Y`YGL=;U71B$4^`DA0*|*4BR*@neDX4%-Qve z3NfqGvX3^>a6MfP8#ebAGoQ?8<$_sk;|W^7MH7 zwz6@9tauY8YcJE{b8z5v-*G94tkR042kB)`%+_zv71Ca#iKsrp4Cy7@7nLQ1IXH~D z`AEZp8as*7X+Rp;q@H>k*wit@>XI6FF-WEKP}F zdU};x8>bX%MbG!g?mYU9<_cMUJM-gH;tz?z4PRDgyLd2OI8y8KR-pGXQ-|D8dZGsF zp~guEezN?lMs0bHD#w|HJBmu@C(LTgZOvbb*OkyL?Y{jlCHQ{hOrt&n3La>=E{5 zGDvTa?QN$f?N=8uf&*uN3#Q=$i?*GLR#vE!M(y|sQ)F5LM8M%&;??+`bBSJ@s8 zszG|I9s0-Sg#KgpsyN=|XjTep(NnrJOnIbjkqK>+>gtD=Blj8(!}w)?I=0dG&D`o+ z6GAA^*gsx)E|6YCG^f+aFMi?roZ*H4*7aU=nQb|w28F;{!wY6U7eL74>%fE&y4uqk1=9iM=1AB)3L3Pmobr96 z?ybfsZ4SgT1!kA14;LQ1ukUtymT;Y%=~}oH$KD4e*G0->0k)2d%S~ycmIMvUR=+dX z9Af^6wnxQx>iZcu*UO33Jth(8*?BJa?MP#rk8eOO9Giu{5$+Z3;x8Q(1&%;~jzCo8Tq z%s5Bapln$tl>D0L*P=wq(9^bZS1{m`q|G%KOSB?4pYBP;R&|BF%l`VZ`Q3n)imb=# zM4B0_N8HUj{7%=0nO>`r;eygCS>dbh_w%=F=bTl!7t%}geANP2VHgDk9ZMHAu(E~Q z;o%9sc6J=k_MVk(%zA2{bKJ?@J7KhRmpxUo{8|Rf9|S&Y49cTS(NxsY38kV1j=EeL6bDNu@ zf>e7Hyd&RcagsW9wU77)0b}t`s6p41>H)bfI@c!SD0pR&(d^#ojVO1yBYnp4&lNw* z3M@qN{%XmDv=c3#E1cH+TSR4IY3!c&UYxduySOm#qBYDOa<@X)g-aNw)?fl=uW0C_ zwS?Q}o^m8ab}q0@;M5xp;tRlTY2I9PH^INC2BWEQm#Jb#$|_uu1Tu-nt_#p&>lTBM zWB=*{k6RHYNdnUQGfTlg;#=zJnU9wYN?Sz^x~AT)eRES7{{49DK5M|*%z`szz#01y z(!-YV^O*VJ<;8SB-Q@t39|UVp!C${b3Qk_eWKvv%x+zW+Tv|uZpCEce9mROQF@C=H zg+;c@@?ng)io!$v4@_=-oCb!t`!o7IL2pXTnLg&vY~q^m$Za^P;O*9*OY8NI|{_K%qa#gmQeQT%%Xc_B5Zpn#G~@3bbo5mQ=&%RW|%nb3L$Y8zgw62$pv5oML^;?FwlSXdky)) zPfn}`d`CPt^~uIyv62I4)Lcp4kG9b#klTt}m6s~7Jk#%*X5Pf~&Mwn7y6ykhPUVyjgBkadIDF{IG&=DHQoCbx&=%Nx>dYEAqhjM$}UVBjvC{8fuZC zU_xY3kpton0=i%Hw~gW1BpkKjj_|?)lCYnB1PS5{L|^u{hfU|oNx(yU=Nuu$FHj0`MBh`Y($83UPD`=K^osq=QN(*hR#j}d%s=xAq3A4#9~%*N zlJMM}i?WrSY^e*!S%clYL_I%|78!WohdiJS`l<8rLD$<~v9V}<;)R3~tsjSmCjcWR z=qz?ivZP4|c=kA4%MGAorP~W2xin?ROa~7O3d)Xk*aW&XAIOh2NIE!oa%_o6$5iNR zlg(f)x+pc@6shEOqu)?_)=ue!&OL~u`b}R+O%~U5Yvaj6^PZ}#l6bj?n!w2|F)E3f zI|Cg%zhADqaC!_{OnLwS!hxxhx1Df|Z@kx|=LMXPP(*x4lAv^|EYsE1BTfARtMru2 zRu@$cU%1XofWKHzL7?$-0I;%JETM{zpbQb#^~|u+k+gUIH}HxzHjbQ z91#%%%L_@um8d;2LKiEsJ0{}Il`;3mxLO+fVk+Rt#Fu$t$L*X`5`dMH9m~*n8AX8s zi{aC>PfcShnc^vzXo;xeI=R<``b(3t7EWvDF6M&$g4PztkDXEZ{ju|SE&^ZAZZ3mc zej1Kf4oFZ{Dfy#|(G-hn;Qq;@_dCwuiRjj-$-9F@-|OW~z3zou=~SLr7E>%`S74o% z^U7TDXRqdYw5t)G*B!N@qmux;`YnEx6cpCLv6}9dosH+OWh% zVUhvUu1eIyqsHJ^r@`*7s&k>{4l>{Cgl%8^E}Q%pPU13o4oZCtPhERm1zLYNsNsjT zg}<@K^5#yre70J;=h7qm@pZWn&d|f7a8840MY9l8mN(!Z%W9=jLmJ%-E74M>VEvs| zqQ1XiaB>90$S)Z&o2TRn;fT&H3Mv*n8XZHwVGYsw!P!q!KhLzpRM}D2B@D7nufBP( zKYLg6$CHs1sbiW@^cAU6qGIFZaaLV7r%8#?&y;G8aMvib((N4Ec@8^)ali4&1Ka4V z9fwgZlu5HT%Ya?{*CWcCa%1PdbG(EhoGwO(1!4IpF4V#pW=6y9v^RFA;HziSd`81Y zZ`4ZW=L{n;M{5|C@AxH{Fw)}i&*JLV@PUg^P5F1DF*AI!k<0-=;R zFxMU*73!%qq8H^h2!4)P?40o!3eDfDv3J`t$-C;wST|N<>?Bo@3R8m@3Etx1OWHs3 zEO&b`)%<38mJ?nTvUWe_IsXGQIh*&)QMBP1x1wW+c@&on`VLaUfDpaC(dhZr)|cp{ zV&>(U>*mJc&7`9*dDeoVH&%=EP6~F57SR^40vwClMTp>H$KL~4R1A(JeNT^}iL1&G z;~O*qgCZBDd38=T7=?wKIUldD5q})=vZ;0l^bYT}J(gQ!bP``d^tvo$C1_(A+wEBm zBIHItKh*x}`pc?KlA-&pUFuXMJW_)R4Due6Vah_x)NJg4%d7$dL`*oGHJ&YmPulDQNfdW zK5?9NZoS@jH4KH|IkVJ9;vb$KNkBMb^K{|kvWD;E6GiWubEfK68`u3hTDxguvxOAb zs5-Bi%=drS9h=R`w#q%SrG>z&OL%;Y-ZovI>slqTq_qNnyVe7W}trpjkdA@(+Tn zzt@8d#|EMQcm*3Kb}Q@n4gilM@8GF@O<+G;F&8mHcz=yQ2(H0aZAVT1`3hKvLNRPa z{0NVezykZg9|R(oom-N~^AjM-0A)*-())k9;@^EYL;-GKpW^?dukQ(=dsP>no80l6 zXWTkt*^+o1U8LWmlU(H`wWU*}G*fD7ky>e32ld52Wdz(Il>Vk*W;_!j?<(lLcykm7 z%kFN!)7vLk7*8n)0bq=}e}gd|EmQz(MDXGTFzW=+G=Gi+CWU_aud?y}C10Rn%8ws- zOhc%veuZN~vw)TZs@JII=e`BACML}Ws|1I8!|bfi;5e)?Knl$$xJ-a;+$@Kt;8oQp}X|;Es4%U5(bvd9DMj;|D;zSVw8& z7IE)^A+t$93wSs`>l}%ll2G#egTUGnxjuu_&HyaRv61*7E-Wm5>_2@E+q99;`6=@5 zUvK!&?(AQ8>94i)FM{r`rSaF&_-kqW&qL_HJs#}X&^GnOsx_4ko=k@@lXae)OFkeW zlAl7eZ6hgRBUVU?Lm4}qqC|KrFsTjI%dAV|G0W=G&Wc#^*kYu^CER(ApMh;WYi?~g ztXEE}AmQVZxL_?{Lffz0Pe$_%q`H2mUG$tC=bOdJ0etv7Pw*{o0X{qtG}t#ZG!~~S zI(%^gWO+|%c599#)8+rn9RNR+zvm7JupuCrEZhIT^zneQ!LUV>JZow8im=m@c7d|` zNHon%d0Xc|Idux+FSsMo5HpPpPb%3khGbcPO&!6=2RM;S~z;G#D(5_Ht%FH(a)C`z<)=)p*jC`>4^HAmY1NONO zvbKSP@iB_%Y-~Ixu@g^^St#-@SX6WJ&7bQfi8wNl_^dLf zZ~|?|^4OE-H7&?;O5k+H_XDXW@Ch-Cd~?hWhtGOONMC{SpxjYA*yzb{!#bZStbp*5>%3(Mb$HX zxc1ud4+5K{v%@Qgl;07%>sJAxUq;Ob&}^R;XfQV6751q~3l)W+UKg8GU6bZl@X@(h zc%SuL8N85rrTnpQdh{-LM*uyBHE+d&;^_rqIJ^`m;B{Kkz!_%Tgs8WD5haMZxkN}S z#g5@|oLkU1M&cB};WCGa8h}0l>tvJHF`tGlvE31C!IzW`_$B*Tgu>Gnxz!^Uh`;Vp zDn1YExLRkEBKy@ZGpJJN$BC&;qS+5C7xW0h$>ahO<6+Pr1OWuzVW*r^}yC8yA0hi?f2K%~O?1As^K3-~q4DwB28=0FgcZ$~?( zMAP%#gC^JYrK*yx^S3I3xNEXYYD7zMU%5zJer$!VDS{-lH=C#e@_>KRn!0? z()=#Qv87aN#00Bt(ljPm5KJnE$jouTn|6^qCzSTa?z;@?!y6|j&yVW{5fxh5kP1M- zlYw6aX5aE1aCZ#&6Kah+vL6h8Iw>iW3mkq^Fh98N`c&RHnL5USYWVa1mIxn}F4h}e z#`LUi@`QqHn^sz^XOUZ{p)y&<+sl8xS|nI%H)zn8H7RErOV@@MsXP#@!TdpBFqZN% zbyg`+%S`%Ar@kpcN%%+gi)hymcL33YvF9q8v+yry=u1p~(2`JivWab^o=Ms(R4IPI zzZlx{V;3QO1Jh?Lpii@G{iR-&*87dpI=+Zk=HR zw(5@bgHv_|Ob|Aa>L&!PFfGB>{MnWV$;~fbN0{~bLZ1{Cn)#^tfOCO0s8hP@0>|Or z_}cRxV*DM!S~h9Dv*M~3%|4(2mFMntE60ye8AHpZlyiuJYcnzS*Mi42-0oU^3OOHF zwz?tcoY!Pi%W+T;itwi}8hhJ>Stu#9XQjp*=9>I2KCP{LNb0B!C^OU;I9mEqHH?uPH;tq`sljpL4p=6lB)1Hv09R1Qy206y2iE(b^q|z^Yv(iSK+6{l@=Ufg;Q0i%;sp=ua zvyC-d=i-zx=D}#u@g32!fGHysB16lWu$v|Cr@<4uO#g$1xDzC+~1{ zajkXPYw7~qlTIhj%bQmp5*~0= zusFL!EL&po>pXl5raN=CsLZw~{j-M_WDM;D-<`KY$H^LTv3-5#+TSbkcby=9EC+m@ zCRU8Yp}VbY?+r|nGCpIVfgQ``dsbEHYF;AGWvby7ADTY29ijrA-(n%a>4F~qWGgl+yw>em*e5^v}N_%S8f)JJZjOLtPe<8GXXlzzH z**Xbe?Xr+{Ydn5?IVPfohPD^SCO@$=E14ads#}D}`D{X?(h^z+x$!WuDO7$frtICa z4ysu{+YVg*3-oL2!mPFIW=V0~w53sQq%U#1TarhDtRT7@${?9HiN9;QnW`LJYJ^RE zIt4e=!fi$tPMd0w8JrRD&OWY>c&Lb|bL6WdNT0H%2wufTV=CGY@8~IwolxA_lJH@! z^Jy8&Ys!J;f$qnJyrjKU5A1!@wtll#)>|}_9}8J_BEv?SU_Qz7<7cNWMM2w=r4FST zBwzQUzhClu!}tSl;&_LA^n8$BjpzA5i?rWjz~7TsZ8Km9UnGMRFx-5XFs5J&coy50 z*&+_|gG%0S7th+6B<)47|Cn*py5xvoNtN{K0Y&$9`A%_LVVSrMBSRH7d-e^L+KI!t0hy>rTd0o&yb5VU~2@1U+br^*_r z+j)$WWJtYyY_SL1L+m6J>M+|20Q@xQ2F&L8iGcX9(a5pCo*}%N0ww}UUGDA*W4QnI zp##~Te^6D|qLyP8h6c&&?|JrKhAJNk>0~x2P9nU}G8z0N9uL@+cvxY_r4Lk^$%l!zTri8ZCX@HBq z$&tSXHuI|YzpSho!v-jw5l9_{N6DFRS!z%ZKc!2%0m#vs!CM?W`X9O7)E9*dkaol0~8| zl{iFJ?|@CSsv)sQppdDIuIsU>CWP+S@9T;pGMwgCAMUK;n%bS8L=0ksm*tquu&^a< zGCO&WQF#Bm$$i}Mq~9CcB2t=E9%HlLfuj1+QMyzJQ$7iSCbh zaZl(wR25ihiqd3mFu0o2rR_JkLGb9yfmVt{TX-||!lNj;8_LMgYzLc4{dY(;c0OTkKvv{%VWf|#XadCJ8@@a7>_q+50j@52jR_4eqI&-Fp zT{y$DFDGiHTpEUC&h?+mQNXZP@Vnl{TOJCbsq(Q!7WRyg-PR&}u95m)KR(t;a)E)4 zjq9iXlObQrEN^VtN}-^mEVu&dgui=p1To0A)9)>aaKHE*C(Q$Ls!Xe$=C>lVA&T}4 zB&kT;(rZCkU?fl%bp>85x`}wW37}BJP#TK*)4e*NEpRHZGoX{s{O&ya23`}Km;5|x zSx1p`iK=baq}H4p1(B5!OcVO#4jz~?)Su)|JvLL;enulm%Ut2mqrw~nYJ9Q*9KDDu z;?AOMtZiG7+>f%JhSLGKeiUJI-;{(9J$?TYFF(NzTN*X9Uz*e6pi%sF?Ds5VR*o?b z*e(B1rRIqx>HHLa3;Rn+-O=)^tVM=5=~m8ers`M=W8YeY*~9a4gQ?vfN{7pCWXf;v zS(hxKHxy0z3vLk?(tyo=q~=t!4n*uUG!Lsg+n$;kyFANh7SMx<|I`k9VB2*hEa*0H z?`fYo-AgkTgtwoipW*Vx@pLOIP!Vv!8*}-fPIMZVQbB$5zi%!wtbNdHc*+^aYbM#? z4Lfu?*7*IJW|6-RI4x(XE-ScUg1s?Vrlpkd=68hl_v{#JGnNnDc>6TYZdSMCc+(!L z-&O1I>yi69-!4ZkYIkcdjwk7^w@8aKFFWn@`V_KB>qR6qA8y z_j(-Aw~LaM2%-qoX!IdBW;T#a1F+XAn*qgw z2SH#1U}8GkkNv&PvQ{%pZwNw&e*08fFy2n=G|!hOf}TA(l+u2SCJZ!Pc)qhi8pNv**Q-JO&_N@>`oM^LcP0k2L9?Xz5E9U*g-=8WIazJTL zSk_;fm6(|+u4M3>hpyq-?|b{nx|iaPkM5Ss|z{ z30B5Q_7P@YGXsrV1{2lJ!n|e$+#d&}VW9zhwHP!s#EA?n{GR-KioU`~_QZDFkDb4)!b6*Gnz|{`%9Yfk>KA9wz^@;z4ng!Cf!fSx z(dA_o0YVC0!YeF{mu(5Azsy)9?Ke-0_{WUGs>Id(e)iVwRo^&wYm7bj?yugTH9%Y< zmmu!Bb5aTCUZV;w{`K4+TgQAUK;=4~N%n}%5=)n*+lQ|!yw z4r#Hnt>U7|x2ebTQpB7|;2?6)_pYaIZ8YP4v{Pv>nkQ_=Wi@?sp(YD+b6X~wnc0)O zrSH~a#+6HD2X}tG3#1`Ui~x3_sgomtKR%}+*SUR zR;Zh4sZwpvUX!!zkUD`HyDb6D&(xHTMTU);=#Z>JsET*(H}le`*}E%t~s zD<8ad3#W;}3o&m5h$rffy3cE!zR#(h*g-t3&yd{}dF|~e;8j@*@=d(`jpU2|hD&4f zL5*OI2TVa;T-?>7}#*``lYOri$_O|rKFZ%iC`=*=1Zm7VHQwUf=ABiEa}>IV={ zB#z`__iVQ%A!*#g*ROdo<#-Xsh{U>~2l+se$}O0l8rzZqDoxfbmx3QD6pVpC(IQO| zA4=7F9#iDKS7?t7qa1c2#L{(@h&4Y$zn@jDzr$=R>B%HQz3ZsW#(P}hg0TqSZDqp3 zIvC}1&>4aj_w1^mffuA{cXXM)9QUoE%qQfS9YGkKyx5PiR~8kL{QUaV>}SFC*P2G#7%uSGbS1M{#M`z?9; zNe3o9cB9CWTkj-ZtgsraFVFY_iL0JFv2AB8d#Ak_uFpxlsNkpzWI*MAvbyE;rr<<`XB3sMNN}4GmA2_O6wKN zsNDX;*+GS*hPq268!}`RW+Ozmp_uaeiW1L!iA=4g`0_Xw5czpJGMrf2b^T}SSquLqpgluf_RjbE=#qj9m`kD zqzeLDNy}5Xqv0is_v)f7#|3W2qj}16fuStYX;~stBvDV2xWaE((ay%3hZcZYZytEY zON7WOmH&d~Ys%=>`M)!nLY%Yvwv6=E(Ip=;P|t}<#_+`L6S=l)e~nwK0S_DivLH8@ zU?U`*3lKLebZ9O57?@pvk$u#<^{;lQ6B?E>(Fs9b`5ysGM0Q{@?SEykGGX=zay8DL z?G$ineMYl(^3UzwW{0MgE?6`^bR*piznuj8C95D#vx^7L@VJ{_fgGR;wsF1rSxaYU zFP@Xp_R6RGPXzgt;e1Yu?Vq~32*4HUPqo+IT%pw7{Fj|fmUs$WjE+J7eO4prjqi3~ zfcWtdud&B8dA5DAh+ACnSj5zvd`>h=rgVbHR}?Fi0QCI!@0k+usDS}yvLAEInZ$Cg z0P78>4x9Fv`tyf~$FAyh9^HW((W z?*&2Zdc;v9Z;Kbc@fIKC3Jm+X=OE8N|7(7m@RIadn(73tuzc8Q zX|4S``sfjkl9HGJ$hl06+Mt^4fzQ^o2a{d1%<|*2Csic02acUg1scfziFO4eLY ziTS-?wBW$(xS^)5MQV>M+FyXHR#>gaxX|}j&zJ`xPpCDiUA__9e^c%e2L69Hgv-H{ zVN+F;8XQ8dseYsd5!^NsuQ=^r7CwhPahk0s^J`a>QFfJ-cT%Dqt=I+!JlkEvd*OyU zb+F%yw|oq~7YsPrR4#0unm9y-Er0TC@~f72YWBR-waV&D&W`ZkzcL4grqbeD1n{cI3ef?AW6g%; zc9a`E3mO7KnlZhD)d)beX1TZiBYFsv6L8Jx%TnTG^I-%p*PBy(?LTrA{)=3Me`>Po z{UiUN6q=8g^aGcc#!$KClQNT28%DC7Gb&(UyS*Dg8#+NS>*^EoO58B}`=u4z(SpL| zj?QVH!g@38>{rEm+)ipl=x!Wr7*Lb$SE2%6zBVFSEoGJ?H{q#DgvbsAh>PqW^)L_|2c-*KZ4+|kN)e1{2#MII2J+K$xrV0 zTDGMUY`F`ab25fr!2yUd*xTPHBp7g;4SEHDV_6q>D}*YT1hEHfE3oeu+;p(UHH%XU ziori|$k2blA(v0~SpVq|Yw>2weC`%Hfn4SD1$aDJz+ot6P-ee)NYesIWRd}l0C z{gxeZ94YiMH8TfNAW+-%y}x9O5jwu>{!VnjgI`I5pedVjucK}NiMTUu7P8lyHfkmw zi&^htMD%2`y=U%13Ql$vYWck^tr&``Zzqe1M zKq;x?Z;ek5Nzf?IxHDGxUi-75p2J4#ffn2NNx^VvP+7HZvw}$D5&3PC?mCPB*^R1C#c2hQ*vQNyp z-YcrbC12*$Q9NL@N#nA{?srVh4ViM^nf`BfU=71uRrkjTmRQB`fC;a6=>Mw zzvAGpIQV}r4rc1YnuY9^wy%WLnh1YBuNJ6guHtB-*f!TwqM82Gp>m6Xr@yJG_Dmio zH(X*n@ju%84ydNqZQWR~fPkO~C=wO05Xu$=q((uSQ6eCr2@w%7#1IgWPEZsCY0^{# zQKYx15IRIex_}5I3WnYh2qlyd;``Bi&OZ0ux8L);ch1}Q-fcN1{JcJbc2MJP&* zj?5esQyAzliW)%?C}Doj3qalq|G1Q^T8qNXqWd4T=5_;-l<_X<1S5Hx>_gmvBHTpX zNz@J}mlgv_-t8W}I)%#@N{5>ljxSeN#}!#7dFR!~JQLh^NGe;m)aL@_n{j{DEO)|v z1zBi0zxA1yTMphh?!2sCyRTQEUm<@WLdc;HmjhY!Em`Lqb1mQVxd!`iG6 zIsHB!QkYTfQ^F@J&ap^CZGlt&E8>v#WB*kdfr>pqiu*p`9AH~9Tc-qqTKD&Zgq8oV zP{DIy2b`EiKX{Ws+6;J;I&=Tl95K7W-TwwMcmH46!@SkN}Tup?_7z%H$NF_ z4tuw3P=OV!+Dl+@O@?}*qP%lqY-x#IQ#uuRGiOG;o;TjWvEjriwsoCdJtQ07fk82zE#SZ z*JMj{9w{shKlI{|_A_zO3kL>+d5vfsuFPGg38#p@99`-(7Dng?(`G` z)ShP>)AR*imn7cG5T1rTrH|GoBC8AIBE$A+b%@q3B38E(r5dou#19n3WHsKt`P~1a zzmCpt$D}Iddd6El-SGWuThy-%(fG0-U^LnVpP5zm_S`th)5rzed9wLTH0kA+HKrv) z#1Ga)25IhF)e3AsXn$7Icj-gG_Nh+sDA8v-8C;~eW9CyY=X;PbI;kV7zlkK+Zo&&Z z>L=XO;Gbp1b1#NzKFtZ*` z)pltQXq;kLj`=fFQj|JB+_2H=UODm0PR|ELW>I3xv@Elpu{n&F;)9pw3@C)hZ)eqbm zvDxi>7j`VTH}1xi#G{X!nw=FzPm{cZ+jX~1X&BR++BsHO%>MUAF@n3YvRxxZWImcE+>wv2LB)47mw{l6#Ih$h z0lgyk9WrE)w%QL5d|LbFI@2z&%eSwHcvsUj^b zFVGH4*_h26hd-$n1>2f#D|T*)qY{N)z^YI{sK5 z&c3in-pIRak@7bw^3go$0F>j6Z6fm}WGK1od z_k(rgXyHQP2`(4!Uo9l_q*N4lyvXmARhZF4by&Nj+kR+uSRNwP8pFIsbnB-eiWi<%PynRX zcICj$I`O&&6LB8rx0xr(nxST&3U;{zIhf3<{*{9W%jOGRHBxt`W_N$uYII!q>+UzB zTrI~DAR7HdZtxv;Ws}R;H|DDPeeFofu5Bsk{W?;@(j56KnNg5NTQP|k*J*Xkc>n%e z2=DH@ZEk{h8lK3cTAFjdZCVOQu+f|5Ic{As0O$MMH6iGJ%OWpvcNhp;Uj^9sT;1pv z1JlX*b}6w!PG3@PyGXl_`am{*S-1R%dm7=L`eLFaZLnCSHdDPI5;3AG?}?BMHmTk; z_cFR({kT4ZT}op5!9B>t5;&Ev)>;MUW#IQY+%mK@x6VscXtX?^seOH}ddt8Tvrry6 zp6vo#1Jw4r52E*&kKOVvZy4^Hm$G}W$NOQ3=PiLb+2L~}v%9yKrQV4v*G?N_-g>y2 zJ$Y>AUfCJ8xBRQngwp!F^3d=Prv$2eU>(v0y&-!QXw4r`g|BIQJclC>9j(4;M(03< zpd?t*MA?p33X40_Y{KHMqJ<;T4P%!i=bfm~=gOJ&!Ah?CHz84^=Jr~w%6#?S+N3nC z3>rp>(&h7cE^nmJHRRl!Vu_IQqCzLYFTl`2ig8g^!6xOWsDg@!qrFm^;*d9^637p7 z9(noi_ogT=RjN`P%XMwDFnc?59)A8(?I9kg6Hl^@#ww3JpBhS_t5Ez>Q+vj!Q5Ft+qCeB> z!swUYx7C*j3!@<6FbV@NQo0;aJA)@)5mtk973-4Q9JQPO+1U9*c+)-{bD#%pfr;k{vkKv;r>Y%;XcHjB#a2C$7yNh*6%WP9F^ zFKIG%)>C@4JVRc%$H77e@y$sFUKigi+nNXHokyKN%v6`2EnJyOIQ8YEkPl96m71zS zyy3S`DdfY0wb#;-^rmC0AKu=v0}+B#W|CJ&r@~X@vYyZB0pkHKVV06_sy-f{CebHf zICe|d5jS6=sKKMhsW>ExK_I%*St_fYxf2Sx07cs8XYd{3Jc$0>bvr?8abMEO>cxl9 zsP0fp_m#(WwC;Jw@o+EW=>=}1ceSwYM8)Z@7NhL_?_bH)4rRD)xL?&6S^ar5)vJcM z=t_Ns9ku$DOaj4*c@Ao8nW2;8o|+fOh1he6Z~G!Q03MoCc}E7UNo(1j$+`k#Wrc-p zIW{KY7smH(6ZD#Wd+@>EXKcP|o#k|yzy7nf`g7n!nT$eN%|w$TUft`LPSy_TJ&?YxL;UtpAALZ22!Drsgp z>70b0qnw|)r%<8DRE1USyFe;`xFZ;^o}Civ&u?~2_yEMfH_S_6G~`=3V)o`hui;Zf zVcR34k|@~ZQJVsc^N6SSbn>ZHp(&0cQ686`QV)e@RZ!BntD;@ecA_a!5vPaXNy^%H zuSm}F+96SWk%UN36s&mgj$TgtlJXOr_t$LZ*V+6&*5Iao zTEi_B(lwv--6Evj-)S{Oza23^iWF6#+uUd}T)AAgUSRgt_~z!1xNQ*V-zewVcf8MQ zF)Qu?5Ygr$B=wzhV^;A+T-Ehwq;mz4rP#6<(>oiuJfpIA0G zyl>YL*}7h=n?rxvApK?6zNE&yK5=Eqz$=`2^pDn@Vdn}6~h((&7O zh?9Ej8l6<|W25sDO@F^k?_9g%PW0Rw7wf@O~|Vd4H#z zZQ>j1PbSa5|2S^pM!QeNO_Q*2PKCQguPz1h>rt=26B=rr;e6liXXLSU|FOo#87k=f zlqJtNQ<~amhrdIVmVA4x)eaIB!aB#=6n5D=e2D(arLR_OZXl#;%XxZ&_bdXxZL+A4 z{?&4<^e+9JiESLrT=-Jqt$PP9M+bzuRV@%f^Nq{%aY_%g7)v{Hwa}E$iZ)^KKG=E3 zoacjK=}P(wo{Q6Vk~j4)WAD!DhSpcqCQ1p5W|D5T4du8?&Vv@21%07aSkkURCSW*Xgwg6~z?t zTYkRIG-1Rg@!n4(@aanoRbF(ewbeK$^|>!#6rvi3wwRr`=SQXzYRA%XR7N+w1Mrq# z`IXw+-+j*F%#UOq%o0sMM78;dI66p4gLyzlg>@SMm?i5(ejOm;S2(Q+RDeSK7-o`f z0RmB3_~g$@;l~Sr0R1iaeUM+->Z#u$!$B-ACQ2JS`5iJ>&E{Bx9m*80cn2cv$mIWs zn%iV)Hmj4G_vLe!)rUYz!`Z6Mzv*%wc8(_P-dMLu3UB}_ME^1W`i5NJfkcF18}7uD zH0}0WOCKk#&CVN_yDJ)x%6u03`bC2QzU=A0&ftEL;(pW2s@i2|Xv40phEj+_{OTsR zQKIkpF0`HF=612FoIRW>!G5V+TF}KMIfsb}3fZ1J@D2ivLjZ9BAPF1IS^D!5H!XQCa-YJ}xk& zvX$ju(92wmSl7WE=$zWS0hsWfA0`aS*@u#^MSdM*p#Pl>6aW9&@ZaXAf7<`V>mT7m z96#)cz}!X@Bw{|wuig90e#Vm&rIS;pY|Tf1Nhuv#0CChoRWkG250asdf8Y|pQSo1K z6@SJ#|FgvEmxbRIS0xW)xLe>C0r)nt_a|L~Lp~Uy`m-}Xk+mcaK*4nGSE~en*mw?Z zd;8z*#eZ>S=KuM+i@uxKr!3spymbN8IAk{D-|q*;GUh-iD$8t+ho{%fYlOE4s zoERx^$>~jEdPJ|ox(pt#dwQE+l#Tym+!OFQ|B2;AX95eb7$4o2~VC_uDdj{yp%fuhTL3{YR3aO)*-)?CD&`m`lEeOSTI zE>@16y92Y_KD!G0W_Z{fgb7LhmhA^ z%)BMPgTJgr4yKViF?uW8%j=pue0er2_V|}Qz{OkuF8#mrtG5(X9mWS%NBZ5BemjPf z?0j{j|B5{4(y?fU0^Qell-_Gx9MRuuk5qf;P!x? zE_o!9ciqZfXB4h!j#t>(GUJJ-f7QLOTf=`*7w>z!4wX@l zOC0(nc@b%NWT(d z3?9|X-kGSDM>?@2>PbtLj}{S=oxeB6i(LIiEnn8HF{Q9~w_VXs*}gx969{`}WIRkk z9_skk+l+nOQEs&V{p}?)#@6-(im#gml0}H`=pb|^Wu!}UCm3uAnf^wmM5JCq_AxnY zI!FtL>kJ|J){jYN>ur^2b zLXy_SsM3SRiPkkD>H;+5De~YnlsQIjAwK5e44J``2d63nR!kD**_yWqj5b0d2FHWM z=jM1e3-mS_g{M8>HYIDdj1kYmC%Pw%x(P&dM#_SA)}t}cdjgYlggP>dGXwPEWChLU z3~JcwBVsSjF=1`wU_X)#dw@{3hP4!0#fyEoPP`DnhHq_Wn%Y8H-s!8!4;@mOQ2F2U z?+T^>@)zGc54^FZQa*15TqYAbUddf$T{$-%UC->?M!4#^@76G?=N^EIP^HgSsd} zIk_bQoBGYQTspPsgP)%v`UQDj_Q>j;6wn+H0oXlh0%zUj5=Bk1Nr@e%-QOX*$wSCa z_+$h_VD1}X(sWWQF_fn2c2W{H*1LgF4`p{Ht#M#;ktL=s&qnJDOxxHBY-lzVx}&#=Mi2n48b|w0$@EeuqHYKwd0==^M>-{Oqm~(^sR@qNlaJ%i(i8p!1yN1;Ti$0U$! zJdy<)=Yp5Ge1}|$57DT|Eg?XcH!$$>BTU#tH*rPq(02%diGsPY;JFgv~;M^XeYd48Oqy+c1bF`G#UMAsX1@S=m65p;EgfP*y=(#OH?6Qb8 zj_h!O@%~wj9+Ab@ttywoscP3k7F{khv{lBox7gQvFa)M7(7?iLZC%LYBMe;8YDwzR;k3w&+l{OG z7RIp2NFmIF9EV3i)p21QUlAgxl)UbnySba@Y{f(ATP+x6zM63yk}