/*

Simple DirectMedia Layer

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.

*/

/* This file contains functions for backwards compatibility with SDL 1.2 */

#if !SDL_VERSION_ATLEAST(2,0,0)

#error You need to compile against SDL 2.0 headers.

#endif

/*

* We report the library version as 1.2.$(SDL12_COMPAT_VERSION). This number

* should be way ahead of what SDL-1.2 Classic would report, so apps can

* decide if they're running under the compat layer, if they really care.

*/

#define SDL12_COMPAT_VERSION 50

#include <stdarg.h>

// !!! IMPLEMENT_ME SDL_CDClose

// !!! IMPLEMENT_ME SDL_CDEject

// !!! IMPLEMENT_ME SDL_CDName

// !!! IMPLEMENT_ME SDL_CDNumDrives

// !!! IMPLEMENT_ME SDL_CDOpen

// !!! IMPLEMENT_ME SDL_CDPause

// !!! IMPLEMENT_ME SDL_CDPlay

// !!! IMPLEMENT_ME SDL_CDPlayTracks

// !!! IMPLEMENT_ME SDL_CDResume

// !!! IMPLEMENT_ME SDL_CDStatus

// !!! IMPLEMENT_ME SDL_CDStop

// !!! IMPLEMENT_ME SDL_CreateYUVOverlay

// !!! IMPLEMENT_ME SDL_DisplayFormat

// !!! IMPLEMENT_ME SDL_DisplayFormatAlpha

// !!! IMPLEMENT_ME SDL_DisplayYUVOverlay

// !!! IMPLEMENT_ME SDL_EnableKeyRepeat

// !!! IMPLEMENT_ME SDL_EnableUNICODE

// !!! IMPLEMENT_ME SDL_FreeYUVOverlay

// !!! IMPLEMENT_ME SDL_GL_Lock

// !!! IMPLEMENT_ME SDL_GL_Unlock

// !!! IMPLEMENT_ME SDL_GL_UpdateRects

// !!! IMPLEMENT_ME SDL_GetKeyName

// !!! IMPLEMENT_ME SDL_GetKeyState

// !!! IMPLEMENT_ME SDL_GetModState

// !!! IMPLEMENT_ME SDL_GetRelativeMouseState

// !!! IMPLEMENT_ME SDL_GetVideoSurface

// !!! IMPLEMENT_ME SDL_GetWMInfo

// !!! IMPLEMENT_ME SDL_SetAlpha

// !!! IMPLEMENT_ME SDL_SetColors

// !!! IMPLEMENT_ME SDL_SetPalette

// !!! IMPLEMENT_ME SDL_SetVideoMode

// !!! IMPLEMENT_ME SDL_SoftStretch

// !!! IMPLEMENT_ME SDL_UnlockSurface

// !!! IMPLEMENT_ME SDL_UnlockYUVOverlay

// !!! IMPLEMENT_ME SDL_UpdateRects

// !!! FIXME: should SDL_VideoInit really be a passthrough?

// !!! FIXME: should SDL_VideoQuit really be a passthrough?

// !!! IMPLEMENT_ME SDL_WM_SetIcon

// !!! IMPLEMENT_ME SDL_WM_ToggleFullScreen

// !!! IMPLEMENT_ME X11_KeyToUnicode

#if 0

#define FIXME(x) do {} while (0)

#else

#define FIXME(x) \

do { \

static SDL_bool seen = SDL_FALSE; \

if (!seen) { \

fprintf(stderr, "FIXME: %s (%s:%d)\n", x, __FILE__, __LINE__); \

seen = SDL_TRUE; \

} \

} while (0)

#endif

static SDL20_##fn##_t SDL20_##fn = NULL;

#include "SDL20_syms.h"

/* Things that _should_ be binary compatible pass right through... */

#define SDL20_SYM_PASSTHROUGH(rc,fn,params,args,ret) \

#include "SDL20_syms.h"

/* these are macros (etc) in the SDL headers, so make our own. */

#define SDL20_OutOfMemory() SDL20_Error(SDL_ENOMEM)

