kc3-lang/SDL

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 2341dfd..0aecd77 100644
--- 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
index 205024d..df2fdc8 100644
--- 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
index 778e555..ee7c60d 100644
--- 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
index 683c8a3..b34592c 100644
--- 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,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);
diff --git a/src/video/SDL_sysvideo.h b/src/video/SDL_sysvideo.h
index ddaaf38..372cb6c 100644
--- 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
index 35599f4..fb333f9 100644
--- 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
new file mode 100644
index 0000000..947dd21
--- /dev/null
+++ 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
new file mode 100644
index 0000000..58230c4
--- /dev/null
+++ 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: */
diff --git a/src/video/offscreen/SDL_offscreenframebuffer.c b/src/video/offscreen/SDL_offscreenframebuffer.c
new file mode 100644
index 0000000..200a7f8
--- /dev/null
+++ b/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: */
diff --git a/src/video/offscreen/SDL_offscreenframebuffer_c.h b/src/video/offscreen/SDL_offscreenframebuffer_c.h
new file mode 100644
index 0000000..af04fe7
--- /dev/null
+++ b/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: */
diff --git a/src/video/offscreen/SDL_offscreenopengl.c b/src/video/offscreen/SDL_offscreenopengl.c
new file mode 100644
index 0000000..0cfcf84
--- /dev/null
+++ b/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: */
diff --git a/src/video/offscreen/SDL_offscreenopengl.h b/src/video/offscreen/SDL_offscreenopengl.h
new file mode 100644
index 0000000..9bda0d5
--- /dev/null
+++ b/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: */
+
diff --git a/src/video/offscreen/SDL_offscreenvideo.c b/src/video/offscreen/SDL_offscreenvideo.c
new file mode 100644
index 0000000..30cf198
--- /dev/null
+++ b/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: */
diff --git a/src/video/offscreen/SDL_offscreenvideo.h b/src/video/offscreen/SDL_offscreenvideo.h
new file mode 100644
index 0000000..dffc263
--- /dev/null
+++ b/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: */
diff --git a/src/video/offscreen/SDL_offscreenwindow.c b/src/video/offscreen/SDL_offscreenwindow.c
new file mode 100644
index 0000000..5a5e469
--- /dev/null
+++ b/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: */
diff --git a/src/video/offscreen/SDL_offscreenwindow.h b/src/video/offscreen/SDL_offscreenwindow.h
new file mode 100644
index 0000000..0db084f
--- /dev/null
+++ b/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: */
+
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 682477f..a380bc8 100644
--- a/test/CMakeLists.txt
+++ b/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.
diff --git a/test/testoffscreen.c b/test/testoffscreen.c
new file mode 100644
index 0000000..63fd444
--- /dev/null
+++ b/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: */