/*

  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.

*/

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

// !!! FIXME: clean up code conventions

// !!! FIXME: grep for VideoWindow20 places that might care if it's NULL

#include "SDL20_include_wrapper.h"

#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_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_LockSurface

// !!! IMPLEMENT_ME SDL_LockYUVOverlay

// !!! IMPLEMENT_ME SDL_LowerBlit

// !!! IMPLEMENT_ME SDL_SetAlpha

// !!! IMPLEMENT_ME SDL_SetColorKey

// !!! IMPLEMENT_ME SDL_SetColors

// !!! IMPLEMENT_ME SDL_SetModState

// !!! IMPLEMENT_ME SDL_SetPalette

// !!! IMPLEMENT_ME SDL_SetVideoMode

// !!! IMPLEMENT_ME SDL_SoftStretch

// !!! IMPLEMENT_ME SDL_UnlockSurface

// !!! IMPLEMENT_ME SDL_UnlockYUVOverlay

// !!! IMPLEMENT_ME SDL_UpdateRects

// !!! IMPLEMENT_ME SDL_UpperBlit

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

#define SDL_BlitSurface SDL_UpperBlit

#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

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

    typedef rc (SDLCALL *SDL20_##fn##_t) params; \

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

    DECLSPEC rc SDLCALL SDL_##fn params { ret SDL20_##fn args; }

#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

typedef struct SDL12_Rect

{

    Sint16 x;

    Sint16 y;

    Uint16 w;

    Uint16 h;

} SDL12_Rect;

typedef struct SDL12_Palette

{

    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_Surface *surface20; /* the real SDL 1.2 has an opaque pointer to a platform-specific thing here named "hwdata". */

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

    //FIXME: SDL12_keysym keysym;

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

typedef struct

{

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

    SDL12_Rect *modeslist12;

    SDL12_Rect **modes12;  /* ptrs to each item in modeslist, for SDL_ListModes() */

} VideoModeList;

// !!! FIXME: go through all of these.

static VideoModeList *VideoModes = NULL;

static int VideoModesCount = 0;

static SDL12_VideoInfo VideoInfo12;

static SDL_Window *VideoWindow20 = NULL;

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 SDL12_Surface *VideoIcon12;

static int EnabledUnicode = 0;

static int VideoDisplayIndex = 0;

static int CDRomInit = 0;

static SDL12_EventFilter EventFilter12 = NULL;

static SDL12_Cursor *CurrentCursor12 = NULL;

static Uint8 EventStates[SDL12_NUMEVENTS];

static int SwapInterval = 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();

    }

    return okay;

}

DECLSPEC const SDL_version * SDLCALL

SDL_Linked_Version(void)

{

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

    return &version;

}

DECLSPEC int SDLCALL

SDL_sscanf(const char *text, const char *fmt, ...)

{

    int retval;

    va_list ap;

    va_start(ap, fmt);

    retval = (int) SDL20_sscanf(text, fmt, ap);

    va_end(ap);

    return retval;

}

DECLSPEC int SDLCALL

SDL_snprintf(char *text, size_t maxlen, const char *fmt, ...)

{

    int retval;

    va_list ap;

    va_start(ap, fmt);

    retval = (int) SDL20_vsnprintf(text, maxlen, fmt, ap);

    va_end(ap);

    return retval;

}

DECLSPEC SDL_bool SDLCALL

SDL_HasMMXExt(void)

{

    /* this isn't accurate, but SDL2 doesn't have this for some reason.

        MMXExt is available in all SSE1 machines, except early Athlon chips,

        so we'll just say it's available if they have SSE1. Oh well. */

    return SDL20_HasSSE();

}

DECLSPEC SDL_bool SDLCALL

SDL_Has3DNowExt(void)

{

    FIXME("check this");

    return SDL20_HasSSE();

}

DECLSPEC int SDLCALL SDL_JoystickOpened(int device_index)

{

    FIXME("write me");

    return 0;

}

static int

GetVideoDisplay()

{

    FIXME("cache this value during SDL_Init() so it doesn't change.");

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

    if ( !variable ) {

        variable = SDL20_getenv("SDL_VIDEO_FULLSCREEN_HEAD");

    }

    if ( variable ) {

        return SDL20_atoi(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].modes12[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->modeslist12 = NULL;

            vmode->modes12 = 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->modeslist12[j].w == mode.w) && (vmode->modeslist12[j].h == mode.h)) {

                break;

            }

        }

        if (j < num_modes) {

            continue;  /* already have this one. */

        }

        FIXME("Make sure mode dimensions fit in 16-bits for SDL12_Rect");

        ptr = SDL20_realloc(vmode->modes12, sizeof (SDL12_Rect *) * (num_modes + 2));

        if (ptr == NULL) {

            return SDL20_OutOfMemory();

        }

        vmode->modes12 = (SDL12_Rect **) ptr;

        ptr = SDL20_realloc(vmode->modeslist12, sizeof (SDL12_Rect) * (num_modes + 1));

        if (ptr == NULL) {

            return SDL20_OutOfMemory();

        }

        vmode->modeslist12 = (SDL12_Rect *) ptr;

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

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

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

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

        vmode->modes12[num_modes] = &vmode->modeslist12[num_modes];

        num_modes++;

    }

    if (VideoModesCount > 0) {

        VideoModes[VideoModesCount-1].modes12[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;

#ifdef __MACOSX__

    extern void sdl12_compat_macos_init(void);

    sdl12_compat_macos_init();

#endif

    #define SETFLAG(flag) if (sdl12flags & SDL12_INIT_##flag) sdl20flags |= SDL_INIT_##flag

    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)

        CDRomInit = 1;

    FIXME("do something about SDL12_INIT_EVENTTHREAD");

    rc = SDL20_Init(sdl20flags);

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

        if (Init12Video() == -1) {

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

            return -1;

        }

    }

    return rc;

}

