mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-12-29 11:40:38 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/gst-libs/gst/gl/gbm/gstgl_gbm_utils.c
Carlos Rafael Giani 4df219f336 gl: Add Mesa3D GBM backend 
This makes it possible to use the GStreamer OpenGL elements without a
windowing system if a libdrm- and Mesa3D-supported GPU is present

https://bugzilla.gnome.org/show_bug.cgi?id=782923
2018-02-23 21:09:45 -05:00

529 lines
14 KiB
C
Raw Blame History

/*
* GStreamer
* Copyright (C) 2018 Carlos Rafael Giani <dv@pseudoterminal.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#include <unistd.h>
#include <fcntl.h>
#include <gudev/gudev.h>
#include "gstgl_gbm_utils.h"
GST_DEBUG_CATEGORY_EXTERN (gst_gl_gbm_debug);
#define GST_CAT_DEFAULT gst_gl_gbm_debug
const gchar *
gst_gl_gbm_get_name_for_drm_connector (drmModeConnector * connector)
{
g_assert (connector != NULL);
switch (connector->connector_type) {
case DRM_MODE_CONNECTOR_Unknown:
return "Unknown";
case DRM_MODE_CONNECTOR_VGA:
return "VGA";
case DRM_MODE_CONNECTOR_DVII:
return "DVI-I";
case DRM_MODE_CONNECTOR_DVID:
return "DVI-D";
case DRM_MODE_CONNECTOR_DVIA:
return "DVI-A";
case DRM_MODE_CONNECTOR_Composite:
return "Composite";
case DRM_MODE_CONNECTOR_SVIDEO:
return "S-Video";
case DRM_MODE_CONNECTOR_LVDS:
return "LVDS";
case DRM_MODE_CONNECTOR_Component:
return "Component";
case DRM_MODE_CONNECTOR_9PinDIN:
return "9-Pin DIN";
case DRM_MODE_CONNECTOR_DisplayPort:
return "DisplayPort";
case DRM_MODE_CONNECTOR_HDMIA:
return "HDMI-A";
case DRM_MODE_CONNECTOR_HDMIB:
return "HDMI-B";
case DRM_MODE_CONNECTOR_TV:
return "TV";
case DRM_MODE_CONNECTOR_eDP:
return "eDP";
case DRM_MODE_CONNECTOR_VIRTUAL:
return "Virtual";
case DRM_MODE_CONNECTOR_DSI:
return "DSI";
default:
return "<unknown>";
}
}
const gchar *
gst_gl_gbm_get_name_for_drm_encoder (drmModeEncoder * encoder)
{
switch (encoder->encoder_type) {
case DRM_MODE_ENCODER_NONE:
return "none";
case DRM_MODE_ENCODER_DAC:
return "DAC";
case DRM_MODE_ENCODER_TMDS:
return "TMDS";
case DRM_MODE_ENCODER_LVDS:
return "LVDS";
case DRM_MODE_ENCODER_TVDAC:
return "TVDAC";
case DRM_MODE_ENCODER_VIRTUAL:
return "Virtual";
case DRM_MODE_ENCODER_DSI:
return "DSI";
default:
return "<unknown>";
}
}
const gchar *
gst_gl_gbm_format_to_string (guint32 format)
{
if (format == GBM_BO_FORMAT_XRGB8888)
format = GBM_FORMAT_XRGB8888;
if (format == GBM_BO_FORMAT_ARGB8888)
format = GBM_FORMAT_ARGB8888;
switch (format) {
case GBM_FORMAT_C8:
return "C8";
case GBM_FORMAT_RGB332:
return "RGB332";
case GBM_FORMAT_BGR233:
return "BGR233";
case GBM_FORMAT_NV12:
return "NV12";
case GBM_FORMAT_XRGB4444:
return "XRGB4444";
case GBM_FORMAT_XBGR4444:
return "XBGR4444";
case GBM_FORMAT_RGBX4444:
return "RGBX4444";
case GBM_FORMAT_BGRX4444:
return "BGRX4444";
case GBM_FORMAT_XRGB1555:
return "XRGB1555";
case GBM_FORMAT_XBGR1555:
return "XBGR1555";
case GBM_FORMAT_RGBX5551:
return "RGBX5551";
case GBM_FORMAT_BGRX5551:
return "BGRX5551";
case GBM_FORMAT_ARGB4444:
return "ARGB4444";
case GBM_FORMAT_ABGR4444:
return "ABGR4444";
case GBM_FORMAT_RGBA4444:
return "RGBA4444";
case GBM_FORMAT_BGRA4444:
return "BGRA4444";
case GBM_FORMAT_ARGB1555:
return "ARGB1555";
case GBM_FORMAT_ABGR1555:
return "ABGR1555";
case GBM_FORMAT_RGBA5551:
return "RGBA5551";
case GBM_FORMAT_BGRA5551:
return "BGRA5551";
case GBM_FORMAT_RGB565:
return "RGB565";
case GBM_FORMAT_BGR565:
return "BGR565";
case GBM_FORMAT_YUYV:
return "YUYV";
case GBM_FORMAT_YVYU:
return "YVYU";
case GBM_FORMAT_UYVY:
return "UYVY";
case GBM_FORMAT_VYUY:
return "VYUY";
case GBM_FORMAT_RGB888:
return "RGB888";
case GBM_FORMAT_BGR888:
return "BGR888";
case GBM_FORMAT_XRGB8888:
return "XRGB8888";
case GBM_FORMAT_XBGR8888:
return "XBGR8888";
case GBM_FORMAT_RGBX8888:
return "RGBX8888";
case GBM_FORMAT_BGRX8888:
return "BGRX8888";
case GBM_FORMAT_AYUV:
return "AYUV";
case GBM_FORMAT_XRGB2101010:
return "XRGB2101010";
case GBM_FORMAT_XBGR2101010:
return "XBGR2101010";
case GBM_FORMAT_RGBX1010102:
return "RGBX1010102";
case GBM_FORMAT_BGRX1010102:
return "BGRX1010102";
case GBM_FORMAT_ARGB8888:
return "ARGB8888";
case GBM_FORMAT_ABGR8888:
return "ABGR8888";
case GBM_FORMAT_RGBA8888:
return "RGBA8888";
case GBM_FORMAT_BGRA8888:
return "BGRA8888";
case GBM_FORMAT_ARGB2101010:
return "ARGB2101010";
case GBM_FORMAT_ABGR2101010:
return "ABGR2101010";
case GBM_FORMAT_RGBA1010102:
return "RGBA1010102";
case GBM_FORMAT_BGRA1010102:
return "BGRA1010102";
default:
return "<unknown>";
}
return NULL;
}
int
gst_gl_gbm_depth_from_format (guint32 format)
{
if (format == GBM_BO_FORMAT_XRGB8888)
format = GBM_FORMAT_XRGB8888;
if (format == GBM_BO_FORMAT_ARGB8888)
format = GBM_FORMAT_ARGB8888;
switch (format) {
case GBM_FORMAT_C8:
case GBM_FORMAT_RGB332:
case GBM_FORMAT_BGR233:
return 8;
case GBM_FORMAT_NV12:
case GBM_FORMAT_XRGB4444:
case GBM_FORMAT_XBGR4444:
case GBM_FORMAT_RGBX4444:
case GBM_FORMAT_BGRX4444:
return 12;
case GBM_FORMAT_XRGB1555:
case GBM_FORMAT_XBGR1555:
case GBM_FORMAT_RGBX5551:
case GBM_FORMAT_BGRX5551:
return 15;
case GBM_FORMAT_ARGB4444:
case GBM_FORMAT_ABGR4444:
case GBM_FORMAT_RGBA4444:
case GBM_FORMAT_BGRA4444:
case GBM_FORMAT_ARGB1555:
case GBM_FORMAT_ABGR1555:
case GBM_FORMAT_RGBA5551:
case GBM_FORMAT_BGRA5551:
case GBM_FORMAT_RGB565:
case GBM_FORMAT_BGR565:
case GBM_FORMAT_YUYV:
case GBM_FORMAT_YVYU:
case GBM_FORMAT_UYVY:
case GBM_FORMAT_VYUY:
return 16;
case GBM_FORMAT_RGB888:
case GBM_FORMAT_BGR888:
case GBM_FORMAT_XRGB8888:
case GBM_FORMAT_XBGR8888:
case GBM_FORMAT_RGBX8888:
case GBM_FORMAT_BGRX8888:
case GBM_FORMAT_AYUV:
return 24;
case GBM_FORMAT_XRGB2101010:
case GBM_FORMAT_XBGR2101010:
case GBM_FORMAT_RGBX1010102:
case GBM_FORMAT_BGRX1010102:
return 30;
case GBM_FORMAT_ARGB8888:
case GBM_FORMAT_ABGR8888:
case GBM_FORMAT_RGBA8888:
case GBM_FORMAT_BGRA8888:
case GBM_FORMAT_ARGB2101010:
case GBM_FORMAT_ABGR2101010:
case GBM_FORMAT_RGBA1010102:
case GBM_FORMAT_BGRA1010102:
return 32;
default:
GST_ERROR ("unknown GBM format %" G_GUINT32_FORMAT, format);
}
return 0;
}
int
gst_gl_gbm_bpp_from_format (guint32 format)
{
if (format == GBM_BO_FORMAT_XRGB8888)
format = GBM_FORMAT_XRGB8888;
if (format == GBM_BO_FORMAT_ARGB8888)
format = GBM_FORMAT_ARGB8888;
switch (format) {
case GBM_FORMAT_C8:
case GBM_FORMAT_RGB332:
case GBM_FORMAT_BGR233:
return 8;
case GBM_FORMAT_NV12:
return 12;
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:
case GBM_FORMAT_YUYV:
case GBM_FORMAT_YVYU:
case GBM_FORMAT_UYVY:
case GBM_FORMAT_VYUY:
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:
case GBM_FORMAT_AYUV:
return 32;
default:
GST_ERROR ("unknown GBM format %" G_GUINT32_FORMAT, format);
}
return 0;
}
static void
gst_gl_gbm_drm_fb_destroy_callback (struct gbm_bo *bo, void *data)
{
int drm_fd = gbm_device_get_fd (gbm_bo_get_device (bo));
GstGLDRMFramebuffer *fb = (GstGLDRMFramebuffer *) (data);
if (fb->fb_id)
drmModeRmFB (drm_fd, fb->fb_id);
g_slice_free1 (sizeof (GstGLDRMFramebuffer), fb);
}
GstGLDRMFramebuffer *
gst_gl_gbm_drm_fb_get_from_bo (struct gbm_bo *bo)
{
GstGLDRMFramebuffer *fb;
int drm_fd;
guint32 width, height, stride, format, handle;
int depth, bpp;
int ret;
/* We want to use this buffer object (abbr. "bo") as a scanout buffer.
* To that end, we associate the bo with the DRM by using drmModeAddFB().
* However, this needs to be called exactly once for the given bo, and the
* counterpart, drmModeRmFB(), needs to be called when the bo is cleaned up.
*
* To fulfill these requirements, add extra framebuffer information to the
* bo as "user data". This way, if this user data pointer is NULL, it means
* that no framebuffer information was generated yet & the bo was not set
* as a scanout buffer with drmModeAddFB() yet, and we have perform these
* steps. Otherwise, if it is non-NULL, we know we do not have to set up
* anything (since it was done already) and just return the pointer to the
* framebuffer information. */
fb = (GstGLDRMFramebuffer *) (gbm_bo_get_user_data (bo));
if (fb != NULL) {
/* The bo was already set up as a scanout framebuffer. Just
* return the framebuffer information. */
return fb;
}
/* If this point is reached, then we have to setup the bo as a
* scanout framebuffer. */
drm_fd = gbm_device_get_fd (gbm_bo_get_device (bo));
fb = g_slice_alloc0 (sizeof (GstGLDRMFramebuffer));
fb->bo = bo;
width = gbm_bo_get_width (bo);
height = gbm_bo_get_height (bo);
stride = gbm_bo_get_stride (bo);
format = gbm_bo_get_format (bo);
handle = gbm_bo_get_handle (bo).u32;
depth = gst_gl_gbm_depth_from_format (format);
bpp = gst_gl_gbm_bpp_from_format (format);
GST_DEBUG ("Attempting to add GBM BO as scanout framebuffer width/height: %"
G_GUINT32_FORMAT "/%" G_GUINT32_FORMAT " pixels stride: %"
G_GUINT32_FORMAT " bytes format: %s depth: %d bits total bpp: %d bits",
width, height, stride, gst_gl_gbm_format_to_string (format), depth, bpp);
/* Set the bo as a scanout framebuffer */
ret = drmModeAddFB (drm_fd, width, height, depth, bpp, stride, handle,
&fb->fb_id);
if (ret != 0) {
GST_ERROR ("Failed to add GBM BO as scanout framebuffer: %s (%d)",
g_strerror (errno), errno);
g_slice_free1 (sizeof (GstGLDRMFramebuffer), fb);
return NULL;
}
/* Add the framebuffer information to the bo as user data, and also install a callback
* that cleans up this extra information whenever the bo itself is discarded */
gbm_bo_set_user_data (bo, fb, gst_gl_gbm_drm_fb_destroy_callback);
return fb;
}
int
gst_gl_gbm_find_and_open_drm_node (void)
{
/* In here we use GUDev to try to autodetect the GPU */
int drm_fd = -1;
GUdevClient *gudev_client = NULL;
GUdevEnumerator *gudev_enum = NULL;
GList *devlist = NULL;
GList *deventry = NULL;
const gchar *subsystems[2] = { "drm", NULL };
gudev_client = g_udev_client_new (subsystems);
if (gudev_client == NULL) {
GST_ERROR ("Could not create gudev client");
goto cleanup;
}
GST_DEBUG ("Created gudev client");
gudev_enum = g_udev_enumerator_new (gudev_client);
if (gudev_enum == NULL) {
GST_ERROR ("Could not create gudev enumerator");
goto cleanup;
}
GST_DEBUG ("Created gudev enumerator");
/* TODO: To be 100% sure we pick the right device, also check
* if this is a GPU, because a pure scanout device could also
* have a DRM subsystem for example. However, currently it is
* unclear how to do that. By trying to create an EGL context? */
g_udev_enumerator_add_match_subsystem (gudev_enum, "drm");
devlist = g_udev_enumerator_execute (gudev_enum);
GST_DEBUG ("Scanned for udev devices with a drm subsytem");
if (devlist == NULL) {
GST_WARNING ("Found no matching DRM devices");
goto cleanup;
}
GST_DEBUG ("Got %u potentially matching device(s)", g_list_length (devlist));
for (deventry = devlist; deventry != NULL; deventry = deventry->next) {
GUdevDevice *gudevice = G_UDEV_DEVICE (deventry->data);
const gchar *devnode = g_udev_device_get_device_file (gudevice);
if ((devnode == NULL) || !g_str_has_prefix (devnode, "/dev/dri/card"))
continue;
GST_DEBUG ("Found DRM device with device node \"%s\"", devnode);
drm_fd = open (devnode, O_RDWR | O_CLOEXEC);
if (drm_fd < 0) {
GST_WARNING ("Cannot open device node \"%s\": %s (%d)", devnode,
g_strerror (errno), errno);
continue;
}
GST_DEBUG ("Device node \"%s\" is a valid DRM device node", devnode);
break;
}
done:
if (devlist != NULL) {
g_list_free_full (devlist, g_object_unref);
devlist = NULL;
GST_DEBUG ("Cleaned up device list");
}
if (gudev_enum != NULL) {
g_object_unref (G_OBJECT (gudev_enum));
gudev_enum = NULL;
GST_DEBUG ("Cleaned up gudev enumerator");
}
if (gudev_client != NULL) {
g_object_unref (G_OBJECT (gudev_client));
gudev_client = NULL;
GST_DEBUG ("Cleaned up gudev client");
}
return drm_fd;
cleanup:
if (drm_fd >= 0) {
close (drm_fd);
drm_fd = -1;
}
goto done;
}
Reference in a new issue View git blame Copy permalink