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

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

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@

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) 
 {

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,6 +97,13 @@ 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 */
@@ -100,6 +111,7 @@ 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);

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);

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

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: */

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: */

src/video/offscreen/SDL_offscreenframebuffer.c

@@ -0,0 +1,90 @@
+/*
+  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
+
+#include "../SDL_sysvideo.h"
+#include "SDL_offscreenframebuffer_c.h"
+
+
+#define OFFSCREEN_SURFACE   "_SDL_DummySurface"
+
+int SDL_OFFSCREEN_CreateWindowFramebuffer(_THIS, SDL_Window * window, Uint32 * format, void ** pixels, int *pitch)
+{
+    SDL_Surface *surface;
+    const Uint32 surface_format = SDL_PIXELFORMAT_RGB888;
+    int w, h;
+    int bpp;
+    Uint32 Rmask, Gmask, Bmask, Amask;
+
+    /* Free the old framebuffer surface */
+    surface = (SDL_Surface *) SDL_GetWindowData(window, OFFSCREEN_SURFACE);
+    SDL_FreeSurface(surface);
+
+    /* Create a new one */
+    SDL_PixelFormatEnumToMasks(surface_format, &bpp, &Rmask, &Gmask, &Bmask, &Amask);
+    SDL_GetWindowSize(window, &w, &h);
+    surface = SDL_CreateRGBSurface(0, w, h, bpp, Rmask, Gmask, Bmask, Amask);
+    if (!surface) {
+        return -1;
+    }
+
+    /* Save the info and return! */
+    SDL_SetWindowData(window, OFFSCREEN_SURFACE, surface);
+    *format = surface_format;
+    *pixels = surface->pixels;
+    *pitch = surface->pitch;
+    return 0;
+}
+
+int SDL_OFFSCREEN_UpdateWindowFramebuffer(_THIS, SDL_Window * window, const SDL_Rect * rects, int numrects)
+{
+    static int frame_number;
+    SDL_Surface *surface;
+
+    surface = (SDL_Surface *) SDL_GetWindowData(window, OFFSCREEN_SURFACE);
+    if (!surface) {
+        return SDL_SetError("Couldn't find offscreen surface for window");
+    }
+
+    /* Send the data to the display */
+    if (SDL_getenv("SDL_VIDEO_OFFSCREEN_SAVE_FRAMES")) {
+        char file[128];
+        SDL_snprintf(file, sizeof(file), "SDL_window%d-%8.8d.bmp",
+                     SDL_GetWindowID(window), ++frame_number);
+        SDL_SaveBMP(surface, file);
+    }
+    return 0;
+}
+
+void SDL_OFFSCREEN_DestroyWindowFramebuffer(_THIS, SDL_Window * window)
+{
+    SDL_Surface *surface;
+
+    surface = (SDL_Surface *) SDL_SetWindowData(window, OFFSCREEN_SURFACE, NULL);
+    SDL_FreeSurface(surface);
+}
+
+#endif /* SDL_VIDEO_DRIVER_OFFSCREEN */
+
+/* vi: set ts=4 sw=4 expandtab: */

src/video/offscreen/SDL_offscreenframebuffer_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"
+
+extern int SDL_OFFSCREEN_CreateWindowFramebuffer(_THIS, SDL_Window * window, Uint32 * format, void ** pixels, int *pitch);
+extern int SDL_OFFSCREEN_UpdateWindowFramebuffer(_THIS, SDL_Window * window, const SDL_Rect * rects, int numrects);
+extern void SDL_OFFSCREEN_DestroyWindowFramebuffer(_THIS, SDL_Window * window);
+
+/* vi: set ts=4 sw=4 expandtab: */

src/video/offscreen/SDL_offscreenopengl.c