#define SDL20_Unsupported() SDL20_Error(SDL_UNSUPPORTED)

#define SDL20_InvalidParamError(param) SDL20_SetError("Parameter '%s' is invalid", (param))

#define SDL20_zero(x) SDL20_memset(&(x), 0, sizeof((x)))

#define SDL20_zerop(x) SDL20_memset((x), 0, sizeof(*(x)))

#define SDL_ReportAssertion SDL20_ReportAssertion

#define SDL12_DEFAULT_REPEAT_DELAY 500

#define SDL12_DEFAULT_REPEAT_INTERVAL 30

#define SDL12_INIT_TIMER 0x00000001

#define SDL12_INIT_AUDIO 0x00000010

#define SDL12_INIT_VIDEO 0x00000020

#define SDL12_INIT_CDROM 0x00000100

#define SDL12_INIT_JOYSTICK 0x00000200

#define SDL12_INIT_NOPARACHUTE 0x00100000

#define SDL12_INIT_EVENTTHREAD 0x01000000

#define SDL12_INIT_EVERYTHING 0x0000FFFF

int ncolors;

SDL_Color *colors;

} SDL12_Palette;

typedef struct SDL12_PixelFormat

{

SDL12_Palette *palette;

Uint8 BitsPerPixel;

Uint8 BytesPerPixel;

Uint8 Rloss;

Uint8 Gloss;

Uint8 Bloss;

Uint8 Aloss;

Uint8 Rshift;

Uint8 Gshift;

Uint8 Bshift;

Uint8 Ashift;

Uint32 Rmask;

Uint32 Gmask;

Uint32 Bmask;

Uint32 Amask;

Uint32 colorkey;

Uint8 alpha;

} SDL12_PixelFormat;

typedef struct SDL12_Surface

{

Uint32 flags;

SDL12_PixelFormat *format;

int w;

int h;

Uint16 pitch;

void *pixels;

int offset;

SDL_Rect clip_rect;

Uint32 unused1;

Uint32 locked;

void *blitmap;

unsigned int format_version;

int refcount;

} SDL12_Surface;

typedef struct SDL12_Overlay

{

Uint32 format;

int w;

int h;

int planes;

Uint16 *pitches;

Uint8 **pixels;

void *hwfuncs;

void *hwdata;

Uint32 hw_overlay :1;

Uint32 UnusedBits :31;

} SDL12_Overlay;

typedef struct

{

Uint32 hw_available :1;

Uint32 wm_available :1;

Uint32 UnusedBits1 :6;

Uint32 UnusedBits2 :1;

Uint32 blit_hw :1;

Uint32 blit_hw_CC :1;

Uint32 blit_hw_A :1;

Uint32 blit_sw :1;

Uint32 blit_sw_CC :1;

Uint32 blit_sw_A :1;

Uint32 blit_fill :1;

Uint32 UnusedBits3 :16;

Uint32 video_mem;

SDL_PixelFormat *vfmt;

int current_w;

int current_h;

} SDL12_VideoInfo;

#define SDL12_HWSURFACE 0x00000001

#define SDL12_ASYNCBLIT 0x00000004

#define SDL12_ANYFORMAT 0x10000000

#define SDL12_HWPALETTE 0x20000000

#define SDL12_DOUBLEBUF 0x40000000

#define SDL12_FULLSCREEN 0x80000000

#define SDL12_OPENGL 0x00000002

#define SDL12_OPENGLBLIT 0x0000000A

#define SDL12_RESIZABLE 0x00000010

#define SDL12_NOFRAME 0x00000020

#define SDL12_HWACCEL 0x00000100

#define SDL12_SRCCOLORKEY 0x00001000

#define SDL12_RLEACCELOK 0x00002000

#define SDL12_RLEACCEL 0x00004000

#define SDL12_SRCALPHA 0x00010000

#define SDL12_PREALLOC 0x01000000

typedef enum

