mirrors/crosvm
1
0
Fork 0
mirror of https://chromium.googlesource.com/crosvm/crosvm synced 2025-02-05 18:20:34 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

gpu_buffer: update minigbm bindings

Browse source 
gbm_bo_get_stride_or_tiling has been recently removed, so update
the bindings to reflect this and other changes.

BUG=chromium:1044341
TEST=build

Change-Id: Ieed3045bd05244a582660ecf9340128e8fa10090
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform/crosvm/+/2013763
Reviewed-by: Manoj Gupta <manojgupta@chromium.org>
Reviewed-by: Zach Reizner <zachr@chromium.org>
Tested-by: Zach Reizner <zachr@chromium.org>
Tested-by: kokoro <noreply+kokoro@google.com>
Commit-Queue: Manoj Gupta <manojgupta@chromium.org>
This commit is contained in:
Gurchetan Singh 2020-01-21 15:39:30 -08:00 committed by Commit Bot
parent e058314700
commit 425aaacad1
2 changed files with 153 additions and 104 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
gpu_buffer/src/lib.rs
View file

@ -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.

249
gpu_buffer/src/raw.rs
View file

@ -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;
}