Copy SDL stuff back from xpdev directory.

src/conio/SDLMain.h

+/*   SDLMain.m - main entry point for our Cocoa-ized SDL app
+       Initial Version: Darrell Walisser <dwaliss1@purdue.edu>
+       Non-NIB-Code & other changes: Max Horn <max@quendi.de>
+
+    Feel free to customize this file to suit your needs
+*/
+
+#import <Cocoa/Cocoa.h>
+
+@interface SDLMain : NSObject
+@end

src/conio/SDLMain.m

+/*   SDLMain.m - main entry point for our Cocoa-ized SDL app
+       Initial Version: Darrell Walisser <dwaliss1@purdue.edu>
+       Non-NIB-Code & other changes: Max Horn <max@quendi.de>
+
+    Feel free to customize this file to suit your needs
+*/
+
+#import "SDL.h"
+#import "SDLMain.h"
+#import <sys/param.h> /* for MAXPATHLEN */
+#import <unistd.h>
+
+/* Use this flag to determine whether we use SDLMain.nib or not */
+#define		SDL_USE_NIB_FILE	0
+
+
+static int    gArgc;
+static char  **gArgv;
+static BOOL   gFinderLaunch;
+
+#if SDL_USE_NIB_FILE
+/* A helper category for NSString */
+@interface NSString (ReplaceSubString)
+- (NSString *)stringByReplacingRange:(NSRange)aRange with:(NSString *)aString;
+@end
+#else
+/* An internal Apple class used to setup Apple menus */
+@interface NSAppleMenuController:NSObject {}
+- (void)controlMenu:(NSMenu *)aMenu;
+@end
+#endif
+
+@interface SDLApplication : NSApplication
+@end
+
+@implementation SDLApplication
+/* Invoked from the Quit menu item */
+- (void)terminate:(id)sender
+{
+    /* Post a SDL_QUIT event */
+    SDL_Event event;
+    event.type = SDL_QUIT;
+    SDL_PushEvent(&event);
+}
+@end
+
+
+/* The main class of the application, the application's delegate */
+@implementation SDLMain
+
+/* Set the working directory to the .app's parent directory */
+- (void) setupWorkingDirectory:(BOOL)shouldChdir
+{
+    char parentdir[MAXPATHLEN];
+    char *c;
+    
+    strncpy ( parentdir, gArgv[0], sizeof(parentdir) );
+    c = (char*) parentdir;
+
+    while (*c != '\0')     /* go to end */
+        c++;
+    
+    while (*c != '/')      /* back up to parent */
+        c--;
+    
+    *c++ = '\0';             /* cut off last part (binary name) */
+  
+    if (shouldChdir)
+    {
+      assert ( chdir (parentdir) == 0 );   /* chdir to the binary app's parent */
+      assert ( chdir ("../../../") == 0 ); /* chdir to the .app's parent */
+    }
+}
+
+#if SDL_USE_NIB_FILE
+
+/* Fix menu to contain the real app name instead of "SDL App" */
+- (void)fixMenu:(NSMenu *)aMenu withAppName:(NSString *)appName
+{
+    NSRange aRange;
+    NSEnumerator *enumerator;
+    NSMenuItem *menuItem;
+
+    aRange = [[aMenu title] rangeOfString:@"SDL App"];
+    if (aRange.length != 0)
+        [aMenu setTitle: [[aMenu title] stringByReplacingRange:aRange with:appName]];
+
+    enumerator = [[aMenu itemArray] objectEnumerator];
+    while ((menuItem = [enumerator nextObject]))
+    {
+        aRange = [[menuItem title] rangeOfString:@"SDL App"];
+        if (aRange.length != 0)
+            [menuItem setTitle: [[menuItem title] stringByReplacingRange:aRange with:appName]];
+        if ([menuItem hasSubmenu])
+            [self fixMenu:[menuItem submenu] withAppName:appName];
+    }
+    [ aMenu sizeToFit ];
+}
+
+#else
+
+void setupAppleMenu(void)
+{
+    /* warning: this code is very odd */
+    NSAppleMenuController *appleMenuController;
+    NSMenu *appleMenu;
+    NSMenuItem *appleMenuItem;
+
+    appleMenuController = [[NSAppleMenuController alloc] init];
+    appleMenu = [[NSMenu alloc] initWithTitle:@""];
+    appleMenuItem = [[NSMenuItem alloc] initWithTitle:@"" action:nil keyEquivalent:@""];
+    
+    [appleMenuItem setSubmenu:appleMenu];
+
+    /* yes, we do need to add it and then remove it --
+       if you don't add it, it doesn't get displayed
+       if you don't remove it, you have an extra, titleless item in the menubar
+       when you remove it, it appears to stick around
+       very, very odd */
+    [[NSApp mainMenu] addItem:appleMenuItem];
+    [appleMenuController controlMenu:appleMenu];
+    [[NSApp mainMenu] removeItem:appleMenuItem];
+    [appleMenu release];
+    [appleMenuItem release];
+}
+
+/* Create a window menu */
+void setupWindowMenu(void)
+{
+    NSMenu		*windowMenu;
+    NSMenuItem	*windowMenuItem;
+    NSMenuItem	*menuItem;
+
+
+    windowMenu = [[NSMenu alloc] initWithTitle:@"Window"];
+    
+    /* "Minimize" item */
+    menuItem = [[NSMenuItem alloc] initWithTitle:@"Minimize" action:@selector(performMiniaturize:) keyEquivalent:@"m"];
+    [windowMenu addItem:menuItem];
+    [menuItem release];
+    
+    /* Put menu into the menubar */
+    windowMenuItem = [[NSMenuItem alloc] initWithTitle:@"Window" action:nil keyEquivalent:@""];
+    [windowMenuItem setSubmenu:windowMenu];
+    [[NSApp mainMenu] addItem:windowMenuItem];
+    
+    /* Tell the application object that this is now the window menu */
+    [NSApp setWindowsMenu:windowMenu];
+
+    /* Finally give up our references to the objects */
+    [windowMenu release];
+    [windowMenuItem release];
+}
+
+extern char **environ;
+
+/* Replacement for NSApplicationMain */
+void CustomApplicationMain (argc, argv)
+{
+    NSAutoreleasePool	*pool = [[NSAutoreleasePool alloc] init];
+    SDLMain				*sdlMain;
+
+    /* Ensure the application object is initialised */
+    [SDLApplication sharedApplication];
+    
+    /* Set up the menubar */
+    [NSApp setMainMenu:[[NSMenu alloc] init]];
+    setupAppleMenu();
+    setupWindowMenu();
+    
+    /* Create SDLMain and make it the app delegate */
+    sdlMain = [[SDLMain alloc] init];
+    [NSApp setDelegate:sdlMain];
+    
+    /* Start the main event loop */
+    [NSApp run];
+    
+    [sdlMain release];
+    [pool release];
+}
+
+#endif
+
+/* Called when the internal event loop has just started running */
+- (void) applicationDidFinishLaunching: (NSNotification *) note
+{
+    int status;
+
+    /* Set the working directory to the .app's parent directory */
+    [self setupWorkingDirectory:gFinderLaunch];
+
+#if SDL_USE_NIB_FILE
+    /* Set the main menu to contain the real app name instead of "SDL App" */
+    [self fixMenu:[NSApp mainMenu] withAppName:[[NSProcessInfo processInfo] processName]];
+#endif
+
+    /* Hand off to main application code */
+    status = SDL_main_env (gArgc, gArgv, environ);
+
+    /* We're done, thank you for playing */
+    exit(status);
+}
+@end
+
+
+@implementation NSString (ReplaceSubString)
+
+- (NSString *)stringByReplacingRange:(NSRange)aRange with:(NSString *)aString
+{
+    unsigned int bufferSize;
+    unsigned int selfLen = [self length];
+    unsigned int aStringLen = [aString length];
+    unichar *buffer;
+    NSRange localRange;
+    NSString *result;
+
+    bufferSize = selfLen + aStringLen - aRange.length;
+    buffer = NSAllocateMemoryPages(bufferSize*sizeof(unichar));
+    
+    /* Get first part into buffer */
+    localRange.location = 0;
+    localRange.length = aRange.location;
+    [self getCharacters:buffer range:localRange];
+    
+    /* Get middle part into buffer */
+    localRange.location = 0;
+    localRange.length = aStringLen;
+    [aString getCharacters:(buffer+aRange.location) range:localRange];
+     
+    /* Get last part into buffer */
+    localRange.location = aRange.location + aRange.length;
+    localRange.length = selfLen - localRange.location;
+    [self getCharacters:(buffer+aRange.location+aStringLen) range:localRange];
+    
+    /* Build output string */
+    result = [NSString stringWithCharacters:buffer length:bufferSize];
+    
+    NSDeallocateMemoryPages(buffer, bufferSize);
+    
+    return result;
+}
+
+@end
+
+
+
+#ifdef main
+#  undef main
+#endif
+
+
+/* Main entry point to executable - should *not* be SDL_main! */
+int main (int argc, char **argv)
+{
+
+    /* Copy the arguments into a global variable */
+    int i;
+    
+    /* This is passed if we are launched by double-clicking */
+    if ( argc >= 2 && strncmp (argv[1], "-psn", 4) == 0 ) {
+        gArgc = 1;
+	gFinderLaunch = YES;
+    } else {
+        gArgc = argc;
+	gFinderLaunch = NO;
+    }
+    gArgv = (char**) malloc (sizeof(*gArgv) * (gArgc+1));
+    assert (gArgv != NULL);
+    for (i = 0; i < gArgc; i++)
+        gArgv[i] = argv[i];
+    gArgv[i] = NULL;
+
+#if SDL_USE_NIB_FILE
+    [SDLApplication poseAsClass:[NSApplication class]];
+    NSApplicationMain (argc, argv);
+#else
+    CustomApplicationMain (argc, argv);
+#endif
+    return 0;
+}

