diff --git a/gpu_buffer/src/lib.rs b/gpu_buffer/src/lib.rs index 3bc4b248b8..5d25fa2044 100644 --- a/gpu_buffer/src/lib.rs +++ b/gpu_buffer/src/lib.rs @@ -392,12 +392,6 @@ impl Buffer { unsafe { gbm_bo_get_stride(self.0) } } - /// Length in bytes of the stride or tiling. - pub fn stride_or_tiling(&self) -> u32 { - // This is always safe to call with a valid gbm_bo pointer. - unsafe { gbm_bo_get_stride_or_tiling(self.0) } - } - /// `Format` of the buffer. pub fn format(&self) -> Format { // This is always safe to call with a valid gbm_bo pointer. @@ -413,7 +407,7 @@ impl Buffer { /// Number of planes present in this buffer. pub fn num_planes(&self) -> usize { // This is always safe to call with a valid gbm_bo pointer. - unsafe { gbm_bo_get_plane_count(self.0) } + unsafe { gbm_bo_get_plane_count(self.0) as usize } } /// Handle as u64 for the given plane. diff --git a/gpu_buffer/src/raw.rs b/gpu_buffer/src/raw.rs index b4255ca549..6f5686a2eb 100644 --- a/gpu_buffer/src/raw.rs +++ b/gpu_buffer/src/raw.rs @@ -3,14 +3,14 @@ // found in the LICENSE file. // Generated with bindgen --whitelist-function='gbm_.*' --whitelist-type='gbm_.*' minigbm/gbm.h -// Hand-modified by zachr +// Then modified manually +/* Added below line manually */ #![allow(dead_code)] -use std::os::raw::{c_char, c_int, c_void}; +/* Added below line manually */ +use std::os::raw::{c_char, c_int, c_uint, c_void}; -/// \file gbm.h -/// \brief Generic Buffer Manager #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct gbm_device { @@ -26,8 +26,6 @@ pub struct gbm_bo { pub struct gbm_surface { _unused: [u8; 0], } -/// Abstraction representing the handle to a buffer allocated by the -/// manager #[repr(C)] #[derive(Copy, Clone)] pub union gbm_bo_handle { @@ -38,64 +36,58 @@ pub union gbm_bo_handle { pub u64: u64, _bindgen_union_align: u64, } - -/// Buffer is going to be presented to the screen using an API such as KMS +pub const GBM_BO_FORMAT_XRGB8888: gbm_bo_format = 0; +pub const GBM_BO_FORMAT_ARGB8888: gbm_bo_format = 1; +pub type gbm_bo_format = u32; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct gbm_format_name_desc { + pub name: [c_char; 5usize], +} pub const GBM_BO_USE_SCANOUT: gbm_bo_flags = 1; -/// Buffer is going to be used as cursor pub const GBM_BO_USE_CURSOR: gbm_bo_flags = 2; -/// Deprecated pub const GBM_BO_USE_CURSOR_64X64: gbm_bo_flags = 2; -/// Buffer is to be used for rendering - for example it is going to be used -/// as the storage for a color buffer pub const GBM_BO_USE_RENDERING: gbm_bo_flags = 4; -/// Deprecated pub const GBM_BO_USE_WRITE: gbm_bo_flags = 8; -/// Buffer is guaranteed to be laid out linearly in memory. That is, the -/// buffer is laid out as an array with 'height' blocks, each block with -/// length 'stride'. Each stride is in the same order as the rows of the -/// buffer. This is intended to be used with buffers that will be accessed -/// via dma-buf mmap(). pub const GBM_BO_USE_LINEAR: gbm_bo_flags = 16; -/// The buffer will be used as a texture that will be sampled from. pub const GBM_BO_USE_TEXTURING: gbm_bo_flags = 32; -/// The buffer will be written to by a camera subsystem. pub const GBM_BO_USE_CAMERA_WRITE: gbm_bo_flags = 64; -/// The buffer will be read from by a camera subsystem. pub const GBM_BO_USE_CAMERA_READ: gbm_bo_flags = 128; -/// Buffer inaccessible to unprivileged users. pub const GBM_BO_USE_PROTECTED: gbm_bo_flags = 256; -/// These flags specify the frequency of software access. These flags do not -/// guarantee the buffer is linear, but do guarantee gbm_bo_map(..) will -/// present a linear view. pub const GBM_BO_USE_SW_READ_OFTEN: gbm_bo_flags = 512; -/// These flags specify the frequency of software access. These flags do not -/// guarantee the buffer is linear, but do guarantee gbm_bo_map(..) will -/// present a linear view. pub const GBM_BO_USE_SW_READ_RARELY: gbm_bo_flags = 1024; -/// These flags specify the frequency of software access. These flags do not -/// guarantee the buffer is linear, but do guarantee gbm_bo_map(..) will -/// present a linear view. pub const GBM_BO_USE_SW_WRITE_OFTEN: gbm_bo_flags = 2048; -/// These flags specify the frequency of software access. These flags do not -/// guarantee the buffer is linear, but do guarantee gbm_bo_map(..) will -/// present a linear view. pub const GBM_BO_USE_SW_WRITE_RARELY: gbm_bo_flags = 4096; -/// 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 +pub const GBM_BO_USE_HW_VIDEO_DECODER: gbm_bo_flags = 8192; +pub const GBM_BO_USE_HW_VIDEO_ENCODER: gbm_bo_flags = 16384; +/* Added below line manually */ #[allow(non_camel_case_types)] pub type gbm_bo_flags = u32; - +/* Added below line manually */ #[link(name = "gbm")] extern "C" { pub fn gbm_device_get_fd(gbm: *mut gbm_device) -> c_int; +} +extern "C" { pub fn gbm_device_get_backend_name(gbm: *mut gbm_device) -> *const c_char; +} +extern "C" { pub fn gbm_device_is_format_supported(gbm: *mut gbm_device, format: u32, usage: u32) -> c_int; +} +extern "C" { + pub fn gbm_device_get_format_modifier_plane_count( + gbm: *mut gbm_device, + format: u32, + modifier: u64, + ) -> c_int; +} +extern "C" { pub fn gbm_device_destroy(gbm: *mut gbm_device); +} +extern "C" { pub fn gbm_create_device(fd: c_int) -> *mut gbm_device; +} +extern "C" { pub fn gbm_bo_create( gbm: *mut gbm_device, width: u32, @@ -103,16 +95,17 @@ extern "C" { 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: u32, + count: c_uint, ) -> *mut gbm_bo; } - #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct gbm_import_fd_data { @@ -122,19 +115,18 @@ pub struct gbm_import_fd_data { pub stride: u32, pub format: u32, } - #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct gbm_import_fd_planar_data { - pub fds: [c_int; 4usize], +pub struct gbm_import_fd_modifier_data { pub width: u32, pub height: u32, pub format: u32, - pub strides: [u32; 4usize], - pub offsets: [u32; 4usize], - pub format_modifiers: [u64; 4usize], + pub num_fds: u32, + pub fds: [c_int; 4usize], + pub strides: [c_int; 4usize], + pub offsets: [c_int; 4usize], + pub modifier: u64, } - extern "C" { pub fn gbm_bo_import( gbm: *mut gbm_device, @@ -143,27 +135,113 @@ extern "C" { usage: u32, ) -> *mut gbm_bo; } - -/// Buffer contents read back (or accessed directly) at transfer -/// create time. pub const GBM_BO_TRANSFER_READ: gbm_bo_transfer_flags = 1; -/// Buffer contents will be written back at unmap time -/// (or modified as a result of being accessed directly). pub const GBM_BO_TRANSFER_WRITE: gbm_bo_transfer_flags = 2; -/// Read/modify/write pub const GBM_BO_TRANSFER_READ_WRITE: gbm_bo_transfer_flags = 3; -/// 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_transfer_usage +/* Added below line manually */ #[allow(non_camel_case_types)] pub type gbm_bo_transfer_flags = u32; - +extern "C" { + pub fn gbm_bo_unmap(bo: *mut gbm_bo, map_data: *mut 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: usize) -> 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: usize) -> 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) -> 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) -> c_int; +} +extern "C" { + pub fn gbm_bo_get_handle_for_plane(bo: *mut gbm_bo, plane: usize) -> gbm_bo_handle; +} +extern "C" { + pub fn gbm_bo_write(bo: *mut gbm_bo, buf: *const c_void, count: usize) -> c_int; +} +extern "C" { + pub fn gbm_bo_set_user_data( + bo: *mut gbm_bo, + data: *mut c_void, + destroy_user_data: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut gbm_bo, arg2: *mut c_void), + >, + ); +} +extern "C" { + pub fn gbm_bo_get_user_data(bo: *mut gbm_bo) -> *mut 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: c_uint, + ) -> *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) -> 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 c_char; +} +extern "C" { + pub fn gbm_bo_get_plane_size(bo: *mut gbm_bo, plane: usize) -> u32; +} +extern "C" { + pub fn gbm_bo_get_plane_fd(bo: *mut gbm_bo, plane: usize) -> c_int; +} extern "C" { pub fn gbm_bo_map( bo: *mut gbm_bo, @@ -176,40 +254,17 @@ extern "C" { map_data: *mut *mut c_void, plane: usize, ) -> *mut c_void; - pub fn gbm_bo_unmap(bo: *mut gbm_bo, map_data: *mut c_void); - pub fn gbm_bo_get_width(bo: *mut gbm_bo) -> u32; - pub fn gbm_bo_get_height(bo: *mut gbm_bo) -> u32; - pub fn gbm_bo_get_stride(bo: *mut gbm_bo) -> u32; - pub fn gbm_bo_get_stride_or_tiling(bo: *mut gbm_bo) -> u32; - pub fn gbm_bo_get_format(bo: *mut gbm_bo) -> u32; - pub fn gbm_bo_get_modifier(bo: *mut gbm_bo) -> u64; - pub fn gbm_bo_get_device(bo: *mut gbm_bo) -> *mut gbm_device; - pub fn gbm_bo_get_handle(bo: *mut gbm_bo) -> gbm_bo_handle; - pub fn gbm_bo_get_fd(bo: *mut gbm_bo) -> c_int; - pub fn gbm_bo_get_plane_count(bo: *mut gbm_bo) -> usize; - pub fn gbm_bo_get_handle_for_plane(bo: *mut gbm_bo, plane: usize) -> gbm_bo_handle; - pub fn gbm_bo_get_plane_fd(bo: *mut gbm_bo, plane: usize) -> c_int; - pub fn gbm_bo_get_offset(bo: *mut gbm_bo, plane: usize) -> u32; - pub fn gbm_bo_get_plane_size(bo: *mut gbm_bo, plane: usize) -> u32; - pub fn gbm_bo_get_stride_for_plane(bo: *mut gbm_bo, plane: usize) -> u32; - pub fn gbm_bo_get_plane_format_modifier(bo: *mut gbm_bo, plane: usize) -> u64; - // Did not generate cleanly by bindgen. Redone manually by zachr. - pub fn gbm_bo_set_user_data( +} +extern "C" { + pub fn gbm_bo_map2( bo: *mut gbm_bo, - data: *mut c_void, - destroy_user_data: extern "C" fn(bo: *mut gbm_bo, data: *mut c_void), - ); - pub fn gbm_bo_get_user_data(bo: *mut gbm_bo) -> *mut c_void; - pub fn gbm_bo_destroy(bo: *mut gbm_bo); - pub fn gbm_surface_create( - gbm: *mut gbm_device, + x: u32, + y: u32, width: u32, height: u32, - format: u32, flags: u32, - ) -> *mut gbm_surface; - pub fn gbm_surface_lock_front_buffer(surface: *mut gbm_surface) -> *mut gbm_bo; - pub fn gbm_surface_release_buffer(surface: *mut gbm_surface, bo: *mut gbm_bo); - pub fn gbm_surface_has_free_buffers(surface: *mut gbm_surface) -> c_int; - pub fn gbm_surface_destroy(surface: *mut gbm_surface); + stride: *mut u32, + map_data: *mut *mut c_void, + plane: c_int, + ) -> *mut c_void; }