@@ -0,0 +1,102 @@
+/*
+  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
+
+#include "SDL_offscreenopengl.h"
+
+#include "SDL_opengl.h"
+
+int
+OFFSCREEN_GL_SwapWindow(_THIS, SDL_Window* window)
+{
+    OFFSCREEN_Window* offscreen_wind = window->driverdata;
+
+    SDL_EGL_SwapBuffers(_this, offscreen_wind->egl_surface);
+    return 0;
+}
+
+int
+OFFSCREEN_GL_MakeCurrent(_THIS, SDL_Window* window, SDL_GLContext context)
+{
+  if (window) {
+      EGLSurface egl_surface = ((OFFSCREEN_Window*)window->driverdata)->egl_surface;
+      return SDL_EGL_MakeCurrent(_this, egl_surface, context);
+  }
+
+  return SDL_EGL_MakeCurrent(_this, NULL, NULL);
+}
+
+SDL_GLContext
+OFFSCREEN_GL_CreateContext(_THIS, SDL_Window* window)
+{
+    OFFSCREEN_Window* offscreen_window = window->driverdata;
+
+    SDL_GLContext context;
+    context = SDL_EGL_CreateContext(_this, offscreen_window->egl_surface);
+
+    return context;
+}
+
+int
+OFFSCREEN_GL_LoadLibrary(_THIS, const char* path)
+{
+    int ret = SDL_EGL_LoadLibraryOnly(_this, path);
+    if (ret != 0) {
+        return ret;
+    }
+
+    ret = SDL_EGL_InitializeOffscreen(_this, 0);
+    if (ret != 0) {
+        return ret;
+    }
+
+    ret = SDL_EGL_ChooseConfig(_this);
+    if (ret != 0) {
+        return ret;
+    }
+
+    return 0;
+}
+
+void
+OFFSCREEN_GL_UnloadLibrary(_THIS)
+{
+    SDL_EGL_UnloadLibrary(_this);
+}
+
+void*
+OFFSCREEN_GL_GetProcAddress(_THIS, const char* proc)
+{
+    void* proc_addr = SDL_EGL_GetProcAddress(_this, proc);
+
+    if (!proc_addr) {
+        SDL_SetError("Failed to find proc address!");
+    }
+
+    return proc_addr;
+}
+
+#endif /* SDL_VIDEO_DRIVER_OFFSCREEN */
+
+/* vi: set ts=4 sw=4 expandtab: */

src/video/offscreen/SDL_offscreenopengl.h

@@ -0,0 +1,54 @@
+/*
+  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.
+*/
+
+#ifndef _SDL_offscreenopengl_h
+#define _SDL_offscreenopengl_h
+
+#include "SDL_offscreenwindow.h"
+
+#include "../SDL_egl_c.h"
+
+#define OFFSCREEN_GL_DeleteContext   SDL_EGL_DeleteContext
+#define OFFSCREEN_GL_GetSwapInterval SDL_EGL_GetSwapInterval
+#define OFFSCREEN_GL_SetSwapInterval SDL_EGL_SetSwapInterval
+
+extern int
+OFFSCREEN_GL_SwapWindow(_THIS, SDL_Window* window);
+
+extern int
+OFFSCREEN_GL_MakeCurrent(_THIS, SDL_Window* window, SDL_GLContext context);
+
+extern SDL_GLContext
+OFFSCREEN_GL_CreateContext(_THIS, SDL_Window* window);
+
+extern int
+OFFSCREEN_GL_LoadLibrary(_THIS, const char* path);
+
+extern void
+OFFSCREEN_GL_UnloadLibrary(_THIS);
+
+extern void*
+OFFSCREEN_GL_GetProcAddress(_THIS, const char* proc);
+
+#endif /* _SDL_offscreenopengl_h */
+
+/* vi: set ts=4 sw=4 expandtab: */
+

src/video/offscreen/SDL_offscreenvideo.c