src/conio/SDL_win32_main.c

+/*
+    SDL_main.c, placed in the public domain by Sam Lantinga  4/13/98
+
+    The WinMain function -- calls your program's main() function
+*/
+
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <stdlib.h>
+
+#include <windows.h>
+#include <malloc.h>			/* For _alloca() */
+
+#ifdef _WIN32_WCE
+# define DIR_SEPERATOR TEXT("\\")
+# undef _getcwd
+# define _getcwd(str,len)	wcscpy(str,TEXT(""))
+# define setbuf(f,b)
+# define setvbuf(w,x,y,z)
+# define fopen		_wfopen
+# define freopen	_wfreopen
+# define remove(x)	DeleteFile(x)
+# define strcat		wcscat
+#else
+# define DIR_SEPERATOR TEXT("/")
+# include <direct.h>
+#endif
+
+/* Include the SDL main definition header */
+#include "SDL.h"
+#include "SDL_main.h"
+extern C_LINKAGE int SDL_main_env(int argc, char *argv[], char **env);
+
+#ifdef main
+# ifndef _WIN32_WCE_EMULATION
+#  undef main
+# endif /* _WIN32_WCE_EMULATION */
+#endif /* main */
+
+#define NO_STDIO_REDIRECT
+
+/* The standard output files */
+#define STDOUT_FILE	TEXT("stdout.txt")
+#define STDERR_FILE	TEXT("stderr.txt")
+
+#ifndef NO_STDIO_REDIRECT
+# ifdef _WIN32_WCE
+  static wchar_t stdoutPath[MAX_PATH];
+  static wchar_t stderrPath[MAX_PATH];
+# else
+  static char stdoutPath[MAX_PATH];
+  static char stderrPath[MAX_PATH];
+# endif
+#endif
+
+/* Special Dynamic/Static hackery */
+#include "sdlfuncs.h"
+struct sdlfuncs sdl;
+
+#if defined(_WIN32_WCE) && _WIN32_WCE < 300
+/* seems to be undefined in Win CE although in online help */
+#define isspace(a) (((CHAR)a == ' ') || ((CHAR)a == '\t'))
+
+/* seems to be undefined in Win CE although in online help */
+char *strrchr(char *str, int c)
+{
+	char *p;
+
+	/* Skip to the end of the string */
+	p=str;
+	while (*p)
+		p++;
+
+	/* Look for the given character */
+	while ( (p >= str) && (*p != (CHAR)c) )
+		p--;
+
+	/* Return NULL if character not found */
+	if ( p < str ) {
+		p = NULL;
+	}
+	return p;
+}
+#endif /* _WIN32_WCE < 300 */
+
+/* Parse a command line buffer into arguments */
+static int ParseCommandLine(char *cmdline, char **argv)
+{
+	char *bufp;
+	int argc;
+
+	argc = 0;
+	for ( bufp = cmdline; *bufp; ) {
+		/* Skip leading whitespace */
+		while ( isspace(*bufp) ) {
+			++bufp;
+		}
+		/* Skip over argument */
+		if ( *bufp == '"' ) {
+			++bufp;
+			if ( *bufp ) {
+				if ( argv ) {
+					argv[argc] = bufp;
+				}
+				++argc;
+			}
+			/* Skip over word */
+			while ( *bufp && (*bufp != '"') ) {
+				++bufp;
+			}
+		} else {
+			if ( *bufp ) {
+				if ( argv ) {
+					argv[argc] = bufp;
+				}
+				++argc;
+			}
+			/* Skip over word */
+			while ( *bufp && ! isspace(*bufp) ) {
+				++bufp;
+			}
+		}
+		if ( *bufp ) {
+			if ( argv ) {
+				*bufp = '\0';
+			}
+			++bufp;
+		}
+	}
+	if ( argv ) {
+		argv[argc] = NULL;
+	}
+	return(argc);
+}
+
+/* Show an error message */
+static void ShowError(const char *title, const char *message)
+{
+/* If USE_MESSAGEBOX is defined, you need to link with user32.lib */
+#ifdef USE_MESSAGEBOX
+	MessageBox(NULL, message, title, MB_ICONEXCLAMATION|MB_OK);
+#else
+	fprintf(stderr, "%s: %s\n", title, message);
+#endif
+}
+
+/* Pop up an out of memory message, returns to Windows */
+static BOOL OutOfMemory(void)
+{
+	ShowError("Fatal Error", "Out of memory - aborting");
+	return FALSE;
+}
+
+/* Remove the output files if there was no output written */
+static void __cdecl cleanup_output(void)
+{
+#ifndef NO_STDIO_REDIRECT
+	FILE *file;
+	int empty;
+#endif
+
+	/* Flush the output in case anything is queued */
+	fclose(stdout);
+	fclose(stderr);
+
+#ifndef NO_STDIO_REDIRECT
+	/* See if the files have any output in them */
+	if ( stdoutPath[0] ) {
+		file = fopen(stdoutPath, TEXT("rb"));
+		if ( file ) {
+			empty = (fgetc(file) == EOF) ? 1 : 0;
+			fclose(file);
+			if ( empty ) {
+				remove(stdoutPath);
+			}
+		}
+	}
+	if ( stderrPath[0] ) {
+		file = fopen(stderrPath, TEXT("rb"));
+		if ( file ) {
+			empty = (fgetc(file) == EOF) ? 1 : 0;
+			fclose(file);
+			if ( empty ) {
+				remove(stderrPath);
+			}
+		}
+	}
+#endif
+}
+
+#if (defined(__BORLANDC__) || defined(_MSC_VER)) && !defined(_WIN32_WCE)
+/* The VC++ compiler needs main defined */
+#define console_main main
+#endif
+
+/* This is where execution begins [console apps] */
+int console_main(int argc, char *argv[], char **env)
+{
+	int n;
+	char *bufp, *appname;
+
+	/* Get the class name from argv[0] */
+	appname = argv[0];
+	if ( (bufp=strrchr(argv[0], '\\')) != NULL ) {
+		appname = bufp+1;
+	} else
+	if ( (bufp=strrchr(argv[0], '/')) != NULL ) {
+		appname = bufp+1;
+	}
+
+	if ( (bufp=strrchr(appname, '.')) == NULL )
+		n = strlen(appname);
+	else
+		n = (bufp-appname);
+
+	bufp = (char *)alloca(n+1);
+	if ( bufp == NULL ) {
+		return OutOfMemory();
+	}
+	strncpy(bufp, appname, n);
+	bufp[n] = '\0';
+	appname = bufp;
+
+	/* Load SDL dynamic link library */
+	if(!load_sdl_funcs(&sdl)) {
+		if ( sdl.Init(SDL_INIT_NOPARACHUTE) < 0 ) {
+			return(FALSE);
+		}
+		atexit(cleanup_output);
+
+#ifndef DISABLE_VIDEO
+		/* Sam:
+		   We still need to pass in the application handle so that
+		   DirectInput will initialize properly when SDL_RegisterApp()
+		   is called later in the video initialization.
+		 */
+		sdl.SetModuleHandle(GetModuleHandle(NULL));
+#endif /* !DISABLE_VIDEO */
+	}
+
+	/* Run the application main() code */
+	n=SDL_main_env(argc, argv, env);
+
+	/* Exit cleanly, calling atexit() functions */
+	exit(n);
+
+	/* Hush little compiler, don't you cry... */
+	return(n);
+}
+
+/* This is where execution begins [windowed apps] */
+#ifdef _WIN32_WCE
+int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrev, LPWSTR szCmdLine, int sw)
+#else
+int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrev, LPSTR szCmdLine, int sw)
+#endif
+{
+	HINSTANCE handle;
+	char **argv;
+	int argc;
+	char *cmdline;
+#ifdef _WIN32_WCE
+	wchar_t *bufp;
+	int nLen;
+#else
+	char *bufp;
+#endif
+#ifndef NO_STDIO_REDIRECT
+	FILE *newfp;
+#endif
+
+	/* Start up DDHELP.EXE before opening any files, so DDHELP doesn't
+	   keep them open.  This is a hack.. hopefully it will be fixed 
+	   someday.  DDHELP.EXE starts up the first time DDRAW.DLL is loaded.
+	 */
+	handle = LoadLibrary(TEXT("DDRAW.DLL"));
+	if ( handle != NULL ) {
+		FreeLibrary(handle);
+	}
+
+#ifndef NO_STDIO_REDIRECT
+	_getcwd( stdoutPath, sizeof( stdoutPath ) );
+	strcat( stdoutPath, DIR_SEPERATOR STDOUT_FILE );
+    
+	/* Redirect standard input and standard output */
+	newfp = freopen(stdoutPath, TEXT("w"), stdout);
+
+#ifndef _WIN32_WCE
+	if ( newfp == NULL ) {	/* This happens on NT */
+#if !defined(stdout)
+		stdout = fopen(stdoutPath, TEXT("w"));
+#else
+		newfp = fopen(stdoutPath, TEXT("w"));
+		if ( newfp ) {
+			*stdout = *newfp;
+		}
+#endif
+	}
+#endif /* _WIN32_WCE */
+
+	_getcwd( stderrPath, sizeof( stderrPath ) );
+	strcat( stderrPath, DIR_SEPERATOR STDERR_FILE );
+
+	newfp = freopen(stderrPath, TEXT("w"), stderr);
+#ifndef _WIN32_WCE
+	if ( newfp == NULL ) {	/* This happens on NT */
+#if !defined(stderr)
+		stderr = fopen(stderrPath, TEXT("w"));
+#else
+		newfp = fopen(stderrPath, TEXT("w"));
+		if ( newfp ) {
+			*stderr = *newfp;
+		}
+#endif
+	}
+#endif /* _WIN32_WCE */
+
+	setvbuf(stdout, NULL, _IOLBF, BUFSIZ);	/* Line buffered */
+	setbuf(stderr, NULL);			/* No buffering */
+#endif /* !NO_STDIO_REDIRECT */
+
+#ifdef _WIN32_WCE
+	nLen = wcslen(szCmdLine)+128+1;
+	bufp = (wchar_t *)alloca(nLen*2);
+	wcscpy (bufp, TEXT("\""));
+	GetModuleFileName(NULL, bufp+1, 128-3);
+	wcscpy (bufp+wcslen(bufp), TEXT("\" "));
+	wcsncpy(bufp+wcslen(bufp), szCmdLine,nLen-wcslen(bufp));
+	nLen = wcslen(bufp)+1;
+	cmdline = (char *)alloca(nLen);
+	if ( cmdline == NULL ) {
+		return OutOfMemory();
+	}
+	WideCharToMultiByte(CP_ACP, 0, bufp, -1, cmdline, nLen, NULL, NULL);
+#else
+	/* Grab the command line (use alloca() on Windows) */
+	bufp = GetCommandLine();
+	cmdline = (char *)alloca(strlen(bufp)+1);
+	if ( cmdline == NULL ) {
+		return OutOfMemory();
+	}
+	strcpy(cmdline, bufp);
+#endif
+
+	/* Parse it into argv and argc */
+	argc = ParseCommandLine(cmdline, NULL);
+	argv = (char **)alloca((argc+1)*(sizeof *argv));
+	if ( argv == NULL ) {
+		return OutOfMemory();
+	}
+	ParseCommandLine(cmdline, argv);
+
+	/* Run the main program (after a little SDL initialization) */
+	return(console_main(argc, argv, _environ));
+}