{

SDL12_NOEVENT = 0,

SDL12_ACTIVEEVENT,

SDL12_KEYDOWN,

SDL12_KEYUP,

SDL12_MOUSEMOTION,

SDL12_MOUSEBUTTONDOWN,

SDL12_MOUSEBUTTONUP,

SDL12_JOYAXISMOTION,

SDL12_JOYBALLMOTION,

SDL12_JOYHATMOTION,

SDL12_JOYBUTTONDOWN,

SDL12_JOYBUTTONUP,

SDL12_QUIT,

SDL12_SYSWMEVENT,

SDL12_EVENT_RESERVEDA,

SDL12_EVENT_RESERVEDB,

SDL12_VIDEORESIZE,

SDL12_VIDEOEXPOSE,

SDL12_USEREVENT = 24,

SDL12_NUMEVENTS = 32

} SDL12_EventType;

#define SDL12_APPMOUSEFOCUS (1<<0)

#define SDL12_APPINPUTFOCUS (1<<1)

#define SDL12_APPACTIVE (1<<2)

typedef struct

{

Uint8 type;

Uint8 gain;

Uint8 state;

} SDL12_ActiveEvent;

typedef struct

{

Uint8 type;

Uint8 which;

Uint8 state;

} SDL12_KeyboardEvent;

typedef struct

{

Uint8 type;

Uint8 which;

Uint8 state;

Uint16 x, y;

Sint16 xrel;

Sint16 yrel;

} SDL12_MouseMotionEvent;

typedef struct

{

Uint8 type;

Uint8 which;

Uint8 button;

Uint8 state;

Uint16 x, y;

} SDL12_MouseButtonEvent;

typedef struct

{

Uint8 type;

Uint8 which;

Uint8 axis;

Sint16 value;

} SDL12_JoyAxisEvent;

typedef struct

{

Uint8 type;

Uint8 which;

Uint8 ball;

Sint16 xrel;

Sint16 yrel;

} SDL12_JoyBallEvent;

typedef struct

{

Uint8 type;

Uint8 which;

Uint8 hat;

Uint8 value;

} SDL12_JoyHatEvent;

typedef struct

{

Uint8 type;

Uint8 which;

Uint8 button;

Uint8 state;

} SDL12_JoyButtonEvent;

typedef struct

{

Uint8 type;

int w;

int h;

} SDL12_ResizeEvent;

typedef struct

{

Uint8 type;

} SDL12_ExposeEvent;

typedef struct

{

Uint8 type;

} SDL12_QuitEvent;

typedef struct

{

Uint8 type;

int code;

void *data1;

void *data2;

} SDL12_UserEvent;

typedef struct

{

Uint8 type;

void *msg;

} SDL12_SysWMEvent;

typedef union

{

Uint8 type;

SDL12_ActiveEvent active;

SDL12_KeyboardEvent key;

SDL12_MouseMotionEvent motion;

SDL12_MouseButtonEvent button;

SDL12_JoyAxisEvent jaxis;

SDL12_JoyBallEvent jball;

SDL12_JoyHatEvent jhat;

SDL12_JoyButtonEvent jbutton;

SDL12_ResizeEvent resize;

SDL12_ExposeEvent expose;

SDL12_QuitEvent quit;

SDL12_UserEvent user;

SDL12_SysWMEvent syswm;

} SDL12_Event;

typedef int (SDLCALL *SDL12_EventFilter)(const SDL12_Event *event12);

static int EventFilter20to12(void *data, SDL_Event *event20);

typedef Uint32 (SDLCALL *SDL12_TimerCallback)(Uint32 interval);

typedef SDL_TimerCallback SDL12_NewTimerCallback;

SDL_Rect area;

Sint16 hot_x;

Sint16 hot_y;

Uint8 *data;

Uint8 *mask;

Uint8 *save[2];

SDL_Cursor *wm_cursor; /* the real SDL 1.2 has an opaque pointer to a platform-specific cursor here. */

} SDL12_Cursor;

typedef enum