@@ -0,0 +1,166 @@
+/*
+  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
+
+/* Offscreen video driver is similar to dummy driver, however its purpose
+ * is enabling applications to use some of the SDL video functionality
+ * (notably context creation) while not requiring a display output.
+ *
+ * An example would be running a graphical program on a headless box
+ * for automated testing.
+ */
+
+#include "SDL_video.h"
+#include "SDL_mouse.h"
+#include "../SDL_sysvideo.h"
+#include "../SDL_pixels_c.h"
+#include "../../events/SDL_events_c.h"
+
+#include "SDL_offscreenvideo.h"
+#include "SDL_offscreenevents_c.h"
+#include "SDL_offscreenframebuffer_c.h"
+#include "SDL_offscreenopengl.h"
+
+#define OFFSCREENVID_DRIVER_NAME "offscreen"
+
+/* Initialization/Query functions */
+static int OFFSCREEN_VideoInit(_THIS);
+static int OFFSCREEN_SetDisplayMode(_THIS, SDL_VideoDisplay * display, SDL_DisplayMode * mode);
+static void OFFSCREEN_VideoQuit(_THIS);
+
+/* OFFSCREEN driver bootstrap functions */
+
+static int
+OFFSCREEN_Available(void)
+{
+    /* Consider it always available */
+    return (1);
+}
+
+static void
+OFFSCREEN_DeleteDevice(SDL_VideoDevice * device)
+{
+    SDL_free(device);
+}
+
+static SDL_VideoDevice *
+OFFSCREEN_CreateDevice(int devindex)
+{
+    SDL_VideoDevice *device;
+
+    /* Initialize all variables that we clean on shutdown */
+    device = (SDL_VideoDevice *) SDL_calloc(1, sizeof(SDL_VideoDevice));
+    if (!device) {
+        SDL_OutOfMemory();
+        return (0);
+    }
+
+    /* General video */
+    device->VideoInit = OFFSCREEN_VideoInit;
+    device->VideoQuit = OFFSCREEN_VideoQuit;
+    device->SetDisplayMode = OFFSCREEN_SetDisplayMode;
+    device->PumpEvents = OFFSCREEN_PumpEvents;
+    device->CreateWindowFramebuffer = SDL_OFFSCREEN_CreateWindowFramebuffer;
+    device->UpdateWindowFramebuffer = SDL_OFFSCREEN_UpdateWindowFramebuffer;
+    device->DestroyWindowFramebuffer = SDL_OFFSCREEN_DestroyWindowFramebuffer;
+    device->free = OFFSCREEN_DeleteDevice;
+
+    /* GL context */
+    device->GL_SwapWindow = OFFSCREEN_GL_SwapWindow;
+    device->GL_MakeCurrent = OFFSCREEN_GL_MakeCurrent;
+    device->GL_CreateContext = OFFSCREEN_GL_CreateContext;
+    device->GL_DeleteContext = OFFSCREEN_GL_DeleteContext;
+    device->GL_LoadLibrary = OFFSCREEN_GL_LoadLibrary;
+    device->GL_UnloadLibrary = OFFSCREEN_GL_UnloadLibrary;
+    device->GL_GetProcAddress = OFFSCREEN_GL_GetProcAddress;
+    device->GL_GetSwapInterval = OFFSCREEN_GL_GetSwapInterval;
+    device->GL_SetSwapInterval = OFFSCREEN_GL_SetSwapInterval;
+
+    /* "Window" */
+    device->CreateSDLWindow = OFFSCREEN_CreateWindow;
+    device->DestroyWindow = OFFSCREEN_DestroyWindow;
+
+    return device;
+}
+
+VideoBootStrap OFFSCREEN_bootstrap = {
+    OFFSCREENVID_DRIVER_NAME, "SDL offscreen video driver",
+    OFFSCREEN_Available, OFFSCREEN_CreateDevice
+};
+
+static Uint32
+OFFSCREEN_GetGlobalMouseState(int *x, int *y)
+{
+    if (x) {
+        *x = 0;
+    }
+
+    if (y) {
+        *y = 0;
+    }
+    return 0;
+}
+
+int
+OFFSCREEN_VideoInit(_THIS)
+{
+    SDL_DisplayMode mode;
+    SDL_Mouse *mouse = NULL;
+
+    /* Use a fake 32-bpp desktop mode */
+    mode.format = SDL_PIXELFORMAT_RGB888;
+    mode.w = 1024;
+    mode.h = 768;
+    mode.refresh_rate = 0;
+    mode.driverdata = NULL;
+    if (SDL_AddBasicVideoDisplay(&mode) < 0) {
+        return -1;
+    }
+
+    SDL_zero(mode);
+    SDL_AddDisplayMode(&_this->displays[0], &mode);
+
+    /* Init mouse */
+    mouse = SDL_GetMouse();
+    /* This function needs to be implemented by every driver */
+    mouse->GetGlobalMouseState = OFFSCREEN_GetGlobalMouseState;
+    
+    /* We're done! */
+    return 0;
+}
+
+static int
+OFFSCREEN_SetDisplayMode(_THIS, SDL_VideoDisplay * display, SDL_DisplayMode * mode)
+{
+    return 0;
+}
+
+void
+OFFSCREEN_VideoQuit(_THIS)
+{
+}
+
+#endif /* SDL_VIDEO_DRIVER_OFFSCREEN */
+
+/* vi: set ts=4 sw=4 expandtab: */

src/video/offscreen/SDL_offscreenvideo.h

