jp9000
/
obs-studio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Drop GLX renderer 

"They must often change, who would be constant in happiness or wisdom"

 - Confucius
master
Georges Basile Stavracas Neto 2022-04-24 12:58:49 -03:00
parent ddb692ab2d
commit ca2d02c2ce
10 changed files with 7 additions and 686 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
UI/obs-app.cpp
View File

@ -1419,8 +1419,7 @@ bool OBSApp::OBSInit()
qRegisterMetaType<VoidFunc>();
#if !defined(_WIN32) && !defined(__APPLE__)
obs_set_nix_platform(OBS_NIX_PLATFORM_X11_GLX);
if (QApplication::platformName() == "xcb" && getenv("OBS_USE_EGL")) {
if (QApplication::platformName() == "xcb") {
obs_set_nix_platform(OBS_NIX_PLATFORM_X11_EGL);
blog(LOG_INFO, "Using EGL/X11");
}

1
UI/qt-wrappers.cpp
View File

@ -121,7 +121,6 @@ bool QTToGSWindow(QWindow *window, gs_window &gswindow)
gswindow.view = (id)window->winId();
#else
switch (obs_get_nix_platform()) {
case OBS_NIX_PLATFORM_X11_GLX:
case OBS_NIX_PLATFORM_X11_EGL:
gswindow.id = window->winId();
gswindow.display = obs_get_nix_platform_display();

3
libobs-opengl/CMakeLists.txt
View File

@ -50,8 +50,7 @@ elseif(OS_POSIX)
find_package(XCB COMPONENTS XCB)
find_package(X11_XCB REQUIRED)
target_sources(libobs-opengl PRIVATE gl-egl-common.c gl-nix.c gl-x11-egl.c
gl-x11-glx.c)
target_sources(libobs-opengl PRIVATE gl-egl-common.c gl-nix.c gl-x11-egl.c)
target_link_libraries(libobs-opengl PRIVATE XCB::XCB X11::X11_xcb)

4
libobs-opengl/gl-nix.c
View File

@ -16,7 +16,6 @@
******************************************************************************/
#include "gl-nix.h"
#include "gl-x11-glx.h"
#include "gl-x11-egl.h"
#ifdef ENABLE_WAYLAND
@ -30,9 +29,6 @@ static void init_winsys(void)
assert(gl_vtable == NULL);
switch (obs_get_nix_platform()) {
case OBS_NIX_PLATFORM_X11_GLX:
gl_vtable = gl_x11_glx_get_winsys_vtable();
break;
case OBS_NIX_PLATFORM_X11_EGL:
gl_vtable = gl_x11_egl_get_winsys_vtable();
break;

649
libobs-opengl/gl-x11-glx.c
View File

@ -1,649 +0,0 @@
/******************************************************************************
Copyright (C) 2014 by Zachary Lund <admin@computerquip.com>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
This program 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 General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/
/* Version 2 of the GLX backend...
* Difference from version 1 is that we use XCB to help alleviate
* pains in a threaded environment that is prone to error.
* These errors must be readable and handled for the sake of,
* not only the users' sanity, but my own.
*
* With that said, we have more error checking capabilities...
* and not all of them are used to help simplify current code.
*
* TODO: Implement more complete error checking.
* NOTE: GLX loading functions are placed illogically
* for the sake of convenience.
*/
#include <X11/Xlib.h>
#include <X11/Xlib-xcb.h>
#include <xcb/xcb.h>
#include <stdio.h>
#include "gl-nix.h"
#include <glad/glad_glx.h>
static const int ctx_attribs[] = {
#ifdef _DEBUG
GLX_CONTEXT_FLAGS_ARB,
GLX_CONTEXT_DEBUG_BIT_ARB,
#endif
GLX_CONTEXT_PROFILE_MASK_ARB,
GLX_CONTEXT_CORE_PROFILE_BIT_ARB,
GLX_CONTEXT_MAJOR_VERSION_ARB,
3,
GLX_CONTEXT_MINOR_VERSION_ARB,
3,
None,
};
static int ctx_pbuffer_attribs[] = {GLX_PBUFFER_WIDTH, 2, GLX_PBUFFER_HEIGHT, 2,
None};
static int ctx_visual_attribs[] = {GLX_STENCIL_SIZE,
0,
GLX_DEPTH_SIZE,
0,
GLX_BUFFER_SIZE,
32,
GLX_ALPHA_SIZE,
8,
GLX_DOUBLEBUFFER,
true,
GLX_X_RENDERABLE,
true,
None};
struct gl_windowinfo {
/* We store this value since we can fetch a lot
* of information not only concerning the config
* but the visual, and various other settings
* for the context.
*/
GLXFBConfig config;
/* Windows in X11 are defined with integers (XID).
* xcb_window_t is a define for this... they are
* compatible with Xlib as well.
*/
xcb_window_t window;
/* We can't fetch screen without a request so we cache it. */
int screen;
};
struct gl_platform {
Display *display;
GLXContext context;
GLXPbuffer pbuffer;
};
/*
* Since we cannot take advantage of the asynchronous nature of xcb,
* all of the helper functions are synchronous but thread-safe.
*
* They check for errors and will return 0 on problems
* with the exception of when 0 is a valid return value... in which case
* read the specific function comments.
*/
/* Returns -1 on invalid screen. */
static int get_screen_num_from_xcb_screen(xcb_connection_t *xcb_conn,
xcb_screen_t *screen)
{
xcb_screen_iterator_t iter =
xcb_setup_roots_iterator(xcb_get_setup(xcb_conn));
int screen_num = 0;
for (; iter.rem; xcb_screen_next(&iter), ++screen_num)
if (iter.data == screen)
return screen_num;
return -1;
}
static xcb_screen_t *get_screen_from_root(xcb_connection_t *xcb_conn,
xcb_window_t root)
{
xcb_screen_iterator_t iter =
xcb_setup_roots_iterator(xcb_get_setup(xcb_conn));
while (iter.rem) {
if (iter.data->root == root)
return iter.data;
xcb_screen_next(&iter);
}
return 0;
}
static inline int get_screen_num_from_root(xcb_connection_t *xcb_conn,
xcb_window_t root)
{
xcb_screen_t *screen = get_screen_from_root(xcb_conn, root);
if (!screen)
return -1;
return get_screen_num_from_xcb_screen(xcb_conn, screen);
}
static xcb_get_geometry_reply_t *get_window_geometry(xcb_connection_t *xcb_conn,
xcb_drawable_t drawable)
{
xcb_get_geometry_cookie_t cookie;
xcb_generic_error_t *error;
xcb_get_geometry_reply_t *reply;
cookie = xcb_get_geometry(xcb_conn, drawable);
reply = xcb_get_geometry_reply(xcb_conn, cookie, &error);
if (error) {
blog(LOG_ERROR, "Failed to fetch parent window geometry!");
free(error);
free(reply);
return 0;
}
return reply;
}
static bool gl_context_create(struct gl_platform *plat)
{
Display *display = plat->display;
int frame_buf_config_count = 0;
GLXFBConfig *config = NULL;
GLXContext context;
bool success = false;
if (!GLAD_GLX_ARB_create_context) {
blog(LOG_ERROR, "ARB_GLX_create_context not supported!");
return false;
}
config = glXChooseFBConfig(display, DefaultScreen(display),
ctx_visual_attribs, &frame_buf_config_count);
if (!config) {
blog(LOG_ERROR, "Failed to create OpenGL frame buffer config");
return false;
}
context = glXCreateContextAttribsARB(display, config[0], NULL, true,
ctx_attribs);
if (!context) {
blog(LOG_ERROR, "Failed to create OpenGL context.");
goto error;
}
plat->context = context;
plat->pbuffer =
glXCreatePbuffer(display, config[0], ctx_pbuffer_attribs);
if (!plat->pbuffer) {
blog(LOG_ERROR, "Failed to create OpenGL pbuffer");
goto error;
}
success = true;
error:
XFree(config);
XSync(display, false);
return success;
}
static void gl_context_destroy(struct gl_platform *plat)
{
Display *display = plat->display;
glXMakeContextCurrent(display, None, None, NULL);
glXDestroyContext(display, plat->context);
bfree(plat);
}
static struct gl_windowinfo *
gl_x11_glx_windowinfo_create(const struct gs_init_data *info)
{
UNUSED_PARAMETER(info);
return bmalloc(sizeof(struct gl_windowinfo));
}
static void gl_x11_glx_windowinfo_destroy(struct gl_windowinfo *info)
{
bfree(info);
}
static Display *open_windowless_display(void)
{
Display *display = XOpenDisplay(NULL);
xcb_connection_t *xcb_conn;
xcb_screen_iterator_t screen_iterator;
xcb_screen_t *screen;
int screen_num;
if (!display) {
blog(LOG_ERROR, "Unable to open new X connection!");
return NULL;
}
xcb_conn = XGetXCBConnection(display);
if (!xcb_conn) {
blog(LOG_ERROR, "Unable to get XCB connection to main display");
goto error;
}
screen_iterator = xcb_setup_roots_iterator(xcb_get_setup(xcb_conn));
screen = screen_iterator.data;
if (!screen) {
blog(LOG_ERROR, "Unable to get screen root");
goto error;
}
screen_num = get_screen_num_from_root(xcb_conn, screen->root);
if (screen_num == -1) {
blog(LOG_ERROR, "Unable to get screen number from root");
goto error;
}
if (!gladLoadGLX(display, screen_num)) {
blog(LOG_ERROR, "Unable to load GLX entry functions.");
goto error;
}
return display;
error:
XCloseDisplay(display);
return NULL;
}
static int x_error_handler(Display *display, XErrorEvent *error)
{
char str1[512];
char str2[512];
char str3[512];
XGetErrorText(display, error->error_code, str1, sizeof(str1));
XGetErrorText(display, error->request_code, str2, sizeof(str2));
XGetErrorText(display, error->minor_code, str3, sizeof(str3));
blog(LOG_ERROR,
"X Error: %s, Major opcode: %s, "
"Minor opcode: %s, Serial: %lu",
str1, str2, str3, error->serial);
return 0;
}
static struct gl_platform *gl_x11_glx_platform_create(gs_device_t *device,
uint32_t adapter)
{
/* There's some trickery here... we're mixing libX11, xcb, and GLX
For an explanation see here: http://xcb.freedesktop.org/MixingCalls/
Essentially, GLX requires Xlib. Everything else we use xcb. */
struct gl_platform *plat = bmalloc(sizeof(struct gl_platform));
Display *display = open_windowless_display();
if (!display) {
goto fail_display_open;
}
XSetEventQueueOwner(display, XCBOwnsEventQueue);
XSetErrorHandler(x_error_handler);
/* We assume later that cur_swap is already set. */
device->plat = plat;
plat->display = display;
if (!gl_context_create(plat)) {
blog(LOG_ERROR, "Failed to create context!");
goto fail_context_create;
}
if (!glXMakeContextCurrent(plat->display, plat->pbuffer, plat->pbuffer,
plat->context)) {
blog(LOG_ERROR, "Failed to make context current.");
goto fail_make_current;
}
if (!gladLoadGL()) {
blog(LOG_ERROR, "Failed to load OpenGL entry functions.");
goto fail_load_gl;
}
goto success;
fail_make_current:
gl_context_destroy(plat);
fail_context_create:
fail_load_gl:
XCloseDisplay(display);
fail_display_open:
bfree(plat);
plat = NULL;
success:
UNUSED_PARAMETER(adapter);
return plat;
}
static void gl_x11_glx_platform_destroy(struct gl_platform *plat)
{
if (!plat) /* In what case would platform be invalid here? */
return;
gl_context_destroy(plat);
}
static bool gl_x11_glx_platform_init_swapchain(struct gs_swap_chain *swap)
{
Display *display = swap->device->plat->display;
xcb_connection_t *xcb_conn = XGetXCBConnection(display);
xcb_window_t wid = xcb_generate_id(xcb_conn);
xcb_window_t parent = swap->info.window.id;
xcb_get_geometry_reply_t *geometry =
get_window_geometry(xcb_conn, parent);
bool status = false;
int screen_num;
int visual;
GLXFBConfig *fb_config;
if (!geometry)
goto fail_geometry_request;
screen_num = get_screen_num_from_root(xcb_conn, geometry->root);
if (screen_num == -1) {
goto fail_screen;
}
/* ...fetch the best match... */
{
int num_configs;
fb_config = glXChooseFBConfig(display, screen_num,
ctx_visual_attribs, &num_configs);
if (!fb_config || !num_configs) {
blog(LOG_ERROR, "Failed to find FBConfig!");
goto fail_fb_config;
}
}
/* ...then fetch matching visual info for xcb. */
{
int error = glXGetFBConfigAttrib(display, fb_config[0],
GLX_VISUAL_ID, &visual);
if (error) {
blog(LOG_ERROR, "Bad call to GetFBConfigAttrib!");
goto fail_visual_id;
}
}
xcb_colormap_t colormap = xcb_generate_id(xcb_conn);
uint32_t mask = XCB_CW_BORDER_PIXEL | XCB_CW_COLORMAP;
uint32_t mask_values[] = {0, colormap, 0};
xcb_create_colormap(xcb_conn, XCB_COLORMAP_ALLOC_NONE, colormap, parent,
visual);
xcb_create_window(xcb_conn, 24 /* Hardcoded? */, wid, parent, 0, 0,
geometry->width, geometry->height, 0, 0, visual, mask,
mask_values);
swap->wi->config = fb_config[0];
swap->wi->window = wid;
xcb_map_window(xcb_conn, wid);
XFree(fb_config);
status = true;
goto success;
fail_visual_id:
XFree(fb_config);
fail_fb_config:
fail_screen:
fail_geometry_request:
success:
free(geometry);
return status;
}
static void gl_x11_glx_platform_cleanup_swapchain(struct gs_swap_chain *swap)
{
UNUSED_PARAMETER(swap);
/* Really nothing to clean up? */
}
static void gl_x11_glx_device_enter_context(gs_device_t *device)
{
GLXContext context = device->plat->context;
Display *display = device->plat->display;
if (device->cur_swap) {
XID window = device->cur_swap->wi->window;
if (!glXMakeContextCurrent(display, window, window, context)) {
blog(LOG_ERROR, "Failed to make context current.");
}
} else {
GLXPbuffer pbuf = device->plat->pbuffer;
if (!glXMakeContextCurrent(display, pbuf, pbuf, context)) {
blog(LOG_ERROR, "Failed to make context current.");
}
}
}
static void gl_x11_glx_device_leave_context(gs_device_t *device)
{
Display *display = device->plat->display;
if (!glXMakeContextCurrent(display, None, None, NULL)) {
blog(LOG_ERROR, "Failed to reset current context.");
}
}
static void *gl_x11_glx_device_get_device_obj(gs_device_t *device)
{
return device->plat->context;
}
static void gl_x11_glx_getclientsize(const struct gs_swap_chain *swap,
uint32_t *width, uint32_t *height)
{
xcb_connection_t *xcb_conn =
XGetXCBConnection(swap->device->plat->display);
xcb_window_t window = swap->wi->window;
xcb_get_geometry_reply_t *geometry =
get_window_geometry(xcb_conn, window);
if (geometry) {
*width = geometry->width;
*height = geometry->height;
}
free(geometry);
}
static void gl_x11_glx_clear_context(gs_device_t *device)
{
Display *display = device->plat->display;
if (!glXMakeContextCurrent(display, None, None, NULL)) {
blog(LOG_ERROR, "Failed to reset current context.");
}
}
static void gl_x11_glx_update(gs_device_t *device)
{
Display *display = device->plat->display;
xcb_window_t window = device->cur_swap->wi->window;
uint32_t values[] = {device->cur_swap->info.cx,
device->cur_swap->info.cy};
xcb_configure_window(XGetXCBConnection(display), window,
XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT,
values);
}
static void gl_x11_glx_device_load_swapchain(gs_device_t *device,
gs_swapchain_t *swap)
{
if (device->cur_swap == swap)
return;
Display *dpy = device->plat->display;
GLXContext ctx = device->plat->context;
device->cur_swap = swap;
if (swap) {
XID window = swap->wi->window;
if (!glXMakeContextCurrent(dpy, window, window, ctx)) {
blog(LOG_ERROR, "Failed to make context current.");
}
} else {
GLXPbuffer pbuf = device->plat->pbuffer;
if (!glXMakeContextCurrent(dpy, pbuf, pbuf, ctx)) {
blog(LOG_ERROR, "Failed to make context current.");
}
}
}
enum swap_type {
SWAP_TYPE_NORMAL,
SWAP_TYPE_EXT,
SWAP_TYPE_MESA,
SWAP_TYPE_SGI,
};
static void gl_x11_glx_device_present(gs_device_t *device)
{
static bool initialized = false;
static enum swap_type swap_type = SWAP_TYPE_NORMAL;
Display *display = device->plat->display;
XID window = device->cur_swap->wi->window;
if (!initialized) {
if (GLAD_GLX_EXT_swap_control)
swap_type = SWAP_TYPE_EXT;
else if (GLAD_GLX_MESA_swap_control)
swap_type = SWAP_TYPE_MESA;
else if (GLAD_GLX_SGI_swap_control)
swap_type = SWAP_TYPE_SGI;
initialized = true;
}
xcb_connection_t *xcb_conn = XGetXCBConnection(display);
xcb_generic_event_t *xcb_event;
while ((xcb_event = xcb_poll_for_event(xcb_conn))) {
/* TODO: Handle XCB events. */
free(xcb_event);
}
switch (swap_type) {
case SWAP_TYPE_EXT:
glXSwapIntervalEXT(display, window, 0);
break;
case SWAP_TYPE_MESA:
glXSwapIntervalMESA(0);
break;
case SWAP_TYPE_SGI:
glXSwapIntervalSGI(0);
break;
case SWAP_TYPE_NORMAL:;
}
glXSwapBuffers(display, window);
}
static struct gs_texture *gl_x11_glx_device_texture_create_from_dmabuf(
gs_device_t *device, unsigned int width, unsigned int height,
uint32_t drm_format, enum gs_color_format color_format,
uint32_t n_planes, const int *fds, const uint32_t *strides,
const uint32_t *offsets, const uint64_t *modifiers)
{
UNUSED_PARAMETER(device);
UNUSED_PARAMETER(width);
UNUSED_PARAMETER(height);
UNUSED_PARAMETER(drm_format);
UNUSED_PARAMETER(color_format);
UNUSED_PARAMETER(n_planes);
UNUSED_PARAMETER(fds);
UNUSED_PARAMETER(strides);
UNUSED_PARAMETER(offsets);
UNUSED_PARAMETER(modifiers);
return NULL;
}
static bool gl_x11_glx_device_query_dmabuf_capabilities(
gs_device_t *device, enum gs_dmabuf_flags *dmabuf_flags,
uint32_t **drm_formats, size_t *n_formats)
{
UNUSED_PARAMETER(device);
UNUSED_PARAMETER(dmabuf_flags);
UNUSED_PARAMETER(drm_formats);
UNUSED_PARAMETER(n_formats);
return false;
}
static bool gl_x11_glx_device_query_dmabuf_modifiers_for_format(
gs_device_t *device, uint32_t drm_format, uint64_t **modifiers,
size_t *n_modifiers)
{
UNUSED_PARAMETER(device);
UNUSED_PARAMETER(drm_format);
UNUSED_PARAMETER(modifiers);
UNUSED_PARAMETER(n_modifiers);
return false;
}
static const struct gl_winsys_vtable glx_winsys_vtable = {
.windowinfo_create = gl_x11_glx_windowinfo_create,
.windowinfo_destroy = gl_x11_glx_windowinfo_destroy,
.platform_create = gl_x11_glx_platform_create,
.platform_destroy = gl_x11_glx_platform_destroy,
.platform_init_swapchain = gl_x11_glx_platform_init_swapchain,
.platform_cleanup_swapchain = gl_x11_glx_platform_cleanup_swapchain,
.device_enter_context = gl_x11_glx_device_enter_context,
.device_leave_context = gl_x11_glx_device_leave_context,
.device_get_device_obj = gl_x11_glx_device_get_device_obj,
.getclientsize = gl_x11_glx_getclientsize,
.clear_context = gl_x11_glx_clear_context,
.update = gl_x11_glx_update,
.device_load_swapchain = gl_x11_glx_device_load_swapchain,
.device_present = gl_x11_glx_device_present,
.device_texture_create_from_dmabuf =
gl_x11_glx_device_texture_create_from_dmabuf,
.device_query_dmabuf_capabilities =
gl_x11_glx_device_query_dmabuf_capabilities,
.device_query_dmabuf_modifiers_for_format =
gl_x11_glx_device_query_dmabuf_modifiers_for_format,
};
const struct gl_winsys_vtable *gl_x11_glx_get_winsys_vtable(void)
{
return &glx_winsys_vtable;
}

22
libobs-opengl/gl-x11-glx.h
View File

@ -1,22 +0,0 @@
/******************************************************************************
Copyright (C) 2014 by Zachary Lund <admin@computerquip.com>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
This program 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 General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/
#pragma once
#include "gl-nix.h"
const struct gl_winsys_vtable *gl_x11_glx_get_winsys_vtable(void);

5
libobs/obs-nix-platform.c
View File

@ -17,12 +17,15 @@
#include "obs-nix-platform.h"
static enum obs_nix_platform_type obs_nix_platform = OBS_NIX_PLATFORM_X11_GLX;
#include <assert.h>
static enum obs_nix_platform_type obs_nix_platform = OBS_NIX_PLATFORM_X11_EGL;
static void *obs_nix_platform_display = NULL;
void obs_set_nix_platform(enum obs_nix_platform_type platform)
{
assert(platform != OBS_NIX_PLATFORM_X11_GLX);
obs_nix_platform = platform;
}

2
libobs/obs-nix-platform.h
View File

@ -24,7 +24,7 @@ extern "C" {
#endif
enum obs_nix_platform_type {
OBS_NIX_PLATFORM_X11_GLX,
OBS_NIX_PLATFORM_X11_GLX OBS_DEPRECATED,
OBS_NIX_PLATFORM_X11_EGL,
#ifdef ENABLE_WAYLAND
OBS_NIX_PLATFORM_WAYLAND,

2
libobs/obs-nix.c
View File

@ -327,7 +327,6 @@ void log_system_info(void)
log_desktop_session_info();
#endif
switch (obs_get_nix_platform()) {
case OBS_NIX_PLATFORM_X11_GLX:
case OBS_NIX_PLATFORM_X11_EGL:
obs_nix_x11_log_info();
break;
@ -341,7 +340,6 @@ void log_system_info(void)
bool obs_hotkeys_platform_init(struct obs_core_hotkeys *hotkeys)
{
switch (obs_get_nix_platform()) {
case OBS_NIX_PLATFORM_X11_GLX:
case OBS_NIX_PLATFORM_X11_EGL:
hotkeys_vtable = obs_nix_x11_get_hotkeys_vtable();
break;

2
plugins/linux-pipewire/linux-pipewire.c
View File

@ -44,8 +44,6 @@ bool obs_module_load(void)
case OBS_NIX_PLATFORM_X11_EGL:
pipewire_capture_load();
break;
case OBS_NIX_PLATFORM_X11_GLX:
break;
}
return true;