{

SDL12_GL_RED_SIZE,

SDL12_GL_GREEN_SIZE,

SDL12_GL_BLUE_SIZE,

SDL12_GL_ALPHA_SIZE,

SDL12_GL_BUFFER_SIZE,

SDL12_GL_DOUBLEBUFFER,

SDL12_GL_DEPTH_SIZE,

SDL12_GL_STENCIL_SIZE,

SDL12_GL_ACCUM_RED_SIZE,

SDL12_GL_ACCUM_GREEN_SIZE,

SDL12_GL_ACCUM_BLUE_SIZE,

SDL12_GL_ACCUM_ALPHA_SIZE,

SDL12_GL_STEREO,

SDL12_GL_MULTISAMPLEBUFFERS,

SDL12_GL_MULTISAMPLESAMPLES,

SDL12_GL_ACCELERATED_VISUAL,

SDL12_GL_SWAP_CONTROL,

SDL12_GL_MAX_ATTRIBUTE

} SDL12_GLattr;

typedef struct

{

Uint32 format;

SDL_Rect *modeslist;

SDL_Rect **modes; /* ptrs to each item in modeslist, for SDL_ListModes() */

} VideoModeList;

static VideoModeList *VideoModes = NULL;

static int VideoModesCount = 0;

static SDL_Renderer *VideoRenderer20 = NULL;

static SDL_Texture *VideoTexture20 = NULL;

static SDL12_Surface *VideoSurface12 = NULL;

static SDL_Surface *VideoConvertSurface20 = NULL;

static SDL_GLContext *VideoGLContext20 = NULL;

static char *WindowTitle = NULL;

static char *WindowIconTitle = NULL;

static int EnabledUnicode = 0;

static int VideoDisplayIndex = 0;

static int CDRomInit = 0;

// !!! FIXME: need a mutex for the event queue.

#define SDL12_MAXEVENTS 128

typedef struct EventQueueType

{

SDL12_Event event12;

struct EventQueueType *next;

} EventQueueType;

static EventQueueType EventQueuePool[SDL12_MAXEVENTS];

static EventQueueType *EventQueueHead = NULL;

static EventQueueType *EventQueueTail = NULL;

static EventQueueType *EventQueueAvailable = NULL;

/* Obviously we can't use SDL_LoadObject() to load SDL2. :) */

#if defined(_WINDOWS)

#define WIN32_LEAN_AND_MEAN 1

#include <windows.h>

#define SDL20_LIBNAME "SDL2.dll"

static HANDLE Loaded_SDL20 = NULL;

#define LoadSDL20Library() ((Loaded_SDL20 = LoadLibraryA(SDL20_LIBNAME)) != NULL)

#define LookupSDL20Sym(sym) GetProcAddress(Loaded_SDL20, sym)

#define CloseSDL20Library() { { if (Loaded_SDL20) { FreeLibrary(Loaded_SDL20); Loaded_SDL20 = NULL; } }

#elif defined(unix) || defined(__APPLE__)

#include <dlfcn.h>

#ifdef __APPLE__

#define SDL20_LIBNAME "libSDL2.dylib"

#else

#define SDL20_LIBNAME "libSDL2-2.0.so.0"

#endif

static void *Loaded_SDL20 = NULL;

#define LoadSDL20Library() ((Loaded_SDL20 = dlopen(SDL20_LIBNAME, RTLD_LOCAL)) != NULL)

#define LookupSDL20Sym(sym) dlsym(Loaded_SDL20, sym)

#define CloseSDL20Library() { if (Loaded_SDL20) { dlclose(Loaded_SDL20); Loaded_SDL20 = NULL; } }

#else

#error Please define your platform.

#endif

static void *

LoadSDL20Symbol(const char *fn, int *okay)

void *retval = NULL;

if (*okay) /* only bother trying if we haven't previously failed. */

{

retval = LookupSDL20Sym(fn);

if (!retval) { fprintf(stderr, "WARNING: LOAD FAILED: %s\n", fn); }

// if (retval == NULL)

// *okay = 0;

}

return retval;

}

static void

UnloadSDL20(void)

#define SDL20_SYM(rc,fn,params,args,ret) SDL20_##fn = NULL;