src/conio/sdlfuncs.c

+#include <stdlib.h>	/* getenv()/exit()/atexit() */
+#include <stdio.h>	/* NULL */
+#ifdef __unix__
+#include <dlfcn.h>
+#endif
+
+#include <SDL.h>
+#ifndef main
+ #define USE_REAL_MAIN
+#endif
+#include "gen_defs.h"
+#ifdef USE_REAL_MAIN
+ #undef main
+#endif
+#include "sdlfuncs.h"
+
+#ifndef _WIN32
+struct sdlfuncs sdl;
+#endif
+
+static int sdl_funcs_loaded=0;
+static int sdl_initialized=0;
+static int sdl_audio_initialized=0;
+static int sdl_video_initialized=0;
+static int (*sdl_drawing_thread)(void *data)=NULL;
+static void (*sdl_exit_drawing_thread)(void)=NULL;
+static int main_returned=0;
+static SDL_sem *sdl_main_sem;
+SDL_sem *sdl_exit_sem;
+
+int XPDEV_main(int argc, char **argv, char **enviro);
+
+#ifdef STATIC_SDL
+int load_sdl_funcs(struct sdlfuncs *sdlf)
+{
+	sdlf->gotfuncs=0;
+	sdlf->Init=SDL_Init;
+	sdlf->Quit=SDL_Quit;
+#ifdef _WIN32
+	sdlf->SetModuleHandle=SDL_SetModuleHandle;
+#endif
+	sdlf->mutexP=SDL_mutexP;
+	sdlf->mutexV=SDL_mutexV;
+	sdlf->PeepEvents=SDL_PeepEvents;
+	sdlf->VideoDriverName=SDL_VideoDriverName;
+	sdlf->SemWait=SDL_SemWait;
+	sdlf->SemPost=SDL_SemPost;
+	sdlf->EventState=SDL_EventState;
+	sdlf->CreateRGBSurface=SDL_CreateRGBSurface;
+	sdlf->CreateRGBSurfaceFrom=SDL_CreateRGBSurfaceFrom;
+	sdlf->FillRect=SDL_FillRect;
+	sdlf->SetColors=SDL_SetColors;
+	sdlf->BlitSurface=SDL_UpperBlit;
+	sdlf->UpdateRects=SDL_UpdateRects;
+	sdlf->SDL_CreateSemaphore=SDL_CreateSemaphore;
+	sdlf->SDL_DestroySemaphore=SDL_DestroySemaphore;
+	sdlf->SDL_CreateMutex=SDL_CreateMutex;
+	sdlf->CreateThread=SDL_CreateThread;
+	sdlf->KillThread=SDL_KillThread;
+	sdlf->WaitThread=SDL_WaitThread;
+	sdlf->WaitEvent=SDL_WaitEvent;
+	sdlf->SetVideoMode=SDL_SetVideoMode;
+	sdlf->FreeSurface=SDL_FreeSurface;
+	sdlf->WM_SetCaption=SDL_WM_SetCaption;
+	sdlf->WM_SetIcon=SDL_WM_SetIcon;
+	sdlf->ShowCursor=SDL_ShowCursor;
+	sdlf->WasInit=SDL_WasInit;
+	sdlf->EnableUNICODE=SDL_EnableUNICODE;
+	sdlf->EnableKeyRepeat=SDL_EnableKeyRepeat;
+	sdlf->GetWMInfo=SDL_GetWMInfo;
+	sdlf->GetError=SDL_GetError;
+	sdlf->InitSubSystem=SDL_InitSubSystem;
+	sdlf->QuitSubSystem=SDL_QuitSubSystem;
+	sdlf->OpenAudio=SDL_OpenAudio;
+	sdlf->CloseAudio=SDL_CloseAudio;
+	sdlf->PauseAudio=SDL_PauseAudio;
+	sdlf->LockAudio=SDL_LockAudio;
+	sdlf->UnlockAudio=SDL_UnlockAudio;
+	sdlf->GetAudioStatus=SDL_GetAudioStatus;
+	sdlf->gotfuncs=1;
+	sdl_funcs_loaded=1;
+	return(0);
+}
+#else
+
+#if defined(_WIN32)
+#include <Windows.h>
+
+int load_sdl_funcs(struct sdlfuncs *sdlf)
+{
+	HMODULE	sdl_dll;
+
+	sdlf->gotfuncs=0;
+	if((sdl_dll=LoadLibrary("SDL.dll"))==NULL)
+		if((sdl_dll=LoadLibrary("SDL-1.2.dll"))==NULL)
+			if((sdl_dll=LoadLibrary("SDL-1.1.dll"))==NULL)
+				return(-1);
+
+	if((sdlf->Init=GetProcAddress(sdl_dll, "SDL_Init"))==NULL) {
+		FreeLibrary(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->Quit=GetProcAddress(sdl_dll, "SDL_Quit"))==NULL) {
+		FreeLibrary(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->SetModuleHandle=GetProcAddress(sdl_dll, "SDL_SetModuleHandle"))==NULL) {
+		FreeLibrary(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->mutexP=GetProcAddress(sdl_dll, "SDL_mutexP"))==NULL) {
+		FreeLibrary(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->mutexV=GetProcAddress(sdl_dll, "SDL_mutexV"))==NULL) {
+		FreeLibrary(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->PeepEvents=GetProcAddress(sdl_dll, "SDL_PeepEvents"))==NULL) {
+		FreeLibrary(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->VideoDriverName=GetProcAddress(sdl_dll, "SDL_VideoDriverName"))==NULL) {
+		FreeLibrary(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->SemWait=GetProcAddress(sdl_dll, "SDL_SemWait"))==NULL) {
+		FreeLibrary(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->SemPost=GetProcAddress(sdl_dll, "SDL_SemPost"))==NULL) {
+		FreeLibrary(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->EventState=GetProcAddress(sdl_dll, "SDL_EventState"))==NULL) {
+		FreeLibrary(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->CreateRGBSurface=GetProcAddress(sdl_dll, "SDL_CreateRGBSurface"))==NULL) {
+		FreeLibrary(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->CreateRGBSurfaceFrom=GetProcAddress(sdl_dll, "SDL_CreateRGBSurfaceFrom"))==NULL) {
+		FreeLibrary(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->FillRect=GetProcAddress(sdl_dll, "SDL_FillRect"))==NULL) {
+		FreeLibrary(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->SetColors=GetProcAddress(sdl_dll, "SDL_SetColors"))==NULL) {
+		FreeLibrary(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->BlitSurface=GetProcAddress(sdl_dll, "SDL_UpperBlit"))==NULL) {
+		FreeLibrary(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->UpdateRects=GetProcAddress(sdl_dll, "SDL_UpdateRects"))==NULL) {
+		FreeLibrary(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->SDL_CreateSemaphore=GetProcAddress(sdl_dll, "SDL_CreateSemaphore"))==NULL) {
+		FreeLibrary(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->SDL_DestroySemaphore=GetProcAddress(sdl_dll, "SDL_DestroySemaphore"))==NULL) {
+		FreeLibrary(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->SDL_CreateMutex=GetProcAddress(sdl_dll, "SDL_CreateMutex"))==NULL) {
+		FreeLibrary(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->CreateThread=GetProcAddress(sdl_dll, "SDL_CreateThread"))==NULL) {
+		FreeLibrary(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->KillThread=GetProcAddress(sdl_dll, "SDL_KillThread"))==NULL) {
+		FreeLibrary(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->WaitThread=GetProcAddress(sdl_dll, "SDL_WaitThread"))==NULL) {
+		FreeLibrary(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->WaitEvent=GetProcAddress(sdl_dll, "SDL_WaitEvent"))==NULL) {
+		FreeLibrary(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->SetVideoMode=GetProcAddress(sdl_dll, "SDL_SetVideoMode"))==NULL) {
+		FreeLibrary(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->FreeSurface=GetProcAddress(sdl_dll, "SDL_FreeSurface"))==NULL) {
+		FreeLibrary(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->WM_SetCaption=GetProcAddress(sdl_dll, "SDL_WM_SetCaption"))==NULL) {
+		FreeLibrary(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->WM_SetIcon=GetProcAddress(sdl_dll, "SDL_WM_SetIcon"))==NULL) {
+		FreeLibrary(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->ShowCursor=GetProcAddress(sdl_dll, "SDL_ShowCursor"))==NULL) {
+		FreeLibrary(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->WasInit=GetProcAddress(sdl_dll, "SDL_WasInit"))==NULL) {
+		FreeLibrary(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->EnableUNICODE=GetProcAddress(sdl_dll, "SDL_EnableUNICODE"))==NULL) {
+		FreeLibrary(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->EnableKeyRepeat=GetProcAddress(sdl_dll, "SDL_EnableKeyRepeat"))==NULL) {
+		FreeLibrary(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->GetWMInfo=GetProcAddress(sdl_dll, "SDL_GetWMInfo"))==NULL) {
+		FreeLibrary(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->GetError=GetProcAddress(sdl_dll, "SDL_GetError"))==NULL) {
+		FreeLibrary(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->InitSubSystem=GetProcAddress(sdl_dll, "SDL_InitSubSystem"))==NULL) {
+		FreeLibrary(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->QuitSubSystem=GetProcAddress(sdl_dll, "SDL_QuitSubSystem"))==NULL) {
+		FreeLibrary(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->OpenAudio=GetProcAddress(sdl_dll, "SDL_OpenAudio"))==NULL) {
+		FreeLibrary(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->CloseAudio=GetProcAddress(sdl_dll, "SDL_CloseAudio"))==NULL) {
+		FreeLibrary(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->PauseAudio=GetProcAddress(sdl_dll, "SDL_PauseAudio"))==NULL) {
+		FreeLibrary(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->LockAudio=GetProcAddress(sdl_dll, "SDL_LockAudio"))==NULL) {
+		FreeLibrary(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->UnlockAudio=GetProcAddress(sdl_dll, "SDL_UnlockAudio"))==NULL) {
+		FreeLibrary(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->GetAudioStatus=GetProcAddress(sdl_dll, "SDL_GetAudioStatus"))==NULL) {
+		FreeLibrary(sdl_dll);
+		return(-1);
+	}
+	sdlf->gotfuncs=1;
+	sdl_funcs_loaded=1;
+	return(0);
+}
+#elif defined(__unix__)
+#include <dlfcn.h>
+
+int load_sdl_funcs(struct sdlfuncs *sdlf)
+{
+	void	*sdl_dll;
+
+	sdlf->gotfuncs=0;
+	if((sdl_dll=dlopen("libSDL.so",RTLD_LAZY|RTLD_GLOBAL))==NULL)
+		if((sdl_dll=dlopen("libSDL-1.2.so",RTLD_LAZY|RTLD_GLOBAL))==NULL)
+			if((sdl_dll=dlopen("libSDL-1.1.so",RTLD_LAZY|RTLD_GLOBAL))==NULL)
+				return(-1);
+
+	if((sdlf->Init=dlsym(sdl_dll, "SDL_Init"))==NULL) {
+		dlclose(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->Quit=dlsym(sdl_dll, "SDL_Quit"))==NULL) {
+		dlclose(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->mutexP=dlsym(sdl_dll, "SDL_mutexP"))==NULL) {
+		dlclose(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->mutexV=dlsym(sdl_dll, "SDL_mutexV"))==NULL) {
+		dlclose(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->PeepEvents=dlsym(sdl_dll, "SDL_PeepEvents"))==NULL) {
+		dlclose(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->VideoDriverName=dlsym(sdl_dll, "SDL_VideoDriverName"))==NULL) {
+		dlclose(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->SemWait=dlsym(sdl_dll, "SDL_SemWait"))==NULL) {
+		dlclose(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->SemPost=dlsym(sdl_dll, "SDL_SemPost"))==NULL) {
+		dlclose(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->EventState=dlsym(sdl_dll, "SDL_EventState"))==NULL) {
+		dlclose(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->CreateRGBSurface=dlsym(sdl_dll, "SDL_CreateRGBSurface"))==NULL) {
+		dlclose(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->CreateRGBSurfaceFrom=dlsym(sdl_dll, "SDL_CreateRGBSurfaceFrom"))==NULL) {
+		dlclose(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->FillRect=dlsym(sdl_dll, "SDL_FillRect"))==NULL) {
+		dlclose(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->SetColors=dlsym(sdl_dll, "SDL_SetColors"))==NULL) {
+		dlclose(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->BlitSurface=dlsym(sdl_dll, "SDL_UpperBlit"))==NULL) {
+		dlclose(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->UpdateRects=dlsym(sdl_dll, "SDL_UpdateRects"))==NULL) {
+		dlclose(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->SDL_CreateSemaphore=dlsym(sdl_dll, "SDL_CreateSemaphore"))==NULL) {
+		dlclose(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->SDL_DestroySemaphore=dlsym(sdl_dll, "SDL_DestroySemaphore"))==NULL) {
+		dlclose(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->SDL_CreateMutex=dlsym(sdl_dll, "SDL_CreateMutex"))==NULL) {
+		dlclose(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->CreateThread=dlsym(sdl_dll, "SDL_CreateThread"))==NULL) {
+		dlclose(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->KillThread=dlsym(sdl_dll, "SDL_KillThread"))==NULL) {
+		dlclose(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->WaitThread=dlsym(sdl_dll, "SDL_WaitThread"))==NULL) {
+		dlclose(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->WaitEvent=dlsym(sdl_dll, "SDL_WaitEvent"))==NULL) {
+		dlclose(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->SetVideoMode=dlsym(sdl_dll, "SDL_SetVideoMode"))==NULL) {
+		dlclose(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->FreeSurface=dlsym(sdl_dll, "SDL_FreeSurface"))==NULL) {
+		dlclose(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->WM_SetCaption=dlsym(sdl_dll, "SDL_WM_SetCaption"))==NULL) {
+		dlclose(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->WM_SetIcon=dlsym(sdl_dll, "SDL_WM_SetIcon"))==NULL) {
+		dlclose(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->ShowCursor=dlsym(sdl_dll, "SDL_ShowCursor"))==NULL) {
+		dlclose(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->WasInit=dlsym(sdl_dll, "SDL_WasInit"))==NULL) {
+		dlclose(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->EnableUNICODE=dlsym(sdl_dll, "SDL_EnableUNICODE"))==NULL) {
+		dlclose(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->EnableKeyRepeat=dlsym(sdl_dll, "SDL_EnableKeyRepeat"))==NULL) {
+		dlclose(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->GetWMInfo=dlsym(sdl_dll, "SDL_GetWMInfo"))==NULL) {
+		dlclose(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->GetError=dlsym(sdl_dll, "SDL_GetError"))==NULL) {
+		dlclose(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->InitSubSystem=dlsym(sdl_dll, "SDL_InitSubSystem"))==NULL) {
+		dlclose(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->QuitSubSystem=dlsym(sdl_dll, "SDL_QuitSubSystem"))==NULL) {
+		dlclose(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->OpenAudio=dlsym(sdl_dll, "SDL_OpenAudio"))==NULL) {
+		dlclose(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->CloseAudio=dlsym(sdl_dll, "SDL_CloseAudio"))==NULL) {
+		dlclose(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->PauseAudio=dlsym(sdl_dll, "SDL_PauseAudio"))==NULL) {
+		dlclose(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->LockAudio=dlsym(sdl_dll, "SDL_LockAudio"))==NULL) {
+		dlclose(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->UnlockAudio=dlsym(sdl_dll, "SDL_UnlockAudio"))==NULL) {
+		dlclose(sdl_dll);
+		return(-1);
+	}
+	if((sdlf->GetAudioStatus=dlsym(sdl_dll, "SDL_GetAudioStatus"))==NULL) {
+		dlclose(sdl_dll);
+		return(-1);
+	}
+	sdlf->gotfuncs=1;
+	sdl_funcs_loaded=1;
+	return(0);
+}
+#endif
+
+#endif
+
+int init_sdl_video(void)
+{
+	/* This is all handled in SDL_main_env() */
+	if(sdl_video_initialized)
+		return(0);
+	else
+		return(-1);
+}
+
+int init_sdl_audio(void)
+{
+	if(!sdl_initialized)
+		return(-1);
+	if(sdl_audio_initialized)
+		return(0);
+	if(sdl.InitSubSystem(SDL_INIT_AUDIO)==0) {
+		sdl_audio_initialized=TRUE;
+		return(0);
+	}
+	return(-1);
+}
+
+struct main_args {
+	int		argc;
+	char	**argv;
+	char	**enviro;
+};
+
+static int sdl_run_main(void *data)
+{
+	struct main_args	*args;
+	int	ret;
+
+	args=data;
+	ret=XPDEV_main(args->argc, args->argv, args->enviro);
+	main_returned=1;
+	sdl.SemPost(sdl_main_sem);
+	if(sdl_exit_drawing_thread!=NULL)
+		sdl_exit_drawing_thread();
+	sdl.SemPost(sdl_exit_sem);
+	return(ret);
+}
+
+void run_sdl_drawing_thread(int (*drawing_thread)(void *data), void (*exit_drawing_thread)(void))
+{
+	sdl_drawing_thread=drawing_thread;
+	sdl_exit_drawing_thread=exit_drawing_thread;
+	sdl.SemPost(sdl_main_sem);
+}
+
+#ifndef main
+int main(int argc, char **argv, char **env)
+#else
+int SDL_main_env(int argc, char **argv, char **env)
+#endif
+{
+	unsigned int i;
+	SDL_Event	ev;
+	char	drivername[64];
+	struct main_args ma;
+	SDL_Thread	*main_thread;
+	int		main_ret;
+	int		use_sdl_video=FALSE;
+
+	ma.argc=argc;
+	ma.argv=argv;
+	ma.enviro=env;
+#ifndef _WIN32
+	load_sdl_funcs(&sdl);
+#endif
+
+	if(sdl.gotfuncs) {
+		use_sdl_video=TRUE;
+
+#ifdef _WIN32
+		/* Fail to windib (ie: No mouse attached) */
+		if(sdl.Init(SDL_INIT_VIDEO)) {
+			if(getenv("SDL_VIDEODRIVER")==NULL) {
+				putenv("SDL_VIDEODRIVER=windib");
+				WinExec(GetCommandLine(), SW_SHOWDEFAULT);
+				return(0);
+			}
+			/* Sure ,we can't use video, but audio is still valid! */
+			if(sdl.Init(0)==0)
+				sdl_initialized=TRUE;
+		}
+		else {
+			sdl_video_initialized=TRUE;
+			sdl_initialized=TRUE;
+		}
+#else
+		/*
+		 * On Linux, SDL doesn't properly detect availability of the
+		 * framebuffer apparently.  This results in remote connections
+		 * displaying on the local framebuffer... a definate no-no.
+		 * This ugly hack attempts to prevent this... of course, remote X11
+		 * connections must still be allowed.
+		 */
+		if((!use_sdl_video) || getenv("REMOTEHOST")!=NULL && getenv("DISPLAY")==NULL) {
+			/* Sure ,we can't use video, but audio is still valid! */
+			if(sdl.Init(0)==0)
+				sdl_initialized=TRUE;
+		}
+		else {
+			if(sdl.Init(SDL_INIT_VIDEO)==0) {
+				sdl_initialized=TRUE;
+				sdl_video_initialized=TRUE;
+			}
+			else {
+				/* Sure ,we can't use video, but audio is still valid! */
+				if(sdl.Init(0)==0)
+					sdl_initialized=TRUE;
+			}
+		}
+#endif
+		if(sdl_video_initialized && sdl.VideoDriverName(drivername, sizeof(drivername))!=NULL) {
+			/* Unacceptable drivers */
+			if((!strcmp(drivername, "caca")) || (!strcmp(drivername,"aalib")) || (!strcmp(drivername,"dummy"))) {
+				sdl.QuitSubSystem(SDL_INIT_VIDEO);
+				sdl_video_initialized=FALSE;
+			}
+			else {
+				sdl_video_initialized=TRUE;
+			}
+		}
+	}
+	if(sdl_video_initialized) {
+		atexit(sdl.Quit);
+		sdl_main_sem=sdl.SDL_CreateSemaphore(0);
+		sdl_exit_sem=sdl.SDL_CreateSemaphore(0);
+		main_thread=sdl.CreateThread(sdl_run_main,&ma);
+		sdl.SemWait(sdl_main_sem);
+		if(sdl_drawing_thread!=NULL) {
+			sdl_drawing_thread(NULL);
+			sdl_exit_drawing_thread=NULL;
+			if(!main_returned) {
+				main_ret=0;
+			}
+		}
+		sdl.SemWait(sdl_exit_sem);
+		if(main_returned)
+			sdl.WaitThread(main_thread, &main_ret);
+	}
+	else
+		main_ret=XPDEV_main(argc, argv, env);
+	return(main_ret);
+}

