/*

Simple DirectMedia Layer

Copyright (C) 1997-2013 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.

*/

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

// !!! IMPLEMENT_ME SDL_GetKeyName

// !!! IMPLEMENT_ME SDL_GetKeyState

// !!! IMPLEMENT_ME SDL_GetModState

// !!! IMPLEMENT_ME SDL_GetRelativeMouseState

// !!! IMPLEMENT_ME SDL_LockSurface

// !!! IMPLEMENT_ME SDL_LowerBlit

// !!! IMPLEMENT_ME SDL_SetColorKey

// !!! IMPLEMENT_ME SDL_SetModState

// !!! IMPLEMENT_ME SDL_SoftStretch

// !!! IMPLEMENT_ME SDL_UnlockSurface

// !!! IMPLEMENT_ME SDL_UpperBlit

// !!! IMPLEMENT_ME X11_KeyToUnicode

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

SDL20_SYM(rc,fn,params,args,ret)

#undef SDL20_SYM

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

#define SDL20_SYM(rc,fn,params,args,ret)

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

#include "SDL20_syms.h"

#undef SDL20_SYM_PASSTHROUGH

#undef SDL20_SYM

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

{

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_Window *VideoWindow20 = NULL;

static SDL12_Surface *WindowSurface = NULL;

static SDL12_Surface *VideoSurface = NULL;

static SDL12_Surface *ShadowSurface = NULL;

static SDL12_Surface *PublicSurface = NULL;

static SDL_GLContext *VideoContext = NULL;

static Uint32 VideoFlags = 0;

static SDL_Rect VideoViewport;

static char *WindowTitle = NULL;

static char *WindowIconTitle = NULL;

static SDL_Surface *VideoIcon;

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 == NULL)

*okay = 0;

}

return retval;

}

static void

UnloadSDL20(void)

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

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)

// !!! FIXME: do something about SDL12_INIT_EVENTTHREAD

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

if (Init12Video() == -1) {

return -1; /* !!! FIXME: should we deinit other subsystems? */

}

}

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

// !!! FIXME: do something about SDL12_INIT_EVENTTHREAD

*_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(VideoInfo.vfmt);

SDL20_zero(VideoInfo);

EventFilter12 = NULL;

EventQueueAvailable = EventQueueHead = EventQueueTail = NULL;

CurrentCursor = NULL;

VideoModes = NULL;

VideoModesCount = 0;

}

DECLSPEC void SDLCALL

SDL_QuitSubSystem(Uint32 sdl12flags)

{

Uint32 sdl20flags, extraflags;

InitFlags12To20(sdl12flags, &sdl20flags, &extraflags);

if (extraflags & SDL12_INIT_CDROM) {

// !!! FIXME: reset a bunch of other global variables too.

if (sdl12flags & SDL12_INIT_VIDEO) {

}

// !!! FIXME: do something about SDL12_INIT_EVENTTHREAD

SDL20_QuitSubSystem(sdl20flags);

// !!! FIXME: UnloadSDL20() ?

}

SDL_Quit(void)

{

SDL20_Quit();

UnloadSDL20();

}

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

SDL_GetError(void)

{

if (!Loaded_SDL20)

{

return noload_errstr;

}

return SDL20_GetError();

}

static const char *

GetDriverName(const char *name, char *namebuf, int maxlen)

{

if (name) {

if (namebuf) {

SDL20_strlcpy(namebuf, name, maxlen);

return namebuf;

} else {

return name;

}

}

return NULL;

}

SDL_AudioDriverName(char *namebuf, int maxlen)

{

return GetDriverName(SDL20_GetCurrentAudioDriver(), namebuf, maxlen);

}

SDL_VideoDriverName(char *namebuf, int maxlen)

{

return GetDriverName(SDL20_GetCurrentVideoDriver(), namebuf, maxlen);

}

SDL_PollEvent(SDL12_Event *event12)

{

EventQueueType *next;

SDL20_PumpEvents(); /* this will run our filter and build our 1.2 queue. */

if (EventQueueHead == NULL)

return 0; /* no events at the moment. */

SDL_memcpy(event12, &EventQueueHead->event12, sizeof (SDL12_Event));

next = EventQueueHead->next;

EventQueueHead->next = EventQueueAvailable;

EventQueueAvailable = EventQueueHead;

EventQueueHead = next;

return 1;

}

SDL_PushEvent(SDL12_Event *event12)

{

EventQueueType *item = EventQueueAvailable;

if (item == NULL)

return -1; /* no space available at the moment. */

EventQueueAvailable = item->next;

if (EventQueueTail)

EventQueueTail->next = item;

else

EventQueueHead = EventQueueTail = item;

item->next = NULL;

SDL_memcpy(&item->event12, event12, sizeof (SDL12_Event));

return 0;

}