@@ -0,0 +1,32 @@
+/*
+  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"
+
+#ifndef _SDL_offscreenvideo_h
+#define _SDL_offscreenvideo_h
+
+#include "../SDL_sysvideo.h"
+#include "../SDL_egl_c.h"
+
+#endif /* _SDL_offscreenvideo_h */
+
+/* vi: set ts=4 sw=4 expandtab: */

src/video/offscreen/SDL_offscreenwindow.c

@@ -0,0 +1,87 @@
+/*
+  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
+
+#include "../SDL_egl_c.h"
+#include "../SDL_sysvideo.h"
+
+#include "SDL_offscreenwindow.h"
+
+int
+OFFSCREEN_CreateWindow(_THIS, SDL_Window* window)
+{
+    OFFSCREEN_Window* offscreen_window = SDL_calloc(1, sizeof(OFFSCREEN_Window));
+
+    if (!offscreen_window) {
+        return SDL_OutOfMemory();
+    }
+
+    window->driverdata = offscreen_window;
+
+    if (window->x == SDL_WINDOWPOS_UNDEFINED) {
+        window->x = 0;
+    }
+
+    if (window->y == SDL_WINDOWPOS_UNDEFINED) {
+        window->y = 0;
+    }
+
+    offscreen_window->sdl_window = window;
+
+    if (window->flags & SDL_WINDOW_OPENGL) {
+
+        if (!_this->egl_data) {
+            return SDL_SetError("Cannot create an OPENGL window invalid egl_data");
+        }
+
+        offscreen_window->egl_surface = SDL_EGL_CreateOffscreenSurface(_this, window->w, window->h);
+
+        if (offscreen_window->egl_surface == EGL_NO_SURFACE) {
+            return SDL_SetError("Failed to created an offscreen surface (EGL display: %p)",
+                                _this->egl_data->egl_display);
+        }
+    }
+    else {
+        offscreen_window->egl_surface = EGL_NO_SURFACE;
+    }
+
+    return 0;
+}
+
+void
+OFFSCREEN_DestroyWindow(_THIS, SDL_Window* window)
+{
+    OFFSCREEN_Window* offscreen_window = window->driverdata;
+
+    if (offscreen_window) {
+        SDL_EGL_DestroySurface(_this, offscreen_window->egl_surface);
+        SDL_free(offscreen_window);
+    }
+
+    window->driverdata = NULL;
+}
+
+#endif /* SDL_VIDEO_DRIVER_OFFSCREEN */
+
+/* vi: set ts=4 sw=4 expandtab: */

src/video/offscreen/SDL_offscreenwindow.h

@@ -0,0 +1,46 @@
+/*
+  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.
+*/
+
+#ifndef _SDL_offscreenwindow_h
+#define _SDL_offscreenwindow_h
+
+#include "../SDL_sysvideo.h"
+#include "SDL_syswm.h"
+
+#include "SDL_offscreenvideo.h"
+
+typedef struct {
+    SDL_Window* sdl_window;
+    EGLSurface egl_surface;
+
+} OFFSCREEN_Window;
+
+
+extern int
+OFFSCREEN_CreateWindow(_THIS, SDL_Window* window);
+
+extern void
+OFFSCREEN_DestroyWindow(_THIS, SDL_Window* window);
+
+#endif /* _SDL_offscreenwindow */
+
+/* vi: set ts=4 sw=4 expandtab: */
+

test/CMakeLists.txt

@@ -86,6 +86,7 @@ add_executable(testbounds testbounds.c)
 add_executable(testcustomcursor testcustomcursor.c)
 add_executable(controllermap controllermap.c)
 add_executable(testvulkan testvulkan.c)
+add_executable(testoffscreen testoffscreen.c)
 
 # HACK: Dummy target to cause the resource files to be copied to the build directory.
 # Need to make it an executable so we can use the TARGET_FILE_DIR generator expression.

test/testoffscreen.c