src/conio/sdlfuncs.h

+#ifndef _SDLFUNCS_H_
+#define _SDLFUNCS_H_
+
+#include "SDL.h"
+#include "SDL_thread.h"
+#include "SDL_syswm.h"
+
+struct sdlfuncs {
+	int	(*Init)	(Uint32 flags);
+	void	(*Quit)	(void);
+	void	(*SetModuleHandle)	(void *hInst);
+	int	(*mutexP)	(SDL_mutex *mutex);
+	int	(*mutexV)	(SDL_mutex *mutex);
+	int	(*PeepEvents)	(SDL_Event *events, int numevents,
+					SDL_eventaction action, Uint32 mask);
+	char	*(*VideoDriverName)	(char *namebuf, int maxlen);
+	int	(*SemWait)	(SDL_sem *sem);
+	int	(*SemPost)	(SDL_sem *sem);
+	Uint8	(*EventState)	(Uint8 type, int state);
+	SDL_Surface	*(*CreateRGBSurface)	(Uint32 flags, int width, int height, int depth,
+							Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask);
+	SDL_Surface *(*CreateRGBSurfaceFrom)(void *pixels, int width, int height, int depth, int pitch,
+							Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask);
+	int	(*FillRect)	(SDL_Surface *dst, SDL_Rect *dstrect, Uint32 color);
+	int	(*SetColors)	(SDL_Surface *surface, SDL_Color *colors, int firstcolor, int ncolors);
+	int	(*BlitSurface)	(SDL_Surface *src, SDL_Rect *srcrect,
+								SDL_Surface *dst, SDL_Rect *dstrect);
+	void	(*UpdateRects)	(SDL_Surface *screen, int numrects, SDL_Rect *rects);
+	SDL_sem *(*SDL_CreateSemaphore)	(Uint32 initial_value);
+	void (*SDL_DestroySemaphore)	(SDL_sem *semaphore);
+	SDL_mutex	*(*SDL_CreateMutex)	(void);
+	struct SDL_Thread	*(*CreateThread)	(int (*fn)(void *), void *data);
+	void	(*KillThread)	(SDL_Thread *thread);
+	void	(*WaitThread)	(SDL_Thread *thread, int *status);
+	int	(*WaitEvent)	(SDL_Event *event);
+	SDL_Surface	*(*SetVideoMode)	(int width, int height, int bpp, Uint32 flags);
+	void	(*FreeSurface)	(SDL_Surface *surface);
+	void	(*WM_SetCaption)	(const char *title, const char *icon);
+	void	(*WM_SetIcon)	(SDL_Surface *icon, Uint8 *mask);
+	int	(*ShowCursor)	(int toggle);
+	Uint32	(*WasInit)	(Uint32 flags);
+	int	(*EnableUNICODE)	(int enable);
+	int	(*EnableKeyRepeat)	(int delay, int interval);
+	int	(*GetWMInfo)	(SDL_SysWMinfo *info);
+	char	*(*GetError)	(void);
+	int (*InitSubSystem)(Uint32 flags);
+	void (*QuitSubSystem)(Uint32 flags);
+	int (*OpenAudio)(SDL_AudioSpec *desired, SDL_AudioSpec *obtained);
+	void (*CloseAudio)(void);
+	void (*LockAudio)(void);
+	void (*UnlockAudio)(void);
+	void (*PauseAudio)(int pause_on);
+	SDL_audiostatus (*GetAudioStatus)(void);
+	int	gotfuncs;
+};
+
+/* Defined in SDL_win32_main.c for Win32 */
+extern struct sdlfuncs	sdl;
+extern SDL_sem *sdl_exit_sem;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+int load_sdl_funcs(struct sdlfuncs *sdlf);
+int init_sdl_audio(void);
+int init_sdl_video(void);
+int SDL_main_env(int argc, char *argv[], char **env);
+void run_sdl_drawing_thread(int (*drawing_thread)(void *data), void (*exit_drawing_thread)(void));
+#ifdef __cplusplus
+}
+#endif
+
+#endif