X-Git-Url: https://git.libre-soc.org/?p=mesa.git;a=blobdiff_plain;f=src%2Fgbm%2Fmain%2Fgbm.c;h=ceeed5082e9c08bdda52028ca80093713f74a4e9;hp=0b5b9ff0b7091a97f6f19e409be049515f36176b;hb=4861d2a3956fd7394fa2da6337a0418cbb00dc82;hpb=55aab92495692f453c04f5b99e67bcb77cd27e14 diff --git a/src/gbm/main/gbm.c b/src/gbm/main/gbm.c index 0b5b9ff0b70..ceeed5082e9 100644 --- a/src/gbm/main/gbm.c +++ b/src/gbm/main/gbm.c @@ -25,29 +25,26 @@ * Benjamin Franzke */ -#define _BSD_SOURCE - #include #include #include #include #include -#include +#ifdef MAJOR_IN_MKDEV +#include +#endif +#ifdef MAJOR_IN_SYSMACROS +#include +#endif #include #include +#include #include "gbm.h" #include "gbmint.h" -#include "common.h" #include "backend.h" -#define ARRAY_SIZE(a) (sizeof(a)/sizeof((a)[0])) - -struct gbm_device *devices[16]; - -static int device_num = 0; - /** Returns the file description for the gbm device * * \return The fd that the struct gbm_device was created with @@ -58,7 +55,6 @@ gbm_device_get_fd(struct gbm_device *gbm) return gbm->fd; } -/* FIXME: maybe superfluous, use udev subclass from the fd? */ /** Get the backend name for the given gbm device * * \return The backend name string - this belongs to the device and must not @@ -82,13 +78,27 @@ gbm_device_get_backend_name(struct gbm_device *gbm) * * \sa enum gbm_bo_format for the list of formats */ -int +GBM_EXPORT int gbm_device_is_format_supported(struct gbm_device *gbm, uint32_t format, uint32_t usage) { return gbm->is_format_supported(gbm, format, usage); } +/** Get the number of planes that are required for a given format+modifier + * + * \param gbm The gbm device returned from gbm_create_device() + * \param format The format to query + * \param modifier The modifier to query + */ +GBM_EXPORT int +gbm_device_get_format_modifier_plane_count(struct gbm_device *gbm, + uint32_t format, + uint64_t modifier) +{ + return gbm->get_format_modifier_plane_count(gbm, format, modifier); +} + /** Destroy the gbm device and free all resources associated with it. * * \param gbm The device created using gbm_create_device() @@ -101,32 +111,6 @@ gbm_device_destroy(struct gbm_device *gbm) gbm->destroy(gbm); } -GBM_EXPORT struct gbm_device * -_gbm_mesa_get_device(int fd) -{ - struct gbm_device *gbm = NULL; - struct stat buf; - dev_t dev; - int i; - - if (fd < 0 || fstat(fd, &buf) < 0 || !S_ISCHR(buf.st_mode)) { - fprintf(stderr, "_gbm_mesa_get_device: invalid fd: %d\n", fd); - return NULL; - } - - for (i = 0; i < device_num; ++i) { - dev = devices[i]->stat.st_rdev; - if (major(dev) == major(buf.st_rdev) && - minor(dev) == minor(buf.st_rdev)) { - gbm = devices[i]; - gbm->refcount++; - break; - } - } - - return gbm; -} - /** Create a gbm device for allocating buffers * * The file descriptor passed in is used by the backend to communicate with @@ -134,7 +118,7 @@ _gbm_mesa_get_device(int fd) * the file descriptor returned when opening a device such as \c * /dev/dri/card0 * - * \param fd The file descriptor for an backend specific device + * \param fd The file descriptor for a backend specific device * \return The newly created struct gbm_device. The resources associated with * the device should be freed with gbm_device_destroy() when it is no longer * needed. If the creation of the device failed NULL will be returned. @@ -146,13 +130,10 @@ gbm_create_device(int fd) struct stat buf; if (fd < 0 || fstat(fd, &buf) < 0 || !S_ISCHR(buf.st_mode)) { - fprintf(stderr, "gbm_create_device: invalid fd: %d\n", fd); + errno = EINVAL; return NULL; } - if (device_num == 0) - memset(devices, 0, sizeof devices); - gbm = _gbm_create_device(fd); if (gbm == NULL) return NULL; @@ -161,9 +142,6 @@ gbm_create_device(int fd) gbm->stat = buf; gbm->refcount = 1; - if (device_num < ARRAY_SIZE(devices)-1) - devices[device_num++] = gbm; - return gbm; } @@ -173,7 +151,7 @@ gbm_create_device(int fd) * \return The width of the allocated buffer object * */ -GBM_EXPORT unsigned int +GBM_EXPORT uint32_t gbm_bo_get_width(struct gbm_bo *bo) { return bo->width; @@ -184,7 +162,7 @@ gbm_bo_get_width(struct gbm_bo *bo) * \param bo The buffer object * \return The height of the allocated buffer object */ -GBM_EXPORT unsigned int +GBM_EXPORT uint32_t gbm_bo_get_height(struct gbm_bo *bo) { return bo->height; @@ -196,12 +174,25 @@ 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 gbm_bo_get_stride_for_plane(bo, 0); +} + +/** Get the stride for the given plane + * + * \param bo The buffer object + * \param plane for which you want the stride + * + * \sa gbm_bo_get_stride() + */ +GBM_EXPORT uint32_t +gbm_bo_get_stride_for_plane(struct gbm_bo *bo, int plane) +{ + return bo->gbm->bo_get_stride(bo, plane); } /** Get the format of the buffer object @@ -209,7 +200,7 @@ gbm_bo_get_pitch(struct gbm_bo *bo) * The format of the pixels in the buffer. * * \param bo The buffer object - * \return The format of buffer object, on of the GBM_FORMAT_* codes + * \return The format of buffer object, one of the GBM_FORMAT_* codes */ GBM_EXPORT uint32_t gbm_bo_get_format(struct gbm_bo *bo) @@ -217,6 +208,101 @@ gbm_bo_get_format(struct gbm_bo *bo) return bo->format; } +/** Get the bit-per-pixel of the buffer object's format + * + * The bits-per-pixel of the buffer object's format. + * + * Note; The 'in-memory pixel' concept makes no sense for YUV formats + * (pixels are the result of the combination of multiple memory sources: + * Y, Cb & Cr; usually these are even in separate buffers), so YUV + * formats are not supported by this function. + * + * \param bo The buffer object + * \return The number of bits0per-pixel of the buffer object's format. + */ +GBM_EXPORT uint32_t +gbm_bo_get_bpp(struct gbm_bo *bo) +{ + switch (bo->format) { + default: + return 0; + case GBM_FORMAT_C8: + case GBM_FORMAT_R8: + case GBM_FORMAT_RGB332: + case GBM_FORMAT_BGR233: + return 8; + case GBM_FORMAT_GR88: + case GBM_FORMAT_XRGB4444: + case GBM_FORMAT_XBGR4444: + case GBM_FORMAT_RGBX4444: + case GBM_FORMAT_BGRX4444: + case GBM_FORMAT_ARGB4444: + case GBM_FORMAT_ABGR4444: + case GBM_FORMAT_RGBA4444: + case GBM_FORMAT_BGRA4444: + case GBM_FORMAT_XRGB1555: + case GBM_FORMAT_XBGR1555: + case GBM_FORMAT_RGBX5551: + case GBM_FORMAT_BGRX5551: + case GBM_FORMAT_ARGB1555: + case GBM_FORMAT_ABGR1555: + case GBM_FORMAT_RGBA5551: + case GBM_FORMAT_BGRA5551: + case GBM_FORMAT_RGB565: + case GBM_FORMAT_BGR565: + return 16; + case GBM_FORMAT_RGB888: + case GBM_FORMAT_BGR888: + return 24; + case GBM_FORMAT_XRGB8888: + case GBM_FORMAT_XBGR8888: + case GBM_FORMAT_RGBX8888: + case GBM_FORMAT_BGRX8888: + case GBM_FORMAT_ARGB8888: + case GBM_FORMAT_ABGR8888: + case GBM_FORMAT_RGBA8888: + case GBM_FORMAT_BGRA8888: + case GBM_FORMAT_XRGB2101010: + case GBM_FORMAT_XBGR2101010: + case GBM_FORMAT_RGBX1010102: + case GBM_FORMAT_BGRX1010102: + case GBM_FORMAT_ARGB2101010: + case GBM_FORMAT_ABGR2101010: + case GBM_FORMAT_RGBA1010102: + case GBM_FORMAT_BGRA1010102: + return 32; + case GBM_FORMAT_XBGR16161616F: + case GBM_FORMAT_ABGR16161616F: + return 64; + } +} + +/** Get the offset for the data of the specified plane + * + * Extra planes, and even the first plane, may have an offset from the start of + * the buffer object. This function will provide the offset for the given plane + * to be used in various KMS APIs. + * + * \param bo The buffer object + * \return The offset + */ +GBM_EXPORT uint32_t +gbm_bo_get_offset(struct gbm_bo *bo, int plane) +{ + return bo->gbm->bo_get_offset(bo, plane); +} + +/** 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; +} + /** Get the handle of the buffer object * * This is stored in the platform generic union gbm_bo_handle type. However @@ -231,6 +317,90 @@ gbm_bo_get_handle(struct gbm_bo *bo) return bo->handle; } +/** Get a DMA-BUF file descriptor for the buffer object + * + * This function creates a DMA-BUF (also known as PRIME) file descriptor + * handle for the buffer object. Each call to gbm_bo_get_fd() returns a new + * file descriptor and the caller is responsible for closing the file + * descriptor. + + * \param bo The buffer object + * \return Returns a file descriptor referring to the underlying buffer or -1 + * if an error occurs. + */ +GBM_EXPORT int +gbm_bo_get_fd(struct gbm_bo *bo) +{ + return bo->gbm->bo_get_fd(bo); +} + +/** Get the number of planes for the given bo. + * + * \param bo The buffer object + * \return The number of planes + */ +GBM_EXPORT int +gbm_bo_get_plane_count(struct gbm_bo *bo) +{ + return bo->gbm->bo_get_planes(bo); +} + +/** Get the handle for the specified plane of the buffer object + * + * This function gets the handle for any plane associated with the BO. When + * dealing with multi-planar formats, or formats which might have implicit + * planes based on different underlying hardware it is necessary for the client + * to be able to get this information to pass to the DRM. + * + * \param bo The buffer object + * \param plane the plane to get a handle for + * + * \sa gbm_bo_get_handle() + */ +GBM_EXPORT union gbm_bo_handle +gbm_bo_get_handle_for_plane(struct gbm_bo *bo, int plane) +{ + return bo->gbm->bo_get_handle(bo, plane); +} + +/** + * Get the chosen modifier for the buffer object + * + * This function returns the modifier that was chosen for the object. These + * properties may be generic, or platform/implementation dependent. + * + * \param bo The buffer object + * \return Returns the selected modifier (chosen by the implementation) for the + * BO. + * \sa gbm_bo_create_with_modifiers() where possible modifiers are set + * \sa gbm_surface_create_with_modifiers() where possible modifiers are set + * \sa define DRM_FORMAT_MOD_* in drm_fourcc.h for possible modifiers + */ +GBM_EXPORT uint64_t +gbm_bo_get_modifier(struct gbm_bo *bo) +{ + return bo->gbm->bo_get_modifier(bo); +} + +/** Write data into the buffer object + * + * If the buffer object was created with the GBM_BO_USE_WRITE flag, + * this function can be used to write data into the buffer object. The + * data is copied directly into the object and it's the responsibility + * 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 0 on success, otherwise -1 is returned an errno set + */ +GBM_EXPORT int +gbm_bo_write(struct gbm_bo *bo, const void *buf, size_t count) +{ + return bo->gbm->bo_write(bo, buf, count); +} + /** Set the user data associated with a buffer object * * \param bo The buffer object @@ -281,14 +451,14 @@ gbm_bo_destroy(struct gbm_bo *bo) * \param gbm The gbm device returned from gbm_create_device() * \param width The width for the buffer * \param height The height for the buffer - * \param format The format to use for the buffer + * \param format The format to use for the buffer, from GBM_FORMAT_* or + * GBM_BO_FORMAT_* tokens * \param usage The union of the usage flags for this buffer * * \return A newly allocated buffer that should be freed with gbm_bo_destroy() * when no longer needed. If an error occurs during allocation %NULL will be - * returned. + * returned and errno set. * - * \sa enum gbm_bo_format for the list of formats * \sa enum gbm_bo_flags for the list of usage flags */ GBM_EXPORT struct gbm_bo * @@ -296,45 +466,119 @@ gbm_bo_create(struct gbm_device *gbm, uint32_t width, uint32_t height, uint32_t format, uint32_t usage) { - if (width == 0 || height == 0) + if (width == 0 || height == 0) { + errno = EINVAL; + return NULL; + } + + return gbm->bo_create(gbm, width, height, format, usage, NULL, 0); +} + +GBM_EXPORT struct gbm_bo * +gbm_bo_create_with_modifiers(struct gbm_device *gbm, + uint32_t width, uint32_t height, + uint32_t format, + const uint64_t *modifiers, + const unsigned int count) +{ + if (width == 0 || height == 0) { + errno = EINVAL; return NULL; + } - if (usage & GBM_BO_USE_CURSOR_64X64 && - (width != 64 || height != 64)) + if ((count && !modifiers) || (modifiers && !count)) { + errno = EINVAL; return NULL; + } - return gbm->bo_create(gbm, width, height, format, usage); + return gbm->bo_create(gbm, width, height, format, 0, modifiers, count); } /** - * Create a buffer object representing the contents of an EGLImage + * Create a gbm buffer object from a foreign object + * + * This function imports a foreign object and creates a new gbm bo for it. + * This enables using the foreign object with a display API such as KMS. + * Currently these types of foreign objects are supported, indicated by the type + * argument: + * + * GBM_BO_IMPORT_WL_BUFFER + * GBM_BO_IMPORT_EGL_IMAGE + * GBM_BO_IMPORT_FD + * GBM_BO_IMPORT_FD_MODIFIER + * + * 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 type The type of object we're importing + * \param buffer 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. + * gbm_bo_destroy() when no longer needed. On error, %NULL is returned + * and errno is set. * * \sa enum gbm_bo_flags for the list of usage flags - * - * \note The expectation is that this function will use an efficient method - * for making the contents of the EGLImage available as a buffer object. */ 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_bo_import(struct gbm_device *gbm, + uint32_t type, void *buffer, uint32_t usage) { - if (width == 0 || height == 0) + return gbm->bo_import(gbm, type, buffer, usage); +} + +/** + * Map a region of a gbm buffer object for cpu access + * + * This function maps a region of a gbm bo for cpu read and/or write + * access. + * + * \param bo The buffer object + * \param x The X (top left origin) starting position of the mapped region for + * the buffer + * \param y The Y (top left origin) starting position of the mapped region for + * the buffer + * \param width The width of the mapped region for the buffer + * \param height The height of the mapped region for the buffer + * \param flags The union of the GBM_BO_TRANSFER_* flags for this buffer + * \param stride Ptr for returned stride in bytes of the mapped region + * \param map_data Returned opaque ptr for the mapped region + * + * \return Address of the mapped buffer that should be unmapped with + * gbm_bo_unmap() when no longer needed. On error, %NULL is returned + * and errno is set. + * + * \sa enum gbm_bo_transfer_flags for the list of flags + */ +GBM_EXPORT void * +gbm_bo_map(struct gbm_bo *bo, + uint32_t x, uint32_t y, + uint32_t width, uint32_t height, + uint32_t flags, uint32_t *stride, void **map_data) +{ + if (!bo || width == 0 || height == 0 || !stride || !map_data) { + errno = EINVAL; return NULL; + } + + return bo->gbm->bo_map(bo, x, y, width, height, + flags, stride, map_data); +} - return gbm->bo_create_from_egl_image(gbm, egl_dpy, egl_image, - width, height, usage); +/** + * Unmap a previously mapped region of a gbm buffer object + * + * This function unmaps a region of a gbm bo for cpu read and/or write + * access. + * + * \param bo The buffer object + * \param map_data opaque ptr returned from prior gbm_bo_map + */ +GBM_EXPORT void +gbm_bo_unmap(struct gbm_bo *bo, void *map_data) +{ + bo->gbm->bo_unmap(bo, map_data); } /** @@ -356,7 +600,23 @@ 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); + return gbm->surface_create(gbm, width, height, format, flags, NULL, 0); +} + +GBM_EXPORT struct gbm_surface * +gbm_surface_create_with_modifiers(struct gbm_device *gbm, + uint32_t width, uint32_t height, + uint32_t format, + const uint64_t *modifiers, + const unsigned int count) +{ + if ((count && !modifiers) || (modifiers && !count)) { + errno = EINVAL; + return NULL; + } + + return gbm->surface_create(gbm, width, height, format, 0, + modifiers, count); } /** @@ -424,7 +684,7 @@ gbm_surface_release_buffer(struct gbm_surface *surf, struct gbm_bo *bo) * * 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 + * buffer, but after one or more buffers have been locked (\sa * gbm_surface_lock_front_buffer()), the application must check for a * free buffer before rendering. * @@ -440,3 +700,39 @@ gbm_surface_has_free_buffers(struct gbm_surface *surf) { return surf->gbm->surface_has_free_buffers(surf); } + +/* The two GBM_BO_FORMAT_[XA]RGB8888 formats alias the GBM_FORMAT_* + * formats of the same name. We want to accept them whenever someone + * has a GBM format, but never return them to the user. */ +uint32_t +gbm_format_canonicalize(uint32_t gbm_format) +{ + switch (gbm_format) { + case GBM_BO_FORMAT_XRGB8888: + return GBM_FORMAT_XRGB8888; + case GBM_BO_FORMAT_ARGB8888: + return GBM_FORMAT_ARGB8888; + default: + return gbm_format; + } +} + +/** + * Returns a string representing the fourcc format name. + * + * \param desc Caller-provided storage for the format name string. + * \return String containing the fourcc of the format. + */ +GBM_EXPORT char * +gbm_format_get_name(uint32_t gbm_format, struct gbm_format_name_desc *desc) +{ + gbm_format = gbm_format_canonicalize(gbm_format); + + desc->name[0] = gbm_format; + desc->name[1] = gbm_format >> 8; + desc->name[2] = gbm_format >> 16; + desc->name[3] = gbm_format >> 24; + desc->name[4] = 0; + + return desc->name; +}