DECLSPEC int SDLCALL

SDL_Init(Uint32 sdl12flags)

{

    FIXME("what was different in 1.2?");

    return SDL_InitSubSystem(sdl12flags);   /* there's no difference betwee Init and InitSubSystem in SDL2. */

}

static void

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

{

    Uint32 flags20 = 0;

    Uint32 extraflags = 0;

    #define SETFLAG(flag) if (flags12 & SDL12_INIT_##flag) flags20 |= SDL_INIT_##flag

    SETFLAG(TIMER);

    SETFLAG(AUDIO);

    SETFLAG(VIDEO);

    SETFLAG(JOYSTICK);

    SETFLAG(NOPARACHUTE);

    #undef SETFLAG

    if ((flags12 & SDL12_INIT_CDROM) && (CDRomInit)) {

        extraflags |= SDL12_INIT_CDROM;

    }

    FIXME("do something about SDL12_INIT_EVENTTHREAD");

    *_flags20 = flags20;

    *_extraflags = extraflags;

}

static Uint32

InitFlags20to12(const Uint32 flags20)

{

    Uint32 flags12 = 0;

    #define SETFLAG(flag) if (flags20 & SDL_INIT_##flag) flags12 |= SDL12_INIT_##flag

    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].modeslist12);

        SDL20_free(VideoModes[i].modes12);

    }

    SDL20_free(VideoModes);

    SDL20_FreeFormat(VideoInfo12.vfmt);

    SDL20_zero(VideoInfo12);

    EventFilter12 = NULL;

    EventQueueAvailable = EventQueueHead = EventQueueTail = NULL;

    CurrentCursor12 = NULL;

    VideoModes = NULL;

    VideoModesCount = 0;

}

DECLSPEC void SDLCALL

SDL_QuitSubSystem(Uint32 sdl12flags)

{

    Uint32 sdl20flags, extraflags;

    InitFlags12To20(sdl12flags, &sdl20flags, &extraflags);

    if (extraflags & SDL12_INIT_CDROM) {

        CDRomInit = 0;

    }

    FIXME("reset a bunch of other global variables too.");

    if (sdl12flags & SDL12_INIT_VIDEO) {

        Quit12Video();

    }

    FIXME("do something about SDL12_INIT_EVENTTHREAD");

    SDL20_QuitSubSystem(sdl20flags);

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

        SDL20_Quit();

        UnloadSDL20();

    }

}

DECLSPEC void SDLCALL

SDL_Quit(void)

{

    SDL_QuitSubSystem(SDL_WasInit(0) | SDL12_INIT_CDROM);

}

DECLSPEC void SDLCALL

SDL_SetError(const char *fmt, ...)

{

    char ch;

    char *str = NULL;

    size_t len = 0;

    va_list ap;

    va_start(ap, fmt);

    len = SDL20_vsnprintf(&ch, 1, fmt, ap);

    va_end(ap);

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

        SDL20_SetError("%s", str);

        SDL20_free(str);

    }

}

DECLSPEC const char * SDLCALL

SDL_GetError(void)

{

    if (SDL20_GetError == NULL)

    {

        static const char noload_errstr[] = "The SDL 2.0 library that the 1.2 compatibility layer needs isn't loaded";

        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;

}

DECLSPEC const char * SDLCALL

SDL_AudioDriverName(char *namebuf, int maxlen)

{

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

}

DECLSPEC const char * SDLCALL

SDL_VideoDriverName(char *namebuf, int maxlen)

{

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

}

DECLSPEC int SDLCALL

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;

}

DECLSPEC int SDLCALL

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;

}

DECLSPEC int SDLCALL

SDL_PeepEvents(SDL12_Event *events12, int numevents, SDL_eventaction action, Uint32 mask)

{

    if (action == SDL_ADDEVENT)

    {

        int i;

        for (i = 0; i < numevents; i++)

        {

            if (SDL_PushEvent(&events12[i]) == -1)

                break;  /* out of space for more events. */

        }

        return i;

    }

    else if ((action == SDL_PEEKEVENT) || (action == SDL_GETEVENT))

    {

        const SDL_bool isGet = (action == SDL_GETEVENT);

        EventQueueType *prev = NULL;

        EventQueueType *item = EventQueueHead;

        EventQueueType *next = NULL;

        int chosen = 0;

        while (chosen < numevents)

        {

            EventQueueType *nextPrev = item;

            if (!item)

                break;  /* no more events at the moment. */