encounter
/
SDL
mirror of https://github.com/encounter/SDL.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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
This commit is contained in:
Brandon Schaefer 2019-09-24 16:36:48 -04:00
parent 3d55a51482
commit 68985371a0
18 changed files with 1018 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
CMakeLists.txt
View File

@ -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

1
include/SDL_config.h.cmake
View File

@ -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@

148
src/video/SDL_egl.c
View File

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

16
src/video/SDL_egl_c.h
View File

@ -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;
@ -82,6 +84,8 @@ typedef struct SDL_EGL_VideoData
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);

1
src/video/SDL_sysvideo.h
View File

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

3
src/video/SDL_video.c
View File

@ -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

42
src/video/offscreen/SDL_offscreenevents.c Normal file
View File

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

28
src/video/offscreen/SDL_offscreenevents_c.h Normal file
View File

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

90
src/video/offscreen/SDL_offscreenframebuffer.c Normal file
View File

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

28
src/video/offscreen/SDL_offscreenframebuffer_c.h Normal file
View File

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

102
src/video/offscreen/SDL_offscreenopengl.c Normal file
View File

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

54
src/video/offscreen/SDL_offscreenopengl.h Normal file
View File

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

166
src/video/offscreen/SDL_offscreenvideo.c Normal file
View File

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

32
src/video/offscreen/SDL_offscreenvideo.h Normal file
View File

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

87
src/video/offscreen/SDL_offscreenwindow.c Normal file
View File

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

46
src/video/offscreen/SDL_offscreenwindow.h Normal file
View File

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

1
test/CMakeLists.txt
View File

@ -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.

170
test/testoffscreen.c Normal file
View File

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