#include "SDL20_syms.h"

CloseSDL20Library();

}

static int

LoadSDL20(void)

{

int okay = 1;

if (!Loaded_SDL20)

{

okay = LoadSDL20Library();

#define SDL20_SYM(rc,fn,params,args,ret) SDL20_##fn = (SDL20_##fn##_t) LoadSDL20Symbol("SDL_" #fn, &okay);

#include "SDL20_syms.h"

if (!okay)

UnloadSDL20();

}

DECLSPEC const SDL_version * SDLCALL

SDL_Linked_Version(void)

{

static const SDL_version version = { 1, 2, SDL12_COMPAT_VERSION };

return &version;

}

static int

GetVideoDisplay()

{

const char *variable = SDL_getenv("SDL_VIDEO_FULLSCREEN_DISPLAY");

if ( !variable ) {

variable = SDL_getenv("SDL_VIDEO_FULLSCREEN_HEAD");

}

if ( variable ) {

} else {

return 0;

}

}

/* This sets up VideoModes and VideoModesCount. You end up with arrays by pixel

format, each with a value that 1.2's SDL_ListModes() can return. */

static int

Init12VidModes(void)

{

const int total = SDL20_GetNumDisplayModes(VideoDisplayIndex);

VideoModeList *vmode = NULL;

int num_modes = 0;

void *ptr = NULL;

int i, j;

SDL_assert(VideoModes == NULL);

SDL_assert(VideoModesCount == 0);

for (i = 0; i < total; ++i) {

SDL_DisplayMode mode;

if (SDL20_GetDisplayMode(VideoDisplayIndex, i, &mode) == -1) {

continue;

} else if (!mode.w || !mode.h) {

SDL_assert(0 && "Can this actually happen?");

continue;

}

if (!vmode || (mode.format != vmode->format)) { // SDL20_GetDisplayMode() sorts on bpp first. We know when to change arrays.

if (VideoModesCount > 0) {

VideoModes[VideoModesCount-1].modes[num_modes] = NULL;

}

ptr = (VideoModeList *) SDL20_realloc(VideoModes, sizeof (VideoModeList) * (VideoModesCount+1));

if (!ptr) {

return SDL20_OutOfMemory();

}

VideoModes = (VideoModeList *) ptr;

vmode = &VideoModes[VideoModesCount];

vmode->format = mode.format;

vmode->modeslist = NULL;

vmode->modes = NULL;

VideoModesCount++;

num_modes = 0;

}

/* make sure we don't have this one already (with a different refresh rate, etc). */

for (j = 0; j < num_modes; j++) {

if ((vmode->modeslist[j].w == mode.w) && (vmode->modeslist[j].h == mode.h)) {

break;

}

}

if (j < num_modes) {

continue; /* already have this one. */

}

ptr = SDL20_realloc(vmode->modes, sizeof (SDL_Rect *) * (num_modes + 2));

if (ptr == NULL) {

return SDL20_OutOfMemory();

}

vmode->modes = (SDL_Rect **) ptr;

ptr = SDL20_realloc(vmode->modeslist, sizeof (SDL_Rect) * (num_modes + 1));

if (ptr == NULL) {

return SDL20_OutOfMemory();

}

vmode->modeslist = (SDL_Rect *) ptr;

vmode->modeslist[num_modes].x = 0;

vmode->modeslist[num_modes].y = 0;

vmode->modeslist[num_modes].w = mode.w;

vmode->modeslist[num_modes].h = mode.h;

vmode->modes[num_modes] = &vmode->modeslist[num_modes];

num_modes++;

}

if (VideoModesCount > 0) {

VideoModes[VideoModesCount-1].modes[num_modes] = NULL;

}

return 0;

}

static int

Init12Video(void)

{

int i;

for (i = 0; i < SDL12_MAXEVENTS-1; i++)

EventQueuePool[i].next = &EventQueuePool[i+1];

EventQueuePool[SDL12_MAXEVENTS-1].next = NULL;

EventQueueHead = EventQueueTail = NULL;

EventQueueAvailable = EventQueuePool;

SDL_memset(EventStates, SDL_ENABLE, sizeof (EventStates)); /* on by default */

EventStates[SDL12_SYSWMEVENT] = SDL_IGNORE; /* off by default. */

SDL20_SetEventFilter(EventFilter20to12, NULL);

VideoDisplayIndex = GetVideoDisplay();

SwapInterval = 0;

if (Init12VidModes() == -1) {

return -1;

}

return 0;

}

DECLSPEC int SDLCALL

SDL_InitSubSystem(Uint32 sdl12flags)

FIXME("there is never a parachute in SDL2, should we catch segfaults ourselves?");

FIXME("support event thread where it makes sense to do so?");

if ( (sdl12flags & SDL12_INIT_EVENTTHREAD) == SDL12_INIT_EVENTTHREAD ) {

return SDL20_SetError("OS doesn't support threaded events");

}

Uint32 sdl20flags = 0;

int rc;

if (!LoadSDL20())

return -1;

SETFLAG(TIMER);

SETFLAG(AUDIO);

SETFLAG(VIDEO);

SETFLAG(JOYSTICK);

SETFLAG(NOPARACHUTE);

#undef SETFLAG

// There's no CDROM in 2.0, but we'll just pretend it succeeded.

if (sdl12flags & SDL12_INIT_CDROM)

if ((rc == 0) && (sdl20flags & SDL_INIT_VIDEO)) {

if (Init12Video() == -1) {

FIXME("should we deinit other subsystems?");

return -1;

}

return rc;

}

SDL_Init(Uint32 sdl12flags)

{

}

static void

InitFlags12To20(const Uint32 flags12, Uint32 *_flags20, Uint32 *_extraflags)

Uint32 extraflags = 0;

SETFLAG(TIMER);

SETFLAG(AUDIO);

SETFLAG(VIDEO);

SETFLAG(JOYSTICK);

SETFLAG(NOPARACHUTE);

#undef SETFLAG

*_flags20 = flags20;

*_extraflags = extraflags;

}

