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
libsdl-org · Sep 24, 2019 · 6898537 · 6898537
1 parent 3d55a51
commit 6898537
Show file tree

Hide file tree

Showing 18 changed files with 1,018 additions and 7 deletions.
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -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

diff --git a/include/SDL_config.h.cmake b/include/SDL_config.h.cmake
@@ -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@

diff --git a/src/video/SDL_egl.c b/src/video/SDL_egl.c
@@ -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) 
 {

diff --git a/src/video/SDL_egl_c.h b/src/video/SDL_egl_c.h
@@ -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);

diff --git a/src/video/SDL_sysvideo.h b/src/video/SDL_sysvideo.h
@@ -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);

diff --git a/src/video/SDL_video.c b/src/video/SDL_video.c
@@ -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

diff --git a/src/video/offscreen/SDL_offscreenevents.c b/src/video/offscreen/SDL_offscreenevents.c
@@ -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: */
diff --git a/src/video/offscreen/SDL_offscreenevents_c.h b/src/video/offscreen/SDL_offscreenevents_c.h
@@ -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: */