@@ -0,0 +1,170 @@
+/*
+  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.
+*/
+
+/* Simple program: picks the offscreen backend and renders each frame to a bmp */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+
+#ifdef __EMSCRIPTEN__
+#include <emscripten/emscripten.h>
+#endif
+
+#include "SDL.h"
+#include "SDL_stdinc.h"
+#include "SDL_opengl.h"
+
+static SDL_Renderer *renderer = NULL;
+static SDL_Window *window = NULL;
+static int done = SDL_FALSE;
+static int frame_number = 0;
+static int width = 640;
+static int height = 480;
+static int max_frames = 200;
+
+void
+draw()
+{
+    SDL_Rect Rect;
+
+    SDL_SetRenderDrawColor(renderer, 0x10, 0x9A, 0xCE, 0xFF);
+    SDL_RenderClear(renderer);
+
+    /* Grow based on the frame just to show a difference per frame of the region */
+    Rect.x = 0;
+    Rect.y = 0;
+    Rect.w = (frame_number * 2) % width;
+    Rect.h = (frame_number * 2) % height;
+    SDL_SetRenderDrawColor(renderer, 0xFF, 0x10, 0x21, 0xFF);
+    SDL_RenderFillRect(renderer, &Rect);
+
+    SDL_RenderPresent(renderer);
+}
+
+void
+save_surface_to_bmp()
+{
+    SDL_Surface* surface;
+    Uint32 r_mask, g_mask, b_mask, a_mask;
+    Uint32 pixel_format;
+    char file[128];
+    int bbp;
+
+    pixel_format = SDL_GetWindowPixelFormat(window);
+    SDL_PixelFormatEnumToMasks(pixel_format, &bbp, &r_mask, &g_mask, &b_mask, &a_mask);
+
+    surface = SDL_CreateRGBSurface(0, width, height, bbp, r_mask, g_mask, b_mask, a_mask);
+    SDL_RenderReadPixels(renderer, NULL, pixel_format, (void*)surface->pixels, surface->pitch);
+
+    SDL_snprintf(file, sizeof(file), "SDL_window%d-%8.8d.bmp",
+        SDL_GetWindowID(window), ++frame_number);
+
+    SDL_SaveBMP(surface, file);
+    SDL_FreeSurface(surface);
+}
+
+void
+loop()
+{
+    SDL_Event event;
+
+    /* Check for events */
+    while (SDL_PollEvent(&event)) {
+        switch (event.type) {
+            case SDL_QUIT:
+            done = SDL_TRUE;
+            break;
+        }
+    }
+
+    draw();
+    save_surface_to_bmp();
+
+#ifdef __EMSCRIPTEN__
+    if (done) {
+        emscripten_cancel_main_loop();
+    }
+#endif
+}
+
+int
+main(int argc, char *argv[])
+{
+    Uint32 then, now, frames;
+
+    /* Enable standard application logging */
+    SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO);
+
+    /* Force the offscreen renderer, if it cannot be created then fail out */
+    if (SDL_VideoInit("offscreen") < 0) {
+        SDL_Log("Couldn't initialize the offscreen video driver: %s\n",
+            SDL_GetError());
+        return SDL_FALSE;
+    }
+
+	/* If OPENGL fails to init it will fallback to using a framebuffer for rendering */
+    window = SDL_CreateWindow("Offscreen Test",
+                 SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
+                 width, height, 0);
+
+    if (!window) {
+        SDL_Log("Couldn't create window: %s\n",
+            SDL_GetError());
+        return SDL_FALSE;
+    }
+
+    renderer = SDL_CreateRenderer(window, -1, 0);
+
+    if (!renderer) {
+        SDL_Log("Couldn't create renderer: %s\n",
+            SDL_GetError());
+        return SDL_FALSE;
+    }
+
+    SDL_RenderClear(renderer);
+
+    srand((unsigned int)time(NULL));
+
+    /* Main render loop */
+    frames = 0;
+    then = SDL_GetTicks();
+    done = 0;
+
+    SDL_Log("Rendering %i frames offscreen\n", max_frames);
+
+#ifdef __EMSCRIPTEN__
+    emscripten_set_main_loop(loop, 0, 1);
+#else
+    while (!done && frames < max_frames) {
+        ++frames;
+        loop();
+
+        /* Print out some timing information, along with remaining frames */
+        if (frames % (max_frames / 10) == 0) {
+            now = SDL_GetTicks();
+            if (now > then) {
+                double fps = ((double) frames * 1000) / (now - then);
+                SDL_Log("Frames remaining: %i rendering at %2.2f frames per second\n", max_frames - frames, fps);
+            }
+        }
+    }
+#endif
+
+    SDL_DestroyRenderer(renderer);
+    SDL_DestroyWindow(window);
+    SDL_Quit();
+
+    return 0;
+}
+
+/* vi: set ts=4 sw=4 expandtab: */