Skip to content
Permalink
Browse files

offscreen: Add new video driver backend Offscreen

The Offscreen video driver is intended to be used for headless rendering
  as well as allows for multiple GPUs to be used for headless rendering

Currently only supports EGL (OpenGL / ES) or Framebuffers
Adds a hint to specifiy which EGL device to use: SDL_HINT_EGL_DEVICE
Adds testoffscreen.c which can be used to test the backend out
Disabled by default for now
  • Loading branch information
BrandonSchaefer committed Sep 24, 2019
1 parent 3d55a51 commit 68985371a071b97b961df56d040fbb5ca6493cf3
@@ -381,6 +381,7 @@ dep_option(VIDEO_VULKAN "Enable Vulkan support" ON "ANDROID OR APPLE OR L
set_option(VIDEO_METAL "Enable Metal support" ${APPLE})
set_option(VIDEO_KMSDRM "Use KMS DRM video driver" ${UNIX_SYS})
dep_option(KMSDRM_SHARED "Dynamically load KMS DRM support" ON "VIDEO_KMSDRM" OFF)
set_option(VIDEO_OFFSCREEN "Use offscreen video driver" OFF)
option_string(BACKGROUNDING_SIGNAL "number to use for magic backgrounding signal or 'OFF'" "OFF")
option_string(FOREGROUNDING_SIGNAL "number to use for magic foregrounding signal or 'OFF'" "OFF")
set_option(HIDAPI "Use HIDAPI for low level joystick drivers" ${OPT_DEF_HIDAPI})
@@ -852,6 +853,13 @@ if(SDL_VIDEO)
set(HAVE_VIDEO_DUMMY TRUE)
set(HAVE_SDL_VIDEO TRUE)
endif()
if(VIDEO_OFFSCREEN)
set(SDL_VIDEO_DRIVER_OFFSCREEN 1)
file(GLOB VIDEO_OFFSCREEN_SOURCES ${SDL2_SOURCE_DIR}/src/video/offscreen/*.c)
set(SOURCE_FILES ${SOURCE_FILES} ${VIDEO_OFFSCREEN_SOURCES})
set(HAVE_VIDEO_OFFSCREEN TRUE)
set(HAVE_SDL_VIDEO TRUE)
endif()
endif()

# Platform-specific options and settings
@@ -328,6 +328,7 @@
#cmakedefine SDL_VIDEO_DRIVER_DIRECTFB @SDL_VIDEO_DRIVER_DIRECTFB@
#cmakedefine SDL_VIDEO_DRIVER_DIRECTFB_DYNAMIC @SDL_VIDEO_DRIVER_DIRECTFB_DYNAMIC@
#cmakedefine SDL_VIDEO_DRIVER_DUMMY @SDL_VIDEO_DRIVER_DUMMY@
#cmakedefine SDL_VIDEO_DRIVER_OFFSCREEN @SDL_VIDEO_DRIVER_OFFSCREEN@
#cmakedefine SDL_VIDEO_DRIVER_WINDOWS @SDL_VIDEO_DRIVER_WINDOWS@
#cmakedefine SDL_VIDEO_DRIVER_WAYLAND @SDL_VIDEO_DRIVER_WAYLAND@
#cmakedefine SDL_VIDEO_DRIVER_RPI @SDL_VIDEO_DRIVER_RPI@
@@ -94,6 +94,11 @@ if (!_this->egl_data->NAME) \
}
#endif

/* it is allowed to not have some of the EGL extensions on start - attempts to use them will fail later. */
#define LOAD_FUNC_EGLEXT(NAME) \
_this->egl_data->NAME = _this->egl_data->eglGetProcAddress(#NAME);


static const char * SDL_EGL_GetErrorName(EGLint eglErrorCode)
{
#define SDL_EGL_ERROR_TRANSLATE(e) case e: return #e;
@@ -256,11 +261,10 @@ SDL_EGL_UnloadLibrary(_THIS)
}

int
SDL_EGL_LoadLibrary(_THIS, const char *egl_path, NativeDisplayType native_display, EGLenum platform)
SDL_EGL_LoadLibraryOnly(_THIS, const char *egl_path)
{
void *dll_handle = NULL, *egl_dll_handle = NULL; /* The naming is counter intuitive, but hey, I just work here -- Gabriel */
const char *path = NULL;
int egl_version_major = 0, egl_version_minor = 0;
#if SDL_VIDEO_DRIVER_WINDOWS || SDL_VIDEO_DRIVER_WINRT
const char *d3dcompiler;
#endif
@@ -406,8 +410,31 @@ SDL_EGL_LoadLibrary(_THIS, const char *egl_path, NativeDisplayType native_displa
LOAD_FUNC(eglWaitNative);
LOAD_FUNC(eglWaitGL);
LOAD_FUNC(eglBindAPI);
LOAD_FUNC(eglQueryAPI);
LOAD_FUNC(eglQueryString);
LOAD_FUNC(eglGetError);
LOAD_FUNC_EGLEXT(eglQueryDevicesEXT);
LOAD_FUNC_EGLEXT(eglGetPlatformDisplayEXT);

_this->gl_config.driver_loaded = 1;

if (path) {
SDL_strlcpy(_this->gl_config.driver_path, path, sizeof(_this->gl_config.driver_path) - 1);
} else {
*_this->gl_config.driver_path = '\0';
}

return 0;
}

int
SDL_EGL_LoadLibrary(_THIS, const char *egl_path, NativeDisplayType native_display, EGLenum platform)
{
int egl_version_major = 0, egl_version_minor = 0;
int library_load_retcode = SDL_EGL_LoadLibraryOnly(_this, egl_path);
if (library_load_retcode != 0) {
return library_load_retcode;
}

if (_this->egl_data->eglQueryString) {
/* EGL 1.5 allows querying for client version */
@@ -447,20 +474,105 @@ SDL_EGL_LoadLibrary(_THIS, const char *egl_path, NativeDisplayType native_displa
_this->egl_data->egl_display = _this->egl_data->eglGetDisplay(native_display);
}
if (_this->egl_data->egl_display == EGL_NO_DISPLAY) {
_this->gl_config.driver_loaded = 0;
*_this->gl_config.driver_path = '\0';
return SDL_SetError("Could not get EGL display");
}

if (_this->egl_data->eglInitialize(_this->egl_data->egl_display, NULL, NULL) != EGL_TRUE) {
_this->gl_config.driver_loaded = 0;
*_this->gl_config.driver_path = '\0';
return SDL_SetError("Could not initialize EGL");
}
#endif

if (path) {
SDL_strlcpy(_this->gl_config.driver_path, path, sizeof(_this->gl_config.driver_path) - 1);
} else {
*_this->gl_config.driver_path = '\0';
_this->egl_data->is_offscreen = 0;

return 0;
}

/**
On multi GPU machines EGL device 0 is not always the first valid GPU.
Container environments can restrict access to some GPUs that are still listed in the EGL
device list. If the requested device is a restricted GPU and cannot be used
(eglInitialize() will fail) then attempt to automatically and silently select the next
valid available GPU for EGL to use.
*/

int
SDL_EGL_InitializeOffscreen(_THIS, int device)
{
EGLDeviceEXT egl_devices[SDL_EGL_MAX_DEVICES];
EGLint num_egl_devices = 0;
const char *egl_device_hint;

if (_this->gl_config.driver_loaded != 1) {
return SDL_SetError("SDL_EGL_LoadLibraryOnly() has not been called or has failed.");
}


/* Check for all extensions that are optional until used and fail if any is missing */
if (_this->egl_data->eglQueryDevicesEXT == NULL) {
return SDL_SetError("eglQueryDevicesEXT is missing (EXT_device_enumeration not supported by the drivers?)");
}

if (_this->egl_data->eglGetPlatformDisplayEXT == NULL) {
return SDL_SetError("eglGetPlatformDisplayEXT is missing (EXT_platform_base not supported by the drivers?)");
}

if (_this->egl_data->eglQueryDevicesEXT(SDL_EGL_MAX_DEVICES, egl_devices, &num_egl_devices) != EGL_TRUE) {
return SDL_SetError("eglQueryDevicesEXT() failed");
}

egl_device_hint = SDL_GetHint("SDL_HINT_EGL_DEVICE");
if (egl_device_hint) {
device = SDL_atoi(egl_device_hint);

if (device >= num_egl_devices) {
return SDL_SetError("Invalid EGL device is requested.");
}

_this->egl_data->egl_display = _this->egl_data->eglGetPlatformDisplayEXT(EGL_PLATFORM_DEVICE_EXT, egl_devices[device], NULL);

if (_this->egl_data->egl_display == EGL_NO_DISPLAY) {
return SDL_SetError("eglGetPlatformDisplayEXT() failed.");
}

if (_this->egl_data->eglInitialize(_this->egl_data->egl_display, NULL, NULL) != EGL_TRUE) {
return SDL_SetError("Could not initialize EGL");
}
}
else {
int i;
SDL_bool found = SDL_FALSE;
EGLDisplay attempted_egl_display;

/* If no hint is provided lets look for the first device/display that will allow us to eglInit */
for (i = 0; i < num_egl_devices; i++) {
attempted_egl_display = _this->egl_data->eglGetPlatformDisplayEXT(EGL_PLATFORM_DEVICE_EXT, egl_devices[i], NULL);

if (attempted_egl_display == EGL_NO_DISPLAY) {
continue;
}

if (_this->egl_data->eglInitialize(attempted_egl_display, NULL, NULL) != EGL_TRUE) {
_this->egl_data->eglTerminate(attempted_egl_display);
continue;
}

/* We did not fail, we'll pick this one! */
_this->egl_data->egl_display = attempted_egl_display;
found = SDL_TRUE;

break;
}

if (!found) {
return SDL_SetError("Could not find a valid EGL device to initialize");
}
}

_this->egl_data->is_offscreen = 1;

return 0;
}

@@ -580,6 +692,11 @@ SDL_EGL_ChooseConfig(_THIS)
attribs[i++] = _this->gl_config.multisamplesamples;
}

if (_this->egl_data->is_offscreen) {
attribs[i++] = EGL_SURFACE_TYPE;
attribs[i++] = EGL_PBUFFER_BIT;
}

attribs[i++] = EGL_RENDERABLE_TYPE;
if (_this->gl_config.profile_mask == SDL_GL_CONTEXT_PROFILE_ES) {
#ifdef EGL_KHR_create_context
@@ -931,6 +1048,25 @@ SDL_EGL_CreateSurface(_THIS, NativeWindowType nw)
return surface;
}

EGLSurface
SDL_EGL_CreateOffscreenSurface(_THIS, int width, int height)
{
EGLint attributes[] = {
EGL_WIDTH, width,
EGL_HEIGHT, height,
EGL_NONE
};

if (SDL_EGL_ChooseConfig(_this) != 0) {
return EGL_NO_SURFACE;
}

return _this->egl_data->eglCreatePbufferSurface(
_this->egl_data->egl_display,
_this->egl_data->egl_config,
attributes);
}

void
SDL_EGL_DestroySurface(_THIS, EGLSurface egl_surface)
{
@@ -29,6 +29,8 @@

#include "SDL_sysvideo.h"

#define SDL_EGL_MAX_DEVICES 8

typedef struct SDL_EGL_VideoData
{
void *egl_dll_handle, *dll_handle;
@@ -81,6 +83,8 @@ typedef struct SDL_EGL_VideoData
EGLBoolean(EGLAPIENTRY *eglSwapInterval) (EGLDisplay dpy, EGLint interval);

const char *(EGLAPIENTRY *eglQueryString) (EGLDisplay dpy, EGLint name);

EGLenum(EGLAPIENTRY *eglQueryAPI)(void);

EGLBoolean(EGLAPIENTRY *eglGetConfigAttrib) (EGLDisplay dpy, EGLConfig config,
EGLint attribute, EGLint * value);
@@ -93,13 +97,21 @@ typedef struct SDL_EGL_VideoData

EGLint(EGLAPIENTRY *eglGetError)(void);

EGLBoolean(EGLAPIENTRY *eglQueryDevicesEXT)(EGLint max_devices,
EGLDeviceEXT* devices,
EGLint* num_devices);

/* whether EGL display was offscreen */
int is_offscreen;

} SDL_EGL_VideoData;

/* OpenGLES functions */
extern int SDL_EGL_GetAttribute(_THIS, SDL_GLattr attrib, int *value);
/* SDL_EGL_LoadLibrary can get a display for a specific platform (EGL_PLATFORM_*)
* or, if 0 is passed, let the implementation decide.
*/
extern int SDL_EGL_LoadLibraryOnly(_THIS, const char *path);
extern int SDL_EGL_LoadLibrary(_THIS, const char *path, NativeDisplayType native_display, EGLenum platform);
extern void *SDL_EGL_GetProcAddress(_THIS, const char *proc);
extern void SDL_EGL_UnloadLibrary(_THIS);
@@ -111,6 +123,10 @@ extern void SDL_EGL_DeleteContext(_THIS, SDL_GLContext context);
extern EGLSurface *SDL_EGL_CreateSurface(_THIS, NativeWindowType nw);
extern void SDL_EGL_DestroySurface(_THIS, EGLSurface egl_surface);

extern EGLSurface SDL_EGL_CreateOffscreenSurface(_THIS, int width, int height);
/* Assumes that LoadLibraryOnly() has succeeded */
extern int SDL_EGL_InitializeOffscreen(_THIS, int device);

/* These need to be wrapped to get the surface for the window by the platform GLES implementation */
extern SDL_GLContext SDL_EGL_CreateContext(_THIS, EGLSurface egl_surface);
extern int SDL_EGL_MakeCurrent(_THIS, EGLSurface egl_surface, SDL_GLContext context);
@@ -429,6 +429,7 @@ extern VideoBootStrap NACL_bootstrap;
extern VideoBootStrap VIVANTE_bootstrap;
extern VideoBootStrap Emscripten_bootstrap;
extern VideoBootStrap QNX_bootstrap;
extern VideoBootStrap OFFSCREEN_bootstrap;

extern SDL_VideoDevice *SDL_GetVideoDevice(void);
extern int SDL_AddBasicVideoDisplay(const SDL_DisplayMode * desktop_mode);
@@ -109,6 +109,9 @@ static VideoBootStrap *bootstrap[] = {
#if SDL_VIDEO_DRIVER_QNX
&QNX_bootstrap,
#endif
#if SDL_VIDEO_DRIVER_OFFSCREEN
&OFFSCREEN_bootstrap,
#endif
#if SDL_VIDEO_DRIVER_DUMMY
&DUMMY_bootstrap,
#endif
@@ -0,0 +1,42 @@
/*
Simple DirectMedia Layer
Copyright (C) 1997-2019 Sam Lantinga <slouken@libsdl.org>
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/

#include "../../SDL_internal.h"

#if SDL_VIDEO_DRIVER_OFFSCREEN

/* Being a offscreen driver, there's no event stream. We just define stubs for
most of the API. */

#include "../../events/SDL_events_c.h"

#include "SDL_offscreenvideo.h"
#include "SDL_offscreenevents_c.h"

void
OFFSCREEN_PumpEvents(_THIS)
{
/* do nothing. */
}

#endif /* SDL_VIDEO_DRIVER_OFFSCREEN */

/* vi: set ts=4 sw=4 expandtab: */
@@ -0,0 +1,28 @@
/*
Simple DirectMedia Layer
Copyright (C) 1997-2019 Sam Lantinga <slouken@libsdl.org>
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/

#include "../../SDL_internal.h"

#include "SDL_offscreenvideo.h"

extern void OFFSCREEN_PumpEvents(_THIS);

/* vi: set ts=4 sw=4 expandtab: */

0 comments on commit 6898537

Please sign in to comment.