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;
}
#[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,
}
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;
}
pub struct gbm {
__library: ::libloading::Library,
pub gbm_device_get_fd:
Result<unsafe extern "C" fn(gbm: *mut gbm_device) -> libc::c_int, ::libloading::Error>,
pub gbm_device_get_backend_name: Result<
unsafe extern "C" fn(gbm: *mut gbm_device) -> *const libc::c_char,
::libloading::Error,
>,
pub gbm_device_is_format_supported: Result<
unsafe extern "C" fn(gbm: *mut gbm_device, format: u32, flags: u32) -> libc::c_int,
::libloading::Error,
>,
pub gbm_device_get_format_modifier_plane_count: Result<
unsafe extern "C" fn(gbm: *mut gbm_device, format: u32, modifier: u64) -> libc::c_int,
::libloading::Error,
>,
pub gbm_device_destroy: Result<unsafe extern "C" fn(gbm: *mut gbm_device), ::libloading::Error>,
pub gbm_create_device:
Result<unsafe extern "C" fn(fd: libc::c_int) -> *mut gbm_device, ::libloading::Error>,
pub gbm_bo_create: Result<
unsafe extern "C" fn(
gbm: *mut gbm_device,
width: u32,
height: u32,
format: u32,
flags: u32,
) -> *mut gbm_bo,
::libloading::Error,
>,
pub gbm_bo_create_with_modifiers: Result<
unsafe extern "C" fn(
gbm: *mut gbm_device,
width: u32,
height: u32,
format: u32,
modifiers: *const u64,
count: libc::c_uint,
) -> *mut gbm_bo,
::libloading::Error,
>,
pub gbm_bo_create_with_modifiers2: Result<
unsafe extern "C" fn(
gbm: *mut gbm_device,
width: u32,
height: u32,
format: u32,
modifiers: *const u64,
count: libc::c_uint,
flags: u32,
) -> *mut gbm_bo,
::libloading::Error,
>,
pub gbm_bo_import: Result<
unsafe extern "C" fn(
gbm: *mut gbm_device,
type_: u32,
buffer: *mut libc::c_void,
flags: u32,
) -> *mut gbm_bo,
::libloading::Error,
>,
pub gbm_bo_map: Result<
unsafe extern "C" fn(
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,
::libloading::Error,
>,
pub gbm_bo_unmap: Result<
unsafe extern "C" fn(bo: *mut gbm_bo, map_data: *mut libc::c_void),
::libloading::Error,
>,
pub gbm_bo_get_width: Result<unsafe extern "C" fn(bo: *mut gbm_bo) -> u32, ::libloading::Error>,
pub gbm_bo_get_height:
Result<unsafe extern "C" fn(bo: *mut gbm_bo) -> u32, ::libloading::Error>,
pub gbm_bo_get_stride:
Result<unsafe extern "C" fn(bo: *mut gbm_bo) -> u32, ::libloading::Error>,
pub gbm_bo_get_stride_for_plane: Result<
unsafe extern "C" fn(bo: *mut gbm_bo, plane: libc::c_int) -> u32,
::libloading::Error,
>,
pub gbm_bo_get_format:
Result<unsafe extern "C" fn(bo: *mut gbm_bo) -> u32, ::libloading::Error>,
pub gbm_bo_get_bpp: Result<unsafe extern "C" fn(bo: *mut gbm_bo) -> u32, ::libloading::Error>,
pub gbm_bo_get_offset: Result<
unsafe extern "C" fn(bo: *mut gbm_bo, plane: libc::c_int) -> u32,
::libloading::Error,
>,
pub gbm_bo_get_device:
Result<unsafe extern "C" fn(bo: *mut gbm_bo) -> *mut gbm_device, ::libloading::Error>,
pub gbm_bo_get_handle:
Result<unsafe extern "C" fn(bo: *mut gbm_bo) -> gbm_bo_handle, ::libloading::Error>,
pub gbm_bo_get_fd:
Result<unsafe extern "C" fn(bo: *mut gbm_bo) -> libc::c_int, ::libloading::Error>,
pub gbm_bo_get_modifier:
Result<unsafe extern "C" fn(bo: *mut gbm_bo) -> u64, ::libloading::Error>,
pub gbm_bo_get_plane_count:
Result<unsafe extern "C" fn(bo: *mut gbm_bo) -> libc::c_int, ::libloading::Error>,
pub gbm_bo_get_handle_for_plane: Result<
unsafe extern "C" fn(bo: *mut gbm_bo, plane: libc::c_int) -> gbm_bo_handle,
::libloading::Error,
>,
pub gbm_bo_get_fd_for_plane: Result<
unsafe extern "C" fn(bo: *mut gbm_bo, plane: libc::c_int) -> libc::c_int,
::libloading::Error,
>,
pub gbm_bo_write: Result<
unsafe extern "C" fn(
bo: *mut gbm_bo,
buf: *const libc::c_void,
count: usize,
) -> libc::c_int,
::libloading::Error,
>,
pub gbm_bo_set_user_data: Result<
unsafe extern "C" fn(
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),
>,
),
::libloading::Error,
>,
pub gbm_bo_get_user_data:
Result<unsafe extern "C" fn(bo: *mut gbm_bo) -> *mut libc::c_void, ::libloading::Error>,
pub gbm_bo_destroy: Result<unsafe extern "C" fn(bo: *mut gbm_bo), ::libloading::Error>,
pub gbm_surface_create: Result<
unsafe extern "C" fn(
gbm: *mut gbm_device,
width: u32,
height: u32,
format: u32,
flags: u32,
) -> *mut gbm_surface,
::libloading::Error,
>,
pub gbm_surface_create_with_modifiers: Result<
unsafe extern "C" fn(
gbm: *mut gbm_device,
width: u32,
height: u32,
format: u32,
modifiers: *const u64,
count: libc::c_uint,
) -> *mut gbm_surface,
::libloading::Error,
>,
pub gbm_surface_create_with_modifiers2: Result<
unsafe extern "C" fn(
gbm: *mut gbm_device,
width: u32,
height: u32,
format: u32,
modifiers: *const u64,
count: libc::c_uint,
flags: u32,
) -> *mut gbm_surface,
::libloading::Error,
>,
pub gbm_surface_lock_front_buffer:
Result<unsafe extern "C" fn(surface: *mut gbm_surface) -> *mut gbm_bo, ::libloading::Error>,
pub gbm_surface_release_buffer: Result<
unsafe extern "C" fn(surface: *mut gbm_surface, bo: *mut gbm_bo),
::libloading::Error,
>,
pub gbm_surface_has_free_buffers:
Result<unsafe extern "C" fn(surface: *mut gbm_surface) -> libc::c_int, ::libloading::Error>,
pub gbm_surface_destroy:
Result<unsafe extern "C" fn(surface: *mut gbm_surface), ::libloading::Error>,
pub gbm_format_get_name: Result<
unsafe extern "C" fn(gbm_format: u32, desc: *mut gbm_format_name_desc) -> *mut libc::c_char,
::libloading::Error,
>,
}
impl gbm {
pub unsafe fn new<P>(path: P) -> Result<Self, ::libloading::Error>
where
P: AsRef<::std::ffi::OsStr>,
{
let library = ::libloading::Library::new(path)?;
Self::from_library(library)
}
pub unsafe fn from_library<L>(library: L) -> Result<Self, ::libloading::Error>
where
L: Into<::libloading::Library>,
{
let __library = library.into();
let gbm_device_get_fd = __library.get(b"gbm_device_get_fd\0").map(|sym| *sym);
let gbm_device_get_backend_name = __library
.get(b"gbm_device_get_backend_name\0")
.map(|sym| *sym);
let gbm_device_is_format_supported = __library
.get(b"gbm_device_is_format_supported\0")
.map(|sym| *sym);
let gbm_device_get_format_modifier_plane_count = __library
.get(b"gbm_device_get_format_modifier_plane_count\0")
.map(|sym| *sym);
let gbm_device_destroy = __library.get(b"gbm_device_destroy\0").map(|sym| *sym);
let gbm_create_device = __library.get(b"gbm_create_device\0").map(|sym| *sym);
let gbm_bo_create = __library.get(b"gbm_bo_create\0").map(|sym| *sym);
let gbm_bo_create_with_modifiers = __library
.get(b"gbm_bo_create_with_modifiers\0")
.map(|sym| *sym);
let gbm_bo_create_with_modifiers2 = __library
.get(b"gbm_bo_create_with_modifiers2\0")
.map(|sym| *sym);
let gbm_bo_import = __library.get(b"gbm_bo_import\0").map(|sym| *sym);
let gbm_bo_map = __library.get(b"gbm_bo_map\0").map(|sym| *sym);
let gbm_bo_unmap = __library.get(b"gbm_bo_unmap\0").map(|sym| *sym);
let gbm_bo_get_width = __library.get(b"gbm_bo_get_width\0").map(|sym| *sym);
let gbm_bo_get_height = __library.get(b"gbm_bo_get_height\0").map(|sym| *sym);
let gbm_bo_get_stride = __library.get(b"gbm_bo_get_stride\0").map(|sym| *sym);
let gbm_bo_get_stride_for_plane = __library
.get(b"gbm_bo_get_stride_for_plane\0")
.map(|sym| *sym);
let gbm_bo_get_format = __library.get(b"gbm_bo_get_format\0").map(|sym| *sym);
let gbm_bo_get_bpp = __library.get(b"gbm_bo_get_bpp\0").map(|sym| *sym);
let gbm_bo_get_offset = __library.get(b"gbm_bo_get_offset\0").map(|sym| *sym);
let gbm_bo_get_device = __library.get(b"gbm_bo_get_device\0").map(|sym| *sym);
let gbm_bo_get_handle = __library.get(b"gbm_bo_get_handle\0").map(|sym| *sym);
let gbm_bo_get_fd = __library.get(b"gbm_bo_get_fd\0").map(|sym| *sym);
let gbm_bo_get_modifier = __library.get(b"gbm_bo_get_modifier\0").map(|sym| *sym);
let gbm_bo_get_plane_count = __library.get(b"gbm_bo_get_plane_count\0").map(|sym| *sym);
let gbm_bo_get_handle_for_plane = __library
.get(b"gbm_bo_get_handle_for_plane\0")
.map(|sym| *sym);
let gbm_bo_get_fd_for_plane = __library.get(b"gbm_bo_get_fd_for_plane\0").map(|sym| *sym);
let gbm_bo_write = __library.get(b"gbm_bo_write\0").map(|sym| *sym);
let gbm_bo_set_user_data = __library.get(b"gbm_bo_set_user_data\0").map(|sym| *sym);
let gbm_bo_get_user_data = __library.get(b"gbm_bo_get_user_data\0").map(|sym| *sym);
let gbm_bo_destroy = __library.get(b"gbm_bo_destroy\0").map(|sym| *sym);
let gbm_surface_create = __library.get(b"gbm_surface_create\0").map(|sym| *sym);
let gbm_surface_create_with_modifiers = __library
.get(b"gbm_surface_create_with_modifiers\0")
.map(|sym| *sym);
let gbm_surface_create_with_modifiers2 = __library
.get(b"gbm_surface_create_with_modifiers2\0")
.map(|sym| *sym);
let gbm_surface_lock_front_buffer = __library
.get(b"gbm_surface_lock_front_buffer\0")
.map(|sym| *sym);
let gbm_surface_release_buffer = __library
.get(b"gbm_surface_release_buffer\0")
.map(|sym| *sym);
let gbm_surface_has_free_buffers = __library
.get(b"gbm_surface_has_free_buffers\0")
.map(|sym| *sym);
let gbm_surface_destroy = __library.get(b"gbm_surface_destroy\0").map(|sym| *sym);
let gbm_format_get_name = __library.get(b"gbm_format_get_name\0").map(|sym| *sym);
Ok(gbm {
__library,
gbm_device_get_fd,
gbm_device_get_backend_name,
gbm_device_is_format_supported,
gbm_device_get_format_modifier_plane_count,
gbm_device_destroy,
gbm_create_device,
gbm_bo_create,
gbm_bo_create_with_modifiers,
gbm_bo_create_with_modifiers2,
gbm_bo_import,
gbm_bo_map,
gbm_bo_unmap,
gbm_bo_get_width,
gbm_bo_get_height,
gbm_bo_get_stride,
gbm_bo_get_stride_for_plane,
gbm_bo_get_format,
gbm_bo_get_bpp,
gbm_bo_get_offset,
gbm_bo_get_device,
gbm_bo_get_handle,
gbm_bo_get_fd,
gbm_bo_get_modifier,
gbm_bo_get_plane_count,
gbm_bo_get_handle_for_plane,
gbm_bo_get_fd_for_plane,
gbm_bo_write,
gbm_bo_set_user_data,
gbm_bo_get_user_data,
gbm_bo_destroy,
gbm_surface_create,
gbm_surface_create_with_modifiers,
gbm_surface_create_with_modifiers2,
gbm_surface_lock_front_buffer,
gbm_surface_release_buffer,
gbm_surface_has_free_buffers,
gbm_surface_destroy,
gbm_format_get_name,
})
}
pub unsafe fn gbm_device_get_fd(&self, gbm: *mut gbm_device) -> libc::c_int {
(self
.gbm_device_get_fd
.as_ref()
.expect("Expected function, got error."))(gbm)
}
pub unsafe fn gbm_device_get_backend_name(&self, gbm: *mut gbm_device) -> *const libc::c_char {
(self
.gbm_device_get_backend_name
.as_ref()
.expect("Expected function, got error."))(gbm)
}
pub unsafe fn gbm_device_is_format_supported(
&self,
gbm: *mut gbm_device,
format: u32,
flags: u32,
) -> libc::c_int {
(self
.gbm_device_is_format_supported
.as_ref()
.expect("Expected function, got error."))(gbm, format, flags)
}
pub unsafe fn gbm_device_get_format_modifier_plane_count(
&self,
gbm: *mut gbm_device,
format: u32,
modifier: u64,
) -> libc::c_int {
(self
.gbm_device_get_format_modifier_plane_count
.as_ref()
.expect("Expected function, got error."))(gbm, format, modifier)
}
pub unsafe fn gbm_device_destroy(&self, gbm: *mut gbm_device) {
(self
.gbm_device_destroy
.as_ref()
.expect("Expected function, got error."))(gbm)
}
pub unsafe fn gbm_create_device(&self, fd: libc::c_int) -> *mut gbm_device {
(self
.gbm_create_device
.as_ref()
.expect("Expected function, got error."))(fd)
}
pub unsafe fn gbm_bo_create(
&self,
gbm: *mut gbm_device,
width: u32,
height: u32,
format: u32,
flags: u32,
) -> *mut gbm_bo {
(self
.gbm_bo_create
.as_ref()
.expect("Expected function, got error."))(gbm, width, height, format, flags)
}
pub unsafe fn gbm_bo_create_with_modifiers(
&self,
gbm: *mut gbm_device,
width: u32,
height: u32,
format: u32,
modifiers: *const u64,
count: libc::c_uint,
) -> *mut gbm_bo {
(self
.gbm_bo_create_with_modifiers
.as_ref()
.expect("Expected function, got error."))(
gbm, width, height, format, modifiers, count
)
}
pub unsafe fn gbm_bo_create_with_modifiers2(
&self,
gbm: *mut gbm_device,
width: u32,
height: u32,
format: u32,
modifiers: *const u64,
count: libc::c_uint,
flags: u32,
) -> *mut gbm_bo {
(self
.gbm_bo_create_with_modifiers2
.as_ref()
.expect("Expected function, got error."))(
gbm, width, height, format, modifiers, count, flags,
)
}
pub unsafe fn gbm_bo_import(
&self,
gbm: *mut gbm_device,
type_: u32,
buffer: *mut libc::c_void,
flags: u32,
) -> *mut gbm_bo {
(self
.gbm_bo_import
.as_ref()
.expect("Expected function, got error."))(gbm, type_, buffer, flags)
}
pub unsafe fn gbm_bo_map(
&self,
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 {
(self
.gbm_bo_map
.as_ref()
.expect("Expected function, got error."))(
bo, x, y, width, height, flags, stride, map_data,
)
}
pub unsafe fn gbm_bo_unmap(&self, bo: *mut gbm_bo, map_data: *mut libc::c_void) {
(self
.gbm_bo_unmap
.as_ref()
.expect("Expected function, got error."))(bo, map_data)
}
pub unsafe fn gbm_bo_get_width(&self, bo: *mut gbm_bo) -> u32 {
(self
.gbm_bo_get_width
.as_ref()
.expect("Expected function, got error."))(bo)
}
pub unsafe fn gbm_bo_get_height(&self, bo: *mut gbm_bo) -> u32 {
(self
.gbm_bo_get_height
.as_ref()
.expect("Expected function, got error."))(bo)
}
pub unsafe fn gbm_bo_get_stride(&self, bo: *mut gbm_bo) -> u32 {
(self
.gbm_bo_get_stride
.as_ref()
.expect("Expected function, got error."))(bo)
}
pub unsafe fn gbm_bo_get_stride_for_plane(&self, bo: *mut gbm_bo, plane: libc::c_int) -> u32 {
(self
.gbm_bo_get_stride_for_plane
.as_ref()
.expect("Expected function, got error."))(bo, plane)
}
pub unsafe fn gbm_bo_get_format(&self, bo: *mut gbm_bo) -> u32 {
(self
.gbm_bo_get_format
.as_ref()
.expect("Expected function, got error."))(bo)
}
pub unsafe fn gbm_bo_get_bpp(&self, bo: *mut gbm_bo) -> u32 {
(self
.gbm_bo_get_bpp
.as_ref()
.expect("Expected function, got error."))(bo)
}
pub unsafe fn gbm_bo_get_offset(&self, bo: *mut gbm_bo, plane: libc::c_int) -> u32 {
(self
.gbm_bo_get_offset
.as_ref()
.expect("Expected function, got error."))(bo, plane)
}
pub unsafe fn gbm_bo_get_device(&self, bo: *mut gbm_bo) -> *mut gbm_device {
(self
.gbm_bo_get_device
.as_ref()
.expect("Expected function, got error."))(bo)
}
pub unsafe fn gbm_bo_get_handle(&self, bo: *mut gbm_bo) -> gbm_bo_handle {
(self
.gbm_bo_get_handle
.as_ref()
.expect("Expected function, got error."))(bo)
}
pub unsafe fn gbm_bo_get_fd(&self, bo: *mut gbm_bo) -> libc::c_int {
(self
.gbm_bo_get_fd
.as_ref()
.expect("Expected function, got error."))(bo)
}
pub unsafe fn gbm_bo_get_modifier(&self, bo: *mut gbm_bo) -> u64 {
(self
.gbm_bo_get_modifier
.as_ref()
.expect("Expected function, got error."))(bo)
}
pub unsafe fn gbm_bo_get_plane_count(&self, bo: *mut gbm_bo) -> libc::c_int {
(self
.gbm_bo_get_plane_count
.as_ref()
.expect("Expected function, got error."))(bo)
}
pub unsafe fn gbm_bo_get_handle_for_plane(
&self,
bo: *mut gbm_bo,
plane: libc::c_int,
) -> gbm_bo_handle {
(self
.gbm_bo_get_handle_for_plane
.as_ref()
.expect("Expected function, got error."))(bo, plane)
}
pub unsafe fn gbm_bo_get_fd_for_plane(
&self,
bo: *mut gbm_bo,
plane: libc::c_int,
) -> libc::c_int {
(self
.gbm_bo_get_fd_for_plane
.as_ref()
.expect("Expected function, got error."))(bo, plane)
}
pub unsafe fn gbm_bo_write(
&self,
bo: *mut gbm_bo,
buf: *const libc::c_void,
count: usize,
) -> libc::c_int {
(self
.gbm_bo_write
.as_ref()
.expect("Expected function, got error."))(bo, buf, count)
}
pub unsafe fn gbm_bo_set_user_data(
&self,
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),
>,
) {
(self
.gbm_bo_set_user_data
.as_ref()
.expect("Expected function, got error."))(bo, data, destroy_user_data)
}
pub unsafe fn gbm_bo_get_user_data(&self, bo: *mut gbm_bo) -> *mut libc::c_void {
(self
.gbm_bo_get_user_data
.as_ref()
.expect("Expected function, got error."))(bo)
}
pub unsafe fn gbm_bo_destroy(&self, bo: *mut gbm_bo) {
(self
.gbm_bo_destroy
.as_ref()
.expect("Expected function, got error."))(bo)
}
pub unsafe fn gbm_surface_create(
&self,
gbm: *mut gbm_device,
width: u32,
height: u32,
format: u32,
flags: u32,
) -> *mut gbm_surface {
(self
.gbm_surface_create
.as_ref()
.expect("Expected function, got error."))(gbm, width, height, format, flags)
}
pub unsafe fn gbm_surface_create_with_modifiers(
&self,
gbm: *mut gbm_device,
width: u32,
height: u32,
format: u32,
modifiers: *const u64,
count: libc::c_uint,
) -> *mut gbm_surface {
(self
.gbm_surface_create_with_modifiers
.as_ref()
.expect("Expected function, got error."))(
gbm, width, height, format, modifiers, count
)
}
pub unsafe fn gbm_surface_create_with_modifiers2(
&self,
gbm: *mut gbm_device,
width: u32,
height: u32,
format: u32,
modifiers: *const u64,
count: libc::c_uint,
flags: u32,
) -> *mut gbm_surface {
(self
.gbm_surface_create_with_modifiers2
.as_ref()
.expect("Expected function, got error."))(
gbm, width, height, format, modifiers, count, flags,
)
}
pub unsafe fn gbm_surface_lock_front_buffer(&self, surface: *mut gbm_surface) -> *mut gbm_bo {
(self
.gbm_surface_lock_front_buffer
.as_ref()
.expect("Expected function, got error."))(surface)
}
pub unsafe fn gbm_surface_release_buffer(&self, surface: *mut gbm_surface, bo: *mut gbm_bo) {
(self
.gbm_surface_release_buffer
.as_ref()
.expect("Expected function, got error."))(surface, bo)
}
pub unsafe fn gbm_surface_has_free_buffers(&self, surface: *mut gbm_surface) -> libc::c_int {
(self
.gbm_surface_has_free_buffers
.as_ref()
.expect("Expected function, got error."))(surface)
}
pub unsafe fn gbm_surface_destroy(&self, surface: *mut gbm_surface) {
(self
.gbm_surface_destroy
.as_ref()
.expect("Expected function, got error."))(surface)
}
pub unsafe fn gbm_format_get_name(
&self,
gbm_format: u32,
desc: *mut gbm_format_name_desc,
) -> *mut libc::c_char {
(self
.gbm_format_get_name
.as_ref()
.expect("Expected function, got error."))(gbm_format, desc)
}
}