static Uint32

InitFlags20to12(const Uint32 flags20)

SETFLAG(TIMER);

SETFLAG(AUDIO);

SETFLAG(VIDEO);

SETFLAG(JOYSTICK);

SETFLAG(NOPARACHUTE);

#undef SETFLAG

return flags12;

}

DECLSPEC Uint32 SDLCALL

SDL_WasInit(Uint32 sdl12flags)

{

Uint32 sdl20flags, extraflags;

InitFlags12To20(sdl12flags, &sdl20flags, &extraflags);

return InitFlags20to12(SDL20_WasInit(sdl20flags)) | extraflags;

}

static void

Quit12Video(void)

{

int i;

for (i = 0; i < VideoModesCount; i++) {

SDL20_free(VideoModes[i].modeslist);

SDL20_free(VideoModes[i].modes);

}

SDL20_free(VideoModes);

SDL20_FreeFormat(VideoInfo12.vfmt);

SDL20_zero(VideoInfo12);

EventFilter12 = NULL;

EventQueueAvailable = EventQueueHead = EventQueueTail = NULL;

VideoModes = NULL;

VideoModesCount = 0;

}

DECLSPEC void SDLCALL

SDL_QuitSubSystem(Uint32 sdl12flags)

{

Uint32 sdl20flags, extraflags;

InitFlags12To20(sdl12flags, &sdl20flags, &extraflags);

if (extraflags & SDL12_INIT_CDROM) {

}

SDL20_QuitSubSystem(sdl20flags);

if ((SDL20_WasInit(0) == 0) && (!CDRomInit)) {

SDL20_Quit();

UnloadSDL20();

}

}

SDL_Quit(void)

{

}

SDL_SetError(const char *fmt, ...)

{

va_list ap;

va_start(ap, fmt);

str = (char *) SDL20_malloc(len + 1);

if (!str)

SDL20_OutOfMemory();

else

{

va_start(ap, fmt);

SDL20_vsnprintf(str, len + 1, fmt, ap);

va_end(ap);