gbm-sys-0.4.0/.cargo_vcs_info.json0000644000000001450000000000100124160ustar { "git": { "sha1": "2b4047f8e5ab4d050d4ed88f5ee2515069478fac" }, "path_in_vcs": "gbm-sys" }gbm-sys-0.4.0/Cargo.toml0000644000000025360000000000100104220ustar # THIS FILE IS AUTOMATICALLY GENERATED BY CARGO # # When uploading crates to the registry Cargo will automatically # "normalize" Cargo.toml files for maximal compatibility # with all versions of Cargo and also rewrite `path` dependencies # to registry (e.g., crates.io) dependencies. # # If you are reading this file be aware that the original Cargo.toml # will likely look very different (and much more reasonable). # See Cargo.toml.orig for the original contents. [package] edition = "2021" name = "gbm-sys" version = "0.4.0" authors = ["Drakulix (Victor Brekenfeld)"] build = "build.rs" autolib = false autobins = false autoexamples = false autotests = false autobenches = false description = "Bindgen generated unsafe libgbm wrapper" documentation = "https://Drakulix.github.io/gbm.rs/gbm-sys" readme = false keywords = [ "gbm", "bindings", ] categories = ["external-ffi-bindings"] license = "MIT" repository = "https://github.com/Drakulix/gbm.rs/tree/master/gbm-sys" [lib] name = "gbm_sys" path = "src/lib.rs" [dependencies.libc] version = "0.2" [build-dependencies.bindgen] version = "0.69" optional = true [build-dependencies.proc-macro2] version = "1.0.69" optional = true [build-dependencies.regex] version = "1.10" optional = true [features] update_bindings = ["use_bindgen"] use_bindgen = [ "bindgen", "dep:proc-macro2", "dep:regex", ] gbm-sys-0.4.0/Cargo.toml.orig000064400000000000000000000014431046102023000140770ustar 00000000000000[package] name = "gbm-sys" version = "0.4.0" authors = ["Drakulix (Victor Brekenfeld)"] build = "build.rs" description = "Bindgen generated unsafe libgbm wrapper" documentation = "https://Drakulix.github.io/gbm.rs/gbm-sys" repository = "https://github.com/Drakulix/gbm.rs/tree/master/gbm-sys" keywords = ["gbm", "bindings"] categories = ["external-ffi-bindings"] license = "MIT" edition = "2021" [lib] path = "src/lib.rs" [build-dependencies.bindgen] version = "0.69" optional = true # Specify version of bindgen deps to fix `check-minimal` test [build-dependencies] proc-macro2 = { version = "1.0.69", optional = true } regex = { version = "1.10", optional = true } [dependencies] libc = "0.2" [features] use_bindgen = ["bindgen", "dep:proc-macro2", "dep:regex"] update_bindings = ["use_bindgen"] gbm-sys-0.4.0/build.rs000064400000000000000000000061041046102023000126540ustar 00000000000000#[cfg(feature = "use_bindgen")] extern crate bindgen; #[cfg(not(feature = "use_bindgen"))] fn main() {} #[cfg(feature = "use_bindgen")] fn main() { use std::{env, path::Path}; const TMP_BIND_PREFIX: &str = "__BINDGEN_TMP_"; const TMP_BIND_PREFIX_REG: &str = "_BINDGEN_TMP_.*"; const INCLUDES: &[&str] = &["gbm.h"]; const MACROS: &[&str] = &[ "GBM_BO_IMPORT_WL_BUFFER", "GBM_BO_IMPORT_EGL_IMAGE", "GBM_BO_IMPORT_FD", "GBM_BO_IMPORT_FD_MODIFIER", ]; // Applies a formatting function over a slice of strings, // concatenating them on separate lines into a single String fn apply_formatting(iter: I, f: F) -> String where I: Iterator, I::Item: AsRef, F: Fn(&str) -> String, { iter.fold(String::new(), |acc, x| acc + &f(x.as_ref()) + "\n") } // Create a name for a temporary value fn tmp_val(name: &str) -> String { format!("{}{}", TMP_BIND_PREFIX, name) } // Create a C include directive fn include(header: &str) -> String { format!("#include <{}>", header) } // Create a C constant fn decl_const(ty: &str, name: &str, value: &str) -> String { format!("const {} {} = {};", ty, name, value) } // Create a C macro definition fn define_macro(name: &str, val: &str) -> String { format!("#define {} {}", name, val) } // Create a C undefinition fn undefine_macro(name: &str) -> String { format!("#undef {}", name) } // Rebind a C macro as a constant // Required for some macros that won't get generated fn rebind_macro(name: &str) -> String { let tmp_name = tmp_val(name); format!( "{}\n{}\n{}\n{}", decl_const("unsigned int", &tmp_name, name), undefine_macro(name), decl_const("unsigned int", name, &tmp_name), define_macro(name, name) ) } // Fully create the header fn create_header() -> String { apply_formatting(INCLUDES.iter(), include) + &apply_formatting(MACROS.iter(), rebind_macro) } // Setup bindings builder let generated = bindgen::builder() .clang_arg("-Iinclude") .header_contents("bindings.h", &create_header()) .blocklist_type(TMP_BIND_PREFIX_REG) .ctypes_prefix("libc") .allowlist_type("^gbm_.*$") .allowlist_function("^gbm_.*$") .allowlist_var("GBM_.*|gbm_.*") .constified_enum_module("^gbm_.*$") // Layout tests are incorrect across architectures .layout_tests(false) .generate() .unwrap(); println!("cargo:rerun-if-changed=include/gbm.h"); // Generate the bindings let out_dir = env::var("OUT_DIR").unwrap(); let dest_path = Path::new(&out_dir).join("bindings.rs"); generated.write_to_file(dest_path).unwrap(); #[cfg(feature = "update_bindings")] { use std::fs; let bind_file = Path::new(&out_dir).join("bindings.rs"); let dest_file = "src/bindings.rs"; fs::copy(bind_file, dest_file).unwrap(); } } gbm-sys-0.4.0/include/gbm.h000064400000000000000000000410301046102023000135450ustar 00000000000000/* * Copyright © 2011 Intel Corporation * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice (including the next * paragraph) shall be included in all copies or substantial portions of the * Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * * Authors: * Benjamin Franzke */ #ifndef _GBM_H_ #define _GBM_H_ #define __GBM__ 1 #include #include #ifdef __cplusplus extern "C" { #endif /** * \file gbm.h * \brief Generic Buffer Manager */ struct gbm_device; struct gbm_bo; struct gbm_surface; /** * \mainpage The Generic Buffer Manager * * This module provides an abstraction that the caller can use to request a * buffer from the underlying memory management system for the platform. * * This allows the creation of portable code whilst still allowing access to * the underlying memory manager. */ /** * Abstraction representing the handle to a buffer allocated by the * manager */ union gbm_bo_handle { void *ptr; int32_t s32; uint32_t u32; int64_t s64; uint64_t u64; }; /** Format of the allocated buffer */ enum gbm_bo_format { /** RGB with 8 bits per channel in a 32 bit value */ GBM_BO_FORMAT_XRGB8888, /** ARGB with 8 bits per channel in a 32 bit value */ GBM_BO_FORMAT_ARGB8888 }; /** * The FourCC format codes are taken from the drm_fourcc.h definition, and * re-namespaced. New GBM formats must not be added, unless they are * identical ports from drm_fourcc. */ #define __gbm_fourcc_code(a,b,c,d) ((uint32_t)(a) | ((uint32_t)(b) << 8) | \ ((uint32_t)(c) << 16) | ((uint32_t)(d) << 24)) #define GBM_FORMAT_BIG_ENDIAN (1<<31) /* format is big endian instead of little endian */ /* color index */ #define GBM_FORMAT_C8 __gbm_fourcc_code('C', '8', ' ', ' ') /* [7:0] C */ /* 8 bpp Red */ #define GBM_FORMAT_R8 __gbm_fourcc_code('R', '8', ' ', ' ') /* [7:0] R */ /* 16 bpp Red */ #define GBM_FORMAT_R16 __gbm_fourcc_code('R', '1', '6', ' ') /* [15:0] R little endian */ /* 16 bpp RG */ #define GBM_FORMAT_GR88 __gbm_fourcc_code('G', 'R', '8', '8') /* [15:0] G:R 8:8 little endian */ /* 32 bpp RG */ #define GBM_FORMAT_RG1616 __gbm_fourcc_code('R', 'G', '3', '2') /* [31:0] R:G 16:16 little endian */ #define GBM_FORMAT_GR1616 __gbm_fourcc_code('G', 'R', '3', '2') /* [31:0] G:R 16:16 little endian */ /* 8 bpp RGB */ #define GBM_FORMAT_RGB332 __gbm_fourcc_code('R', 'G', 'B', '8') /* [7:0] R:G:B 3:3:2 */ #define GBM_FORMAT_BGR233 __gbm_fourcc_code('B', 'G', 'R', '8') /* [7:0] B:G:R 2:3:3 */ /* 16 bpp RGB */ #define GBM_FORMAT_XRGB4444 __gbm_fourcc_code('X', 'R', '1', '2') /* [15:0] x:R:G:B 4:4:4:4 little endian */ #define GBM_FORMAT_XBGR4444 __gbm_fourcc_code('X', 'B', '1', '2') /* [15:0] x:B:G:R 4:4:4:4 little endian */ #define GBM_FORMAT_RGBX4444 __gbm_fourcc_code('R', 'X', '1', '2') /* [15:0] R:G:B:x 4:4:4:4 little endian */ #define GBM_FORMAT_BGRX4444 __gbm_fourcc_code('B', 'X', '1', '2') /* [15:0] B:G:R:x 4:4:4:4 little endian */ #define GBM_FORMAT_ARGB4444 __gbm_fourcc_code('A', 'R', '1', '2') /* [15:0] A:R:G:B 4:4:4:4 little endian */ #define GBM_FORMAT_ABGR4444 __gbm_fourcc_code('A', 'B', '1', '2') /* [15:0] A:B:G:R 4:4:4:4 little endian */ #define GBM_FORMAT_RGBA4444 __gbm_fourcc_code('R', 'A', '1', '2') /* [15:0] R:G:B:A 4:4:4:4 little endian */ #define GBM_FORMAT_BGRA4444 __gbm_fourcc_code('B', 'A', '1', '2') /* [15:0] B:G:R:A 4:4:4:4 little endian */ #define GBM_FORMAT_XRGB1555 __gbm_fourcc_code('X', 'R', '1', '5') /* [15:0] x:R:G:B 1:5:5:5 little endian */ #define GBM_FORMAT_XBGR1555 __gbm_fourcc_code('X', 'B', '1', '5') /* [15:0] x:B:G:R 1:5:5:5 little endian */ #define GBM_FORMAT_RGBX5551 __gbm_fourcc_code('R', 'X', '1', '5') /* [15:0] R:G:B:x 5:5:5:1 little endian */ #define GBM_FORMAT_BGRX5551 __gbm_fourcc_code('B', 'X', '1', '5') /* [15:0] B:G:R:x 5:5:5:1 little endian */ #define GBM_FORMAT_ARGB1555 __gbm_fourcc_code('A', 'R', '1', '5') /* [15:0] A:R:G:B 1:5:5:5 little endian */ #define GBM_FORMAT_ABGR1555 __gbm_fourcc_code('A', 'B', '1', '5') /* [15:0] A:B:G:R 1:5:5:5 little endian */ #define GBM_FORMAT_RGBA5551 __gbm_fourcc_code('R', 'A', '1', '5') /* [15:0] R:G:B:A 5:5:5:1 little endian */ #define GBM_FORMAT_BGRA5551 __gbm_fourcc_code('B', 'A', '1', '5') /* [15:0] B:G:R:A 5:5:5:1 little endian */ #define GBM_FORMAT_RGB565 __gbm_fourcc_code('R', 'G', '1', '6') /* [15:0] R:G:B 5:6:5 little endian */ #define GBM_FORMAT_BGR565 __gbm_fourcc_code('B', 'G', '1', '6') /* [15:0] B:G:R 5:6:5 little endian */ /* 24 bpp RGB */ #define GBM_FORMAT_RGB888 __gbm_fourcc_code('R', 'G', '2', '4') /* [23:0] R:G:B little endian */ #define GBM_FORMAT_BGR888 __gbm_fourcc_code('B', 'G', '2', '4') /* [23:0] B:G:R little endian */ /* 32 bpp RGB */ #define GBM_FORMAT_XRGB8888 __gbm_fourcc_code('X', 'R', '2', '4') /* [31:0] x:R:G:B 8:8:8:8 little endian */ #define GBM_FORMAT_XBGR8888 __gbm_fourcc_code('X', 'B', '2', '4') /* [31:0] x:B:G:R 8:8:8:8 little endian */ #define GBM_FORMAT_RGBX8888 __gbm_fourcc_code('R', 'X', '2', '4') /* [31:0] R:G:B:x 8:8:8:8 little endian */ #define GBM_FORMAT_BGRX8888 __gbm_fourcc_code('B', 'X', '2', '4') /* [31:0] B:G:R:x 8:8:8:8 little endian */ #define GBM_FORMAT_ARGB8888 __gbm_fourcc_code('A', 'R', '2', '4') /* [31:0] A:R:G:B 8:8:8:8 little endian */ #define GBM_FORMAT_ABGR8888 __gbm_fourcc_code('A', 'B', '2', '4') /* [31:0] A:B:G:R 8:8:8:8 little endian */ #define GBM_FORMAT_RGBA8888 __gbm_fourcc_code('R', 'A', '2', '4') /* [31:0] R:G:B:A 8:8:8:8 little endian */ #define GBM_FORMAT_BGRA8888 __gbm_fourcc_code('B', 'A', '2', '4') /* [31:0] B:G:R:A 8:8:8:8 little endian */ #define GBM_FORMAT_XRGB2101010 __gbm_fourcc_code('X', 'R', '3', '0') /* [31:0] x:R:G:B 2:10:10:10 little endian */ #define GBM_FORMAT_XBGR2101010 __gbm_fourcc_code('X', 'B', '3', '0') /* [31:0] x:B:G:R 2:10:10:10 little endian */ #define GBM_FORMAT_RGBX1010102 __gbm_fourcc_code('R', 'X', '3', '0') /* [31:0] R:G:B:x 10:10:10:2 little endian */ #define GBM_FORMAT_BGRX1010102 __gbm_fourcc_code('B', 'X', '3', '0') /* [31:0] B:G:R:x 10:10:10:2 little endian */ #define GBM_FORMAT_ARGB2101010 __gbm_fourcc_code('A', 'R', '3', '0') /* [31:0] A:R:G:B 2:10:10:10 little endian */ #define GBM_FORMAT_ABGR2101010 __gbm_fourcc_code('A', 'B', '3', '0') /* [31:0] A:B:G:R 2:10:10:10 little endian */ #define GBM_FORMAT_RGBA1010102 __gbm_fourcc_code('R', 'A', '3', '0') /* [31:0] R:G:B:A 10:10:10:2 little endian */ #define GBM_FORMAT_BGRA1010102 __gbm_fourcc_code('B', 'A', '3', '0') /* [31:0] B:G:R:A 10:10:10:2 little endian */ /* * Floating point 64bpp RGB * IEEE 754-2008 binary16 half-precision float * [15:0] sign:exponent:mantissa 1:5:10 */ #define GBM_FORMAT_XBGR16161616F __gbm_fourcc_code('X', 'B', '4', 'H') /* [63:0] x:B:G:R 16:16:16:16 little endian */ #define GBM_FORMAT_ABGR16161616F __gbm_fourcc_code('A', 'B', '4', 'H') /* [63:0] A:B:G:R 16:16:16:16 little endian */ /* packed YCbCr */ #define GBM_FORMAT_YUYV __gbm_fourcc_code('Y', 'U', 'Y', 'V') /* [31:0] Cr0:Y1:Cb0:Y0 8:8:8:8 little endian */ #define GBM_FORMAT_YVYU __gbm_fourcc_code('Y', 'V', 'Y', 'U') /* [31:0] Cb0:Y1:Cr0:Y0 8:8:8:8 little endian */ #define GBM_FORMAT_UYVY __gbm_fourcc_code('U', 'Y', 'V', 'Y') /* [31:0] Y1:Cr0:Y0:Cb0 8:8:8:8 little endian */ #define GBM_FORMAT_VYUY __gbm_fourcc_code('V', 'Y', 'U', 'Y') /* [31:0] Y1:Cb0:Y0:Cr0 8:8:8:8 little endian */ #define GBM_FORMAT_AYUV __gbm_fourcc_code('A', 'Y', 'U', 'V') /* [31:0] A:Y:Cb:Cr 8:8:8:8 little endian */ /* * 2 plane YCbCr * index 0 = Y plane, [7:0] Y * index 1 = Cr:Cb plane, [15:0] Cr:Cb little endian * or * index 1 = Cb:Cr plane, [15:0] Cb:Cr little endian */ #define GBM_FORMAT_NV12 __gbm_fourcc_code('N', 'V', '1', '2') /* 2x2 subsampled Cr:Cb plane */ #define GBM_FORMAT_NV21 __gbm_fourcc_code('N', 'V', '2', '1') /* 2x2 subsampled Cb:Cr plane */ #define GBM_FORMAT_NV16 __gbm_fourcc_code('N', 'V', '1', '6') /* 2x1 subsampled Cr:Cb plane */ #define GBM_FORMAT_NV61 __gbm_fourcc_code('N', 'V', '6', '1') /* 2x1 subsampled Cb:Cr plane */ /* * 3 plane YCbCr * index 0: Y plane, [7:0] Y * index 1: Cb plane, [7:0] Cb * index 2: Cr plane, [7:0] Cr * or * index 1: Cr plane, [7:0] Cr * index 2: Cb plane, [7:0] Cb */ #define GBM_FORMAT_YUV410 __gbm_fourcc_code('Y', 'U', 'V', '9') /* 4x4 subsampled Cb (1) and Cr (2) planes */ #define GBM_FORMAT_YVU410 __gbm_fourcc_code('Y', 'V', 'U', '9') /* 4x4 subsampled Cr (1) and Cb (2) planes */ #define GBM_FORMAT_YUV411 __gbm_fourcc_code('Y', 'U', '1', '1') /* 4x1 subsampled Cb (1) and Cr (2) planes */ #define GBM_FORMAT_YVU411 __gbm_fourcc_code('Y', 'V', '1', '1') /* 4x1 subsampled Cr (1) and Cb (2) planes */ #define GBM_FORMAT_YUV420 __gbm_fourcc_code('Y', 'U', '1', '2') /* 2x2 subsampled Cb (1) and Cr (2) planes */ #define GBM_FORMAT_YVU420 __gbm_fourcc_code('Y', 'V', '1', '2') /* 2x2 subsampled Cr (1) and Cb (2) planes */ #define GBM_FORMAT_YUV422 __gbm_fourcc_code('Y', 'U', '1', '6') /* 2x1 subsampled Cb (1) and Cr (2) planes */ #define GBM_FORMAT_YVU422 __gbm_fourcc_code('Y', 'V', '1', '6') /* 2x1 subsampled Cr (1) and Cb (2) planes */ #define GBM_FORMAT_YUV444 __gbm_fourcc_code('Y', 'U', '2', '4') /* non-subsampled Cb (1) and Cr (2) planes */ #define GBM_FORMAT_YVU444 __gbm_fourcc_code('Y', 'V', '2', '4') /* non-subsampled Cr (1) and Cb (2) planes */ struct gbm_format_name_desc { char name[5]; }; /** * Flags to indicate the intended use for the buffer - these are passed into * gbm_bo_create(). The caller must set the union of all the flags that are * appropriate * * \sa Use gbm_device_is_format_supported() to check if the combination of format * and use flags are supported */ enum gbm_bo_flags { /** * Buffer is going to be presented to the screen using an API such as KMS */ GBM_BO_USE_SCANOUT = (1 << 0), /** * Buffer is going to be used as cursor */ GBM_BO_USE_CURSOR = (1 << 1), /** * Deprecated */ GBM_BO_USE_CURSOR_64X64 = GBM_BO_USE_CURSOR, /** * Buffer is to be used for rendering - for example it is going to be used * as the storage for a color buffer */ GBM_BO_USE_RENDERING = (1 << 2), /** * Buffer can be used for gbm_bo_write. This is guaranteed to work * with GBM_BO_USE_CURSOR, but may not work for other combinations. */ GBM_BO_USE_WRITE = (1 << 3), /** * Buffer is linear, i.e. not tiled. */ GBM_BO_USE_LINEAR = (1 << 4), /** * Buffer is protected, i.e. encrypted and not readable by CPU or any * other non-secure / non-trusted components nor by non-trusted OpenGL, * OpenCL, and Vulkan applications. */ GBM_BO_USE_PROTECTED = (1 << 5), }; int gbm_device_get_fd(struct gbm_device *gbm); const char * gbm_device_get_backend_name(struct gbm_device *gbm); int gbm_device_is_format_supported(struct gbm_device *gbm, uint32_t format, uint32_t flags); int gbm_device_get_format_modifier_plane_count(struct gbm_device *gbm, uint32_t format, uint64_t modifier); void gbm_device_destroy(struct gbm_device *gbm); struct gbm_device * gbm_create_device(int fd); struct gbm_bo * gbm_bo_create(struct gbm_device *gbm, uint32_t width, uint32_t height, uint32_t format, uint32_t flags); struct gbm_bo * gbm_bo_create_with_modifiers(struct gbm_device *gbm, uint32_t width, uint32_t height, uint32_t format, const uint64_t *modifiers, const unsigned int count); struct gbm_bo * gbm_bo_create_with_modifiers2(struct gbm_device *gbm, uint32_t width, uint32_t height, uint32_t format, const uint64_t *modifiers, const unsigned int count, uint32_t flags); #define GBM_BO_IMPORT_WL_BUFFER 0x5501 #define GBM_BO_IMPORT_EGL_IMAGE 0x5502 #define GBM_BO_IMPORT_FD 0x5503 #define GBM_BO_IMPORT_FD_MODIFIER 0x5504 struct gbm_import_fd_data { int fd; uint32_t width; uint32_t height; uint32_t stride; uint32_t format; }; #define GBM_MAX_PLANES 4 struct gbm_import_fd_modifier_data { uint32_t width; uint32_t height; uint32_t format; uint32_t num_fds; int fds[GBM_MAX_PLANES]; int strides[GBM_MAX_PLANES]; int offsets[GBM_MAX_PLANES]; uint64_t modifier; }; struct gbm_bo * gbm_bo_import(struct gbm_device *gbm, uint32_t type, void *buffer, uint32_t flags); /** * Flags to indicate the type of mapping for the buffer - these are * passed into gbm_bo_map(). The caller must set the union of all the * flags that are appropriate. * * These flags are independent of the GBM_BO_USE_* creation flags. However, * mapping the buffer may require copying to/from a staging buffer. * * See also: pipe_map_flags */ enum gbm_bo_transfer_flags { /** * Buffer contents read back (or accessed directly) at transfer * create time. */ GBM_BO_TRANSFER_READ = (1 << 0), /** * Buffer contents will be written back at unmap time * (or modified as a result of being accessed directly). */ GBM_BO_TRANSFER_WRITE = (1 << 1), /** * Read/modify/write */ GBM_BO_TRANSFER_READ_WRITE = (GBM_BO_TRANSFER_READ | GBM_BO_TRANSFER_WRITE), }; void * gbm_bo_map(struct gbm_bo *bo, uint32_t x, uint32_t y, uint32_t width, uint32_t height, uint32_t flags, uint32_t *stride, void **map_data); void gbm_bo_unmap(struct gbm_bo *bo, void *map_data); uint32_t gbm_bo_get_width(struct gbm_bo *bo); uint32_t gbm_bo_get_height(struct gbm_bo *bo); uint32_t gbm_bo_get_stride(struct gbm_bo *bo); uint32_t gbm_bo_get_stride_for_plane(struct gbm_bo *bo, int plane); uint32_t gbm_bo_get_format(struct gbm_bo *bo); uint32_t gbm_bo_get_bpp(struct gbm_bo *bo); uint32_t gbm_bo_get_offset(struct gbm_bo *bo, int plane); struct gbm_device * gbm_bo_get_device(struct gbm_bo *bo); union gbm_bo_handle gbm_bo_get_handle(struct gbm_bo *bo); int gbm_bo_get_fd(struct gbm_bo *bo); uint64_t gbm_bo_get_modifier(struct gbm_bo *bo); int gbm_bo_get_plane_count(struct gbm_bo *bo); union gbm_bo_handle gbm_bo_get_handle_for_plane(struct gbm_bo *bo, int plane); int gbm_bo_get_fd_for_plane(struct gbm_bo *bo, int plane); int gbm_bo_write(struct gbm_bo *bo, const void *buf, size_t count); void gbm_bo_set_user_data(struct gbm_bo *bo, void *data, void (*destroy_user_data)(struct gbm_bo *, void *)); void * gbm_bo_get_user_data(struct gbm_bo *bo); void gbm_bo_destroy(struct gbm_bo *bo); struct gbm_surface * gbm_surface_create(struct gbm_device *gbm, uint32_t width, uint32_t height, uint32_t format, uint32_t flags); struct gbm_surface * gbm_surface_create_with_modifiers(struct gbm_device *gbm, uint32_t width, uint32_t height, uint32_t format, const uint64_t *modifiers, const unsigned int count); struct gbm_surface * gbm_surface_create_with_modifiers2(struct gbm_device *gbm, uint32_t width, uint32_t height, uint32_t format, const uint64_t *modifiers, const unsigned int count, uint32_t flags); struct gbm_bo * gbm_surface_lock_front_buffer(struct gbm_surface *surface); void gbm_surface_release_buffer(struct gbm_surface *surface, struct gbm_bo *bo); int gbm_surface_has_free_buffers(struct gbm_surface *surface); void gbm_surface_destroy(struct gbm_surface *surface); char * gbm_format_get_name(uint32_t gbm_format, struct gbm_format_name_desc *desc); #ifdef __cplusplus } #endif #endif gbm-sys-0.4.0/src/bindings.rs000064400000000000000000000206771046102023000141540ustar 00000000000000/* automatically generated by rust-bindgen 0.69.5 */ pub const GBM_FORMAT_BIG_ENDIAN: u32 = 2147483648; pub const GBM_BO_IMPORT_WL_BUFFER: u32 = 21761; pub const GBM_BO_IMPORT_EGL_IMAGE: u32 = 21762; pub const GBM_BO_IMPORT_FD: u32 = 21763; pub const GBM_BO_IMPORT_FD_MODIFIER: u32 = 21764; pub const GBM_MAX_PLANES: u32 = 4; #[doc = " \\file gbm.h\n \\brief Generic Buffer Manager"] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct gbm_device { _unused: [u8; 0], } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct gbm_bo { _unused: [u8; 0], } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct gbm_surface { _unused: [u8; 0], } #[doc = " Abstraction representing the handle to a buffer allocated by the\n manager"] #[repr(C)] #[derive(Copy, Clone)] pub union gbm_bo_handle { pub ptr: *mut libc::c_void, pub s32: i32, pub u32_: u32, pub s64: i64, pub u64_: u64, } pub mod gbm_bo_format { #[doc = " Format of the allocated buffer"] pub type Type = libc::c_uint; #[doc = " RGB with 8 bits per channel in a 32 bit value"] pub const GBM_BO_FORMAT_XRGB8888: Type = 0; #[doc = " ARGB with 8 bits per channel in a 32 bit value"] pub const GBM_BO_FORMAT_ARGB8888: Type = 1; } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct gbm_format_name_desc { pub name: [libc::c_char; 5usize], } pub mod gbm_bo_flags { #[doc = " Flags to indicate the intended use for the buffer - these are passed into\n gbm_bo_create(). The caller must set the union of all the flags that are\n appropriate\n\n \\sa Use gbm_device_is_format_supported() to check if the combination of format\n and use flags are supported"] pub type Type = libc::c_uint; #[doc = " Buffer is going to be presented to the screen using an API such as KMS"] pub const GBM_BO_USE_SCANOUT: Type = 1; #[doc = " Buffer is going to be used as cursor"] pub const GBM_BO_USE_CURSOR: Type = 2; #[doc = " Deprecated"] pub const GBM_BO_USE_CURSOR_64X64: Type = 2; #[doc = " Buffer is to be used for rendering - for example it is going to be used\n as the storage for a color buffer"] pub const GBM_BO_USE_RENDERING: Type = 4; #[doc = " Buffer can be used for gbm_bo_write. This is guaranteed to work\n with GBM_BO_USE_CURSOR, but may not work for other combinations."] pub const GBM_BO_USE_WRITE: Type = 8; #[doc = " Buffer is linear, i.e. not tiled."] pub const GBM_BO_USE_LINEAR: Type = 16; #[doc = " Buffer is protected, i.e. encrypted and not readable by CPU or any\n other non-secure / non-trusted components nor by non-trusted OpenGL,\n OpenCL, and Vulkan applications."] pub const GBM_BO_USE_PROTECTED: Type = 32; } extern "C" { pub fn gbm_device_get_fd(gbm: *mut gbm_device) -> libc::c_int; } extern "C" { pub fn gbm_device_get_backend_name(gbm: *mut gbm_device) -> *const libc::c_char; } extern "C" { pub fn gbm_device_is_format_supported( gbm: *mut gbm_device, format: u32, flags: u32, ) -> libc::c_int; } extern "C" { pub fn gbm_device_get_format_modifier_plane_count( gbm: *mut gbm_device, format: u32, modifier: u64, ) -> libc::c_int; } extern "C" { pub fn gbm_device_destroy(gbm: *mut gbm_device); } extern "C" { pub fn gbm_create_device(fd: libc::c_int) -> *mut gbm_device; } extern "C" { pub fn gbm_bo_create( gbm: *mut gbm_device, width: u32, height: u32, format: u32, flags: u32, ) -> *mut gbm_bo; } extern "C" { pub fn gbm_bo_create_with_modifiers( gbm: *mut gbm_device, width: u32, height: u32, format: u32, modifiers: *const u64, count: libc::c_uint, ) -> *mut gbm_bo; } extern "C" { pub fn gbm_bo_create_with_modifiers2( gbm: *mut gbm_device, width: u32, height: u32, format: u32, modifiers: *const u64, count: libc::c_uint, flags: u32, ) -> *mut gbm_bo; } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct gbm_import_fd_data { pub fd: libc::c_int, pub width: u32, pub height: u32, pub stride: u32, pub format: u32, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct gbm_import_fd_modifier_data { pub width: u32, pub height: u32, pub format: u32, pub num_fds: u32, pub fds: [libc::c_int; 4usize], pub strides: [libc::c_int; 4usize], pub offsets: [libc::c_int; 4usize], pub modifier: u64, } extern "C" { pub fn gbm_bo_import( gbm: *mut gbm_device, type_: u32, buffer: *mut libc::c_void, flags: u32, ) -> *mut gbm_bo; } pub mod gbm_bo_transfer_flags { #[doc = " Flags to indicate the type of mapping for the buffer - these are\n passed into gbm_bo_map(). The caller must set the union of all the\n flags that are appropriate.\n\n These flags are independent of the GBM_BO_USE_* creation flags. However,\n mapping the buffer may require copying to/from a staging buffer.\n\n See also: pipe_map_flags"] pub type Type = libc::c_uint; #[doc = " Buffer contents read back (or accessed directly) at transfer\n create time."] pub const GBM_BO_TRANSFER_READ: Type = 1; #[doc = " Buffer contents will be written back at unmap time\n (or modified as a result of being accessed directly)."] pub const GBM_BO_TRANSFER_WRITE: Type = 2; #[doc = " Read/modify/write"] pub const GBM_BO_TRANSFER_READ_WRITE: Type = 3; } extern "C" { pub fn gbm_bo_map( bo: *mut gbm_bo, x: u32, y: u32, width: u32, height: u32, flags: u32, stride: *mut u32, map_data: *mut *mut libc::c_void, ) -> *mut libc::c_void; } extern "C" { pub fn gbm_bo_unmap(bo: *mut gbm_bo, map_data: *mut libc::c_void); } extern "C" { pub fn gbm_bo_get_width(bo: *mut gbm_bo) -> u32; } extern "C" { pub fn gbm_bo_get_height(bo: *mut gbm_bo) -> u32; } extern "C" { pub fn gbm_bo_get_stride(bo: *mut gbm_bo) -> u32; } extern "C" { pub fn gbm_bo_get_stride_for_plane(bo: *mut gbm_bo, plane: libc::c_int) -> u32; } extern "C" { pub fn gbm_bo_get_format(bo: *mut gbm_bo) -> u32; } extern "C" { pub fn gbm_bo_get_bpp(bo: *mut gbm_bo) -> u32; } extern "C" { pub fn gbm_bo_get_offset(bo: *mut gbm_bo, plane: libc::c_int) -> u32; } extern "C" { pub fn gbm_bo_get_device(bo: *mut gbm_bo) -> *mut gbm_device; } extern "C" { pub fn gbm_bo_get_handle(bo: *mut gbm_bo) -> gbm_bo_handle; } extern "C" { pub fn gbm_bo_get_fd(bo: *mut gbm_bo) -> libc::c_int; } extern "C" { pub fn gbm_bo_get_modifier(bo: *mut gbm_bo) -> u64; } extern "C" { pub fn gbm_bo_get_plane_count(bo: *mut gbm_bo) -> libc::c_int; } extern "C" { pub fn gbm_bo_get_handle_for_plane(bo: *mut gbm_bo, plane: libc::c_int) -> gbm_bo_handle; } extern "C" { pub fn gbm_bo_get_fd_for_plane(bo: *mut gbm_bo, plane: libc::c_int) -> libc::c_int; } extern "C" { pub fn gbm_bo_write(bo: *mut gbm_bo, buf: *const libc::c_void, count: usize) -> libc::c_int; } extern "C" { pub fn gbm_bo_set_user_data( bo: *mut gbm_bo, data: *mut libc::c_void, destroy_user_data: ::std::option::Option< unsafe extern "C" fn(arg1: *mut gbm_bo, arg2: *mut libc::c_void), >, ); } extern "C" { pub fn gbm_bo_get_user_data(bo: *mut gbm_bo) -> *mut libc::c_void; } extern "C" { pub fn gbm_bo_destroy(bo: *mut gbm_bo); } extern "C" { pub fn gbm_surface_create( gbm: *mut gbm_device, width: u32, height: u32, format: u32, flags: u32, ) -> *mut gbm_surface; } extern "C" { pub fn gbm_surface_create_with_modifiers( gbm: *mut gbm_device, width: u32, height: u32, format: u32, modifiers: *const u64, count: libc::c_uint, ) -> *mut gbm_surface; } extern "C" { pub fn gbm_surface_create_with_modifiers2( gbm: *mut gbm_device, width: u32, height: u32, format: u32, modifiers: *const u64, count: libc::c_uint, flags: u32, ) -> *mut gbm_surface; } extern "C" { pub fn gbm_surface_lock_front_buffer(surface: *mut gbm_surface) -> *mut gbm_bo; } extern "C" { pub fn gbm_surface_release_buffer(surface: *mut gbm_surface, bo: *mut gbm_bo); } extern "C" { pub fn gbm_surface_has_free_buffers(surface: *mut gbm_surface) -> libc::c_int; } extern "C" { pub fn gbm_surface_destroy(surface: *mut gbm_surface); } extern "C" { pub fn gbm_format_get_name( gbm_format: u32, desc: *mut gbm_format_name_desc, ) -> *mut libc::c_char; } gbm-sys-0.4.0/src/lib.rs000064400000000000000000000006271046102023000131160ustar 00000000000000#![allow(non_camel_case_types, non_upper_case_globals)] // Allowed this because some bindgen tests looks like // it tries to dereference null pointers but actually // it is not so. #![cfg_attr(test, allow(deref_nullptr))] #[cfg(feature = "use_bindgen")] include!(concat!(env!("OUT_DIR"), "/bindings.rs")); #[cfg(not(feature = "use_bindgen"))] include!("bindings.rs"); #[link(name = "gbm")] extern "C" {}