gpu_buffer: update minigbm bindings

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>

2 files changed, 142 insertions, 93 deletions

diff --git a/gpu_buffer/src/lib.rs b/gpu_buffer/src/lib.rs
index 3bc4b24..5d25fa2 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 b4255ca..6f5686a 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,64 +135,74 @@ 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_map(
-        bo: *mut gbm_bo,
-        x: u32,
-        y: u32,
-        width: u32,
-        height: u32,
-        flags: u32,
-        stride: *mut u32,
-        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);
+}
+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;
-    pub fn gbm_bo_get_stride_or_tiling(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;
-    pub fn gbm_bo_get_modifier(bo: *mut gbm_bo) -> u64;
+}
+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;
-    pub fn gbm_bo_get_plane_count(bo: *mut gbm_bo) -> usize;
+}
+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;
-    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.
+}
+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: extern "C" fn(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,
@@ -208,8 +210,61 @@ extern "C" {
         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,
+        x: u32,
+        y: u32,
+        width: u32,
+        height: u32,
+        flags: u32,
+        stride: *mut u32,
+        map_data: *mut *mut c_void,
+        plane: usize,
+    ) -> *mut c_void;
+}
+extern "C" {
+    pub fn gbm_bo_map2(
+        bo: *mut gbm_bo,
+        x: u32,
+        y: u32,
+        width: u32,
+        height: u32,
+        flags: u32,
+        stride: *mut u32,
+        map_data: *mut *mut c_void,
+        plane: c_int,
+    ) -> *mut c_void;
+}