From 71d604a9b6d0f50f7cb8e500a3906586987c8e89 Mon Sep 17 00:00:00 2001 From: Rob Clark Date: Mon, 6 Aug 2012 11:31:55 -0500 Subject: [PATCH] sync w/ latest wayland (gbm_surface, etc) --- gbm.c | 207 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++------- gbm.h | 203 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--- gbmint.h | 32 +++++++--- 3 files changed, 404 insertions(+), 38 deletions(-) diff --git a/gbm.c b/gbm.c index 9459720..c58576d 100644 --- a/gbm.c +++ b/gbm.c @@ -84,8 +84,7 @@ gbm_device_get_backend_name(struct gbm_device *gbm) */ int gbm_device_is_format_supported(struct gbm_device *gbm, - enum gbm_bo_format format, - uint32_t usage) + uint32_t format, uint32_t usage) { return gbm->is_format_supported(gbm, format, usage); } @@ -197,12 +196,12 @@ gbm_bo_get_height(struct gbm_bo *bo) * gbm_bo_create() * * \param bo The buffer object - * \return The stride of the allocated buffer object + * \return The stride of the allocated buffer object in bytes */ GBM_EXPORT uint32_t -gbm_bo_get_pitch(struct gbm_bo *bo) +gbm_bo_get_stride(struct gbm_bo *bo) { - return bo->pitch; + return bo->stride; } /** Get the format of the buffer object @@ -232,6 +231,65 @@ gbm_bo_get_handle(struct gbm_bo *bo) return bo->handle; } +/** Write data into the buffer object + * + * If the buffer object was created with the GBM_BO_USE_WRITE flag, + * this function can used to write data into the buffer object. The + * data is copied directly into the object and it's the responsiblity + * of the caller to make sure the data represents valid pixel data, + * according to the width, height, stride and format of the buffer object. + * + * \param bo The buffer object + * \param buf The data to write + * \param count The number of bytes to write + * \return Returns -1 on error, 0 otherwise + */ +GBM_EXPORT int +gbm_bo_write(struct gbm_bo *bo, const void *buf, size_t count) +{ + return bo->gbm->bo_write(bo, buf, count); +} + +/** Get the gbm device used to create the buffer object + * + * \param bo The buffer object + * \return Returns the gbm device with which the buffer object was created + */ +GBM_EXPORT struct gbm_device * +gbm_bo_get_device(struct gbm_bo *bo) +{ + return bo->gbm; +} + +/** Set the user data associated with a buffer object + * + * \param bo The buffer object + * \param data The data to associate to the buffer object + * \param destroy_user_data A callback (which may be %NULL) that will be + * called prior to the buffer destruction + */ +GBM_EXPORT void +gbm_bo_set_user_data(struct gbm_bo *bo, void *data, + void (*destroy_user_data)(struct gbm_bo *, void *)) +{ + bo->user_data = data; + bo->destroy_user_data = destroy_user_data; +} + +/** Get the user data associated with a buffer object + * + * \param bo The buffer object + * \return Returns the user data associated with the buffer object or %NULL + * if no data was associated with it + * + * \sa gbm_bo_set_user_data() + */ +GBM_EXPORT void * +gbm_bo_get_user_data(struct gbm_bo *bo) +{ + return bo->user_data; +} + /** * Destroys the given buffer object and frees all resources associated with * it. @@ -241,6 +299,9 @@ gbm_bo_get_handle(struct gbm_bo *bo) GBM_EXPORT void gbm_bo_destroy(struct gbm_bo *bo) { + if (bo->destroy_user_data) + bo->destroy_user_data(bo, bo->user_data); + bo->gbm->bo_destroy(bo); } @@ -263,7 +324,7 @@ gbm_bo_destroy(struct gbm_bo *bo) GBM_EXPORT struct gbm_bo * gbm_bo_create(struct gbm_device *gbm, uint32_t width, uint32_t height, - enum gbm_bo_format format, uint32_t usage) + uint32_t format, uint32_t usage) { if (width == 0 || height == 0) return NULL; @@ -276,32 +337,136 @@ gbm_bo_create(struct gbm_device *gbm, } /** - * Create a buffer object representing the contents of an EGLImage + * Create a gbm buffer object from an foreign object + * + * This function imports a foreign object and creates a new gbm bo for it. + * This enabled using the foreign object with a display API such as KMS. + * Currently two types of foreign objects are supported, indicated by the type + * argument: + * + * GBM_BO_IMPORT_WL_BUFFER + * GBM_BO_IMPORT_EGL_IMAGE + * + * The the gbm bo shares the underlying pixels but its life-time is + * independent of the foreign object. * * \param gbm The gbm device returned from gbm_create_device() - * \param egl_dpy The EGLDisplay on which the EGLImage was created - * \param egl_image The EGLImage to create the buffer from - * \param width The width to use in the creation of the buffer object - * \param height The height to use in the creation of the buffer object + * \param gbm The type of object we're importing + * \param gbm Pointer to the external object * \param usage The union of the usage flags for this buffer * * \return A newly allocated buffer object that should be freed with * gbm_bo_destroy() when no longer needed. * * \sa enum gbm_bo_flags for the list of usage flags + */ +GBM_EXPORT struct gbm_bo * +gbm_bo_import(struct gbm_device *gbm, + uint32_t type, void *buffer, uint32_t usage) +{ + return gbm->bo_import(gbm, type, buffer, usage); +} + +/** + * Allocate a surface object + * + * \param gbm The gbm device returned from gbm_create_device() + * \param width The width for the surface + * \param height The height for the surface + * \param format The format to use for the surface + * + * \return A newly allocated surface that should be freed with + * gbm_surface_destroy() when no longer needed. If an error occurs + * during allocation %NULL will be returned. + * + * \sa enum gbm_bo_format for the list of formats + */ +GBM_EXPORT struct gbm_surface * +gbm_surface_create(struct gbm_device *gbm, + uint32_t width, uint32_t height, + uint32_t format, uint32_t flags) +{ + return gbm->surface_create(gbm, width, height, format, flags); +} + +/** + * Destroys the given surface and frees all resources associated with + * it. + * + * All buffers locked with gbm_surface_lock_front_buffer() should be + * released prior to calling this function. + * + * \param surf The surface + */ +GBM_EXPORT void +gbm_surface_destroy(struct gbm_surface *surf) +{ + surf->gbm->surface_destroy(surf); +} + +/** + * Lock the surface's current front buffer + * + * Lock rendering to the surface's current front buffer until it is + * released with gbm_surface_release_buffer(). + * + * This function must be called exactly once after calling + * eglSwapBuffers. Calling it before any eglSwapBuffer has happened + * on the surface or two or more times after eglSwapBuffers is an + * error. A new bo representing the new front buffer is returned. On + * multiple invocations, all the returned bos must be released in + * order to release the actual surface buffer. * - * \note The expectation is that this function will use an efficient method - * for making the contents of the EGLImage available as a buffer object. + * \param surf The surface + * + * \return A buffer object that should be released with + * gbm_surface_release_buffer() when no longer needed. The implementation + * is free to reuse buffers released with gbm_surface_release_buffer() so + * this bo should not be destroyed using gbm_bo_destroy(). If an error + * occurs this function returns %NULL. */ GBM_EXPORT struct gbm_bo * -gbm_bo_create_from_egl_image(struct gbm_device *gbm, - void *egl_dpy, void *egl_image, - uint32_t width, uint32_t height, - uint32_t usage) +gbm_surface_lock_front_buffer(struct gbm_surface *surf) { - if (width == 0 || height == 0) - return NULL; + return surf->gbm->surface_lock_front_buffer(surf); +} + +/** + * Release a locked buffer obtained with gbm_surface_lock_front_buffer() + * + * Returns the underlying buffer to the gbm surface. Releasing a bo + * will typically make gbm_surface_has_free_buffer() return 1 and thus + * allow rendering the next frame, but not always. The implementation + * may choose to destroy the bo immediately or reuse it, in which case + * the user data associated with it is unchanged. + * + * \param surf The surface + * \param bo The buffer object + */ +GBM_EXPORT void +gbm_surface_release_buffer(struct gbm_surface *surf, struct gbm_bo *bo) +{ + surf->gbm->surface_release_buffer(surf, bo); +} - return gbm->bo_create_from_egl_image(gbm, egl_dpy, egl_image, - width, height, usage); +/** + * Return whether or not a surface has free (non-locked) buffers + * + * Before starting a new frame, the surface must have a buffer + * available for rendering. Initially, a gbm surface will have a free + * buffer, but after one of more buffers have been locked (\sa + * gbm_surface_lock_front_buffer()), the application must check for a + * free buffer before rendering. + * + * If a surface doesn't have a free buffer, the application must + * return a buffer to the surface using gbm_surface_release_buffer() + * and after that, the application can query for free buffers again. + * + * \param surf The surface + * \return 1 if the surface has free buffers, 0 otherwise + */ +GBM_EXPORT int +gbm_surface_has_free_buffers(struct gbm_surface *surf) +{ + return surf->gbm->surface_has_free_buffers(surf); } diff --git a/gbm.h b/gbm.h index 05d2292..9d2a030 100644 --- a/gbm.h +++ b/gbm.h @@ -37,9 +37,29 @@ extern "C" { #include +/** + * \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; @@ -48,15 +68,145 @@ union gbm_bo_handle { uint64_t u64; }; +/** Format of the allocated buffer */ enum gbm_bo_format { - GBM_BO_FORMAT_XRGB8888, - GBM_BO_FORMAT_ARGB8888, + /** 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 }; +#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 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 */ + +/* 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 */ + + +/** + * 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 - the dimensions for the buffer + * must be 64x64 if this flag is passed. + */ GBM_BO_USE_CURSOR_64X64 = (1 << 1), + /** + * 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_64X64. but may not work for other + * combinations. + */ + GBM_BO_USE_WRITE = (1 << 3), }; int @@ -67,8 +217,7 @@ gbm_device_get_backend_name(struct gbm_device *gbm); int gbm_device_is_format_supported(struct gbm_device *gbm, - enum gbm_bo_format format, - uint32_t usage); + uint32_t format, uint32_t usage); void gbm_device_destroy(struct gbm_device *gbm); @@ -79,13 +228,14 @@ gbm_create_device(int fd); struct gbm_bo * gbm_bo_create(struct gbm_device *gbm, uint32_t width, uint32_t height, - enum gbm_bo_format format, uint32_t flags); + uint32_t format, uint32_t flags); + +#define GBM_BO_IMPORT_WL_BUFFER 0x5501 +#define GBM_BO_IMPORT_EGL_IMAGE 0x5502 struct gbm_bo * -gbm_bo_create_from_egl_image(struct gbm_device *gbm, - void *egl_dpy, void *egl_img, - uint32_t width, uint32_t height, - uint32_t usage); +gbm_bo_import(struct gbm_device *gbm, uint32_t type, + void *buffer, uint32_t usage); uint32_t gbm_bo_get_width(struct gbm_bo *bo); @@ -94,14 +244,47 @@ uint32_t gbm_bo_get_height(struct gbm_bo *bo); uint32_t -gbm_bo_get_pitch(struct gbm_bo *bo); +gbm_bo_get_stride(struct gbm_bo *bo); + +uint32_t +gbm_bo_get_format(struct gbm_bo *bo); + +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_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_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); + #ifdef __cplusplus } #endif diff --git a/gbmint.h b/gbmint.h index 66c4c41..a467bea 100644 --- a/gbmint.h +++ b/gbmint.h @@ -59,18 +59,26 @@ struct gbm_device { void (*destroy)(struct gbm_device *gbm); int (*is_format_supported)(struct gbm_device *gbm, - enum gbm_bo_format format, + uint32_t format, uint32_t usage); struct gbm_bo *(*bo_create)(struct gbm_device *gbm, uint32_t width, uint32_t height, - enum gbm_bo_format format, + uint32_t format, uint32_t usage); - struct gbm_bo *(*bo_create_from_egl_image)(struct gbm_device *gbm, - void *egl_dpy, void *egl_img, - uint32_t width, uint32_t height, - uint32_t usage); + struct gbm_bo *(*bo_import)(struct gbm_device *gbm, uint32_t type, + void *buffer, uint32_t usage); + int (*bo_write)(struct gbm_bo *bo, const void *buf, size_t data); void (*bo_destroy)(struct gbm_bo *bo); + + struct gbm_surface *(*surface_create)(struct gbm_device *gbm, + uint32_t width, uint32_t height, + uint32_t format, uint32_t flags); + struct gbm_bo *(*surface_lock_front_buffer)(struct gbm_surface *surface); + void (*surface_release_buffer)(struct gbm_surface *surface, + struct gbm_bo *bo); + int (*surface_has_free_buffers)(struct gbm_surface *surface); + void (*surface_destroy)(struct gbm_surface *surface); }; /** @@ -82,9 +90,19 @@ struct gbm_bo { struct gbm_device *gbm; uint32_t width; uint32_t height; - uint32_t pitch; + uint32_t stride; uint32_t format; union gbm_bo_handle handle; + void *user_data; + void (*destroy_user_data)(struct gbm_bo *, void *); +}; + +struct gbm_surface { + struct gbm_device *gbm; + uint32_t width; + uint32_t height; + uint32_t format; + uint32_t flags; }; struct gbm_backend { -- 2.7.4