Wiimote and nJoy > Gamepad changes

1. Added LiveUpdates, while the configuration window is open nJoy and Wiimote will check for connected/disconnected pads
2. Removed the 'Nintendo RVL-CNT-01' device from the device list, and other SDL devices with no axes/buttons
3. Added SDL (from the current SVN) to get debugging information for SDL.dll
4. Added 'Upright Wiimote' option to emulated Wiimote options

git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4534 8ced0084-cf51-0410-be5f-012b33b47a6e

Externals/SDL/src/SDL.c

@@ -0,0 +1,360 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* Initialization code for SDL */
+
+#include "SDL.h"
+#include "SDL_fatal.h"
+#if !SDL_VIDEO_DISABLED
+#include "video/SDL_leaks.h"
+#endif
+
+#if SDL_THREAD_PTH
+#include <pth.h>
+#endif
+
+/* Initialization/Cleanup routines */
+#if !SDL_JOYSTICK_DISABLED
+extern int SDL_JoystickInit(void);
+extern void SDL_JoystickQuit(void);
+#endif
+#if !SDL_HAPTIC_DISABLED
+extern int SDL_HapticInit(void);
+extern int SDL_HapticQuit(void);
+#endif
+#if !SDL_TIMERS_DISABLED
+extern void SDL_StartTicks(void);
+extern int SDL_TimerInit(void);
+extern void SDL_TimerQuit(void);
+#endif
+#if defined(__WIN32__)
+extern int SDL_HelperWindowCreate(void);
+extern int SDL_HelperWindowDestroy(void);
+#endif
+
+/* The initialized subsystems */
+static Uint32 SDL_initialized = 0;
+static Uint32 ticks_started = 0;
+
+#ifdef CHECK_LEAKS
+int surfaces_allocated = 0;
+#endif
+
+int
+SDL_InitSubSystem(Uint32 flags)
+{
+#if !SDL_VIDEO_DISABLED
+    /* Initialize the video/event subsystem */
+    if ((flags & SDL_INIT_VIDEO) && !(SDL_initialized & SDL_INIT_VIDEO)) {
+        if (SDL_VideoInit(NULL, (flags & SDL_INIT_EVENTTHREAD)) < 0) {
+            return (-1);
+        }
+        SDL_initialized |= SDL_INIT_VIDEO;
+    }
+#else
+    if (flags & SDL_INIT_VIDEO) {
+        SDL_SetError("SDL not built with video support");
+        return (-1);
+    }
+#endif
+
+#if !SDL_AUDIO_DISABLED
+    /* Initialize the audio subsystem */
+    if ((flags & SDL_INIT_AUDIO) && !(SDL_initialized & SDL_INIT_AUDIO)) {
+        if (SDL_AudioInit(NULL) < 0) {
+            return (-1);
+        }
+        SDL_initialized |= SDL_INIT_AUDIO;
+    }
+#else
+    if (flags & SDL_INIT_AUDIO) {
+        SDL_SetError("SDL not built with audio support");
+        return (-1);
+    }
+#endif
+
+#if !SDL_TIMERS_DISABLED
+    /* Initialize the timer subsystem */
+    if (!ticks_started) {
+        SDL_StartTicks();
+        ticks_started = 1;
+    }
+    if ((flags & SDL_INIT_TIMER) && !(SDL_initialized & SDL_INIT_TIMER)) {
+        if (SDL_TimerInit() < 0) {
+            return (-1);
+        }
+        SDL_initialized |= SDL_INIT_TIMER;
+    }
+#else
+    if (flags & SDL_INIT_TIMER) {
+        SDL_SetError("SDL not built with timer support");
+        return (-1);
+    }
+#endif
+
+#if !SDL_JOYSTICK_DISABLED
+    /* Initialize the joystick subsystem */
+    if ((flags & SDL_INIT_JOYSTICK) && !(SDL_initialized & SDL_INIT_JOYSTICK)) {
+        if (SDL_JoystickInit() < 0) {
+            return (-1);
+        }
+        SDL_initialized |= SDL_INIT_JOYSTICK;
+    }
+#else
+    if (flags & SDL_INIT_JOYSTICK) {
+        SDL_SetError("SDL not built with joystick support");
+        return (-1);
+    }
+#endif
+
+#if !SDL_HAPTIC_DISABLED
+    /* Initialize the haptic subsystem */
+    if ((flags & SDL_INIT_HAPTIC) && !(SDL_initialized & SDL_INIT_HAPTIC)) {
+        if (SDL_HapticInit() < 0) {
+            return (-1);
+        }
+        SDL_initialized |= SDL_INIT_HAPTIC;
+    }
+#else
+    if (flags & SDL_INIT_HAPTIC) {
+        SDL_SetError("SDL not built with haptic (force feedback) support");
+        return (-1);
+    }
+#endif
+    return (0);
+}
+
+int
+SDL_Init(Uint32 flags)
+{
+#if !SDL_THREADS_DISABLED && SDL_THREAD_PTH
+    if (!pth_init()) {
+        return -1;
+    }
+#endif
+
+    /* Clear the error message */
+    SDL_ClearError();
+
+#if defined(__WIN32__)
+    if (SDL_HelperWindowCreate() < 0) {
+        return -1;
+    }
+#endif
+
+    /* Initialize the desired subsystems */
+    if (SDL_InitSubSystem(flags) < 0) {
+        return (-1);
+    }
+
+    /* Everything is initialized */
+    if (!(flags & SDL_INIT_NOPARACHUTE)) {
+        SDL_InstallParachute();
+    }
+    return (0);
+}
+
+void
+SDL_QuitSubSystem(Uint32 flags)
+{
+    /* Shut down requested initialized subsystems */
+#if !SDL_JOYSTICK_DISABLED
+    if ((flags & SDL_initialized & SDL_INIT_JOYSTICK)) {
+        SDL_JoystickQuit();
+        SDL_initialized &= ~SDL_INIT_JOYSTICK;
+    }
+#endif
+#if !SDL_HAPTIC_DISABLED
+    if ((flags & SDL_initialized & SDL_INIT_HAPTIC)) {
+        SDL_HapticQuit();
+        SDL_initialized &= ~SDL_INIT_HAPTIC;
+    }
+#endif
+#if !SDL_TIMERS_DISABLED
+    if ((flags & SDL_initialized & SDL_INIT_TIMER)) {
+        SDL_TimerQuit();
+        SDL_initialized &= ~SDL_INIT_TIMER;
+    }
+#endif
+#if !SDL_AUDIO_DISABLED
+    if ((flags & SDL_initialized & SDL_INIT_AUDIO)) {
+        SDL_AudioQuit();
+        SDL_initialized &= ~SDL_INIT_AUDIO;
+    }
+#endif
+#if !SDL_VIDEO_DISABLED
+    if ((flags & SDL_initialized & SDL_INIT_VIDEO)) {
+        SDL_VideoQuit();
+        SDL_initialized &= ~SDL_INIT_VIDEO;
+    }
+#endif
+}
+
+Uint32
+SDL_WasInit(Uint32 flags)
+{
+    if (!flags) {
+        flags = SDL_INIT_EVERYTHING;
+    }
+    return (SDL_initialized & flags);
+}
+
+void
+SDL_Quit(void)
+{
+    /* Quit all subsystems */
+#ifdef DEBUG_BUILD
+    printf("[SDL_Quit] : Enter! Calling QuitSubSystem()\n");
+    fflush(stdout);
+#endif
+
+#if defined(__WIN32__)
+    SDL_HelperWindowDestroy();
+#endif
+    SDL_QuitSubSystem(SDL_INIT_EVERYTHING);
+
+#ifdef CHECK_LEAKS
+#ifdef DEBUG_BUILD
+    printf("[SDL_Quit] : CHECK_LEAKS\n");
+    fflush(stdout);
+#endif
+
+    /* Print the number of surfaces not freed */
+    if (surfaces_allocated != 0) {
+        fprintf(stderr, "SDL Warning: %d SDL surfaces extant\n",
+                surfaces_allocated);
+    }
+#endif
+#ifdef DEBUG_BUILD
+    printf("[SDL_Quit] : SDL_UninstallParachute()\n");
+    fflush(stdout);
+#endif
+
+    /* Uninstall any parachute signal handlers */
+    SDL_UninstallParachute();
+
+#if !SDL_THREADS_DISABLED && SDL_THREAD_PTH
+    pth_kill();
+#endif
+#ifdef DEBUG_BUILD
+    printf("[SDL_Quit] : Returning!\n");
+    fflush(stdout);
+#endif
+
+}
+
+/* Get the library version number */
+void
+SDL_GetVersion(SDL_version * ver)
+{
+    SDL_VERSION(ver);
+}
+
+/* Get the library source revision */
+int
+SDL_GetRevision(void)
+{
+    return SDL_REVISION;
+}
+
+/* Get the name of the platform */
+const char *
+SDL_GetPlatform()
+{
+#if __AIX__
+    return "AIX";
+#elif __HAIKU__
+/* Haiku must appear here before BeOS, since it also defines __BEOS__ */
+    return "Haiku";
+#elif __BEOS__
+    return "BeOS";
+#elif __BSDI__
+    return "BSDI";
+#elif __DREAMCAST__
+    return "Dreamcast";
+#elif __FREEBSD__
+    return "FreeBSD";
+#elif __HPUX__
+    return "HP-UX";
+#elif __IRIX__
+    return "Irix";
+#elif __LINUX__
+    return "Linux";
+#elif __MINT__
+    return "Atari MiNT";
+#elif __MACOS__
+    return "MacOS Classic";
+#elif __MACOSX__
+    return "Mac OS X";
+#elif __NETBSD__
+    return "NetBSD";
+#elif __OPENBSD__
+    return "OpenBSD";
+#elif __OS2__
+    return "OS/2";
+#elif __OSF__
+    return "OSF/1";
+#elif __QNXNTO__
+    return "QNX Neutrino";
+#elif __RISCOS__
+    return "RISC OS";
+#elif __SOLARIS__
+    return "Solaris";
+#elif __WIN32__
+#ifdef _WIN32_WCE
+    return "Windows CE";
+#else
+    return "Windows";
+#endif
+#elif __IPHONEOS__
+    return "iPhone OS";
+#else
+    return "Unknown (see SDL_platform.h)";
+#endif
+}
+
+#if defined(__WIN32__)
+
+#if !defined(HAVE_LIBC) || (defined(__WATCOMC__) && defined(BUILD_DLL))
+/* Need to include DllMain() on Watcom C for some reason.. */
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+
+BOOL APIENTRY
+_DllMainCRTStartup(HANDLE hModule,
+                   DWORD ul_reason_for_call, LPVOID lpReserved)
+{
+    switch (ul_reason_for_call) {
+    case DLL_PROCESS_ATTACH:
+    case DLL_THREAD_ATTACH:
+    case DLL_THREAD_DETACH:
+    case DLL_PROCESS_DETACH:
+        break;
+    }
+    return TRUE;
+}
+#endif /* building DLL with Watcom C */
+
+#endif /* __WIN32__ */
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/SDL_error.c

@@ -0,0 +1,259 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* Simple error handling in SDL */
+
+#include "SDL_error.h"
+#include "SDL_error_c.h"
+
+/* Routine to get the thread-specific error variable */
+#if SDL_THREADS_DISABLED
+/* !!! FIXME: what does this comment mean? Victim of Search and Replace? */
+/* The  SDL_arraysize(The ),default (non-thread-safe) global error variable */
+static SDL_error SDL_global_error;
+#define SDL_GetErrBuf()	(&SDL_global_error)
+#else
+extern SDL_error *SDL_GetErrBuf(void);
+#endif /* SDL_THREADS_DISABLED */
+
+#define SDL_ERRBUFIZE	1024
+
+/* Private functions */
+
+static const char *
+SDL_LookupString(const char *key)
+{
+    /* FIXME: Add code to lookup key in language string hash-table */
+    return key;
+}
+
+/* Public functions */
+
+void
+SDL_SetError(const char *fmt, ...)
+{
+    va_list ap;
+    SDL_error *error;
+
+    /* Copy in the key, mark error as valid */
+    error = SDL_GetErrBuf();
+    error->error = 1;
+    SDL_strlcpy((char *) error->key, fmt, sizeof(error->key));
+
+    va_start(ap, fmt);
+    error->argc = 0;
+    while (*fmt) {
+        if (*fmt++ == '%') {
+            while (*fmt == '.' || (*fmt >= '0' && *fmt <= '9')) {
+                ++fmt;
+            }
+            switch (*fmt++) {
+            case 0:            /* Malformed format string.. */
+                --fmt;
+                break;
+            case 'c':
+            case 'i':
+            case 'd':
+            case 'u':
+            case 'o':
+            case 'x':
+            case 'X':
+                error->args[error->argc++].value_i = va_arg(ap, int);
+                break;
+            case 'f':
+                error->args[error->argc++].value_f = va_arg(ap, double);
+                break;
+            case 'p':
+                error->args[error->argc++].value_ptr = va_arg(ap, void *);
+                break;
+            case 's':
+                {
+                    int i = error->argc;
+                    const char *str = va_arg(ap, const char *);
+                    if (str == NULL)
+                        str = "(null)";
+                    SDL_strlcpy((char *) error->args[i].buf, str,
+                                ERR_MAX_STRLEN);
+                    error->argc++;
+                }
+                break;
+            default:
+                break;
+            }
+            if (error->argc >= ERR_MAX_ARGS) {
+                break;
+            }
+        }
+    }
+    va_end(ap);
+
+    /* If we are in debug mode, print out an error message */
+#ifdef DEBUG_ERROR
+    fprintf(stderr, "SDL_SetError: %s\n", SDL_GetError());
+#endif
+}
+
+/* This function has a bit more overhead than most error functions
+   so that it supports internationalization and thread-safe errors.
+*/
+char *
+SDL_GetErrorMsg(char *errstr, unsigned int maxlen)
+{
+    SDL_error *error;
+
+    /* Clear the error string */
+    *errstr = '\0';
+    --maxlen;
+
+    /* Get the thread-safe error, and print it out */
+    error = SDL_GetErrBuf();
+    if (error->error) {
+        const char *fmt;
+        char *msg = errstr;
+        int len;
+        int argi;
+
+        fmt = SDL_LookupString(error->key);
+        argi = 0;
+        while (*fmt && (maxlen > 0)) {
+            if (*fmt == '%') {
+                char tmp[32], *spot = tmp;
+                *spot++ = *fmt++;
+                while ((*fmt == '.' || (*fmt >= '0' && *fmt <= '9'))
+                       && spot < (tmp + SDL_arraysize(tmp) - 2)) {
+                    *spot++ = *fmt++;
+                }
+                *spot++ = *fmt++;
+                *spot++ = '\0';
+                switch (spot[-2]) {
+                case '%':
+                    *msg++ = '%';
+                    maxlen -= 1;
+                    break;
+                case 'c':
+                case 'i':
+                case 'd':
+                case 'u':
+                case 'o':
+                case 'x':
+                case 'X':
+                    len =
+                        SDL_snprintf(msg, maxlen, tmp,
+                                     error->args[argi++].value_i);
+                    msg += len;
+                    maxlen -= len;
+                    break;
+                case 'f':
+                    len =
+                        SDL_snprintf(msg, maxlen, tmp,
+                                     error->args[argi++].value_f);
+                    msg += len;
+                    maxlen -= len;
+                    break;
+                case 'p':
+                    len =
+                        SDL_snprintf(msg, maxlen, tmp,
+                                     error->args[argi++].value_ptr);
+                    msg += len;
+                    maxlen -= len;
+                    break;
+                case 's':
+                    len =
+                        SDL_snprintf(msg, maxlen, tmp,
+                                     SDL_LookupString(error->args[argi++].
+                                                      buf));
+                    msg += len;
+                    maxlen -= len;
+                    break;
+                }
+            } else {
+                *msg++ = *fmt++;
+                maxlen -= 1;
+            }
+        }
+        *msg = 0;               /* NULL terminate the string */
+    }
+    return (errstr);
+}
+
+/* Available for backwards compatibility */
+char *
+SDL_GetError(void)
+{
+    static char errmsg[SDL_ERRBUFIZE];
+
+    return ((char *) SDL_GetErrorMsg(errmsg, SDL_ERRBUFIZE));
+}
+
+void
+SDL_ClearError(void)
+{
+    SDL_error *error;
+
+    error = SDL_GetErrBuf();
+    error->error = 0;
+}
+
+/* Very common errors go here */
+void
+SDL_Error(SDL_errorcode code)
+{
+    switch (code) {
+    case SDL_ENOMEM:
+        SDL_SetError("Out of memory");
+        break;
+    case SDL_EFREAD:
+        SDL_SetError("Error reading from datastream");
+        break;
+    case SDL_EFWRITE:
+        SDL_SetError("Error writing to datastream");
+        break;
+    case SDL_EFSEEK:
+        SDL_SetError("Error seeking in datastream");
+        break;
+    case SDL_UNSUPPORTED:
+        SDL_SetError("That operation is not supported");
+        break;
+    default:
+        SDL_SetError("Unknown SDL error");
+        break;
+    }
+}
+
+#ifdef TEST_ERROR
+int
+main(int argc, char *argv[])
+{
+    char buffer[BUFSIZ + 1];
+
+    SDL_SetError("Hi there!");
+    printf("Error 1: %s\n", SDL_GetError());
+    SDL_ClearError();
+    SDL_memset(buffer, '1', BUFSIZ);
+    buffer[BUFSIZ] = 0;
+    SDL_SetError("This is the error: %s (%f)", buffer, 1.0);
+    printf("Error 2: %s\n", SDL_GetError());
+    exit(0);
+}
+#endif
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/SDL_error_c.h

@@ -0,0 +1,61 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* This file defines a structure that carries language-independent
+   error messages
+*/
+
+#ifndef _SDL_error_c_h
+#define _SDL_error_c_h
+
+#define ERR_MAX_STRLEN	128
+#define ERR_MAX_ARGS	5
+
+typedef struct SDL_error
+{
+    /* This is a numeric value corresponding to the current error */
+    int error;
+
+    /* This is a key used to index into a language hashtable containing
+       internationalized versions of the SDL error messages.  If the key
+       is not in the hashtable, or no hashtable is available, the key is
+       used directly as an error message format string.
+     */
+    char key[ERR_MAX_STRLEN];
+
+    /* These are the arguments for the error functions */
+    int argc;
+    union
+    {
+        void *value_ptr;
+#if 0                           /* What is a character anyway?  (UNICODE issues) */
+        unsigned char value_c;
+#endif
+        int value_i;
+        double value_f;
+        char buf[ERR_MAX_STRLEN];
+    } args[ERR_MAX_ARGS];
+} SDL_error;
+
+#endif /* _SDL_error_c_h */
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/SDL_fatal.c

@@ -0,0 +1,140 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* General fatal signal handling code for SDL */
+
+#ifdef HAVE_SIGNAL_H
+
+#include <signal.h>
+
+#include "SDL_stdinc.h"
+#include "SDL_fatal.h"
+
+/* This installs some signal handlers for the more common fatal signals,
+   so that if the programmer is lazy, the app doesn't die so horribly if
+   the program crashes.
+*/
+
+static void
+SDL_Parachute(int sig)
+{
+    signal(sig, SIG_DFL);
+    SDL_Quit();
+    raise(sig);
+}
+
+static const int SDL_fatal_signals[] = {
+    SIGSEGV,
+#ifdef SIGBUS
+    SIGBUS,
+#endif
+#ifdef SIGFPE
+    SIGFPE,
+#endif
+#ifdef SIGQUIT
+    SIGQUIT,
+#endif
+    0
+};
+
+void
+SDL_InstallParachute(void)
+{
+    /* Set a handler for any fatal signal not already handled */
+    int i;
+#ifdef HAVE_SIGACTION
+    struct sigaction action;
+
+    for (i = 0; SDL_fatal_signals[i]; ++i) {
+        sigaction(SDL_fatal_signals[i], NULL, &action);
+        if (action.sa_handler == SIG_DFL) {
+            action.sa_handler = SDL_Parachute;
+            sigaction(SDL_fatal_signals[i], &action, NULL);
+        }
+    }
+#ifdef SIGALRM
+    /* Set SIGALRM to be ignored -- necessary on Solaris */
+    sigaction(SIGALRM, NULL, &action);
+    if (action.sa_handler == SIG_DFL) {
+        action.sa_handler = SIG_IGN;
+        sigaction(SIGALRM, &action, NULL);
+    }
+#endif
+#else
+    void (*ohandler) (int);
+
+    for (i = 0; SDL_fatal_signals[i]; ++i) {
+        ohandler = signal(SDL_fatal_signals[i], SDL_Parachute);
+        if (ohandler != SIG_DFL) {
+            signal(SDL_fatal_signals[i], ohandler);
+        }
+    }
+#endif /* HAVE_SIGACTION */
+    return;
+}
+
+void
+SDL_UninstallParachute(void)
+{
+    /* Remove a handler for any fatal signal handled */
+    int i;
+#ifdef HAVE_SIGACTION
+    struct sigaction action;
+
+    for (i = 0; SDL_fatal_signals[i]; ++i) {
+        sigaction(SDL_fatal_signals[i], NULL, &action);
+        if (action.sa_handler == SDL_Parachute) {
+            action.sa_handler = SIG_DFL;
+            sigaction(SDL_fatal_signals[i], &action, NULL);
+        }
+    }
+#else
+    void (*ohandler) (int);
+
+    for (i = 0; SDL_fatal_signals[i]; ++i) {
+        ohandler = signal(SDL_fatal_signals[i], SIG_DFL);
+        if (ohandler != SDL_Parachute) {
+            signal(SDL_fatal_signals[i], ohandler);
+        }
+    }
+#endif /* HAVE_SIGACTION */
+}
+
+#else
+
+/* No signals on this platform, nothing to do.. */
+
+void
+SDL_InstallParachute(void)
+{
+    return;
+}
+
+void
+SDL_UninstallParachute(void)
+{
+    return;
+}
+
+#endif /* HAVE_SIGNAL_H */
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/SDL_fatal.h

@@ -0,0 +1,28 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* General fatal signal handling code for SDL */
+
+extern void SDL_InstallParachute(void);
+extern void SDL_UninstallParachute(void);
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/atomic/dummy/SDL_atomic.c

@@ -0,0 +1,469 @@
+/*
+  SDL - Simple DirectMedia Layer
+  Copyright (C) 1997-2009 Sam Lantinga
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+  Sam Lantinga
+  slouken@libsdl.org
+
+  Contributed by Bob Pendleton, bob@pendleton.com
+*/
+
+#include "SDL_stdinc.h"
+#include "SDL_atomic.h"
+
+#include "SDL_error.h"
+
+/*
+  This file provides 32, and 64 bit atomic operations. If the
+  operations are provided by the native hardware and operating system
+  they are used. If they are not then the operations are emulated
+  using the SDL spin lock operations. If spin lock can not be
+  implemented then these functions must fail.
+*/
+
+/* 
+  DUMMY VERSION.
+
+  This version of the code assumes there is no support for atomic
+  operations. Therefore, every function sets the SDL error
+  message. Oddly enough, if you only have one thread then this
+  version actuallys works.
+*/
+
+/*
+  Native spinlock routines. Because this is the dummy implementation
+  these will always call SDL_SetError() and do nothing.
+*/
+
+void 
+SDL_AtomicLock(SDL_SpinLock *lock)
+{
+   SDL_SetError("SDL_atomic.c: is not implemented on this platform");
+}
+
+void 
+SDL_AtomicUnlock(SDL_SpinLock *lock)
+{
+   SDL_SetError("SDL_atomic.c: is not implemented on this platform");
+}
+
+/*
+  Note that platform specific versions can be built from this version
+  by changing the #undefs to #defines and adding platform specific
+  code.
+*/
+
+#undef  nativeTestThenSet32
+#undef  nativeClear32
+#undef  nativeFetchThenIncrement32
+#undef  nativeFetchThenDecrement32
+#undef  nativeFetchThenAdd32
+#undef  nativeFetchThenSubtract32
+#undef  nativeIncrementThenFetch32
+#undef  nativeDecrementThenFetch32
+#undef  nativeAddThenFetch32
+#undef  nativeSubtractThenFetch32
+
+#undef  nativeTestThenSet64
+#undef  nativeClear64
+#undef  nativeFetchThenIncrement64
+#undef  nativeFetchThenDecrement64
+#undef  nativeFetchThenAdd64
+#undef  nativeFetchThenSubtract64
+#undef  nativeIncrementThenFetch64
+#undef  nativeDecrementThenFetch64
+#undef  nativeAddThenFetch64
+#undef  nativeSubtractThenFetch64
+
+/* 
+  If any of the operations are not provided then we must emulate some
+  of them. That means we need a nice implementation of spin locks
+  that avoids the "one big lock" problem. We use a vector of spin
+  locks and pick which one to use based on the address of the operand
+  of the function.
+
+  To generate the index of the lock we first shift by 3 bits to get
+  rid on the zero bits that result from 32 and 64 bit allignment of
+  data. We then mask off all but 5 bits and use those 5 bits as an
+  index into the table. 
+
+  Picking the lock this way insures that accesses to the same data at
+  the same time will go to the same lock. OTOH, accesses to different
+  data have only a 1/32 chance of hitting the same lock. That should
+  pretty much eliminate the chances of several atomic operations on
+  different data from waiting on the same "big lock". If it isn't
+  then the table of locks can be expanded to a new size so long as
+  the new size is a power of two.
+*/
+
+static SDL_SpinLock locks[32] = {
+   0, 0, 0, 0, 0, 0, 0, 0,
+   0, 0, 0, 0, 0, 0, 0, 0,
+   0, 0, 0, 0, 0, 0, 0, 0,
+   0, 0, 0, 0, 0, 0, 0, 0,
+};
+
+static __inline__ void
+privateWaitLock(volatile void *ptr)
+{
+#if SIZEOF_VOIDP == 4
+   Uint32 index = ((((Uint32)ptr) >> 3) & 0x1f);
+#elif SIZEOF_VOIDP == 8
+   Uint64 index = ((((Uint64)ptr) >> 3) & 0x1f);
+#endif
+
+   SDL_AtomicLock(&locks[index]);
+}
+
+static __inline__ void
+privateUnlock(volatile void *ptr)
+{
+#if SIZEOF_VOIDP == 4
+   Uint32 index = ((((Uint32)ptr) >> 3) & 0x1f);
+#elif SIZEOF_VOIDP == 8
+   Uint64 index = ((((Uint64)ptr) >> 3) & 0x1f);
+#endif
+
+   SDL_AtomicUnlock(&locks[index]);
+}
+
+/* 32 bit atomic operations */
+
+SDL_bool
+SDL_AtomicTestThenSet32(volatile Uint32 * ptr)
+{
+#ifdef nativeTestThenSet32
+#else
+   SDL_bool result = SDL_FALSE;
+
+   privateWaitLock(ptr);
+   result = (*ptr == 0);
+   if (result)
+   {
+      *ptr = 1;
+   }
+   privateUnlock(ptr);
+
+   return result;
+#endif
+}
+
+void
+SDL_AtomicClear32(volatile Uint32 * ptr)
+{
+#ifdef nativeClear32
+#else
+   privateWaitLock(ptr);
+   *ptr = 0;
+   privateUnlock(ptr);
+
+   return;
+#endif
+}
+
+Uint32
+SDL_AtomicFetchThenIncrement32(volatile Uint32 * ptr)
+{
+#ifdef nativeFetchThenIncrement32
+#else
+   Uint32 tmp = 0;
+
+   privateWaitLock(ptr);
+   tmp = *ptr;
+   (*ptr)+= 1;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint32
+SDL_AtomicFetchThenDecrement32(volatile Uint32 * ptr)
+{
+#ifdef nativeFetchThenDecrement32
+#else
+   Uint32 tmp = 0;
+
+   privateWaitLock(ptr);
+   tmp = *ptr;
+   (*ptr) -= 1;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint32
+SDL_AtomicFetchThenAdd32(volatile Uint32 * ptr, Uint32 value)
+{
+#ifdef nativeFetchThenAdd32
+#else
+   Uint32 tmp = 0;
+
+   privateWaitLock(ptr);
+   tmp = *ptr;
+   (*ptr)+= value;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint32
+SDL_AtomicFetchThenSubtract32(volatile Uint32 * ptr, Uint32 value)
+{
+#ifdef nativeFetchThenSubtract32
+#else
+   Uint32 tmp = 0;
+
+   privateWaitLock(ptr);
+   tmp = *ptr;
+   (*ptr)-= value;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint32
+SDL_AtomicIncrementThenFetch32(volatile Uint32 * ptr)
+{
+#ifdef nativeIncrementThenFetch32
+#else
+   Uint32 tmp = 0;
+
+   privateWaitLock(ptr);
+   (*ptr)+= 1;
+   tmp = *ptr;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint32
+SDL_AtomicDecrementThenFetch32(volatile Uint32 * ptr)
+{
+#ifdef nativeDecrementThenFetch32
+#else
+   Uint32 tmp = 0;
+
+   privateWaitLock(ptr);
+   (*ptr)-= 1;
+   tmp = *ptr;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint32
+SDL_AtomicAddThenFetch32(volatile Uint32 * ptr, Uint32 value)
+{
+#ifdef nativeAddThenFetch32
+#else
+   Uint32 tmp = 0;
+
+   privateWaitLock(ptr);
+   (*ptr)+= value;
+   tmp = *ptr;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint32
+SDL_AtomicSubtractThenFetch32(volatile Uint32 * ptr, Uint32 value)
+{
+#ifdef nativeSubtractThenFetch32
+#else
+   Uint32 tmp = 0;
+
+   privateWaitLock(ptr);
+   (*ptr)-= value;
+   tmp = *ptr;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+/* 64 bit atomic operations */
+#ifdef SDL_HAS_64BIT_TYPE
+
+SDL_bool
+SDL_AtomicTestThenSet64(volatile Uint64 * ptr)
+{
+#ifdef nativeTestThenSet64
+#else
+   SDL_bool result = SDL_FALSE;
+
+   privateWaitLock(ptr);
+   result = (*ptr == 0);
+   if (result)
+   {
+      *ptr = 1;
+   }
+   privateUnlock(ptr);
+
+   return result;
+#endif
+}
+
+void
+SDL_AtomicClear64(volatile Uint64 * ptr)
+{
+#ifdef nativeClear64
+#else
+   privateWaitLock(ptr);
+   *ptr = 0;
+   privateUnlock(ptr);
+
+   return;
+#endif
+}
+
+Uint64
+SDL_AtomicFetchThenIncrement64(volatile Uint64 * ptr)
+{
+#ifdef nativeFetchThenIncrement64
+#else
+   Uint64 tmp = 0;
+
+   privateWaitLock(ptr);
+   tmp = *ptr;
+   (*ptr)+= 1;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint64
+SDL_AtomicFetchThenDecrement64(volatile Uint64 * ptr)
+{
+#ifdef nativeFetchThenDecrement64
+#else
+   Uint64 tmp = 0;
+
+   privateWaitLock(ptr);
+   tmp = *ptr;
+   (*ptr) -= 1;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint64
+SDL_AtomicFetchThenAdd64(volatile Uint64 * ptr, Uint64 value)
+{
+#ifdef nativeFetchThenAdd64
+#else
+   Uint64 tmp = 0;
+
+   privateWaitLock(ptr);
+   tmp = *ptr;
+   (*ptr)+= value;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint64
+SDL_AtomicFetchThenSubtract64(volatile Uint64 * ptr, Uint64 value)
+{
+#ifdef nativeFetchThenSubtract64
+#else
+   Uint64 tmp = 0;
+
+   privateWaitLock(ptr);
+   tmp = *ptr;
+   (*ptr)-= value;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint64
+SDL_AtomicIncrementThenFetch64(volatile Uint64 * ptr)
+{
+#ifdef nativeIncrementThenFetch64
+#else
+   Uint64 tmp = 0;
+
+   privateWaitLock(ptr);
+   (*ptr)+= 1;
+   tmp = *ptr;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint64
+SDL_AtomicDecrementThenFetch64(volatile Uint64 * ptr)
+{
+#ifdef nativeDecrementThenFetch64
+#else
+   Uint64 tmp = 0;
+
+   privateWaitLock(ptr);
+   (*ptr)-= 1;
+   tmp = *ptr;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint64
+SDL_AtomicAddThenFetch64(volatile Uint64 * ptr, Uint64 value)
+{
+#ifdef nativeAddThenFetch64
+#else
+   Uint64 tmp = 0;
+
+   privateWaitLock(ptr);
+   (*ptr)+= value;
+   tmp = *ptr;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint64
+SDL_AtomicSubtractThenFetch64(volatile Uint64 * ptr, Uint64 value)
+{
+#ifdef nativeSubtractThenFetch64
+#else
+   Uint64 tmp = 0;
+
+   privateWaitLock(ptr);
+   (*ptr)-= value;
+   tmp = *ptr;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+#endif
+

Externals/SDL/src/atomic/linux/SDL_atomic.c

@@ -0,0 +1,510 @@
+/*
+  SDL - Simple DirectMedia Layer
+  Copyright (C) 1997-2009 Sam Lantinga
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+  Sam Lantinga
+  slouken@libsdl.org
+
+  Contributed by Bob Pendleton, bob@pendleton.com
+*/
+
+#include "SDL_stdinc.h"
+#include "SDL_atomic.h"
+
+#include "SDL_error.h"
+
+/*
+  This file provides 32, and 64 bit atomic operations. If the
+  operations are provided by the native hardware and operating system
+  they are used. If they are not then the operations are emulated
+  using the SDL spin lock operations. If spin lock can not be
+  implemented then these functions must fail.
+*/
+
+/* 
+  LINUX/GCC VERSION.
+
+  This version of the code assumes support of the atomic builtins as
+  documented at gcc.gnu.org/onlinedocs/gcc/Atomic-Builtins.html This
+  code should work on any modern x86 or other processor supported by
+  GCC. 
+
+  Some processors will only support some of these operations so
+  #ifdefs will have to be added as incompatibilities are discovered
+*/
+
+/*
+  Native spinlock routines.
+*/
+
+void 
+SDL_AtomicLock(SDL_SpinLock *lock)
+{
+   while (0 != __sync_lock_test_and_set(lock, 1))
+   {
+   }
+}
+
+void 
+SDL_AtomicUnlock(SDL_SpinLock *lock)
+{
+   __sync_lock_test_and_set(lock, 0);
+}
+
+/*
+  Note that platform specific versions can be built from this version
+  by changing the #undefs to #defines and adding platform specific
+  code.
+*/
+
+#define nativeTestThenSet32
+#define nativeClear32
+#define nativeFetchThenIncrement32
+#define nativeFetchThenDecrement32
+#define nativeFetchThenAdd32
+#define nativeFetchThenSubtract32
+#define nativeIncrementThenFetch32
+#define nativeDecrementThenFetch32
+#define nativeAddThenFetch32
+#define nativeSubtractThenFetch32
+
+#ifdef SDL_HAS_64BIT_TYPE
+  #ifdef __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8
+    #define nativeTestThenSet64
+    #define nativeClear64
+    #define nativeFetchThenIncrement64
+    #define nativeFetchThenDecrement64
+    #define nativeFetchThenAdd64
+    #define nativeFetchThenSubtract64
+    #define nativeIncrementThenFetch64
+    #define nativeDecrementThenFetch64
+    #define nativeAddThenFetch64
+    #define nativeSubtractThenFetch64
+  #else
+    #undef  nativeTestThenSet64
+    #undef  nativeClear64
+    #undef  nativeFetchThenIncrement64
+    #undef  nativeFetchThenDecrement64
+    #undef  nativeFetchThenAdd64
+    #undef  nativeFetchThenSubtract64
+    #undef  nativeIncrementThenFetch64
+    #undef  nativeDecrementThenFetch64
+    #undef  nativeAddThenFetch64
+    #undef  nativeSubtractThenFetch64
+  #endif /* __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8 */
+#endif /* SDL_HAS_64BIT_TYPE */
+
+/* 
+  If any of the operations are not provided then we must emulate some
+  of them. That means we need a nice implementation of spin locks
+  that avoids the "one big lock" problem. We use a vector of spin
+  locks and pick which one to use based on the address of the operand
+  of the function.
+
+  To generate the index of the lock we first shift by 3 bits to get
+  rid on the zero bits that result from 32 and 64 bit allignment of
+  data. We then mask off all but 5 bits and use those 5 bits as an
+  index into the table. 
+
+  Picking the lock this way insures that accesses to the same data at
+  the same time will go to the same lock. OTOH, accesses to different
+  data have only a 1/32 chance of hitting the same lock. That should
+  pretty much eliminate the chances of several atomic operations on
+  different data from waiting on the same "big lock". If it isn't
+  then the table of locks can be expanded to a new size so long as
+  the new size is a power of two.
+*/
+
+static SDL_SpinLock locks[32] = {
+   0, 0, 0, 0, 0, 0, 0, 0,
+   0, 0, 0, 0, 0, 0, 0, 0,
+   0, 0, 0, 0, 0, 0, 0, 0,
+   0, 0, 0, 0, 0, 0, 0, 0,
+};
+
+static __inline__ void
+privateWaitLock(volatile void *ptr)
+{
+#if SIZEOF_VOIDP == 4
+   Uint32 index = ((((Uint32)ptr) >> 3) & 0x1f);
+#elif SIZEOF_VOIDP == 8
+   Uint64 index = ((((Uint64)ptr) >> 3) & 0x1f);
+#endif
+
+   SDL_AtomicLock(&locks[index]);
+}
+
+static __inline__ void
+privateUnlock(volatile void *ptr)
+{
+#if SIZEOF_VOIDP == 4
+   Uint32 index = ((((Uint32)ptr) >> 3) & 0x1f);
+#elif SIZEOF_VOIDP == 8
+   Uint64 index = ((((Uint64)ptr) >> 3) & 0x1f);
+#endif
+
+   SDL_AtomicUnlock(&locks[index]);
+}
+
+/* 32 bit atomic operations */
+
+SDL_bool
+SDL_AtomicTestThenSet32(volatile Uint32 * ptr)
+{
+#ifdef nativeTestThenSet32
+   return 0 == __sync_lock_test_and_set(ptr, 1);
+#else
+   SDL_bool result = SDL_FALSE;
+
+   privateWaitLock(ptr);
+   result = (*ptr == 0);
+   if (result)
+   {
+      *ptr = 1;
+   }
+   privateUnlock(ptr);
+
+   return result;
+#endif
+}
+
+void
+SDL_AtomicClear32(volatile Uint32 * ptr)
+{
+#ifdef nativeClear32
+   __sync_lock_test_and_set(ptr, 0);
+   return;
+#else
+   privateWaitLock(ptr);
+   *ptr = 0;
+   privateUnlock(ptr);
+
+   return;
+#endif
+}
+
+Uint32
+SDL_AtomicFetchThenIncrement32(volatile Uint32 * ptr)
+{
+#ifdef nativeFetchThenIncrement32
+   return __sync_fetch_and_add(ptr, 1);
+#else
+   Uint32 tmp = 0;
+
+   privateWaitLock(ptr);
+   tmp = *ptr;
+   (*ptr)+= 1;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint32
+SDL_AtomicFetchThenDecrement32(volatile Uint32 * ptr)
+{
+#ifdef nativeFetchThenDecrement32
+   return __sync_fetch_and_sub(ptr, 1);
+#else
+   Uint32 tmp = 0;
+
+   privateWaitLock(ptr);
+   tmp = *ptr;
+   (*ptr) -= 1;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint32
+SDL_AtomicFetchThenAdd32(volatile Uint32 * ptr, Uint32 value)
+{
+#ifdef nativeFetchThenAdd32
+   return __sync_fetch_and_add(ptr, value);
+#else
+   Uint32 tmp = 0;
+
+   privateWaitLock(ptr);
+   tmp = *ptr;
+   (*ptr)+= value;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint32
+SDL_AtomicFetchThenSubtract32(volatile Uint32 * ptr, Uint32 value)
+{
+#ifdef nativeFetchThenSubtract32
+   return __sync_fetch_and_sub(ptr, value);
+#else
+   Uint32 tmp = 0;
+
+   privateWaitLock(ptr);
+   tmp = *ptr;
+   (*ptr)-= value;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint32
+SDL_AtomicIncrementThenFetch32(volatile Uint32 * ptr)
+{
+#ifdef nativeIncrementThenFetch32
+   return __sync_add_and_fetch(ptr, 1);
+#else
+   Uint32 tmp = 0;
+
+   privateWaitLock(ptr);
+   (*ptr)+= 1;
+   tmp = *ptr;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint32
+SDL_AtomicDecrementThenFetch32(volatile Uint32 * ptr)
+{
+#ifdef nativeDecrementThenFetch32
+   return __sync_sub_and_fetch(ptr, 1);
+#else
+   Uint32 tmp = 0;
+
+   privateWaitLock(ptr);
+   (*ptr)-= 1;
+   tmp = *ptr;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint32
+SDL_AtomicAddThenFetch32(volatile Uint32 * ptr, Uint32 value)
+{
+#ifdef nativeAddThenFetch32
+   return __sync_add_and_fetch(ptr, value);
+#else
+   Uint32 tmp = 0;
+
+   privateWaitLock(ptr);
+   (*ptr)+= value;
+   tmp = *ptr;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint32
+SDL_AtomicSubtractThenFetch32(volatile Uint32 * ptr, Uint32 value)
+{
+#ifdef nativeSubtractThenFetch32
+   return __sync_sub_and_fetch(ptr, value);
+#else
+   Uint32 tmp = 0;
+
+   privateWaitLock(ptr);
+   (*ptr)-= value;
+   tmp = *ptr;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+/* 64 bit atomic operations */
+#ifdef SDL_HAS_64BIT_TYPE
+
+SDL_bool
+SDL_AtomicTestThenSet64(volatile Uint64 * ptr)
+{
+#ifdef nativeTestThenSet64
+   return 0 == __sync_lock_test_and_set(ptr, 1);
+#else
+   SDL_bool result = SDL_FALSE;
+
+   privateWaitLock(ptr);
+   result = (*ptr == 0);
+   if (result)
+   {
+      *ptr = 1;
+   }
+   privateUnlock(ptr);
+
+   return result;
+#endif
+}
+
+void
+SDL_AtomicClear64(volatile Uint64 * ptr)
+{
+#ifdef nativeClear64
+   __sync_lock_test_and_set(ptr, 0);
+   return;
+#else
+   privateWaitLock(ptr);
+   *ptr = 0;
+   privateUnlock(ptr);
+
+   return;
+#endif
+}
+
+Uint64
+SDL_AtomicFetchThenIncrement64(volatile Uint64 * ptr)
+{
+#ifdef nativeFetchThenIncrement64
+   return __sync_fetch_and_add(ptr, 1);
+#else
+   Uint64 tmp = 0;
+
+   privateWaitLock(ptr);
+   tmp = *ptr;
+   (*ptr)+= 1;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint64
+SDL_AtomicFetchThenDecrement64(volatile Uint64 * ptr)
+{
+#ifdef nativeFetchThenDecrement64
+   return __sync_fetch_and_sub(ptr, 1);
+#else
+   Uint64 tmp = 0;
+
+   privateWaitLock(ptr);
+   tmp = *ptr;
+   (*ptr) -= 1;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint64
+SDL_AtomicFetchThenAdd64(volatile Uint64 * ptr, Uint64 value)
+{
+#ifdef nativeFetchThenAdd64
+   return __sync_fetch_and_add(ptr, value);
+#else
+   Uint64 tmp = 0;
+
+   privateWaitLock(ptr);
+   tmp = *ptr;
+   (*ptr)+= value;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint64
+SDL_AtomicFetchThenSubtract64(volatile Uint64 * ptr, Uint64 value)
+{
+#ifdef nativeFetchThenSubtract64
+   return __sync_fetch_and_sub(ptr, value);
+#else
+   Uint64 tmp = 0;
+
+   privateWaitLock(ptr);
+   tmp = *ptr;
+   (*ptr)-= value;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint64
+SDL_AtomicIncrementThenFetch64(volatile Uint64 * ptr)
+{
+#ifdef nativeIncrementThenFetch64
+   return __sync_add_and_fetch(ptr, 1);
+#else
+   Uint64 tmp = 0;
+
+   privateWaitLock(ptr);
+   (*ptr)+= 1;
+   tmp = *ptr;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint64
+SDL_AtomicDecrementThenFetch64(volatile Uint64 * ptr)
+{
+#ifdef nativeDecrementThenFetch64
+   return __sync_sub_and_fetch(ptr, 1);
+#else
+   Uint64 tmp = 0;
+
+   privateWaitLock(ptr);
+   (*ptr)-= 1;
+   tmp = *ptr;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint64
+SDL_AtomicAddThenFetch64(volatile Uint64 * ptr, Uint64 value)
+{
+#ifdef nativeAddThenFetch64
+   return __sync_add_and_fetch(ptr, value);
+#else
+   Uint64 tmp = 0;
+
+   privateWaitLock(ptr);
+   (*ptr)+= value;
+   tmp = *ptr;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint64
+SDL_AtomicSubtractThenFetch64(volatile Uint64 * ptr, Uint64 value)
+{
+#ifdef nativeSubtractThenFetch64
+   return __sync_sub_and_fetch(ptr, value);
+#else
+   Uint64 tmp = 0;
+
+   privateWaitLock(ptr);
+   (*ptr)-= value;
+   tmp = *ptr;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+#endif /* SDL_HAS_64BIT_TYPE */

Externals/SDL/src/atomic/macosx/SDL_atomic.c

@@ -0,0 +1,469 @@
+/*
+  SDL - Simple DirectMedia Layer
+  Copyright (C) 1997-2009 Sam Lantinga
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+  Sam Lantinga
+  slouken@libsdl.org
+
+  Contributed by Bob Pendleton, bob@pendleton.com
+*/
+
+#include "SDL_stdinc.h"
+#include "SDL_atomic.h"
+
+#include "SDL_error.h"
+
+/*
+  This file provides 32, and 64 bit atomic operations. If the
+  operations are provided by the native hardware and operating system
+  they are used. If they are not then the operations are emulated
+  using the SDL spin lock operations. If spin lock can not be
+  implemented then these functions must fail.
+*/
+
+/* 
+  DUMMY VERSION.
+
+  This version of the code assumes there is no support for atomic
+  operations. Therefore, every function sets the SDL error
+  message. Oddly enough, if you only have one thread then this
+  version actuallys works.
+*/
+
+/*
+  Native spinlock routines. Because this is the dummy implementation
+  these will always call SDL_SetError() and do nothing.
+*/
+
+void 
+SDL_AtomicLock(SDL_SpinLock *lock)
+{
+   SDL_SetError("SDL_atomic.c: is not implemented on this platform");
+}
+
+void 
+SDL_AtomicUnlock(SDL_SpinLock *lock)
+{
+   SDL_SetError("SDL_atomic.c: is not implemented on this platform");
+}
+
+/*
+  Note that platform specific versions can be built from this version
+  by changing the #undefs to #defines and adding platform specific
+  code.
+*/
+
+#undef  nativeTestThenSet32
+#undef  nativeClear32
+#undef  nativeFetchThenIncrement32
+#undef  nativeFetchThenDecrement32
+#undef  nativeFetchThenAdd32
+#undef  nativeFetchThenSubtract32
+#undef  nativeIncrementThenFetch32
+#undef  nativeDecrementThenFetch32
+#undef  nativeAddThenFetch32
+#undef  nativeSubtractThenFetch32
+
+#undef  nativeTestThenSet64
+#undef  nativeClear64
+#undef  nativeFetchThenIncrement64
+#undef  nativeFetchThenDecrement64
+#undef  nativeFetchThenAdd64
+#undef  nativeFetchThenSubtract64
+#undef  nativeIncrementThenFetch64
+#undef  nativeDecrementThenFetch64
+#undef  nativeAddThenFetch64
+#undef  nativeSubtractThenFetch64
+
+/* 
+  If any of the operations are not provided then we must emulate some
+  of them. That means we need a nice implementation of spin locks
+  that avoids the "one big lock" problem. We use a vector of spin
+  locks and pick which one to use based on the address of the operand
+  of the function.
+
+  To generate the index of the lock we first shift by 3 bits to get
+  rid on the zero bits that result from 32 and 64 bit allignment of
+  data. We then mask off all but 5 bits and use those 5 bits as an
+  index into the table. 
+
+  Picking the lock this way insures that accesses to the same data at
+  the same time will go to the same lock. OTOH, accesses to different
+  data have only a 1/32 chance of hitting the same lock. That should
+  pretty much eliminate the chances of several atomic operations on
+  different data from waiting on the same "big lock". If it isn't
+  then the table of locks can be expanded to a new size so long as
+  the new size is a power of two.
+*/
+
+static SDL_SpinLock locks[32] = {
+   0, 0, 0, 0, 0, 0, 0, 0,
+   0, 0, 0, 0, 0, 0, 0, 0,
+   0, 0, 0, 0, 0, 0, 0, 0,
+   0, 0, 0, 0, 0, 0, 0, 0,
+};
+
+static __inline__ void
+privateWaitLock(volatile void *ptr)
+{
+#if SIZEOF_VOIDP == 4
+   Uint32 index = ((((Uint32)ptr) >> 3) & 0x1f);
+#elif SIZEOF_VOIDP == 8
+   Uint64 index = ((((Uint64)ptr) >> 3) & 0x1f);
+#endif
+
+   SDL_AtomicLock(&locks[index]);
+}
+
+static __inline__ void
+privateUnlock(volatile void *ptr)
+{
+#if SIZEOF_VOIDP == 4
+   Uint32 index = ((((Uint32)ptr) >> 3) & 0x1f);
+#elif SIZEOF_VOIDP == 8
+   Uint64 index = ((((Uint64)ptr) >> 3) & 0x1f);
+#endif
+
+   SDL_AtomicUnlock(&locks[index]);
+}
+
+/* 32 bit atomic operations */
+
+SDL_bool
+SDL_AtomicTestThenSet32(volatile Uint32 * ptr)
+{
+#ifdef nativeTestThenSet32
+#else
+   SDL_bool result = SDL_FALSE;
+
+   privateWaitLock(ptr);
+   result = (*ptr == 0);
+   if (result)
+   {
+      *ptr = 1;
+   }
+   privateUnlock(ptr);
+
+   return result;
+#endif
+}
+
+void
+SDL_AtomicClear32(volatile Uint32 * ptr)
+{
+#ifdef nativeClear32
+#else
+   privateWaitLock(ptr);
+   *ptr = 0;
+   privateUnlock(ptr);
+
+   return;
+#endif
+}
+
+Uint32
+SDL_AtomicFetchThenIncrement32(volatile Uint32 * ptr)
+{
+#ifdef nativeFetchThenIncrement32
+#else
+   Uint32 tmp = 0;
+
+   privateWaitLock(ptr);
+   tmp = *ptr;
+   (*ptr)+= 1;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint32
+SDL_AtomicFetchThenDecrement32(volatile Uint32 * ptr)
+{
+#ifdef nativeFetchThenDecrement32
+#else
+   Uint32 tmp = 0;
+
+   privateWaitLock(ptr);
+   tmp = *ptr;
+   (*ptr) -= 1;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint32
+SDL_AtomicFetchThenAdd32(volatile Uint32 * ptr, Uint32 value)
+{
+#ifdef nativeFetchThenAdd32
+#else
+   Uint32 tmp = 0;
+
+   privateWaitLock(ptr);
+   tmp = *ptr;
+   (*ptr)+= value;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint32
+SDL_AtomicFetchThenSubtract32(volatile Uint32 * ptr, Uint32 value)
+{
+#ifdef nativeFetchThenSubtract32
+#else
+   Uint32 tmp = 0;
+
+   privateWaitLock(ptr);
+   tmp = *ptr;
+   (*ptr)-= value;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint32
+SDL_AtomicIncrementThenFetch32(volatile Uint32 * ptr)
+{
+#ifdef nativeIncrementThenFetch32
+#else
+   Uint32 tmp = 0;
+
+   privateWaitLock(ptr);
+   (*ptr)+= 1;
+   tmp = *ptr;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint32
+SDL_AtomicDecrementThenFetch32(volatile Uint32 * ptr)
+{
+#ifdef nativeDecrementThenFetch32
+#else
+   Uint32 tmp = 0;
+
+   privateWaitLock(ptr);
+   (*ptr)-= 1;
+   tmp = *ptr;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint32
+SDL_AtomicAddThenFetch32(volatile Uint32 * ptr, Uint32 value)
+{
+#ifdef nativeAddThenFetch32
+#else
+   Uint32 tmp = 0;
+
+   privateWaitLock(ptr);
+   (*ptr)+= value;
+   tmp = *ptr;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint32
+SDL_AtomicSubtractThenFetch32(volatile Uint32 * ptr, Uint32 value)
+{
+#ifdef nativeSubtractThenFetch32
+#else
+   Uint32 tmp = 0;
+
+   privateWaitLock(ptr);
+   (*ptr)-= value;
+   tmp = *ptr;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+/* 64 bit atomic operations */
+#ifdef SDL_HAS_64BIT_TYPE
+
+SDL_bool
+SDL_AtomicTestThenSet64(volatile Uint64 * ptr)
+{
+#ifdef nativeTestThenSet64
+#else
+   SDL_bool result = SDL_FALSE;
+
+   privateWaitLock(ptr);
+   result = (*ptr == 0);
+   if (result)
+   {
+      *ptr = 1;
+   }
+   privateUnlock(ptr);
+
+   return result;
+#endif
+}
+
+void
+SDL_AtomicClear64(volatile Uint64 * ptr)
+{
+#ifdef nativeClear64
+#else
+   privateWaitLock(ptr);
+   *ptr = 0;
+   privateUnlock(ptr);
+
+   return;
+#endif
+}
+
+Uint64
+SDL_AtomicFetchThenIncrement64(volatile Uint64 * ptr)
+{
+#ifdef nativeFetchThenIncrement64
+#else
+   Uint64 tmp = 0;
+
+   privateWaitLock(ptr);
+   tmp = *ptr;
+   (*ptr)+= 1;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint64
+SDL_AtomicFetchThenDecrement64(volatile Uint64 * ptr)
+{
+#ifdef nativeFetchThenDecrement64
+#else
+   Uint64 tmp = 0;
+
+   privateWaitLock(ptr);
+   tmp = *ptr;
+   (*ptr) -= 1;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint64
+SDL_AtomicFetchThenAdd64(volatile Uint64 * ptr, Uint64 value)
+{
+#ifdef nativeFetchThenAdd64
+#else
+   Uint64 tmp = 0;
+
+   privateWaitLock(ptr);
+   tmp = *ptr;
+   (*ptr)+= value;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint64
+SDL_AtomicFetchThenSubtract64(volatile Uint64 * ptr, Uint64 value)
+{
+#ifdef nativeFetchThenSubtract64
+#else
+   Uint64 tmp = 0;
+
+   privateWaitLock(ptr);
+   tmp = *ptr;
+   (*ptr)-= value;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint64
+SDL_AtomicIncrementThenFetch64(volatile Uint64 * ptr)
+{
+#ifdef nativeIncrementThenFetch64
+#else
+   Uint64 tmp = 0;
+
+   privateWaitLock(ptr);
+   (*ptr)+= 1;
+   tmp = *ptr;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint64
+SDL_AtomicDecrementThenFetch64(volatile Uint64 * ptr)
+{
+#ifdef nativeDecrementThenFetch64
+#else
+   Uint64 tmp = 0;
+
+   privateWaitLock(ptr);
+   (*ptr)-= 1;
+   tmp = *ptr;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint64
+SDL_AtomicAddThenFetch64(volatile Uint64 * ptr, Uint64 value)
+{
+#ifdef nativeAddThenFetch64
+#else
+   Uint64 tmp = 0;
+
+   privateWaitLock(ptr);
+   (*ptr)+= value;
+   tmp = *ptr;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint64
+SDL_AtomicSubtractThenFetch64(volatile Uint64 * ptr, Uint64 value)
+{
+#ifdef nativeSubtractThenFetch64
+#else
+   Uint64 tmp = 0;
+
+   privateWaitLock(ptr);
+   (*ptr)-= value;
+   tmp = *ptr;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+#endif
+

Externals/SDL/src/atomic/qnx/SDL_atomic.c

@@ -0,0 +1,505 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+
+    QNX native atomic operations
+    Copyright (C) 2009 Mike Gorchak
+    (mike@malva.ua, lestat@i.com.ua)
+*/
+
+#include "SDL_stdinc.h"
+#include "SDL_atomic.h"
+#include "SDL_error.h"
+
+#include <atomic.h>
+
+/* SMP Exchange for PPC platform */
+#ifdef __PPC__
+#include <ppc/smpxchg.h>
+#endif /* __PPC__ */
+
+/* SMP Exchange for ARM platform */
+#ifdef __ARM__
+#include <arm/smpxchg.h>
+#endif /* __ARM__ */
+
+/* SMP Exchange for MIPS platform */
+#if defined (__MIPSEB__) || defined(__MIPSEL__)
+#include <mips/smpxchg.h>
+#endif /* __MIPSEB__ || __MIPSEL__ */
+
+/* SMP Exchange for SH platform */
+#ifdef __SH__
+#include <sh/smpxchg.h>
+#endif /* __SH__ */
+
+/* SMP Exchange for x86 platform */
+#ifdef __X86__
+#include <x86/smpxchg.h>
+#endif /* __X86__ */
+
+/*
+  This file provides 32, and 64 bit atomic operations. If the
+  operations are provided by the native hardware and operating system
+  they are used. If they are not then the operations are emulated
+  using the SDL spin lock operations. If spin lock can not be
+  implemented then these functions must fail.
+*/
+
+void 
+SDL_AtomicLock(SDL_SpinLock *lock)
+{
+   unsigned volatile* l = (unsigned volatile*)lock;
+   Uint32 oldval = 0;
+   Uint32 newval = 1;
+
+   oldval = _smp_xchg(l, newval);
+   while(1 == oldval)
+   {
+      oldval = _smp_xchg(l, newval);
+   }
+}
+
+void 
+SDL_AtomicUnlock(SDL_SpinLock *lock)
+{
+   unsigned volatile* l = (unsigned volatile*)lock;
+   Uint32 newval = 0;
+
+   _smp_xchg(l, newval);
+}
+
+/*
+   QNX 6.4.1 supports only 32 bit atomic access
+*/
+
+#undef   nativeTestThenSet32
+#define  nativeClear32
+#define  nativeFetchThenIncrement32
+#define  nativeFetchThenDecrement32
+#define  nativeFetchThenAdd32
+#define  nativeFetchThenSubtract32
+#define  nativeIncrementThenFetch32
+#define  nativeDecrementThenFetch32
+#define  nativeAddThenFetch32
+#define  nativeSubtractThenFetch32
+
+#undef  nativeTestThenSet64
+#undef  nativeClear64
+#undef  nativeFetchThenIncrement64
+#undef  nativeFetchThenDecrement64
+#undef  nativeFetchThenAdd64
+#undef  nativeFetchThenSubtract64
+#undef  nativeIncrementThenFetch64
+#undef  nativeDecrementThenFetch64
+#undef  nativeAddThenFetch64
+#undef  nativeSubtractThenFetch64
+
+/*
+  If any of the operations are not provided then we must emulate some
+  of them. That means we need a nice implementation of spin locks
+  that avoids the "one big lock" problem. We use a vector of spin
+  locks and pick which one to use based on the address of the operand
+  of the function.
+
+  To generate the index of the lock we first shift by 3 bits to get
+  rid on the zero bits that result from 32 and 64 bit allignment of
+  data. We then mask off all but 5 bits and use those 5 bits as an
+  index into the table.
+
+  Picking the lock this way insures that accesses to the same data at
+  the same time will go to the same lock. OTOH, accesses to different
+  data have only a 1/32 chance of hitting the same lock. That should
+  pretty much eliminate the chances of several atomic operations on
+  different data from waiting on the same "big lock". If it isn't
+  then the table of locks can be expanded to a new size so long as
+  the new size is a power of two.
+*/
+
+static SDL_SpinLock locks[32] = {
+   0, 0, 0, 0, 0, 0, 0, 0,
+   0, 0, 0, 0, 0, 0, 0, 0,
+   0, 0, 0, 0, 0, 0, 0, 0,
+   0, 0, 0, 0, 0, 0, 0, 0,
+};
+
+static __inline__ void
+privateWaitLock(volatile void *ptr)
+{
+#if SIZEOF_VOIDP == 4
+   Uint32 index = ((((Uint32)ptr) >> 3) & 0x1f);
+#elif SIZEOF_VOIDP == 8
+   Uint64 index = ((((Uint64)ptr) >> 3) & 0x1f);
+#endif /* SIZEOF_VOIDP */
+
+   SDL_AtomicLock(&locks[index]);
+}
+
+static __inline__ void
+privateUnlock(volatile void *ptr)
+{
+#if SIZEOF_VOIDP == 4
+   Uint32 index = ((((Uint32)ptr) >> 3) & 0x1f);
+#elif SIZEOF_VOIDP == 8
+   Uint64 index = ((((Uint64)ptr) >> 3) & 0x1f);
+#endif /* SIZEOF_VOIDP */
+
+   SDL_AtomicUnlock(&locks[index]);
+}
+
+/* 32 bit atomic operations */
+
+SDL_bool
+SDL_AtomicTestThenSet32(volatile Uint32 * ptr)
+{
+#ifdef nativeTestThenSet32
+#else
+   SDL_bool result = SDL_FALSE;
+
+   privateWaitLock(ptr);
+   result = (*ptr == 0);
+   if (result)
+   {
+      *ptr = 1;
+   }
+   privateUnlock(ptr);
+
+   return result;
+#endif /* nativeTestThenSet32 */
+}
+
+void
+SDL_AtomicClear32(volatile Uint32 * ptr)
+{
+#ifdef nativeClear32
+   atomic_clr(ptr, 0xFFFFFFFF);
+#else
+   privateWaitLock(ptr);
+   *ptr = 0;
+   privateUnlock(ptr);
+
+   return;
+#endif /* nativeClear32 */
+}
+
+Uint32
+SDL_AtomicFetchThenIncrement32(volatile Uint32 * ptr)
+{
+#ifdef nativeFetchThenIncrement32
+   return atomic_add_value(ptr, 0x00000001);
+#else
+   Uint32 tmp = 0;
+
+   privateWaitLock(ptr);
+   tmp = *ptr;
+   (*ptr)+= 1;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif /* nativeFetchThenIncrement32 */
+}
+
+Uint32
+SDL_AtomicFetchThenDecrement32(volatile Uint32 * ptr)
+{
+#ifdef nativeFetchThenDecrement32
+   return atomic_sub_value(ptr, 0x00000001);
+#else
+   Uint32 tmp = 0;
+
+   privateWaitLock(ptr);
+   tmp = *ptr;
+   (*ptr) -= 1;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif /* nativeFetchThenDecrement32 */
+}
+
+Uint32
+SDL_AtomicFetchThenAdd32(volatile Uint32 * ptr, Uint32 value)
+{
+#ifdef nativeFetchThenAdd32
+   return atomic_add_value(ptr, value);
+#else
+   Uint32 tmp = 0;
+
+   privateWaitLock(ptr);
+   tmp = *ptr;
+   (*ptr)+= value;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif /* nativeFetchThenAdd32 */
+}
+
+Uint32
+SDL_AtomicFetchThenSubtract32(volatile Uint32 * ptr, Uint32 value)
+{
+#ifdef nativeFetchThenSubtract32
+   return atomic_sub_value(ptr, value);
+#else
+   Uint32 tmp = 0;
+
+   privateWaitLock(ptr);
+   tmp = *ptr;
+   (*ptr)-= value;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif /* nativeFetchThenSubtract32 */
+}
+
+Uint32
+SDL_AtomicIncrementThenFetch32(volatile Uint32 * ptr)
+{
+#ifdef nativeIncrementThenFetch32
+   atomic_add(ptr, 0x00000001);
+   return atomic_add_value(ptr, 0x00000000);
+#else
+   Uint32 tmp = 0;
+
+   privateWaitLock(ptr);
+   (*ptr)+= 1;
+   tmp = *ptr;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif /* nativeIncrementThenFetch32 */
+}
+
+Uint32
+SDL_AtomicDecrementThenFetch32(volatile Uint32 * ptr)
+{
+#ifdef nativeDecrementThenFetch32
+   atomic_sub(ptr, 0x00000001);
+   return atomic_sub_value(ptr, 0x00000000);
+#else
+   Uint32 tmp = 0;
+
+   privateWaitLock(ptr);
+   (*ptr)-= 1;
+   tmp = *ptr;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif /* nativeDecrementThenFetch32 */
+}
+
+Uint32
+SDL_AtomicAddThenFetch32(volatile Uint32 * ptr, Uint32 value)
+{
+#ifdef nativeAddThenFetch32
+   atomic_add(ptr, value);
+   return atomic_add_value(ptr, 0x00000000);
+#else
+   Uint32 tmp = 0;
+
+   privateWaitLock(ptr);
+   (*ptr)+= value;
+   tmp = *ptr;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif /* nativeAddThenFetch32 */
+}
+
+Uint32
+SDL_AtomicSubtractThenFetch32(volatile Uint32 * ptr, Uint32 value)
+{
+#ifdef nativeSubtractThenFetch32
+   atomic_sub(ptr, value);
+   return atomic_sub_value(ptr, 0x00000000);
+#else
+   Uint32 tmp = 0;
+
+   privateWaitLock(ptr);
+   (*ptr)-= value;
+   tmp = *ptr;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif /* nativeSubtractThenFetch32 */
+}
+
+/* 64 bit atomic operations */
+#ifdef SDL_HAS_64BIT_TYPE
+
+SDL_bool
+SDL_AtomicTestThenSet64(volatile Uint64 * ptr)
+{
+#ifdef nativeTestThenSet64
+#else
+   SDL_bool result = SDL_FALSE;
+
+   privateWaitLock(ptr);
+   result = (*ptr == 0);
+   if (result)
+   {
+      *ptr = 1;
+   }
+   privateUnlock(ptr);
+
+   return result;
+#endif /* nativeTestThenSet64 */
+}
+
+void
+SDL_AtomicClear64(volatile Uint64 * ptr)
+{
+#ifdef nativeClear64
+#else
+   privateWaitLock(ptr);
+   *ptr = 0;
+   privateUnlock(ptr);
+
+   return;
+#endif /* nativeClear64 */
+}
+
+Uint64
+SDL_AtomicFetchThenIncrement64(volatile Uint64 * ptr)
+{
+#ifdef nativeFetchThenIncrement64
+#else
+   Uint64 tmp = 0;
+
+   privateWaitLock(ptr);
+   tmp = *ptr;
+   (*ptr)+= 1;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif /* nativeFetchThenIncrement64 */
+}
+
+Uint64
+SDL_AtomicFetchThenDecrement64(volatile Uint64 * ptr)
+{
+#ifdef nativeFetchThenDecrement64
+#else
+   Uint64 tmp = 0;
+
+   privateWaitLock(ptr);
+   tmp = *ptr;
+   (*ptr) -= 1;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif /* nativeFetchThenDecrement64 */
+}
+
+Uint64
+SDL_AtomicFetchThenAdd64(volatile Uint64 * ptr, Uint64 value)
+{
+#ifdef nativeFetchThenAdd64
+#else
+   Uint64 tmp = 0;
+
+   privateWaitLock(ptr);
+   tmp = *ptr;
+   (*ptr)+= value;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif /* nativeFetchThenAdd64 */
+}
+
+Uint64
+SDL_AtomicFetchThenSubtract64(volatile Uint64 * ptr, Uint64 value)
+{
+#ifdef nativeFetchThenSubtract64
+#else
+   Uint64 tmp = 0;
+
+   privateWaitLock(ptr);
+   tmp = *ptr;
+   (*ptr)-= value;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif /* nativeFetchThenSubtract64 */
+}
+
+Uint64
+SDL_AtomicIncrementThenFetch64(volatile Uint64 * ptr)
+{
+#ifdef nativeIncrementThenFetch64
+#else
+   Uint64 tmp = 0;
+
+   privateWaitLock(ptr);
+   (*ptr)+= 1;
+   tmp = *ptr;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif /* nativeIncrementThenFetch64 */
+}
+
+Uint64
+SDL_AtomicDecrementThenFetch64(volatile Uint64 * ptr)
+{
+#ifdef nativeDecrementThenFetch64
+#else
+   Uint64 tmp = 0;
+
+   privateWaitLock(ptr);
+   (*ptr)-= 1;
+   tmp = *ptr;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif /* nativeDecrementThenFetch64 */
+}
+
+Uint64
+SDL_AtomicAddThenFetch64(volatile Uint64 * ptr, Uint64 value)
+{
+#ifdef nativeAddThenFetch64
+#else
+   Uint64 tmp = 0;
+
+   privateWaitLock(ptr);
+   (*ptr)+= value;
+   tmp = *ptr;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif /* nativeAddThenFetch64 */
+}
+
+Uint64
+SDL_AtomicSubtractThenFetch64(volatile Uint64 * ptr, Uint64 value)
+{
+#ifdef nativeSubtractThenFetch64
+#else
+   Uint64 tmp = 0;
+
+   privateWaitLock(ptr);
+   (*ptr)-= value;
+   tmp = *ptr;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif /* nativeSubtractThenFetch64 */
+}
+
+#endif /* SDL_HAS_64BIT_TYPE */

Externals/SDL/src/atomic/win32/SDL_atomic.c

@@ -0,0 +1,510 @@
+/*
+  SDL - Simple DirectMedia Layer
+  Copyright (C) 1997-2009 Sam Lantinga
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+  Sam Lantinga
+  slouken@libsdl.org
+
+  Contributed by Bob Pendleton, bob@pendleton.com
+*/
+
+#include "SDL_stdinc.h"
+#include "SDL_atomic.h"
+
+#include "SDL_error.h"
+#include "Windows.h"
+
+/*
+  This file provides 32, and 64 bit atomic operations. If the
+  operations are provided by the native hardware and operating system
+  they are used. If they are not then the operations are emulated
+  using the SDL spin lock operations. If spin lock can not be
+  implemented then these functions must fail.
+*/
+
+/* 
+  WIN32 VERSION.
+
+  This makes use of native Windows atomic operations.
+*/
+
+/*
+  Native spinlock routines. Because this is the dummy implementation
+  these will always call SDL_SetError() and do nothing.
+*/
+
+void 
+SDL_AtomicLock(SDL_SpinLock *lock)
+{
+  long volatile * l = (long volatile *)lock;
+  Uint32 old = 0;
+  Uint32 new = 1;
+
+  old = InterlockedExchange(l, new);
+  while(1 == old)
+    {
+      old = InterlockedExchange(l, new);
+    }
+}
+
+void 
+SDL_AtomicUnlock(SDL_SpinLock *lock)
+{
+  long volatile * l = (long volatile *)lock;
+  Uint32 new = 0;
+
+  InterlockedExchange(l, new);
+}
+
+/*
+  Note that platform specific versions can be built from this version
+  by changing the #undefs to #defines and adding platform specific
+  code.
+*/
+
+#define nativeTestThenSet32
+#define nativeClear32
+#define nativeFetchThenIncrement32
+#define nativeFetchThenDecrement32
+#define nativeFetchThenAdd32
+#define nativeFetchThenSubtract32
+#define nativeIncrementThenFetch32
+#define nativeDecrementThenFetch32
+#define nativeAddThenFetch32
+#define nativeSubtractThenFetch32
+
+#undef  nativeTestThenSet64
+#undef  nativeClear64
+#undef  nativeFetchThenIncrement64
+#undef  nativeFetchThenDecrement64
+#undef  nativeFetchThenAdd64
+#undef  nativeFetchThenSubtract64
+#undef  nativeIncrementThenFetch64
+#undef  nativeDecrementThenFetch64
+#undef  nativeAddThenFetch64
+#undef  nativeSubtractThenFetch64
+
+/* 
+  If any of the operations are not provided then we must emulate some
+  of them. That means we need a nice implementation of spin locks
+  that avoids the "one big lock" problem. We use a vector of spin
+  locks and pick which one to use based on the address of the operand
+  of the function.
+
+  To generate the index of the lock we first shift by 3 bits to get
+  rid on the zero bits that result from 32 and 64 bit allignment of
+  data. We then mask off all but 5 bits and use those 5 bits as an
+  index into the table. 
+
+  Picking the lock this way insures that accesses to the same data at
+  the same time will go to the same lock. OTOH, accesses to different
+  data have only a 1/32 chance of hitting the same lock. That should
+  pretty much eliminate the chances of several atomic operations on
+  different data from waiting on the same "big lock". If it isn't
+  then the table of locks can be expanded to a new size so long as
+  the new size is a power of two.
+*/
+
+static SDL_SpinLock locks[32] = {
+   0, 0, 0, 0, 0, 0, 0, 0,
+   0, 0, 0, 0, 0, 0, 0, 0,
+   0, 0, 0, 0, 0, 0, 0, 0,
+   0, 0, 0, 0, 0, 0, 0, 0,
+};
+
+static __inline__ void
+privateWaitLock(volatile void *ptr)
+{
+#if SIZEOF_VOIDP == 4
+   Uint32 index = ((((Uint32)ptr) >> 3) & 0x1f);
+#elif SIZEOF_VOIDP == 8
+   Uint64 index = ((((Uint64)ptr) >> 3) & 0x1f);
+#endif
+
+   SDL_AtomicLock(&locks[index]);
+}
+
+static __inline__ void
+privateUnlock(volatile void *ptr)
+{
+#if SIZEOF_VOIDP == 4
+   Uint32 index = ((((Uint32)ptr) >> 3) & 0x1f);
+#elif SIZEOF_VOIDP == 8
+   Uint64 index = ((((Uint64)ptr) >> 3) & 0x1f);
+#endif
+
+   SDL_AtomicUnlock(&locks[index]);
+}
+
+/* 32 bit atomic operations */
+
+SDL_bool
+SDL_AtomicTestThenSet32(volatile Uint32 * ptr)
+{
+#ifdef nativeTestThenSet32
+  long volatile * p = (long volatile *)ptr;
+  Uint32 new = 1;
+
+  return 0 == InterlockedExchange(p, new);
+#else
+   SDL_bool result = SDL_FALSE;
+
+   privateWaitLock(ptr);
+   result = (*ptr == 0);
+   if (result)
+   {
+      *ptr = 1;
+   }
+   privateUnlock(ptr);
+
+   return result;
+#endif
+}
+
+void
+SDL_AtomicClear32(volatile Uint32 * ptr)
+{
+#ifdef nativeClear32
+  long volatile * p = (long volatile *)ptr;
+  Uint32 new = 0;
+
+  InterlockedExchange(p, new);
+#else
+   privateWaitLock(ptr);
+   *ptr = 0;
+   privateUnlock(ptr);
+
+   return;
+#endif
+}
+
+Uint32
+SDL_AtomicFetchThenIncrement32(volatile Uint32 * ptr)
+{
+#ifdef nativeFetchThenIncrement32
+  long volatile * p = (long volatile *)ptr;
+
+  return InterlockedExchangeAdd(p, 1);
+#else
+   Uint32 tmp = 0;
+
+   privateWaitLock(ptr);
+   tmp = *ptr;
+   (*ptr)+= 1;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint32
+SDL_AtomicFetchThenDecrement32(volatile Uint32 * ptr)
+{
+#ifdef nativeFetchThenDecrement32
+  long volatile * p = (long volatile *)ptr;
+
+  return InterlockedExchangeAdd(p, -1);
+#else
+   Uint32 tmp = 0;
+
+   privateWaitLock(ptr);
+   tmp = *ptr;
+   (*ptr) -= 1;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint32
+SDL_AtomicFetchThenAdd32(volatile Uint32 * ptr, Uint32 value)
+{
+#ifdef nativeFetchThenAdd32
+  long volatile * p = (long volatile *)ptr;
+
+  return InterlockedExchangeAdd(p, value);
+#else
+   Uint32 tmp = 0;
+
+   privateWaitLock(ptr);
+   tmp = *ptr;
+   (*ptr)+= value;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint32
+SDL_AtomicFetchThenSubtract32(volatile Uint32 * ptr, Uint32 value)
+{
+#ifdef nativeFetchThenSubtract32
+  long volatile * p = (long volatile *)ptr;
+
+  return InterlockedExchangeAdd(p, (0 - value));
+#else
+   Uint32 tmp = 0;
+
+   privateWaitLock(ptr);
+   tmp = *ptr;
+   (*ptr)-= value;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint32
+SDL_AtomicIncrementThenFetch32(volatile Uint32 * ptr)
+{
+#ifdef nativeIncrementThenFetch32
+  long volatile * p = (LONG volatile *)ptr;
+
+  return InterlockedIncrement(p);
+#else
+   Uint32 tmp = 0;
+
+   privateWaitLock(ptr);
+   (*ptr)+= 1;
+   tmp = *ptr;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint32
+SDL_AtomicDecrementThenFetch32(volatile Uint32 * ptr)
+{
+#ifdef nativeDecrementThenFetch32
+  long volatile * p = (LONG volatile *)ptr;
+
+  return InterlockedDecrement(p);
+#else
+   Uint32 tmp = 0;
+
+   privateWaitLock(ptr);
+   (*ptr)-= 1;
+   tmp = *ptr;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint32
+SDL_AtomicAddThenFetch32(volatile Uint32 * ptr, Uint32 value)
+{
+#ifdef nativeAddThenFetch32
+  long volatile * p = (long volatile *)ptr;
+
+  return InterlockedExchangeAdd(p, value) + value;
+#else
+   Uint32 tmp = 0;
+
+   privateWaitLock(ptr);
+   (*ptr)+= value;
+   tmp = *ptr;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint32
+SDL_AtomicSubtractThenFetch32(volatile Uint32 * ptr, Uint32 value)
+{
+#ifdef nativeSubtractThenFetch32
+  long volatile * p = (long volatile *)ptr;
+
+  return InterlockedExchangeAdd(p, (0 - value)) - value;
+#else
+   Uint32 tmp = 0;
+
+   privateWaitLock(ptr);
+   (*ptr)-= value;
+   tmp = *ptr;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+/* 64 bit atomic operations */
+#ifdef SDL_HAS_64BIT_TYPE
+
+SDL_bool
+SDL_AtomicTestThenSet64(volatile Uint64 * ptr)
+{
+#ifdef nativeTestThenSet64
+#else
+   SDL_bool result = SDL_FALSE;
+
+   privateWaitLock(ptr);
+   result = (*ptr == 0);
+   if (result)
+   {
+      *ptr = 1;
+   }
+   privateUnlock(ptr);
+
+   return result;
+#endif
+}
+
+void
+SDL_AtomicClear64(volatile Uint64 * ptr)
+{
+#ifdef nativeClear64
+#else
+   privateWaitLock(ptr);
+   *ptr = 0;
+   privateUnlock(ptr);
+
+   return;
+#endif
+}
+
+Uint64
+SDL_AtomicFetchThenIncrement64(volatile Uint64 * ptr)
+{
+#ifdef nativeFetchThenIncrement64
+#else
+   Uint64 tmp = 0;
+
+   privateWaitLock(ptr);
+   tmp = *ptr;
+   (*ptr)+= 1;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint64
+SDL_AtomicFetchThenDecrement64(volatile Uint64 * ptr)
+{
+#ifdef nativeFetchThenDecrement64
+#else
+   Uint64 tmp = 0;
+
+   privateWaitLock(ptr);
+   tmp = *ptr;
+   (*ptr) -= 1;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint64
+SDL_AtomicFetchThenAdd64(volatile Uint64 * ptr, Uint64 value)
+{
+#ifdef nativeFetchThenAdd64
+#else
+   Uint64 tmp = 0;
+
+   privateWaitLock(ptr);
+   tmp = *ptr;
+   (*ptr)+= value;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint64
+SDL_AtomicFetchThenSubtract64(volatile Uint64 * ptr, Uint64 value)
+{
+#ifdef nativeFetchThenSubtract64
+#else
+   Uint64 tmp = 0;
+
+   privateWaitLock(ptr);
+   tmp = *ptr;
+   (*ptr)-= value;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint64
+SDL_AtomicIncrementThenFetch64(volatile Uint64 * ptr)
+{
+#ifdef nativeIncrementThenFetch64
+#else
+   Uint64 tmp = 0;
+
+   privateWaitLock(ptr);
+   (*ptr)+= 1;
+   tmp = *ptr;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint64
+SDL_AtomicDecrementThenFetch64(volatile Uint64 * ptr)
+{
+#ifdef nativeDecrementThenFetch64
+#else
+   Uint64 tmp = 0;
+
+   privateWaitLock(ptr);
+   (*ptr)-= 1;
+   tmp = *ptr;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint64
+SDL_AtomicAddThenFetch64(volatile Uint64 * ptr, Uint64 value)
+{
+#ifdef nativeAddThenFetch64
+#else
+   Uint64 tmp = 0;
+
+   privateWaitLock(ptr);
+   (*ptr)+= value;
+   tmp = *ptr;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+
+Uint64
+SDL_AtomicSubtractThenFetch64(volatile Uint64 * ptr, Uint64 value)
+{
+#ifdef nativeSubtractThenFetch64
+#else
+   Uint64 tmp = 0;
+
+   privateWaitLock(ptr);
+   (*ptr)-= value;
+   tmp = *ptr;
+   privateUnlock(ptr);
+
+   return tmp;
+#endif
+}
+#endif
+

Externals/SDL/src/audio/SDL_audio_c.h

@@ -0,0 +1,56 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* Functions and variables exported from SDL_audio.c for SDL_sysaudio.c */
+
+/* Functions to get a list of "close" audio formats */
+extern SDL_AudioFormat SDL_FirstAudioFormat(SDL_AudioFormat format);
+extern SDL_AudioFormat SDL_NextAudioFormat(void);
+
+/* Function to calculate the size and silence for a SDL_AudioSpec */
+extern void SDL_CalculateAudioSpec(SDL_AudioSpec * spec);
+
+/* The actual mixing thread function */
+extern int SDLCALL SDL_RunAudio(void *audiop);
+
+/* this is used internally to access some autogenerated code. */
+typedef struct
+{
+    SDL_AudioFormat src_fmt;
+    SDL_AudioFormat dst_fmt;
+    SDL_AudioFilter filter;
+} SDL_AudioTypeFilters;
+extern const SDL_AudioTypeFilters sdl_audio_type_filters[];
+
+/* this is used internally to access some autogenerated code. */
+typedef struct
+{
+    SDL_AudioFormat fmt;
+    int channels;
+    int upsample;
+    int multiple;
+    SDL_AudioFilter filter;
+} SDL_AudioRateFilters;
+extern const SDL_AudioRateFilters sdl_audio_rate_filters[];
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/SDL_audiodev.c

@@ -0,0 +1,138 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* Get the name of the audio device we use for output */
+
+#if SDL_AUDIO_DRIVER_BSD || SDL_AUDIO_DRIVER_OSS || SDL_AUDIO_DRIVER_SUNAUDIO
+
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include "SDL_stdinc.h"
+#include "SDL_audiodev_c.h"
+
+#ifndef _PATH_DEV_DSP
+#if defined(__NETBSD__) || defined(__OPENBSD__)
+#define _PATH_DEV_DSP  "/dev/audio"
+#else
+#define _PATH_DEV_DSP  "/dev/dsp"
+#endif
+#endif
+#ifndef _PATH_DEV_DSP24
+#define _PATH_DEV_DSP24	"/dev/sound/dsp"
+#endif
+#ifndef _PATH_DEV_AUDIO
+#define _PATH_DEV_AUDIO	"/dev/audio"
+#endif
+
+static inline void
+test_device(const char *fname, int flags, int (*test) (int fd),
+            char ***devices, int *devCount)
+{
+    struct stat sb;
+    if ((stat(fname, &sb) == 0) && (S_ISCHR(sb.st_mode))) {
+        int audio_fd = open(fname, flags, 0);
+        if ((audio_fd >= 0) && (test(audio_fd))) {
+            void *p =
+                SDL_realloc(*devices, ((*devCount) + 1) * sizeof(char *));
+            if (p != NULL) {
+                size_t len = strlen(fname) + 1;
+                char *str = (char *) SDL_malloc(len);
+                *devices = (char **) p;
+                if (str != NULL) {
+                    SDL_strlcpy(str, fname, len);
+                    (*devices)[(*devCount)++] = str;
+                }
+            }
+            close(audio_fd);
+        }
+    }
+}
+
+void
+SDL_FreeUnixAudioDevices(char ***devices, int *devCount)
+{
+    int i = *devCount;
+    if ((i > 0) && (*devices != NULL)) {
+        while (i--) {
+            SDL_free((*devices)[i]);
+        }
+    }
+
+    if (*devices != NULL) {
+        SDL_free(*devices);
+    }
+
+    *devices = NULL;
+    *devCount = 0;
+}
+
+static int
+test_stub(int fd)
+{
+    return 1;
+}
+
+void
+SDL_EnumUnixAudioDevices(int flags, int classic, int (*test) (int fd),
+                         char ***devices, int *devCount)
+{
+    const char *audiodev;
+    char audiopath[1024];
+
+    if (test == NULL)
+        test = test_stub;
+
+    /* Figure out what our audio device is */
+    if (((audiodev = SDL_getenv("SDL_PATH_DSP")) == NULL) &&
+        ((audiodev = SDL_getenv("AUDIODEV")) == NULL)) {
+        if (classic) {
+            audiodev = _PATH_DEV_AUDIO;
+        } else {
+            struct stat sb;
+
+            /* Added support for /dev/sound/\* in Linux 2.4 */
+            if (((stat("/dev/sound", &sb) == 0) && S_ISDIR(sb.st_mode))
+                && ((stat(_PATH_DEV_DSP24, &sb) == 0)
+                    && S_ISCHR(sb.st_mode))) {
+                audiodev = _PATH_DEV_DSP24;
+            } else {
+                audiodev = _PATH_DEV_DSP;
+            }
+        }
+    }
+    test_device(audiodev, flags, test, devices, devCount);
+
+    if (SDL_strlen(audiodev) < (sizeof(audiopath) - 3)) {
+        int instance = 0;
+        while (instance++ <= 64) {
+            SDL_snprintf(audiopath, SDL_arraysize(audiopath),
+                         "%s%d", audiodev, instance);
+            test_device(audiopath, flags, test, devices, devCount);
+        }
+    }
+}
+
+#endif /* Audio driver selection */
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/SDL_audiodev_c.h

@@ -0,0 +1,28 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+void SDL_EnumUnixAudioDevices(int flags, int classic, int (*test) (int fd),
+                              char ***devs, int *count);
+void SDL_FreeUnixAudioDevices(char ***devices, int *devCount);
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/SDL_audiomem.h

@@ -0,0 +1,26 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#define SDL_AllocAudioMem	SDL_malloc
+#define SDL_FreeAudioMem	SDL_free
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/SDL_mixer.c

@@ -0,0 +1,361 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* This provides the default mixing callback for the SDL audio routines */
+
+#include "SDL_cpuinfo.h"
+#include "SDL_timer.h"
+#include "SDL_audio.h"
+#include "SDL_sysaudio.h"
+#include "SDL_mixer_MMX.h"
+#include "SDL_mixer_MMX_VC.h"
+#include "SDL_mixer_m68k.h"
+
+/* This table is used to add two sound values together and pin
+ * the value to avoid overflow.  (used with permission from ARDI)
+ * Changed to use 0xFE instead of 0xFF for better sound quality.
+ */
+static const Uint8 mix8[] = {
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03,
+    0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E,
+    0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19,
+    0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24,
+    0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,
+    0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A,
+    0x3B, 0x3C, 0x3D, 0x3E, 0x3F, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45,
+    0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50,
+    0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B,
+    0x5C, 0x5D, 0x5E, 0x5F, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
+    0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71,
+    0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C,
+    0x7D, 0x7E, 0x7F, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+    0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92,
+    0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D,
+    0x9E, 0x9F, 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8,
+    0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3,
+    0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE,
+    0xBF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9,
+    0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4,
+    0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF,
+    0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA,
+    0xEB, 0xEC, 0xED, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5,
+    0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFE, 0xFE,
+    0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
+    0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
+    0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
+    0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
+    0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
+    0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
+    0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
+    0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
+    0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
+    0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
+    0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
+    0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE
+};
+
+/* The volume ranges from 0 - 128 */
+#define ADJUST_VOLUME(s, v)	(s = (s*v)/SDL_MIX_MAXVOLUME)
+#define ADJUST_VOLUME_U8(s, v)	(s = (((s-128)*v)/SDL_MIX_MAXVOLUME)+128)
+
+
+void
+SDL_MixAudioFormat(Uint8 * dst, const Uint8 * src, SDL_AudioFormat format,
+                   Uint32 len, int volume)
+{
+    if (volume == 0) {
+        return;
+    }
+
+    switch (format) {
+
+    case AUDIO_U8:
+        {
+#if defined(__GNUC__) && defined(__M68000__) && defined(SDL_ASSEMBLY_ROUTINES)
+            SDL_MixAudio_m68k_U8((char *) dst, (char *) src,
+                                 (unsigned long) len, (long) volume,
+                                 (char *) mix8);
+#else
+            Uint8 src_sample;
+
+            while (len--) {
+                src_sample = *src;
+                ADJUST_VOLUME_U8(src_sample, volume);
+                *dst = mix8[*dst + src_sample];
+                ++dst;
+                ++src;
+            }
+#endif
+        }
+        break;
+
+    case AUDIO_S8:
+        {
+#if defined(__GNUC__) && defined(__i386__) && defined(SDL_ASSEMBLY_ROUTINES)
+            if (SDL_HasMMX()) {
+                SDL_MixAudio_MMX_S8((char *) dst, (char *) src,
+                                    (unsigned int) len, (int) volume);
+            } else
+#elif ((defined(_MSC_VER) && defined(_M_IX86)) || defined(__WATCOMC__)) && defined(SDL_ASSEMBLY_ROUTINES)
+            if (SDL_HasMMX()) {
+                SDL_MixAudio_MMX_S8_VC((char *) dst, (char *) src,
+                                       (unsigned int) len, (int) volume);
+            } else
+#endif
+#if defined(__GNUC__) && defined(__M68000__) && defined(SDL_ASSEMBLY_ROUTINES)
+                SDL_MixAudio_m68k_S8((char *) dst, (char *) src,
+                                     (unsigned long) len, (long) volume);
+#else
+            {
+                Sint8 *dst8, *src8;
+                Sint8 src_sample;
+                int dst_sample;
+                const int max_audioval = ((1 << (8 - 1)) - 1);
+                const int min_audioval = -(1 << (8 - 1));
+
+                src8 = (Sint8 *) src;
+                dst8 = (Sint8 *) dst;
+                while (len--) {
+                    src_sample = *src8;
+                    ADJUST_VOLUME(src_sample, volume);
+                    dst_sample = *dst8 + src_sample;
+                    if (dst_sample > max_audioval) {
+                        *dst8 = max_audioval;
+                    } else if (dst_sample < min_audioval) {
+                        *dst8 = min_audioval;
+                    } else {
+                        *dst8 = dst_sample;
+                    }
+                    ++dst8;
+                    ++src8;
+                }
+            }
+#endif
+        }
+        break;
+
+    case AUDIO_S16LSB:
+        {
+#if defined(__GNUC__) && defined(__i386__) && defined(SDL_ASSEMBLY_ROUTINES)
+            if (SDL_HasMMX()) {
+                SDL_MixAudio_MMX_S16((char *) dst, (char *) src,
+                                     (unsigned int) len, (int) volume);
+            } else
+#elif ((defined(_MSC_VER) && defined(_M_IX86)) || defined(__WATCOMC__)) && defined(SDL_ASSEMBLY_ROUTINES)
+            if (SDL_HasMMX()) {
+                SDL_MixAudio_MMX_S16_VC((char *) dst, (char *) src,
+                                        (unsigned int) len, (int) volume);
+            } else
+#endif
+#if defined(__GNUC__) && defined(__M68000__) && defined(SDL_ASSEMBLY_ROUTINES)
+                SDL_MixAudio_m68k_S16LSB((short *) dst, (short *) src,
+                                         (unsigned long) len, (long) volume);
+#else
+            {
+                Sint16 src1, src2;
+                int dst_sample;
+                const int max_audioval = ((1 << (16 - 1)) - 1);
+                const int min_audioval = -(1 << (16 - 1));
+
+                len /= 2;
+                while (len--) {
+                    src1 = ((src[1]) << 8 | src[0]);
+                    ADJUST_VOLUME(src1, volume);
+                    src2 = ((dst[1]) << 8 | dst[0]);
+                    src += 2;
+                    dst_sample = src1 + src2;
+                    if (dst_sample > max_audioval) {
+                        dst_sample = max_audioval;
+                    } else if (dst_sample < min_audioval) {
+                        dst_sample = min_audioval;
+                    }
+                    dst[0] = dst_sample & 0xFF;
+                    dst_sample >>= 8;
+                    dst[1] = dst_sample & 0xFF;
+                    dst += 2;
+                }
+            }
+#endif
+        }
+        break;
+
+    case AUDIO_S16MSB:
+        {
+#if defined(__GNUC__) && defined(__M68000__) && defined(SDL_ASSEMBLY_ROUTINES)
+            SDL_MixAudio_m68k_S16MSB((short *) dst, (short *) src,
+                                     (unsigned long) len, (long) volume);
+#else
+            Sint16 src1, src2;
+            int dst_sample;
+            const int max_audioval = ((1 << (16 - 1)) - 1);
+            const int min_audioval = -(1 << (16 - 1));
+
+            len /= 2;
+            while (len--) {
+                src1 = ((src[0]) << 8 | src[1]);
+                ADJUST_VOLUME(src1, volume);
+                src2 = ((dst[0]) << 8 | dst[1]);
+                src += 2;
+                dst_sample = src1 + src2;
+                if (dst_sample > max_audioval) {
+                    dst_sample = max_audioval;
+                } else if (dst_sample < min_audioval) {
+                    dst_sample = min_audioval;
+                }
+                dst[1] = dst_sample & 0xFF;
+                dst_sample >>= 8;
+                dst[0] = dst_sample & 0xFF;
+                dst += 2;
+            }
+#endif
+        }
+        break;
+
+    case AUDIO_S32LSB:
+        {
+            const Uint32 *src32 = (Uint32 *) src;
+            Uint32 *dst32 = (Uint32 *) dst;
+            Sint64 src1, src2;
+            Sint64 dst_sample;
+            const Sint64 max_audioval = ((((Sint64) 1) << (32 - 1)) - 1);
+            const Sint64 min_audioval = -(((Sint64) 1) << (32 - 1));
+
+            len /= 4;
+            while (len--) {
+                src1 = (Sint64) ((Sint32) SDL_SwapLE32(*src32));
+                src32++;
+                ADJUST_VOLUME(src1, volume);
+                src2 = (Sint64) ((Sint32) SDL_SwapLE32(*dst32));
+                dst_sample = src1 + src2;
+                if (dst_sample > max_audioval) {
+                    dst_sample = max_audioval;
+                } else if (dst_sample < min_audioval) {
+                    dst_sample = min_audioval;
+                }
+                *(dst32++) = SDL_SwapLE32((Uint32) ((Sint32) dst_sample));
+            }
+        }
+        break;
+
+    case AUDIO_S32MSB:
+        {
+            const Uint32 *src32 = (Uint32 *) src;
+            Uint32 *dst32 = (Uint32 *) dst;
+            Sint64 src1, src2;
+            Sint64 dst_sample;
+            const Sint64 max_audioval = ((((Sint64) 1) << (32 - 1)) - 1);
+            const Sint64 min_audioval = -(((Sint64) 1) << (32 - 1));
+
+            len /= 4;
+            while (len--) {
+                src1 = (Sint64) ((Sint32) SDL_SwapBE32(*src32));
+                src32++;
+                ADJUST_VOLUME(src1, volume);
+                src2 = (Sint64) ((Sint32) SDL_SwapBE32(*dst32));
+                dst_sample = src1 + src2;
+                if (dst_sample > max_audioval) {
+                    dst_sample = max_audioval;
+                } else if (dst_sample < min_audioval) {
+                    dst_sample = min_audioval;
+                }
+                *(dst32++) = SDL_SwapBE32((Uint32) ((Sint32) dst_sample));
+            }
+        }
+        break;
+
+    case AUDIO_F32LSB:
+        {
+            const float fmaxvolume = 1.0f / ((float) SDL_MIX_MAXVOLUME);
+            const float fvolume = (float) volume;
+            const float *src32 = (float *) src;
+            float *dst32 = (float *) dst;
+            float src1, src2;
+            double dst_sample;
+            /* !!! FIXME: are these right? */
+            const double max_audioval = 3.402823466e+38F;
+            const double min_audioval = -3.402823466e+38F;
+
+            len /= 4;
+            while (len--) {
+                src1 = ((SDL_SwapFloatLE(*src32) * fvolume) * fmaxvolume);
+                src2 = SDL_SwapFloatLE(*dst32);
+                src32++;
+
+                dst_sample = ((double) src1) + ((double) src2);
+                if (dst_sample > max_audioval) {
+                    dst_sample = max_audioval;
+                } else if (dst_sample < min_audioval) {
+                    dst_sample = min_audioval;
+                }
+                *(dst32++) = SDL_SwapFloatLE((float) dst_sample);
+            }
+        }
+        break;
+
+    case AUDIO_F32MSB:
+        {
+            const float fmaxvolume = 1.0f / ((float) SDL_MIX_MAXVOLUME);
+            const float fvolume = (float) volume;
+            const float *src32 = (float *) src;
+            float *dst32 = (float *) dst;
+            float src1, src2;
+            double dst_sample;
+            /* !!! FIXME: are these right? */
+            const double max_audioval = 3.402823466e+38F;
+            const double min_audioval = -3.402823466e+38F;
+
+            len /= 4;
+            while (len--) {
+                src1 = ((SDL_SwapFloatBE(*src32) * fvolume) * fmaxvolume);
+                src2 = SDL_SwapFloatBE(*dst32);
+                src32++;
+
+                dst_sample = ((double) src1) + ((double) src2);
+                if (dst_sample > max_audioval) {
+                    dst_sample = max_audioval;
+                } else if (dst_sample < min_audioval) {
+                    dst_sample = min_audioval;
+                }
+                *(dst32++) = SDL_SwapFloatBE((float) dst_sample);
+            }
+        }
+        break;
+
+    default:                   /* If this happens... FIXME! */
+        SDL_SetError("SDL_MixAudio(): unknown audio format");
+        return;
+    }
+}
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/SDL_mixer_MMX.c

@@ -0,0 +1,120 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/*
+    MMX assembler version of SDL_MixAudio for signed little endian 16 bit samples and signed 8 bit samples
+    Copyright 2002 Stephane Marchesin (stephane.marchesin@wanadoo.fr)
+    This code is licensed under the LGPL (see COPYING for details)
+ 
+    Assumes buffer size in bytes is a multiple of 16
+    Assumes SDL_MIX_MAXVOLUME = 128
+*/
+
+
+/***********************************************
+*   Mixing for 16 bit signed buffers
+***********************************************/
+
+#if defined(__GNUC__) && defined(__i386__) && defined(SDL_ASSEMBLY_ROUTINES)
+void
+SDL_MixAudio_MMX_S16(char *dst, char *src, unsigned int size, int volume)
+{
+    __asm__ __volatile__("	movl %3,%%eax\n"        /* eax = volume */
+                         "	movl %2,%%edx\n"        /* edx = size */
+                         "	shrl $4,%%edx\n"        /* process 16 bytes per iteration = 8 samples */
+                         "	jz .endS16\n" "	pxor %%mm0,%%mm0\n" "	movd %%eax,%%mm0\n" "	movq %%mm0,%%mm1\n" "	psllq $16,%%mm0\n" "	por %%mm1,%%mm0\n" "	psllq $16,%%mm0\n" "	por %%mm1,%%mm0\n" "	psllq $16,%%mm0\n" "	por %%mm1,%%mm0\n"      /* mm0 = vol|vol|vol|vol */
+                         ".align 8\n" "	.mixloopS16:\n" "	movq (%1),%%mm1\n"      /* mm1 = a|b|c|d */
+                         "	movq %%mm1,%%mm2\n"     /* mm2 = a|b|c|d */
+                         "	movq 8(%1),%%mm4\n"     /* mm4 = e|f|g|h */
+                         /* pr<70> charger le buffer dst dans mm7 */
+                         "	movq (%0),%%mm7\n"      /* mm7 = dst[0] */
+                         /* multiplier par le volume */
+                         "	pmullw %%mm0,%%mm1\n"   /* mm1 = l(a*v)|l(b*v)|l(c*v)|l(d*v) */
+                         "	pmulhw %%mm0,%%mm2\n"   /* mm2 = h(a*v)|h(b*v)|h(c*v)|h(d*v) */
+                         "	movq %%mm4,%%mm5\n"     /* mm5 = e|f|g|h */
+                         "	pmullw %%mm0,%%mm4\n"   /* mm4 = l(e*v)|l(f*v)|l(g*v)|l(h*v) */
+                         "	pmulhw %%mm0,%%mm5\n"   /* mm5 = h(e*v)|h(f*v)|h(g*v)|h(h*v) */
+                         "	movq %%mm1,%%mm3\n"     /* mm3 = l(a*v)|l(b*v)|l(c*v)|l(d*v) */
+                         "	punpckhwd %%mm2,%%mm1\n"        /* mm1 = a*v|b*v */
+                         "	movq %%mm4,%%mm6\n"     /* mm6 = l(e*v)|l(f*v)|l(g*v)|l(h*v) */
+                         "	punpcklwd %%mm2,%%mm3\n"        /* mm3 = c*v|d*v */
+                         "	punpckhwd %%mm5,%%mm4\n"        /* mm4 = e*f|f*v */
+                         "	punpcklwd %%mm5,%%mm6\n"        /* mm6 = g*v|h*v */
+                         /* pr<70> charger le buffer dst dans mm5 */
+                         "	movq 8(%0),%%mm5\n"     /* mm5 = dst[1] */
+                         /* diviser par 128 */
+                         "	psrad $7,%%mm1\n"       /* mm1 = a*v/128|b*v/128 , 128 = SDL_MIX_MAXVOLUME */
+                         "	add $16,%1\n" "	psrad $7,%%mm3\n"       /* mm3 = c*v/128|d*v/128 */
+                         "	psrad $7,%%mm4\n"       /* mm4 = e*v/128|f*v/128 */
+                         /* mm1 = le sample avec le volume modifi<66> */
+                         "	packssdw %%mm1,%%mm3\n" /* mm3 = s(a*v|b*v|c*v|d*v) */
+                         "	psrad $7,%%mm6\n"       /* mm6= g*v/128|h*v/128 */
+                         "	paddsw %%mm7,%%mm3\n"   /* mm3 = adjust_volume(src)+dst */
+                         /* mm4 = le sample avec le volume modifi<66> */
+                         "	packssdw %%mm4,%%mm6\n" /* mm6 = s(e*v|f*v|g*v|h*v) */
+                         "	movq %%mm3,(%0)\n" "	paddsw %%mm5,%%mm6\n"   /* mm6 = adjust_volume(src)+dst */
+                         "	movq %%mm6,8(%0)\n"
+                         "	add $16,%0\n"
+                         "	dec %%edx\n"
+                         "	jnz .mixloopS16\n"
+                         "	emms\n"
+                         ".endS16:\n"::"r"(dst), "r"(src),
+                         "m"(size), "m"(volume):"eax", "edx", "memory");
+}
+
+
+
+/*////////////////////////////////////////////// */
+/* Mixing for 8 bit signed buffers */
+/*////////////////////////////////////////////// */
+
+void
+SDL_MixAudio_MMX_S8(char *dst, char *src, unsigned int size, int volume)
+{
+    __asm__ __volatile__("	movl %3,%%eax\n"        /* eax = volume */
+                         "	movd %%eax,%%mm0\n" "	movq %%mm0,%%mm1\n" "	psllq $16,%%mm0\n" "	por %%mm1,%%mm0\n" "	psllq $16,%%mm0\n" "	por %%mm1,%%mm0\n" "	psllq $16,%%mm0\n" "	por %%mm1,%%mm0\n" "	movl %2,%%edx\n"        /* edx = size */
+                         "	shr $3,%%edx\n" /* process 8 bytes per iteration = 8 samples */
+                         "	cmp $0,%%edx\n" "	je .endS8\n" ".align 8\n" "	.mixloopS8:\n" "	pxor %%mm2,%%mm2\n"     /* mm2 = 0 */
+                         "	movq (%1),%%mm1\n"      /* mm1 = a|b|c|d|e|f|g|h */
+                         "	movq %%mm1,%%mm3\n"     /* mm3 = a|b|c|d|e|f|g|h */
+                         /* on va faire le "sign extension" en faisant un cmp avec 0 qui retourne 1 si <0, 0 si >0 */
+                         "	pcmpgtb %%mm1,%%mm2\n"  /* mm2 = 11111111|00000000|00000000.... */
+                         "	punpckhbw %%mm2,%%mm1\n"        /* mm1 = 0|a|0|b|0|c|0|d */
+                         "	punpcklbw %%mm2,%%mm3\n"        /* mm3 = 0|e|0|f|0|g|0|h */
+                         "	movq (%0),%%mm2\n"      /* mm2 = destination */
+                         "	pmullw %%mm0,%%mm1\n"   /* mm1 = v*a|v*b|v*c|v*d */
+                         "	add $8,%1\n" "	pmullw %%mm0,%%mm3\n"   /* mm3 = v*e|v*f|v*g|v*h */
+                         "	psraw $7,%%mm1\n"       /* mm1 = v*a/128|v*b/128|v*c/128|v*d/128  */
+                         "	psraw $7,%%mm3\n"       /* mm3 = v*e/128|v*f/128|v*g/128|v*h/128 */
+                         "	packsswb %%mm1,%%mm3\n" /* mm1 = v*a/128|v*b/128|v*c/128|v*d/128|v*e/128|v*f/128|v*g/128|v*h/128 */
+                         "	paddsb %%mm2,%%mm3\n"   /* add to destination buffer */
+                         "	movq %%mm3,(%0)\n"      /* store back to ram */
+                         "	add $8,%0\n"
+                         "	dec %%edx\n"
+                         "	jnz .mixloopS8\n"
+                         ".endS8:\n"
+                         "	emms\n"::"r"(dst), "r"(src), "m"(size),
+                         "m"(volume):"eax", "edx", "memory");
+}
+#endif
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/SDL_mixer_MMX.h

@@ -0,0 +1,15 @@
+/*
+    headers for MMX assembler version of SDL_MixAudio
+    Copyright 2002 Stephane Marchesin (stephane.marchesin@wanadoo.fr)
+    This code is licensed under the LGPL (see COPYING for details)
+
+    Assumes buffer size in bytes is a multiple of 16
+    Assumes SDL_MIX_MAXVOLUME = 128
+*/
+#include "SDL_config.h"
+
+#if defined(__GNUC__) && defined(__i386__) && defined(SDL_ASSEMBLY_ROUTINES)
+void SDL_MixAudio_MMX_S16(char *, char *, unsigned int, int);
+void SDL_MixAudio_MMX_S8(char *, char *, unsigned int, int);
+#endif
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/SDL_mixer_MMX_VC.c

@@ -0,0 +1,188 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#include "SDL_mixer_MMX_VC.h"
+
+#if ((defined(_MSC_VER) && defined(_M_IX86)) || defined(__WATCOMC__)) && defined(SDL_ASSEMBLY_ROUTINES)
+// MMX assembler version of SDL_MixAudio for signed little endian 16 bit samples and signed 8 bit samples
+// Copyright 2002 Stephane Marchesin (stephane.marchesin@wanadoo.fr)
+// Converted to Intel ASM notation by Cth
+// This code is licensed under the LGPL (see COPYING for details)
+// 
+// Assumes buffer size in bytes is a multiple of 16
+// Assumes SDL_MIX_MAXVOLUME = 128
+
+
+////////////////////////////////////////////////
+// Mixing for 16 bit signed buffers
+////////////////////////////////////////////////
+
+void
+SDL_MixAudio_MMX_S16_VC(char *dst, char *src, unsigned int nSize, int volume)
+{
+    /* *INDENT-OFF* */
+	__asm
+	{
+
+		push	edi
+		push	esi
+		push	ebx
+		
+		mov		edi, dst		// edi = dst
+		mov		esi, src		// esi = src
+		mov		eax, volume		// eax = volume
+		mov		ebx, nSize		// ebx = size
+		shr		ebx, 4			// process 16 bytes per iteration = 8 samples
+		jz		endS16
+		
+		pxor	mm0, mm0
+		movd	mm0, eax		//%%eax,%%mm0
+		movq	mm1, mm0		//%%mm0,%%mm1
+		psllq	mm0, 16			//$16,%%mm0
+		por		mm0, mm1		//%%mm1,%%mm0
+		psllq	mm0, 16			//$16,%%mm0
+		por		mm0, mm1		//%%mm1,%%mm0
+		psllq	mm0, 16			//$16,%%mm0
+		por		mm0, mm1		//%%mm1,%%mm0			// mm0 = vol|vol|vol|vol
+
+		#ifndef __WATCOMC__
+		align	16
+		#endif
+mixloopS16:
+		movq	mm1, [esi]		//(%%esi),%%mm1\n" // mm1 = a|b|c|d
+		movq	mm2, mm1		//%%mm1,%%mm2\n" // mm2 = a|b|c|d
+		movq	mm4, [esi + 8]	//8(%%esi),%%mm4\n" // mm4 = e|f|g|h
+		// pre charger le buffer dst dans mm7
+		movq	mm7, [edi]		//(%%edi),%%mm7\n" // mm7 = dst[0]"
+		// multiplier par le volume
+		pmullw	mm1, mm0		//%%mm0,%%mm1\n" // mm1 = l(a*v)|l(b*v)|l(c*v)|l(d*v)
+		pmulhw	mm2, mm0		//%%mm0,%%mm2\n" // mm2 = h(a*v)|h(b*v)|h(c*v)|h(d*v)
+		movq	mm5, mm4		//%%mm4,%%mm5\n" // mm5 = e|f|g|h
+		pmullw	mm4, mm0		//%%mm0,%%mm4\n" // mm4 = l(e*v)|l(f*v)|l(g*v)|l(h*v)
+		pmulhw	mm5, mm0		//%%mm0,%%mm5\n" // mm5 = h(e*v)|h(f*v)|h(g*v)|h(h*v)
+		movq	mm3, mm1		//%%mm1,%%mm3\n" // mm3 = l(a*v)|l(b*v)|l(c*v)|l(d*v)
+		punpckhwd	mm1, mm2	//%%mm2,%%mm1\n" // mm1 = a*v|b*v
+		movq		mm6, mm4	//%%mm4,%%mm6\n" // mm6 = l(e*v)|l(f*v)|l(g*v)|l(h*v)
+		punpcklwd	mm3, mm2	//%%mm2,%%mm3\n" // mm3 = c*v|d*v
+		punpckhwd	mm4, mm5	//%%mm5,%%mm4\n" // mm4 = e*f|f*v
+		punpcklwd	mm6, mm5	//%%mm5,%%mm6\n" // mm6 = g*v|h*v
+		// pre charger le buffer dst dans mm5
+		movq	mm5, [edi + 8]	//8(%%edi),%%mm5\n" // mm5 = dst[1]
+		// diviser par 128
+		psrad	mm1, 7			//$7,%%mm1\n" // mm1 = a*v/128|b*v/128 , 128 = SDL_MIX_MAXVOLUME
+		add		esi, 16			//$16,%%esi\n"
+		psrad	mm3, 7			//$7,%%mm3\n" // mm3 = c*v/128|d*v/128
+		psrad	mm4, 7			//$7,%%mm4\n" // mm4 = e*v/128|f*v/128
+		// mm1 = le sample avec le volume modifie
+		packssdw	mm3, mm1	//%%mm1,%%mm3\n" // mm3 = s(a*v|b*v|c*v|d*v)
+		psrad	mm6, 7			//$7,%%mm6\n" // mm6= g*v/128|h*v/128
+		paddsw	mm3, mm7		//%%mm7,%%mm3\n" // mm3 = adjust_volume(src)+dst
+		// mm4 = le sample avec le volume modifie
+		packssdw	mm6, mm4	//%%mm4,%%mm6\n" // mm6 = s(e*v|f*v|g*v|h*v)
+		movq	[edi], mm3		//%%mm3,(%%edi)\n"
+		paddsw	mm6, mm5		//%%mm5,%%mm6\n" // mm6 = adjust_volume(src)+dst
+		movq	[edi + 8], mm6	//%%mm6,8(%%edi)\n"
+		add		edi, 16			//$16,%%edi\n"
+		dec		ebx				//%%ebx\n"
+		jnz mixloopS16
+
+endS16:
+		emms
+		
+		pop		ebx
+		pop		esi
+		pop		edi
+	}
+    /* *INDENT-ON* */
+}
+
+////////////////////////////////////////////////
+// Mixing for 8 bit signed buffers
+////////////////////////////////////////////////
+
+void
+SDL_MixAudio_MMX_S8_VC(char *dst, char *src, unsigned int nSize, int volume)
+{
+    /* *INDENT-OFF* */
+	_asm
+	{
+
+		push	edi
+		push	esi
+		push	ebx
+		
+		mov		edi, dst	//movl	%0,%%edi	// edi = dst
+		mov		esi, src	//%1,%%esi	// esi = src
+		mov		eax, volume	//%3,%%eax	// eax = volume
+
+		movd	mm0, eax	//%%eax,%%mm0
+		movq	mm1, mm0	//%%mm0,%%mm1
+		psllq	mm0, 16		//$16,%%mm0
+		por		mm0, mm1	//%%mm1,%%mm0
+		psllq	mm0, 16		//$16,%%mm0
+		por		mm0, mm1	//%%mm1,%%mm0
+		psllq	mm0, 16		//$16,%%mm0
+		por		mm0, mm1	//%%mm1,%%mm0
+		
+		mov		ebx, nSize	//%2,%%ebx	// ebx = size
+		shr		ebx, 3		//$3,%%ebx	// process 8 bytes per iteration = 8 samples
+		cmp		ebx, 0		//$0,%%ebx
+		je		endS8
+
+		#ifndef __WATCOMC__
+		align 16
+		#endif
+mixloopS8:
+		pxor	mm2, mm2	//%%mm2,%%mm2		// mm2 = 0
+		movq	mm1, [esi]	//(%%esi),%%mm1	// mm1 = a|b|c|d|e|f|g|h
+		movq	mm3, mm1	//%%mm1,%%mm3 	// mm3 = a|b|c|d|e|f|g|h
+		// on va faire le "sign extension" en faisant un cmp avec 0 qui retourne 1 si <0, 0 si >0
+		pcmpgtb		mm2, mm1	//%%mm1,%%mm2	// mm2 = 11111111|00000000|00000000....
+		punpckhbw	mm1, mm2	//%%mm2,%%mm1	// mm1 = 0|a|0|b|0|c|0|d
+		punpcklbw	mm3, mm2	//%%mm2,%%mm3	// mm3 = 0|e|0|f|0|g|0|h
+		movq	mm2, [edi]	//(%%edi),%%mm2	// mm2 = destination
+		pmullw	mm1, mm0	//%%mm0,%%mm1	// mm1 = v*a|v*b|v*c|v*d
+		add		esi, 8		//$8,%%esi
+		pmullw	mm3, mm0	//%%mm0,%%mm3	// mm3 = v*e|v*f|v*g|v*h
+		psraw	mm1, 7		//$7,%%mm1		// mm1 = v*a/128|v*b/128|v*c/128|v*d/128 
+		psraw	mm3, 7		//$7,%%mm3		// mm3 = v*e/128|v*f/128|v*g/128|v*h/128
+		packsswb mm3, mm1	//%%mm1,%%mm3	// mm1 = v*a/128|v*b/128|v*c/128|v*d/128|v*e/128|v*f/128|v*g/128|v*h/128
+		paddsb	mm3, mm2	//%%mm2,%%mm3	// add to destination buffer
+		movq	[edi], mm3	//%%mm3,(%%edi)	// store back to ram
+		add		edi, 8		//$8,%%edi
+		dec		ebx			//%%ebx
+		jnz		mixloopS8
+		
+endS8:
+		emms
+		
+		pop		ebx
+		pop		esi
+		pop		edi
+	}
+    /* *INDENT-ON* */
+}
+
+#endif /* SDL_ASSEMBLY_ROUTINES */
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/SDL_mixer_MMX_VC.h

@@ -0,0 +1,37 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+
+#if ((defined(_MSC_VER) && defined(_M_IX86)) || defined(__WATCOMC__)) && defined(SDL_ASSEMBLY_ROUTINES)
+/* headers for MMX assembler version of SDL_MixAudio
+   Copyright 2002 Stephane Marchesin (stephane.marchesin@wanadoo.fr)
+   Converted to Intel ASM notation by Cth
+   This code is licensed under the LGPL (see COPYING for details)
+   
+   Assumes buffer size in bytes is a multiple of 16
+   Assumes SDL_MIX_MAXVOLUME = 128
+*/
+void SDL_MixAudio_MMX_S16_VC(char *, char *, unsigned int, int);
+void SDL_MixAudio_MMX_S8_VC(char *, char *, unsigned int, int);
+#endif
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/SDL_mixer_m68k.c

@@ -0,0 +1,140 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/*
+	m68k assembly mix routines
+
+	Patrice Mandin
+*/
+
+#if defined(__M68000__) && defined(__GNUC__)
+void
+SDL_MixAudio_m68k_U8(char *dst, char *src, long len, long volume, char *mix8)
+{
+    __asm__ __volatile__("tstl	%2\n" "	beqs	stoploop_u8\n" "mixloop_u8:\n"
+                         /* Mix a sample */
+                         "	moveq	#0,%%d0\n" "	moveq	#0,%%d1\n" "	moveb	%1@+,%%d0\n"    /* d0 = *src++ */
+                         "	sub	#128,%%d0\n"    /* d0 -= 128 */
+                         "	muls	%3,%%d0\n"      /* d0 *= volume (0<=volume<=128) */
+                         "	moveb	%0@,%%d1\n"     /* d1 = *dst */
+                         "	asr	#7,%%d0\n"      /* d0 /= 128 (SDL_MIX_MAXVOLUME) */
+                         "	add	#128,%%d0\n"    /* d0 += 128 */
+                         "	add	%%d1,%%d0\n"
+                         "	moveb	%4@(%%d0:w),%0@+\n"
+                         /* Loop till done */
+                         "	subql	#1,%2\n" "	bhis	mixloop_u8\n" "stoploop_u8:\n": /* no return value */
+                         :      /* input */
+                         "a"(dst), "a"(src), "d"(len), "d"(volume), "a"(mix8):  /* clobbered registers */
+                         "d0", "d1", "cc", "memory");
+}
+
+void
+SDL_MixAudio_m68k_S8(char *dst, char *src, long len, long volume)
+{
+    __asm__ __volatile__("tstl	%2\n"
+                         "	beqs	stoploop_s8\n"
+                         "	moveq	#-128,%%d2\n"
+                         "	moveq	#127,%%d3\n" "mixloop_s8:\n"
+                         /* Mix a sample */
+                         "	moveq	#0,%%d0\n" "	moveq	#0,%%d1\n" "	moveb	%1@+,%%d0\n"    /* d0 = *src++ */
+                         "	muls	%3,%%d0\n"      /* d0 *= volume (0<=volume<=128) */
+                         "	moveb	%0@,%%d1\n"     /* d1 = *dst */
+                         "	asr	#7,%%d0\n"      /* d0 /= 128 (SDL_MIX_MAXVOLUME) */
+                         "	add	%%d1,%%d0\n"
+                         "	cmp	%%d2,%%d0\n"
+                         "	bges	lower_limit_s8\n"
+                         "	move	%%d2,%%d0\n"
+                         "lower_limit_s8:\n"
+                         "	cmp	%%d3,%%d0\n"
+                         "	bles	upper_limit_s8\n"
+                         "	move	%%d3,%%d0\n"
+                         "upper_limit_s8:\n" "	moveb	%%d0,%0@+\n"
+                         /* Loop till done */
+                         "	subql	#1,%2\n" "	bhis	mixloop_s8\n" "stoploop_s8:\n": /* no return value */
+                         :      /* input */
+                         "a"(dst), "a"(src), "d"(len), "d"(volume):     /* clobbered registers */
+                         "d0", "d1", "d2", "d3", "cc", "memory");
+}
+
+void
+SDL_MixAudio_m68k_S16MSB(short *dst, short *src, long len, long volume)
+{
+    __asm__ __volatile__("tstl	%2\n"
+                         "	beqs	stoploop_s16msb\n"
+                         "	movel	#-32768,%%d2\n"
+                         "	movel	#32767,%%d3\n"
+                         "	lsrl	#1,%2\n" "mixloop_s16msb:\n"
+                         /* Mix a sample */
+                         "	move	%1@+,%%d0\n"    /* d0 = *src++ */
+                         "	muls	%3,%%d0\n"      /* d0 *= volume (0<=volume<=128) */
+                         "	move	%0@,%%d1\n"     /* d1 = *dst */
+                         "	extl	%%d1\n" /* extend d1 to 32 bits */
+                         "	asrl	#7,%%d0\n"      /* d0 /= 128 (SDL_MIX_MAXVOLUME) */
+                         "	addl	%%d1,%%d0\n"
+                         "	cmpl	%%d2,%%d0\n"
+                         "	bges	lower_limit_s16msb\n"
+                         "	move	%%d2,%%d0\n"
+                         "lower_limit_s16msb:\n"
+                         "	cmpl	%%d3,%%d0\n"
+                         "	bles	upper_limit_s16msb\n"
+                         "	move	%%d3,%%d0\n"
+                         "upper_limit_s16msb:\n" "	move	%%d0,%0@+\n"
+                         /* Loop till done */
+                         "	subql	#1,%2\n" "	bhis	mixloop_s16msb\n" "stoploop_s16msb:\n": /* no return value */
+                         :      /* input */
+                         "a"(dst), "a"(src), "d"(len), "d"(volume):     /* clobbered registers */
+                         "d0", "d1", "d2", "d3", "cc", "memory");
+}
+
+void
+SDL_MixAudio_m68k_S16LSB(short *dst, short *src, long len, long volume)
+{
+    __asm__ __volatile__("tstl	%2\n"
+                         "	beqs	stoploop_s16lsb\n"
+                         "	movel	#-32768,%%d2\n"
+                         "	movel	#32767,%%d3\n"
+                         "	lsrl	#1,%2\n" "mixloop_s16lsb:\n"
+                         /* Mix a sample */
+                         "	move	%1@+,%%d0\n"    /* d0 = *src++ */
+                         "	rorw	#8,%%d0\n" "	muls	%3,%%d0\n"      /* d0 *= volume (0<=volume<=128) */
+                         "	move	%0@,%%d1\n"     /* d1 = *dst */
+                         "	rorw	#8,%%d1\n" "	extl	%%d1\n" /* extend d1 to 32 bits */
+                         "	asrl	#7,%%d0\n"      /* d0 /= 128 (SDL_MIX_MAXVOLUME) */
+                         "	addl	%%d1,%%d0\n"
+                         "	cmpl	%%d2,%%d0\n"
+                         "	bges	lower_limit_s16lsb\n"
+                         "	move	%%d2,%%d0\n"
+                         "lower_limit_s16lsb:\n"
+                         "	cmpl	%%d3,%%d0\n"
+                         "	bles	upper_limit_s16lsb\n"
+                         "	move	%%d3,%%d0\n"
+                         "upper_limit_s16lsb:\n"
+                         "	rorw	#8,%%d0\n" "	move	%%d0,%0@+\n"
+                         /* Loop till done */
+                         "	subql	#1,%2\n" "	bhis	mixloop_s16lsb\n" "stoploop_s16lsb:\n": /* no return value */
+                         :      /* input */
+                         "a"(dst), "a"(src), "d"(len), "d"(volume):     /* clobbered registers */
+                         "d0", "d1", "d2", "d3", "cc", "memory");
+}
+#endif
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/SDL_mixer_m68k.h

@@ -0,0 +1,38 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/*
+	m68k assembly mix routines
+
+	Patrice Mandin
+*/
+
+#if defined(__M68000__) && defined(__GNUC__)
+void SDL_MixAudio_m68k_U8(char *dst, char *src, long len, long volume,
+                          char *mix8);
+void SDL_MixAudio_m68k_S8(char *dst, char *src, long len, long volume);
+
+void SDL_MixAudio_m68k_S16MSB(short *dst, short *src, long len, long volume);
+void SDL_MixAudio_m68k_S16LSB(short *dst, short *src, long len, long volume);
+#endif
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/SDL_sysaudio.h

@@ -0,0 +1,129 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is SDL_free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifndef _SDL_sysaudio_h
+#define _SDL_sysaudio_h
+
+#include "SDL_mutex.h"
+#include "SDL_thread.h"
+
+/* The SDL audio driver */
+typedef struct SDL_AudioDevice SDL_AudioDevice;
+#define _THIS	SDL_AudioDevice *_this
+
+typedef struct SDL_AudioDriverImpl
+{
+    int (*DetectDevices) (int iscapture);
+    const char *(*GetDeviceName) (int index, int iscapture);
+    int (*OpenDevice) (_THIS, const char *devname, int iscapture);
+    void (*ThreadInit) (_THIS); /* Called by audio thread at start */
+    void (*WaitDevice) (_THIS);
+    void (*PlayDevice) (_THIS);
+    Uint8 *(*GetDeviceBuf) (_THIS);
+    void (*WaitDone) (_THIS);
+    void (*CloseDevice) (_THIS);
+    void (*LockDevice) (_THIS);
+    void (*UnlockDevice) (_THIS);
+    void (*Deinitialize) (void);
+
+    /* Some flags to push duplicate code into the core and reduce #ifdefs. */
+    int ProvidesOwnCallbackThread:1;
+    int SkipMixerLock:1;
+    int HasCaptureSupport:1;
+    int OnlyHasDefaultOutputDevice:1;
+    int OnlyHasDefaultInputDevice:1;
+} SDL_AudioDriverImpl;
+
+
+typedef struct SDL_AudioDriver
+{
+    /* * * */
+    /* The name of this audio driver */
+    const char *name;
+
+    /* * * */
+    /* The description of this audio driver */
+    const char *desc;
+
+    SDL_AudioDriverImpl impl;
+} SDL_AudioDriver;
+
+
+/* Streamer */
+typedef struct
+{
+    Uint8 *buffer;
+    int max_len;                /* the maximum length in bytes */
+    int read_pos, write_pos;    /* the position of the write and read heads in bytes */
+} SDL_AudioStreamer;
+
+
+/* Define the SDL audio driver structure */
+struct SDL_AudioDevice
+{
+    /* * * */
+    /* Data common to all devices */
+
+    /* The current audio specification (shared with audio thread) */
+    SDL_AudioSpec spec;
+
+    /* An audio conversion block for audio format emulation */
+    SDL_AudioCVT convert;
+
+    /* The streamer, if sample rate conversion necessitates it */
+    int use_streamer;
+    SDL_AudioStreamer streamer;
+
+    /* Current state flags */
+    int iscapture;
+    int enabled;
+    int paused;
+    int opened;
+
+    /* Fake audio buffer for when the audio hardware is busy */
+    Uint8 *fake_stream;
+
+    /* A semaphore for locking the mixing buffers */
+    SDL_mutex *mixer_lock;
+
+    /* A thread to feed the audio device */
+    SDL_Thread *thread;
+    Uint32 threadid;
+
+    /* * * */
+    /* Data private to this driver */
+    struct SDL_PrivateAudioData *hidden;
+};
+#undef _THIS
+
+typedef struct AudioBootStrap
+{
+    const char *name;
+    const char *desc;
+    int (*init) (SDL_AudioDriverImpl * impl);
+    int demand_only:1;          /* 1==request explicitly, or it won't be available. */
+} AudioBootStrap;
+
+#endif /* _SDL_sysaudio_h */
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/SDL_wave.c

@@ -0,0 +1,633 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* Microsoft WAVE file loading routines */
+
+#include "SDL_audio.h"
+#include "SDL_wave.h"
+
+
+static int ReadChunk(SDL_RWops * src, Chunk * chunk);
+
+struct MS_ADPCM_decodestate
+{
+    Uint8 hPredictor;
+    Uint16 iDelta;
+    Sint16 iSamp1;
+    Sint16 iSamp2;
+};
+static struct MS_ADPCM_decoder
+{
+    WaveFMT wavefmt;
+    Uint16 wSamplesPerBlock;
+    Uint16 wNumCoef;
+    Sint16 aCoeff[7][2];
+    /* * * */
+    struct MS_ADPCM_decodestate state[2];
+} MS_ADPCM_state;
+
+static int
+InitMS_ADPCM(WaveFMT * format)
+{
+    Uint8 *rogue_feel;
+    Uint16 extra_info;
+    int i;
+
+    /* Set the rogue pointer to the MS_ADPCM specific data */
+    MS_ADPCM_state.wavefmt.encoding = SDL_SwapLE16(format->encoding);
+    MS_ADPCM_state.wavefmt.channels = SDL_SwapLE16(format->channels);
+    MS_ADPCM_state.wavefmt.frequency = SDL_SwapLE32(format->frequency);
+    MS_ADPCM_state.wavefmt.byterate = SDL_SwapLE32(format->byterate);
+    MS_ADPCM_state.wavefmt.blockalign = SDL_SwapLE16(format->blockalign);
+    MS_ADPCM_state.wavefmt.bitspersample =
+        SDL_SwapLE16(format->bitspersample);
+    rogue_feel = (Uint8 *) format + sizeof(*format);
+    if (sizeof(*format) == 16) {
+        extra_info = ((rogue_feel[1] << 8) | rogue_feel[0]);
+        rogue_feel += sizeof(Uint16);
+    }
+    MS_ADPCM_state.wSamplesPerBlock = ((rogue_feel[1] << 8) | rogue_feel[0]);
+    rogue_feel += sizeof(Uint16);
+    MS_ADPCM_state.wNumCoef = ((rogue_feel[1] << 8) | rogue_feel[0]);
+    rogue_feel += sizeof(Uint16);
+    if (MS_ADPCM_state.wNumCoef != 7) {
+        SDL_SetError("Unknown set of MS_ADPCM coefficients");
+        return (-1);
+    }
+    for (i = 0; i < MS_ADPCM_state.wNumCoef; ++i) {
+        MS_ADPCM_state.aCoeff[i][0] = ((rogue_feel[1] << 8) | rogue_feel[0]);
+        rogue_feel += sizeof(Uint16);
+        MS_ADPCM_state.aCoeff[i][1] = ((rogue_feel[1] << 8) | rogue_feel[0]);
+        rogue_feel += sizeof(Uint16);
+    }
+    return (0);
+}
+
+static Sint32
+MS_ADPCM_nibble(struct MS_ADPCM_decodestate *state,
+                Uint8 nybble, Sint16 * coeff)
+{
+    const Sint32 max_audioval = ((1 << (16 - 1)) - 1);
+    const Sint32 min_audioval = -(1 << (16 - 1));
+    const Sint32 adaptive[] = {
+        230, 230, 230, 230, 307, 409, 512, 614,
+        768, 614, 512, 409, 307, 230, 230, 230
+    };
+    Sint32 new_sample, delta;
+
+    new_sample = ((state->iSamp1 * coeff[0]) +
+                  (state->iSamp2 * coeff[1])) / 256;
+    if (nybble & 0x08) {
+        new_sample += state->iDelta * (nybble - 0x10);
+    } else {
+        new_sample += state->iDelta * nybble;
+    }
+    if (new_sample < min_audioval) {
+        new_sample = min_audioval;
+    } else if (new_sample > max_audioval) {
+        new_sample = max_audioval;
+    }
+    delta = ((Sint32) state->iDelta * adaptive[nybble]) / 256;
+    if (delta < 16) {
+        delta = 16;
+    }
+    state->iDelta = (Uint16) delta;
+    state->iSamp2 = state->iSamp1;
+    state->iSamp1 = (Sint16) new_sample;
+    return (new_sample);
+}
+
+static int
+MS_ADPCM_decode(Uint8 ** audio_buf, Uint32 * audio_len)
+{
+    struct MS_ADPCM_decodestate *state[2];
+    Uint8 *freeable, *encoded, *decoded;
+    Sint32 encoded_len, samplesleft;
+    Sint8 nybble, stereo;
+    Sint16 *coeff[2];
+    Sint32 new_sample;
+
+    /* Allocate the proper sized output buffer */
+    encoded_len = *audio_len;
+    encoded = *audio_buf;
+    freeable = *audio_buf;
+    *audio_len = (encoded_len / MS_ADPCM_state.wavefmt.blockalign) *
+        MS_ADPCM_state.wSamplesPerBlock *
+        MS_ADPCM_state.wavefmt.channels * sizeof(Sint16);
+    *audio_buf = (Uint8 *) SDL_malloc(*audio_len);
+    if (*audio_buf == NULL) {
+        SDL_Error(SDL_ENOMEM);
+        return (-1);
+    }
+    decoded = *audio_buf;
+
+    /* Get ready... Go! */
+    stereo = (MS_ADPCM_state.wavefmt.channels == 2);
+    state[0] = &MS_ADPCM_state.state[0];
+    state[1] = &MS_ADPCM_state.state[stereo];
+    while (encoded_len >= MS_ADPCM_state.wavefmt.blockalign) {
+        /* Grab the initial information for this block */
+        state[0]->hPredictor = *encoded++;
+        if (stereo) {
+            state[1]->hPredictor = *encoded++;
+        }
+        state[0]->iDelta = ((encoded[1] << 8) | encoded[0]);
+        encoded += sizeof(Sint16);
+        if (stereo) {
+            state[1]->iDelta = ((encoded[1] << 8) | encoded[0]);
+            encoded += sizeof(Sint16);
+        }
+        state[0]->iSamp1 = ((encoded[1] << 8) | encoded[0]);
+        encoded += sizeof(Sint16);
+        if (stereo) {
+            state[1]->iSamp1 = ((encoded[1] << 8) | encoded[0]);
+            encoded += sizeof(Sint16);
+        }
+        state[0]->iSamp2 = ((encoded[1] << 8) | encoded[0]);
+        encoded += sizeof(Sint16);
+        if (stereo) {
+            state[1]->iSamp2 = ((encoded[1] << 8) | encoded[0]);
+            encoded += sizeof(Sint16);
+        }
+        coeff[0] = MS_ADPCM_state.aCoeff[state[0]->hPredictor];
+        coeff[1] = MS_ADPCM_state.aCoeff[state[1]->hPredictor];
+
+        /* Store the two initial samples we start with */
+        decoded[0] = state[0]->iSamp2 & 0xFF;
+        decoded[1] = state[0]->iSamp2 >> 8;
+        decoded += 2;
+        if (stereo) {
+            decoded[0] = state[1]->iSamp2 & 0xFF;
+            decoded[1] = state[1]->iSamp2 >> 8;
+            decoded += 2;
+        }
+        decoded[0] = state[0]->iSamp1 & 0xFF;
+        decoded[1] = state[0]->iSamp1 >> 8;
+        decoded += 2;
+        if (stereo) {
+            decoded[0] = state[1]->iSamp1 & 0xFF;
+            decoded[1] = state[1]->iSamp1 >> 8;
+            decoded += 2;
+        }
+
+        /* Decode and store the other samples in this block */
+        samplesleft = (MS_ADPCM_state.wSamplesPerBlock - 2) *
+            MS_ADPCM_state.wavefmt.channels;
+        while (samplesleft > 0) {
+            nybble = (*encoded) >> 4;
+            new_sample = MS_ADPCM_nibble(state[0], nybble, coeff[0]);
+            decoded[0] = new_sample & 0xFF;
+            new_sample >>= 8;
+            decoded[1] = new_sample & 0xFF;
+            decoded += 2;
+
+            nybble = (*encoded) & 0x0F;
+            new_sample = MS_ADPCM_nibble(state[1], nybble, coeff[1]);
+            decoded[0] = new_sample & 0xFF;
+            new_sample >>= 8;
+            decoded[1] = new_sample & 0xFF;
+            decoded += 2;
+
+            ++encoded;
+            samplesleft -= 2;
+        }
+        encoded_len -= MS_ADPCM_state.wavefmt.blockalign;
+    }
+    SDL_free(freeable);
+    return (0);
+}
+
+struct IMA_ADPCM_decodestate
+{
+    Sint32 sample;
+    Sint8 index;
+};
+static struct IMA_ADPCM_decoder
+{
+    WaveFMT wavefmt;
+    Uint16 wSamplesPerBlock;
+    /* * * */
+    struct IMA_ADPCM_decodestate state[2];
+} IMA_ADPCM_state;
+
+static int
+InitIMA_ADPCM(WaveFMT * format)
+{
+    Uint8 *rogue_feel;
+    Uint16 extra_info;
+
+    /* Set the rogue pointer to the IMA_ADPCM specific data */
+    IMA_ADPCM_state.wavefmt.encoding = SDL_SwapLE16(format->encoding);
+    IMA_ADPCM_state.wavefmt.channels = SDL_SwapLE16(format->channels);
+    IMA_ADPCM_state.wavefmt.frequency = SDL_SwapLE32(format->frequency);
+    IMA_ADPCM_state.wavefmt.byterate = SDL_SwapLE32(format->byterate);
+    IMA_ADPCM_state.wavefmt.blockalign = SDL_SwapLE16(format->blockalign);
+    IMA_ADPCM_state.wavefmt.bitspersample =
+        SDL_SwapLE16(format->bitspersample);
+    rogue_feel = (Uint8 *) format + sizeof(*format);
+    if (sizeof(*format) == 16) {
+        extra_info = ((rogue_feel[1] << 8) | rogue_feel[0]);
+        rogue_feel += sizeof(Uint16);
+    }
+    IMA_ADPCM_state.wSamplesPerBlock = ((rogue_feel[1] << 8) | rogue_feel[0]);
+    return (0);
+}
+
+static Sint32
+IMA_ADPCM_nibble(struct IMA_ADPCM_decodestate *state, Uint8 nybble)
+{
+    const Sint32 max_audioval = ((1 << (16 - 1)) - 1);
+    const Sint32 min_audioval = -(1 << (16 - 1));
+    const int index_table[16] = {
+        -1, -1, -1, -1,
+        2, 4, 6, 8,
+        -1, -1, -1, -1,
+        2, 4, 6, 8
+    };
+    const Sint32 step_table[89] = {
+        7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 19, 21, 23, 25, 28, 31,
+        34, 37, 41, 45, 50, 55, 60, 66, 73, 80, 88, 97, 107, 118, 130,
+        143, 157, 173, 190, 209, 230, 253, 279, 307, 337, 371, 408,
+        449, 494, 544, 598, 658, 724, 796, 876, 963, 1060, 1166, 1282,
+        1411, 1552, 1707, 1878, 2066, 2272, 2499, 2749, 3024, 3327,
+        3660, 4026, 4428, 4871, 5358, 5894, 6484, 7132, 7845, 8630,
+        9493, 10442, 11487, 12635, 13899, 15289, 16818, 18500, 20350,
+        22385, 24623, 27086, 29794, 32767
+    };
+    Sint32 delta, step;
+
+    /* Compute difference and new sample value */
+    step = step_table[state->index];
+    delta = step >> 3;
+    if (nybble & 0x04)
+        delta += step;
+    if (nybble & 0x02)
+        delta += (step >> 1);
+    if (nybble & 0x01)
+        delta += (step >> 2);
+    if (nybble & 0x08)
+        delta = -delta;
+    state->sample += delta;
+
+    /* Update index value */
+    state->index += index_table[nybble];
+    if (state->index > 88) {
+        state->index = 88;
+    } else if (state->index < 0) {
+        state->index = 0;
+    }
+
+    /* Clamp output sample */
+    if (state->sample > max_audioval) {
+        state->sample = max_audioval;
+    } else if (state->sample < min_audioval) {
+        state->sample = min_audioval;
+    }
+    return (state->sample);
+}
+
+/* Fill the decode buffer with a channel block of data (8 samples) */
+static void
+Fill_IMA_ADPCM_block(Uint8 * decoded, Uint8 * encoded,
+                     int channel, int numchannels,
+                     struct IMA_ADPCM_decodestate *state)
+{
+    int i;
+    Sint8 nybble;
+    Sint32 new_sample;
+
+    decoded += (channel * 2);
+    for (i = 0; i < 4; ++i) {
+        nybble = (*encoded) & 0x0F;
+        new_sample = IMA_ADPCM_nibble(state, nybble);
+        decoded[0] = new_sample & 0xFF;
+        new_sample >>= 8;
+        decoded[1] = new_sample & 0xFF;
+        decoded += 2 * numchannels;
+
+        nybble = (*encoded) >> 4;
+        new_sample = IMA_ADPCM_nibble(state, nybble);
+        decoded[0] = new_sample & 0xFF;
+        new_sample >>= 8;
+        decoded[1] = new_sample & 0xFF;
+        decoded += 2 * numchannels;
+
+        ++encoded;
+    }
+}
+
+static int
+IMA_ADPCM_decode(Uint8 ** audio_buf, Uint32 * audio_len)
+{
+    struct IMA_ADPCM_decodestate *state;
+    Uint8 *freeable, *encoded, *decoded;
+    Sint32 encoded_len, samplesleft;
+    unsigned int c, channels;
+
+    /* Check to make sure we have enough variables in the state array */
+    channels = IMA_ADPCM_state.wavefmt.channels;
+    if (channels > SDL_arraysize(IMA_ADPCM_state.state)) {
+        SDL_SetError("IMA ADPCM decoder can only handle %d channels",
+                     SDL_arraysize(IMA_ADPCM_state.state));
+        return (-1);
+    }
+    state = IMA_ADPCM_state.state;
+
+    /* Allocate the proper sized output buffer */
+    encoded_len = *audio_len;
+    encoded = *audio_buf;
+    freeable = *audio_buf;
+    *audio_len = (encoded_len / IMA_ADPCM_state.wavefmt.blockalign) *
+        IMA_ADPCM_state.wSamplesPerBlock *
+        IMA_ADPCM_state.wavefmt.channels * sizeof(Sint16);
+    *audio_buf = (Uint8 *) SDL_malloc(*audio_len);
+    if (*audio_buf == NULL) {
+        SDL_Error(SDL_ENOMEM);
+        return (-1);
+    }
+    decoded = *audio_buf;
+
+    /* Get ready... Go! */
+    while (encoded_len >= IMA_ADPCM_state.wavefmt.blockalign) {
+        /* Grab the initial information for this block */
+        for (c = 0; c < channels; ++c) {
+            /* Fill the state information for this block */
+            state[c].sample = ((encoded[1] << 8) | encoded[0]);
+            encoded += 2;
+            if (state[c].sample & 0x8000) {
+                state[c].sample -= 0x10000;
+            }
+            state[c].index = *encoded++;
+            /* Reserved byte in buffer header, should be 0 */
+            if (*encoded++ != 0) {
+                /* Uh oh, corrupt data?  Buggy code? */ ;
+            }
+
+            /* Store the initial sample we start with */
+            decoded[0] = (Uint8) (state[c].sample & 0xFF);
+            decoded[1] = (Uint8) (state[c].sample >> 8);
+            decoded += 2;
+        }
+
+        /* Decode and store the other samples in this block */
+        samplesleft = (IMA_ADPCM_state.wSamplesPerBlock - 1) * channels;
+        while (samplesleft > 0) {
+            for (c = 0; c < channels; ++c) {
+                Fill_IMA_ADPCM_block(decoded, encoded,
+                                     c, channels, &state[c]);
+                encoded += 4;
+                samplesleft -= 8;
+            }
+            decoded += (channels * 8 * 2);
+        }
+        encoded_len -= IMA_ADPCM_state.wavefmt.blockalign;
+    }
+    SDL_free(freeable);
+    return (0);
+}
+
+SDL_AudioSpec *
+SDL_LoadWAV_RW(SDL_RWops * src, int freesrc,
+               SDL_AudioSpec * spec, Uint8 ** audio_buf, Uint32 * audio_len)
+{
+    int was_error;
+    Chunk chunk;
+    int lenread;
+    int IEEE_float_encoded, MS_ADPCM_encoded, IMA_ADPCM_encoded;
+    int samplesize;
+
+    /* WAV magic header */
+    Uint32 RIFFchunk;
+    Uint32 wavelen = 0;
+    Uint32 WAVEmagic;
+    Uint32 headerDiff = 0;
+
+    /* FMT chunk */
+    WaveFMT *format = NULL;
+
+    /* Make sure we are passed a valid data source */
+    was_error = 0;
+    if (src == NULL) {
+        was_error = 1;
+        goto done;
+    }
+
+    /* Check the magic header */
+    RIFFchunk = SDL_ReadLE32(src);
+    wavelen = SDL_ReadLE32(src);
+    if (wavelen == WAVE) {      /* The RIFFchunk has already been read */
+        WAVEmagic = wavelen;
+        wavelen = RIFFchunk;
+        RIFFchunk = RIFF;
+    } else {
+        WAVEmagic = SDL_ReadLE32(src);
+    }
+    if ((RIFFchunk != RIFF) || (WAVEmagic != WAVE)) {
+        SDL_SetError("Unrecognized file type (not WAVE)");
+        was_error = 1;
+        goto done;
+    }
+    headerDiff += sizeof(Uint32);       /* for WAVE */
+
+    /* Read the audio data format chunk */
+    chunk.data = NULL;
+    do {
+        if (chunk.data != NULL) {
+            SDL_free(chunk.data);
+        }
+        lenread = ReadChunk(src, &chunk);
+        if (lenread < 0) {
+            was_error = 1;
+            goto done;
+        }
+        /* 2 Uint32's for chunk header+len, plus the lenread */
+        headerDiff += lenread + 2 * sizeof(Uint32);
+    } while ((chunk.magic == FACT) || (chunk.magic == LIST));
+
+    /* Decode the audio data format */
+    format = (WaveFMT *) chunk.data;
+    if (chunk.magic != FMT) {
+        SDL_SetError("Complex WAVE files not supported");
+        was_error = 1;
+        goto done;
+    }
+    IEEE_float_encoded = MS_ADPCM_encoded = IMA_ADPCM_encoded = 0;
+    switch (SDL_SwapLE16(format->encoding)) {
+    case PCM_CODE:
+        /* We can understand this */
+        break;
+    case IEEE_FLOAT_CODE:
+        IEEE_float_encoded = 1;
+        /* We can understand this */
+        break;
+    case MS_ADPCM_CODE:
+        /* Try to understand this */
+        if (InitMS_ADPCM(format) < 0) {
+            was_error = 1;
+            goto done;
+        }
+        MS_ADPCM_encoded = 1;
+        break;
+    case IMA_ADPCM_CODE:
+        /* Try to understand this */
+        if (InitIMA_ADPCM(format) < 0) {
+            was_error = 1;
+            goto done;
+        }
+        IMA_ADPCM_encoded = 1;
+        break;
+    case MP3_CODE:
+        SDL_SetError("MPEG Layer 3 data not supported",
+                     SDL_SwapLE16(format->encoding));
+        was_error = 1;
+        goto done;
+    default:
+        SDL_SetError("Unknown WAVE data format: 0x%.4x",
+                     SDL_SwapLE16(format->encoding));
+        was_error = 1;
+        goto done;
+    }
+    SDL_memset(spec, 0, (sizeof *spec));
+    spec->freq = SDL_SwapLE32(format->frequency);
+
+    if (IEEE_float_encoded) {
+        if ((SDL_SwapLE16(format->bitspersample)) != 32) {
+            was_error = 1;
+        } else {
+            spec->format = AUDIO_F32;
+        }
+    } else {
+        switch (SDL_SwapLE16(format->bitspersample)) {
+        case 4:
+            if (MS_ADPCM_encoded || IMA_ADPCM_encoded) {
+                spec->format = AUDIO_S16;
+            } else {
+                was_error = 1;
+            }
+            break;
+        case 8:
+            spec->format = AUDIO_U8;
+            break;
+        case 16:
+            spec->format = AUDIO_S16;
+            break;
+        case 32:
+            spec->format = AUDIO_S32;
+            break;
+        default:
+            was_error = 1;
+            break;
+        }
+    }
+
+    if (was_error) {
+        SDL_SetError("Unknown %d-bit PCM data format",
+                     SDL_SwapLE16(format->bitspersample));
+        goto done;
+    }
+    spec->channels = (Uint8) SDL_SwapLE16(format->channels);
+    spec->samples = 4096;       /* Good default buffer size */
+
+    /* Read the audio data chunk */
+    *audio_buf = NULL;
+    do {
+        if (*audio_buf != NULL) {
+            SDL_free(*audio_buf);
+        }
+        lenread = ReadChunk(src, &chunk);
+        if (lenread < 0) {
+            was_error = 1;
+            goto done;
+        }
+        *audio_len = lenread;
+        *audio_buf = chunk.data;
+        if (chunk.magic != DATA)
+            headerDiff += lenread + 2 * sizeof(Uint32);
+    } while (chunk.magic != DATA);
+    headerDiff += 2 * sizeof(Uint32);   /* for the data chunk and len */
+
+    if (MS_ADPCM_encoded) {
+        if (MS_ADPCM_decode(audio_buf, audio_len) < 0) {
+            was_error = 1;
+            goto done;
+        }
+    }
+    if (IMA_ADPCM_encoded) {
+        if (IMA_ADPCM_decode(audio_buf, audio_len) < 0) {
+            was_error = 1;
+            goto done;
+        }
+    }
+
+    /* Don't return a buffer that isn't a multiple of samplesize */
+    samplesize = ((SDL_AUDIO_BITSIZE(spec->format)) / 8) * spec->channels;
+    *audio_len &= ~(samplesize - 1);
+
+  done:
+    if (format != NULL) {
+        SDL_free(format);
+    }
+    if (src) {
+        if (freesrc) {
+            SDL_RWclose(src);
+        } else {
+            /* seek to the end of the file (given by the RIFF chunk) */
+            SDL_RWseek(src, wavelen - chunk.length - headerDiff, RW_SEEK_CUR);
+        }
+    }
+    if (was_error) {
+        spec = NULL;
+    }
+    return (spec);
+}
+
+/* Since the WAV memory is allocated in the shared library, it must also
+   be freed here.  (Necessary under Win32, VC++)
+ */
+void
+SDL_FreeWAV(Uint8 * audio_buf)
+{
+    if (audio_buf != NULL) {
+        SDL_free(audio_buf);
+    }
+}
+
+static int
+ReadChunk(SDL_RWops * src, Chunk * chunk)
+{
+    chunk->magic = SDL_ReadLE32(src);
+    chunk->length = SDL_ReadLE32(src);
+    chunk->data = (Uint8 *) SDL_malloc(chunk->length);
+    if (chunk->data == NULL) {
+        SDL_Error(SDL_ENOMEM);
+        return (-1);
+    }
+    if (SDL_RWread(src, chunk->data, chunk->length, 1) != 1) {
+        SDL_Error(SDL_EFREAD);
+        SDL_free(chunk->data);
+        return (-1);
+    }
+    return (chunk->length);
+}
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/SDL_wave.h

@@ -0,0 +1,65 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is SDL_free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* WAVE files are little-endian */
+
+/*******************************************/
+/* Define values for Microsoft WAVE format */
+/*******************************************/
+#define RIFF		0x46464952      /* "RIFF" */
+#define WAVE		0x45564157      /* "WAVE" */
+#define FACT		0x74636166      /* "fact" */
+#define LIST		0x5453494c      /* "LIST" */
+#define FMT		0x20746D66      /* "fmt " */
+#define DATA		0x61746164      /* "data" */
+#define PCM_CODE	0x0001
+#define MS_ADPCM_CODE	0x0002
+#define IEEE_FLOAT_CODE	0x0003
+#define IMA_ADPCM_CODE	0x0011
+#define MP3_CODE	0x0055
+#define WAVE_MONO	1
+#define WAVE_STEREO	2
+
+/* Normally, these three chunks come consecutively in a WAVE file */
+typedef struct WaveFMT
+{
+/* Not saved in the chunk we read:
+	Uint32	FMTchunk;
+	Uint32	fmtlen;
+*/
+    Uint16 encoding;
+    Uint16 channels;            /* 1 = mono, 2 = stereo */
+    Uint32 frequency;           /* One of 11025, 22050, or 44100 Hz */
+    Uint32 byterate;            /* Average bytes per second */
+    Uint16 blockalign;          /* Bytes per sample block */
+    Uint16 bitspersample;       /* One of 8, 12, 16, or 4 for ADPCM */
+} WaveFMT;
+
+/* The general chunk found in the WAVE file */
+typedef struct Chunk
+{
+    Uint32 magic;
+    Uint32 length;
+    Uint8 *data;
+} Chunk;
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/alsa/SDL_alsa_audio.c

@@ -0,0 +1,621 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* Allow access to a raw mixing buffer */
+
+#include <sys/types.h>
+#include <signal.h>             /* For kill() */
+#include <errno.h>
+#include <string.h>
+
+#include "SDL_timer.h"
+#include "SDL_audio.h"
+#include "../SDL_audiomem.h"
+#include "../SDL_audio_c.h"
+#include "SDL_alsa_audio.h"
+
+#ifdef SDL_AUDIO_DRIVER_ALSA_DYNAMIC
+#include "SDL_loadso.h"
+#endif
+
+/* The tag name used by ALSA audio */
+#define DRIVER_NAME         "alsa"
+
+/* The default ALSA audio driver */
+#define DEFAULT_DEVICE	"default"
+
+static int (*ALSA_snd_pcm_open)
+  (snd_pcm_t **, const char *, snd_pcm_stream_t, int);
+static int (*ALSA_snd_pcm_close) (snd_pcm_t * pcm);
+static snd_pcm_sframes_t(*ALSA_snd_pcm_writei)
+  (snd_pcm_t *, const void *, snd_pcm_uframes_t);
+static int (*ALSA_snd_pcm_resume) (snd_pcm_t *);
+static int (*ALSA_snd_pcm_prepare) (snd_pcm_t *);
+static int (*ALSA_snd_pcm_drain) (snd_pcm_t *);
+static const char *(*ALSA_snd_strerror) (int);
+static size_t(*ALSA_snd_pcm_hw_params_sizeof) (void);
+static size_t(*ALSA_snd_pcm_sw_params_sizeof) (void);
+static int (*ALSA_snd_pcm_hw_params_any) (snd_pcm_t *, snd_pcm_hw_params_t *);
+static int (*ALSA_snd_pcm_hw_params_set_access)
+  (snd_pcm_t *, snd_pcm_hw_params_t *, snd_pcm_access_t);
+static int (*ALSA_snd_pcm_hw_params_set_format)
+  (snd_pcm_t *, snd_pcm_hw_params_t *, snd_pcm_format_t);
+static int (*ALSA_snd_pcm_hw_params_set_channels)
+  (snd_pcm_t *, snd_pcm_hw_params_t *, unsigned int);
+static int (*ALSA_snd_pcm_hw_params_set_rate_near)
+  (snd_pcm_t *, snd_pcm_hw_params_t *, unsigned int *, int *);
+static int (*ALSA_snd_pcm_hw_params_set_period_size_near)
+  (snd_pcm_t *, snd_pcm_hw_params_t *, snd_pcm_uframes_t *, int *);
+static int (*ALSA_snd_pcm_hw_params_get_channels)
+  (const snd_pcm_hw_params_t *, unsigned int *);
+static snd_pcm_sframes_t(*ALSA_snd_pcm_hw_params_get_period_size)
+  (const snd_pcm_hw_params_t *);
+static int (*ALSA_snd_pcm_hw_params_set_periods_near)
+  (snd_pcm_t *, snd_pcm_hw_params_t *, unsigned int *, int *);
+static int (*ALSA_snd_pcm_hw_params_get_periods) (snd_pcm_hw_params_t *);
+static int (*ALSA_snd_pcm_hw_params) (snd_pcm_t *, snd_pcm_hw_params_t *);
+static int (*ALSA_snd_pcm_sw_params_current) (snd_pcm_t *,
+                                              snd_pcm_sw_params_t *);
+static int (*ALSA_snd_pcm_sw_params_set_start_threshold)
+  (snd_pcm_t *, snd_pcm_sw_params_t *, snd_pcm_uframes_t);
+static int (*ALSA_snd_pcm_sw_params_set_avail_min)
+  (snd_pcm_t *, snd_pcm_sw_params_t *, snd_pcm_uframes_t);
+static int (*ALSA_snd_pcm_sw_params) (snd_pcm_t *, snd_pcm_sw_params_t *);
+static int (*ALSA_snd_pcm_nonblock) (snd_pcm_t *, int);
+#define snd_pcm_hw_params_sizeof ALSA_snd_pcm_hw_params_sizeof
+#define snd_pcm_sw_params_sizeof ALSA_snd_pcm_sw_params_sizeof
+
+
+#ifdef SDL_AUDIO_DRIVER_ALSA_DYNAMIC
+
+static const char *alsa_library = SDL_AUDIO_DRIVER_ALSA_DYNAMIC;
+static void *alsa_handle = NULL;
+
+static int
+load_alsa_sym(const char *fn, void **addr)
+{
+    *addr = SDL_LoadFunction(alsa_handle, fn);
+    if (*addr == NULL) {
+        /* Don't call SDL_SetError(): SDL_LoadFunction already did. */
+        return 0;
+    }
+
+    return 1;
+}
+
+/* cast funcs to char* first, to please GCC's strict aliasing rules. */
+#define SDL_ALSA_SYM(x) \
+    if (!load_alsa_sym(#x, (void **) (char *) &ALSA_##x)) return -1
+#else
+#define SDL_ALSA_SYM(x) ALSA_##x = x
+#endif
+
+static int
+load_alsa_syms(void)
+{
+    SDL_ALSA_SYM(snd_pcm_open);
+    SDL_ALSA_SYM(snd_pcm_close);
+    SDL_ALSA_SYM(snd_pcm_writei);
+    SDL_ALSA_SYM(snd_pcm_resume);
+    SDL_ALSA_SYM(snd_pcm_prepare);
+    SDL_ALSA_SYM(snd_pcm_drain);
+    SDL_ALSA_SYM(snd_strerror);
+    SDL_ALSA_SYM(snd_pcm_hw_params_sizeof);
+    SDL_ALSA_SYM(snd_pcm_sw_params_sizeof);
+    SDL_ALSA_SYM(snd_pcm_hw_params_any);
+    SDL_ALSA_SYM(snd_pcm_hw_params_set_access);
+    SDL_ALSA_SYM(snd_pcm_hw_params_set_format);
+    SDL_ALSA_SYM(snd_pcm_hw_params_set_channels);
+    SDL_ALSA_SYM(snd_pcm_hw_params_get_channels);
+    SDL_ALSA_SYM(snd_pcm_hw_params_set_rate_near);
+    SDL_ALSA_SYM(snd_pcm_hw_params_set_period_size_near);
+    SDL_ALSA_SYM(snd_pcm_hw_params_get_period_size);
+    SDL_ALSA_SYM(snd_pcm_hw_params_set_periods_near);
+    SDL_ALSA_SYM(snd_pcm_hw_params_get_periods);
+    SDL_ALSA_SYM(snd_pcm_hw_params);
+    SDL_ALSA_SYM(snd_pcm_sw_params_current);
+    SDL_ALSA_SYM(snd_pcm_sw_params_set_start_threshold);
+    SDL_ALSA_SYM(snd_pcm_sw_params_set_avail_min);
+    SDL_ALSA_SYM(snd_pcm_sw_params);
+    SDL_ALSA_SYM(snd_pcm_nonblock);
+    return 0;
+}
+
+#undef SDL_ALSA_SYM
+
+#ifdef SDL_AUDIO_DRIVER_ALSA_DYNAMIC
+
+static void
+UnloadALSALibrary(void)
+{
+    if (alsa_handle != NULL) {
+		SDL_UnloadObject(alsa_handle);
+        alsa_handle = NULL;
+    }
+}
+
+static int
+LoadALSALibrary(void)
+{
+    int retval = 0;
+    if (alsa_handle == NULL) {
+        alsa_handle = SDL_LoadObject(alsa_library);
+        if (alsa_handle == NULL) {
+            retval = -1;
+            /* Don't call SDL_SetError(): SDL_LoadObject already did. */
+        } else {
+            retval = load_alsa_syms();
+            if (retval < 0) {
+                UnloadALSALibrary();
+            }
+        }
+    }
+    return retval;
+}
+
+#else
+
+static void
+UnloadALSALibrary(void)
+{
+}
+
+static int
+LoadALSALibrary(void)
+{
+    load_alsa_syms();
+    return 0;
+}
+
+#endif /* SDL_AUDIO_DRIVER_ALSA_DYNAMIC */
+
+static const char *
+get_audio_device(int channels)
+{
+    const char *device;
+
+    device = SDL_getenv("AUDIODEV");    /* Is there a standard variable name? */
+    if (device == NULL) {
+        if (channels == 6)
+            device = "surround51";
+        else if (channels == 4)
+            device = "surround40";
+        else
+            device = DEFAULT_DEVICE;
+    }
+    return device;
+}
+
+
+/* This function waits until it is possible to write a full sound buffer */
+static void
+ALSA_WaitDevice(_THIS)
+{
+    /* Check to see if the thread-parent process is still alive */
+    {
+        static int cnt = 0;
+        /* Note that this only works with thread implementations 
+           that use a different process id for each thread.
+         */
+        /* Check every 10 loops */
+        if (this->hidden->parent && (((++cnt) % 10) == 0)) {
+            if (kill(this->hidden->parent, 0) < 0 && errno == ESRCH) {
+                this->enabled = 0;
+            }
+        }
+    }
+}
+
+
+/* !!! FIXME: is there a channel swizzler in alsalib instead? */
+/*
+ * http://bugzilla.libsdl.org/show_bug.cgi?id=110
+ * "For Linux ALSA, this is FL-FR-RL-RR-C-LFE
+ *  and for Windows DirectX [and CoreAudio], this is FL-FR-C-LFE-RL-RR"
+ */
+#define SWIZ6(T) \
+    T *ptr = (T *) this->hidden->mixbuf; \
+    const Uint32 count = (this->spec.samples / 6); \
+    Uint32 i; \
+    for (i = 0; i < count; i++, ptr += 6) { \
+        T tmp; \
+        tmp = ptr[2]; ptr[2] = ptr[4]; ptr[4] = tmp; \
+        tmp = ptr[3]; ptr[3] = ptr[5]; ptr[5] = tmp; \
+    }
+
+static __inline__ void
+swizzle_alsa_channels_6_64bit(_THIS)
+{
+    SWIZ6(Uint64);
+}
+
+static __inline__ void
+swizzle_alsa_channels_6_32bit(_THIS)
+{
+    SWIZ6(Uint32);
+}
+
+static __inline__ void
+swizzle_alsa_channels_6_16bit(_THIS)
+{
+    SWIZ6(Uint16);
+}
+
+static __inline__ void
+swizzle_alsa_channels_6_8bit(_THIS)
+{
+    SWIZ6(Uint8);
+}
+
+#undef SWIZ6
+
+
+/*
+ * Called right before feeding this->hidden->mixbuf to the hardware. Swizzle
+ *  channels from Windows/Mac order to the format alsalib will want.
+ */
+static __inline__ void
+swizzle_alsa_channels(_THIS)
+{
+    if (this->spec.channels == 6) {
+        const Uint16 fmtsize = (this->spec.format & 0xFF);      /* bits/channel. */
+        if (fmtsize == 16)
+            swizzle_alsa_channels_6_16bit(this);
+        else if (fmtsize == 8)
+            swizzle_alsa_channels_6_8bit(this);
+        else if (fmtsize == 32)
+            swizzle_alsa_channels_6_32bit(this);
+        else if (fmtsize == 64)
+            swizzle_alsa_channels_6_64bit(this);
+    }
+
+    /* !!! FIXME: update this for 7.1 if needed, later. */
+}
+
+
+static void
+ALSA_PlayDevice(_THIS)
+{
+    int status;
+    int sample_len;
+    signed short *sample_buf;
+
+    swizzle_alsa_channels(this);
+
+    sample_len = this->spec.samples;
+    sample_buf = (signed short *) this->hidden->mixbuf;
+
+    while (sample_len > 0) {
+        status = ALSA_snd_pcm_writei(this->hidden->pcm_handle,
+                                     sample_buf, sample_len);
+
+        if (status < 0) {
+            if (status == -EAGAIN) {
+                SDL_Delay(1);
+                continue;
+            }
+            if (status == -ESTRPIPE) {
+                do {
+                    SDL_Delay(1);
+                    status = ALSA_snd_pcm_resume(this->hidden->pcm_handle);
+                } while (status == -EAGAIN);
+            }
+            if (status < 0) {
+                status = ALSA_snd_pcm_prepare(this->hidden->pcm_handle);
+            }
+            if (status < 0) {
+                /* Hmm, not much we can do - abort */
+                this->enabled = 0;
+                return;
+            }
+            continue;
+        }
+        sample_buf += status * this->spec.channels;
+        sample_len -= status;
+    }
+}
+
+static Uint8 *
+ALSA_GetDeviceBuf(_THIS)
+{
+    return (this->hidden->mixbuf);
+}
+
+static void
+ALSA_CloseDevice(_THIS)
+{
+    if (this->hidden != NULL) {
+        if (this->hidden->mixbuf != NULL) {
+            SDL_FreeAudioMem(this->hidden->mixbuf);
+            this->hidden->mixbuf = NULL;
+        }
+        if (this->hidden->pcm_handle) {
+            ALSA_snd_pcm_drain(this->hidden->pcm_handle);
+            ALSA_snd_pcm_close(this->hidden->pcm_handle);
+            this->hidden->pcm_handle = NULL;
+        }
+        SDL_free(this->hidden);
+        this->hidden = NULL;
+    }
+}
+
+static int
+ALSA_OpenDevice(_THIS, const char *devname, int iscapture)
+{
+    int status = 0;
+    snd_pcm_t *pcm_handle = NULL;
+    snd_pcm_hw_params_t *hwparams = NULL;
+    snd_pcm_sw_params_t *swparams = NULL;
+    snd_pcm_format_t format = 0;
+    snd_pcm_uframes_t frames = 0;
+    SDL_AudioFormat test_format = 0;
+    unsigned int rate = 0;
+    unsigned int periods = 0;
+    unsigned int channels = 0;
+
+    /* Initialize all variables that we clean on shutdown */
+    this->hidden = (struct SDL_PrivateAudioData *)
+        SDL_malloc((sizeof *this->hidden));
+    if (this->hidden == NULL) {
+        SDL_OutOfMemory();
+        return 0;
+    }
+    SDL_memset(this->hidden, 0, (sizeof *this->hidden));
+
+    /* Open the audio device */
+    /* Name of device should depend on # channels in spec */
+    status = ALSA_snd_pcm_open(&pcm_handle,
+                               get_audio_device(this->spec.channels),
+                               SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
+
+    if (status < 0) {
+        ALSA_CloseDevice(this);
+        SDL_SetError("ALSA: Couldn't open audio device: %s",
+                     ALSA_snd_strerror(status));
+        return 0;
+    }
+
+    this->hidden->pcm_handle = pcm_handle;
+
+    /* Figure out what the hardware is capable of */
+    snd_pcm_hw_params_alloca(&hwparams);
+    status = ALSA_snd_pcm_hw_params_any(pcm_handle, hwparams);
+    if (status < 0) {
+        ALSA_CloseDevice(this);
+        SDL_SetError("ALSA: Couldn't get hardware config: %s",
+                     ALSA_snd_strerror(status));
+        return 0;
+    }
+
+    /* SDL only uses interleaved sample output */
+    status = ALSA_snd_pcm_hw_params_set_access(pcm_handle, hwparams,
+                                               SND_PCM_ACCESS_RW_INTERLEAVED);
+    if (status < 0) {
+        ALSA_CloseDevice(this);
+        SDL_SetError("ALSA: Couldn't set interleaved access: %s",
+                     ALSA_snd_strerror(status));
+        return 0;
+    }
+
+    /* Try for a closest match on audio format */
+    status = -1;
+    for (test_format = SDL_FirstAudioFormat(this->spec.format);
+         test_format && (status < 0);) {
+        status = 0;             /* if we can't support a format, it'll become -1. */
+        switch (test_format) {
+        case AUDIO_U8:
+            format = SND_PCM_FORMAT_U8;
+            break;
+        case AUDIO_S8:
+            format = SND_PCM_FORMAT_S8;
+            break;
+        case AUDIO_S16LSB:
+            format = SND_PCM_FORMAT_S16_LE;
+            break;
+        case AUDIO_S16MSB:
+            format = SND_PCM_FORMAT_S16_BE;
+            break;
+        case AUDIO_U16LSB:
+            format = SND_PCM_FORMAT_U16_LE;
+            break;
+        case AUDIO_U16MSB:
+            format = SND_PCM_FORMAT_U16_BE;
+            break;
+        case AUDIO_S32LSB:
+            format = SND_PCM_FORMAT_S32_LE;
+            break;
+        case AUDIO_S32MSB:
+            format = SND_PCM_FORMAT_S32_BE;
+            break;
+        case AUDIO_F32LSB:
+            format = SND_PCM_FORMAT_FLOAT_LE;
+            break;
+        case AUDIO_F32MSB:
+            format = SND_PCM_FORMAT_FLOAT_BE;
+            break;
+        default:
+            status = -1;
+            break;
+        }
+        if (status >= 0) {
+            status = ALSA_snd_pcm_hw_params_set_format(pcm_handle,
+                                                       hwparams, format);
+        }
+        if (status < 0) {
+            test_format = SDL_NextAudioFormat();
+        }
+    }
+    if (status < 0) {
+        ALSA_CloseDevice(this);
+        SDL_SetError("ALSA: Couldn't find any hardware audio formats");
+        return 0;
+    }
+    this->spec.format = test_format;
+
+    /* Set the number of channels */
+    status = ALSA_snd_pcm_hw_params_set_channels(pcm_handle, hwparams,
+                                                 this->spec.channels);
+    channels = this->spec.channels;
+    if (status < 0) {
+        status = ALSA_snd_pcm_hw_params_get_channels(hwparams, &channels);
+        if (status < 0) {
+            ALSA_CloseDevice(this);
+            SDL_SetError("ALSA: Couldn't set audio channels");
+            return 0;
+        }
+        this->spec.channels = channels;
+    }
+
+    /* Set the audio rate */
+    rate = this->spec.freq;
+    status = ALSA_snd_pcm_hw_params_set_rate_near(pcm_handle, hwparams,
+                                                  &rate, NULL);
+    if (status < 0) {
+        ALSA_CloseDevice(this);
+        SDL_SetError("ALSA: Couldn't set audio frequency: %s",
+                     ALSA_snd_strerror(status));
+        return 0;
+    }
+    this->spec.freq = rate;
+
+    /* Set the buffer size, in samples */
+    frames = this->spec.samples;
+    status = ALSA_snd_pcm_hw_params_set_period_size_near(pcm_handle, hwparams,
+                                                         &frames, NULL);
+    if ( status < 0 ) {
+        ALSA_CloseDevice(this);
+        SDL_SetError("ALSA: Couldn't set audio frequency: %s",
+                     ALSA_snd_strerror(status));
+        return(-1);
+    }
+    this->spec.samples = frames;
+
+    periods = 2;
+    ALSA_snd_pcm_hw_params_set_periods_near(pcm_handle, hwparams,
+                                            &periods, NULL);
+
+    /* "set" the hardware with the desired parameters */
+    status = ALSA_snd_pcm_hw_params(pcm_handle, hwparams);
+    if (status < 0) {
+        ALSA_CloseDevice(this);
+        SDL_SetError("ALSA: Couldn't set hardware audio parameters: %s",
+                     ALSA_snd_strerror(status));
+        return 0;
+    }
+#if AUDIO_DEBUG
+    {
+        snd_pcm_sframes_t bufsize;
+        int fragments;
+        bufsize = ALSA_snd_pcm_hw_params_get_period_size(hwparams);
+        fragments = ALSA_snd_pcm_hw_params_get_periods(hwparams);
+        fprintf(stderr, "ALSA: bufsize = %ld, fragments = %d\n", bufsize,
+                fragments);
+    }
+#endif
+
+    /* Set the software parameters */
+    snd_pcm_sw_params_alloca(&swparams);
+    status = ALSA_snd_pcm_sw_params_current(pcm_handle, swparams);
+    if (status < 0) {
+        ALSA_CloseDevice(this);
+        SDL_SetError("ALSA: Couldn't get software config: %s",
+                     ALSA_snd_strerror(status));
+        return 0;
+    }
+    status =
+        ALSA_snd_pcm_sw_params_set_start_threshold(pcm_handle, swparams, 0);
+    if (status < 0) {
+        ALSA_CloseDevice(this);
+        SDL_SetError("ALSA: Couldn't set start threshold: %s",
+                     ALSA_snd_strerror(status));
+        return 0;
+    }
+    status =
+        ALSA_snd_pcm_sw_params_set_avail_min(pcm_handle, swparams, frames);
+    if (status < 0) {
+        ALSA_CloseDevice(this);
+        SDL_SetError("Couldn't set avail min: %s", ALSA_snd_strerror(status));
+        return 0;
+    }
+    status = ALSA_snd_pcm_sw_params(pcm_handle, swparams);
+    if (status < 0) {
+        ALSA_CloseDevice(this);
+        SDL_SetError("Couldn't set software audio parameters: %s",
+                     ALSA_snd_strerror(status));
+        return 0;
+    }
+
+    /* Calculate the final parameters for this audio specification */
+    SDL_CalculateAudioSpec(&this->spec);
+
+    /* Allocate mixing buffer */
+    this->hidden->mixlen = this->spec.size;
+    this->hidden->mixbuf = (Uint8 *) SDL_AllocAudioMem(this->hidden->mixlen);
+    if (this->hidden->mixbuf == NULL) {
+        ALSA_CloseDevice(this);
+        SDL_OutOfMemory();
+        return 0;
+    }
+    SDL_memset(this->hidden->mixbuf, this->spec.silence, this->spec.size);
+
+    /* Get the parent process id (we're the parent of the audio thread) */
+    this->hidden->parent = getpid();
+
+    /* Switch to blocking mode for playback */
+    ALSA_snd_pcm_nonblock(pcm_handle, 0);
+
+    /* We're ready to rock and roll. :-) */
+    return 1;
+}
+
+static void
+ALSA_Deinitialize(void)
+{
+    UnloadALSALibrary();
+}
+
+static int
+ALSA_Init(SDL_AudioDriverImpl * impl)
+{
+    if (LoadALSALibrary() < 0) {
+        return 0;
+    }
+
+    /* Set the function pointers */
+    impl->OpenDevice = ALSA_OpenDevice;
+    impl->WaitDevice = ALSA_WaitDevice;
+    impl->GetDeviceBuf = ALSA_GetDeviceBuf;
+    impl->PlayDevice = ALSA_PlayDevice;
+    impl->CloseDevice = ALSA_CloseDevice;
+    impl->Deinitialize = ALSA_Deinitialize;
+    impl->OnlyHasDefaultOutputDevice = 1;       /* !!! FIXME: Add device enum! */
+
+    return 1;                   /* !!! FIXME: return 2 once device enum is implemented. */
+}
+
+
+AudioBootStrap ALSA_bootstrap = {
+    DRIVER_NAME, "ALSA 0.9 PCM audio", ALSA_Init, 0
+};
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/alsa/SDL_alsa_audio.h

@@ -0,0 +1,48 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifndef _ALSA_PCM_audio_h
+#define _ALSA_PCM_audio_h
+
+#include <alsa/asoundlib.h>
+
+#include "../SDL_sysaudio.h"
+
+/* Hidden "this" pointer for the audio functions */
+#define _THIS	SDL_AudioDevice *this
+
+struct SDL_PrivateAudioData
+{
+    /* The audio device handle */
+    snd_pcm_t *pcm_handle;
+
+    /* The parent process id, to detect when application quits */
+    pid_t parent;
+
+    /* Raw mixing buffer */
+    Uint8 *mixbuf;
+    int mixlen;
+};
+
+#endif /* _ALSA_PCM_audio_h */
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/arts/SDL_artsaudio.c

@@ -0,0 +1,379 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* Allow access to a raw mixing buffer */
+
+#ifdef HAVE_SIGNAL_H
+#include <signal.h>
+#endif
+#include <unistd.h>
+#include <errno.h>
+
+#include "SDL_timer.h"
+#include "SDL_audio.h"
+#include "../SDL_audiomem.h"
+#include "../SDL_audio_c.h"
+#include "SDL_artsaudio.h"
+
+#ifdef SDL_AUDIO_DRIVER_ARTS_DYNAMIC
+#include "SDL_name.h"
+#include "SDL_loadso.h"
+#else
+#define SDL_NAME(X)	X
+#endif
+
+/* The tag name used by artsc audio */
+#define ARTS_DRIVER_NAME         "arts"
+
+#ifdef SDL_AUDIO_DRIVER_ARTS_DYNAMIC
+
+static const char *arts_library = SDL_AUDIO_DRIVER_ARTS_DYNAMIC;
+static void *arts_handle = NULL;
+
+/* !!! FIXME: I hate this SDL_NAME clutter...it makes everything so messy! */
+static int (*SDL_NAME(arts_init)) (void);
+static void (*SDL_NAME(arts_free)) (void);
+static arts_stream_t(*SDL_NAME(arts_play_stream)) (int rate, int bits,
+                                                   int channels,
+                                                   const char *name);
+static int (*SDL_NAME(arts_stream_set)) (arts_stream_t s,
+                                         arts_parameter_t param, int value);
+static int (*SDL_NAME(arts_stream_get)) (arts_stream_t s,
+                                         arts_parameter_t param);
+static int (*SDL_NAME(arts_write)) (arts_stream_t s, const void *buffer,
+                                    int count);
+static void (*SDL_NAME(arts_close_stream)) (arts_stream_t s);
+static int (*SDL_NAME(arts_suspended)) (void);
+static const char *(*SDL_NAME(arts_error_text)) (int errorcode);
+
+#define SDL_ARTS_SYM(x) { #x, (void **) (char *) &SDL_NAME(x) }
+static struct
+{
+    const char *name;
+    void **func;
+} arts_functions[] = {
+/* *INDENT-OFF* */
+    SDL_ARTS_SYM(arts_init),
+    SDL_ARTS_SYM(arts_free),
+    SDL_ARTS_SYM(arts_play_stream),
+    SDL_ARTS_SYM(arts_stream_set),
+    SDL_ARTS_SYM(arts_stream_get),
+    SDL_ARTS_SYM(arts_write),
+    SDL_ARTS_SYM(arts_close_stream),
+    SDL_ARTS_SYM(arts_suspended),
+    SDL_ARTS_SYM(arts_error_text),
+/* *INDENT-ON* */
+};
+
+#undef SDL_ARTS_SYM
+
+static void
+UnloadARTSLibrary()
+{
+    if (arts_handle != NULL) {
+        SDL_UnloadObject(arts_handle);
+        arts_handle = NULL;
+    }
+}
+
+static int
+LoadARTSLibrary(void)
+{
+    int i, retval = -1;
+
+    if (arts_handle == NULL) {
+        arts_handle = SDL_LoadObject(arts_library);
+        if (arts_handle != NULL) {
+            retval = 0;
+            for (i = 0; i < SDL_arraysize(arts_functions); ++i) {
+                *arts_functions[i].func =
+                    SDL_LoadFunction(arts_handle, arts_functions[i].name);
+                if (!*arts_functions[i].func) {
+                    retval = -1;
+                    UnloadARTSLibrary();
+                    break;
+                }
+            }
+        }
+    }
+
+    return retval;
+}
+
+#else
+
+static void
+UnloadARTSLibrary()
+{
+    return;
+}
+
+static int
+LoadARTSLibrary(void)
+{
+    return 0;
+}
+
+#endif /* SDL_AUDIO_DRIVER_ARTS_DYNAMIC */
+
+/* This function waits until it is possible to write a full sound buffer */
+static void
+ARTS_WaitDevice(_THIS)
+{
+    Sint32 ticks;
+
+    /* Check to see if the thread-parent process is still alive */
+    {
+        static int cnt = 0;
+        /* Note that this only works with thread implementations
+           that use a different process id for each thread.
+         */
+        /* Check every 10 loops */
+        if (this->hidden->parent && (((++cnt) % 10) == 0)) {
+            if (kill(this->hidden->parent, 0) < 0 && errno == ESRCH) {
+                this->enabled = 0;
+            }
+        }
+    }
+
+    /* Use timer for general audio synchronization */
+    ticks =
+        ((Sint32) (this->hidden->next_frame - SDL_GetTicks())) - FUDGE_TICKS;
+    if (ticks > 0) {
+        SDL_Delay(ticks);
+    }
+}
+
+static void
+ARTS_PlayDevice(_THIS)
+{
+    /* Write the audio data */
+    int written = SDL_NAME(arts_write) (this->hidden->stream,
+                                        this->hidden->mixbuf,
+                                        this->hidden->mixlen);
+
+    /* If timer synchronization is enabled, set the next write frame */
+    if (this->hidden->frame_ticks) {
+        this->hidden->next_frame += this->hidden->frame_ticks;
+    }
+
+    /* If we couldn't write, assume fatal error for now */
+    if (written < 0) {
+        this->enabled = 0;
+    }
+#ifdef DEBUG_AUDIO
+    fprintf(stderr, "Wrote %d bytes of audio data\n", written);
+#endif
+}
+
+static void
+ARTS_WaitDone(_THIS)
+{
+    /* !!! FIXME: camp here until buffer drains... SDL_Delay(???); */
+}
+
+
+static Uint8 *
+ARTS_GetDeviceBuf(_THIS)
+{
+    return (this->hidden->mixbuf);
+}
+
+
+static void
+ARTS_CloseDevice(_THIS)
+{
+    if (this->hidden != NULL) {
+        if (this->hidden->mixbuf != NULL) {
+            SDL_FreeAudioMem(this->hidden->mixbuf);
+            this->hidden->mixbuf = NULL;
+        }
+        if (this->hidden->stream) {
+            SDL_NAME(arts_close_stream) (this->hidden->stream);
+            this->hidden->stream = 0;
+        }
+        SDL_NAME(arts_free) ();
+        SDL_free(this->hidden);
+        this->hidden = NULL;
+    }
+}
+
+
+static int
+ARTS_OpenDevice(_THIS, const char *devname, int iscapture)
+{
+    int rc = 0;
+    int bits = 0, frag_spec = 0;
+    SDL_AudioFormat test_format = 0, format = 0;
+
+    /* Initialize all variables that we clean on shutdown */
+    this->hidden = (struct SDL_PrivateAudioData *)
+        SDL_malloc((sizeof *this->hidden));
+    if (this->hidden == NULL) {
+        SDL_OutOfMemory();
+        return 0;
+    }
+    SDL_memset(this->hidden, 0, (sizeof *this->hidden));
+
+    /* Try for a closest match on audio format */
+    for (test_format = SDL_FirstAudioFormat(this->spec.format);
+         !format && test_format;) {
+#ifdef DEBUG_AUDIO
+        fprintf(stderr, "Trying format 0x%4.4x\n", test_format);
+#endif
+        switch (test_format) {
+        case AUDIO_U8:
+            bits = 8;
+            format = 1;
+            break;
+        case AUDIO_S16LSB:
+            bits = 16;
+            format = 1;
+            break;
+        default:
+            format = 0;
+            break;
+        }
+        if (!format) {
+            test_format = SDL_NextAudioFormat();
+        }
+    }
+    if (format == 0) {
+        ARTS_CloseDevice(this);
+        SDL_SetError("Couldn't find any hardware audio formats");
+        return 0;
+    }
+    this->spec.format = test_format;
+
+    if ((rc = SDL_NAME(arts_init) ()) != 0) {
+        ARTS_CloseDevice(this);
+        SDL_SetError("Unable to initialize ARTS: %s",
+                     SDL_NAME(arts_error_text) (rc));
+        return 0;
+    }
+
+    if (!SDL_NAME(arts_suspended) ()) {
+        ARTS_CloseDevice(this);
+        SDL_SetError("ARTS can not open audio device");
+        return 0;
+    }
+
+    this->hidden->stream = SDL_NAME(arts_play_stream) (this->spec.freq,
+                                                       bits,
+                                                       this->spec.channels,
+                                                       "SDL");
+
+    /* Play nothing so we have at least one write (server bug workaround). */
+    SDL_NAME(arts_write) (this->hidden->stream, "", 0);
+
+    /* Calculate the final parameters for this audio specification */
+    SDL_CalculateAudioSpec(&this->spec);
+
+    /* Determine the power of two of the fragment size */
+    for (frag_spec = 0; (0x01 << frag_spec) < this->spec.size; ++frag_spec);
+    if ((0x01 << frag_spec) != this->spec.size) {
+        ARTS_CloseDevice(this);
+        SDL_SetError("Fragment size must be a power of two");
+        return 0;
+    }
+    frag_spec |= 0x00020000;    /* two fragments, for low latency */
+
+#ifdef ARTS_P_PACKET_SETTINGS
+    SDL_NAME(arts_stream_set) (this->hidden->stream,
+                               ARTS_P_PACKET_SETTINGS, frag_spec);
+#else
+    SDL_NAME(arts_stream_set) (this->hidden->stream, ARTS_P_PACKET_SIZE,
+                               frag_spec & 0xffff);
+    SDL_NAME(arts_stream_set) (this->hidden->stream, ARTS_P_PACKET_COUNT,
+                               frag_spec >> 16);
+#endif
+    this->spec.size = SDL_NAME(arts_stream_get) (this->hidden->stream,
+                                                 ARTS_P_PACKET_SIZE);
+
+    /* Allocate mixing buffer */
+    this->hidden->mixlen = this->spec.size;
+    this->hidden->mixbuf = (Uint8 *) SDL_AllocAudioMem(this->hidden->mixlen);
+    if (this->hidden->mixbuf == NULL) {
+        ARTS_CloseDevice(this);
+        SDL_OutOfMemory();
+        return 0;
+    }
+    SDL_memset(this->hidden->mixbuf, this->spec.silence, this->spec.size);
+
+    /* Get the parent process id (we're the parent of the audio thread) */
+    this->hidden->parent = getpid();
+
+    /* We're ready to rock and roll. :-) */
+    return 1;
+}
+
+
+static void
+ARTS_Deinitialize(void)
+{
+    UnloadARTSLibrary();
+}
+
+
+static int
+ARTS_Init(SDL_AudioDriverImpl * impl)
+{
+    if (LoadARTSLibrary() < 0) {
+        return 0;
+    } else {
+        if (SDL_NAME(arts_init) () != 0) {
+            UnloadARTSLibrary();
+            SDL_SetError("ARTS: arts_init failed (no audio server?)");
+            return 0;
+        }
+
+        /* Play a stream so aRts doesn't crash */
+        if (SDL_NAME(arts_suspended) ()) {
+            arts_stream_t stream;
+            stream = SDL_NAME(arts_play_stream) (44100, 16, 2, "SDL");
+            SDL_NAME(arts_write) (stream, "", 0);
+            SDL_NAME(arts_close_stream) (stream);
+        }
+
+        SDL_NAME(arts_free) ();
+    }
+
+    /* Set the function pointers */
+    impl->OpenDevice = ARTS_OpenDevice;
+    impl->PlayDevice = ARTS_PlayDevice;
+    impl->WaitDevice = ARTS_WaitDevice;
+    impl->GetDeviceBuf = ARTS_GetDeviceBuf;
+    impl->CloseDevice = ARTS_CloseDevice;
+    impl->WaitDone = ARTS_WaitDone;
+    impl->Deinitialize = ARTS_Deinitialize;
+    impl->OnlyHasDefaultOutputDevice = 1;
+
+    return 1;
+}
+
+
+AudioBootStrap ARTS_bootstrap = {
+    ARTS_DRIVER_NAME, "Analog RealTime Synthesizer", ARTS_Init, 0
+};
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/arts/SDL_artsaudio.h

@@ -0,0 +1,53 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifndef _SDL_artscaudio_h
+#define _SDL_artscaudio_h
+
+#include <artsc.h>
+
+#include "../SDL_sysaudio.h"
+
+/* Hidden "this" pointer for the audio functions */
+#define _THIS	SDL_AudioDevice *this
+
+struct SDL_PrivateAudioData
+{
+    /* The stream descriptor for the audio device */
+    arts_stream_t stream;
+
+    /* The parent process id, to detect when application quits */
+    pid_t parent;
+
+    /* Raw mixing buffer */
+    Uint8 *mixbuf;
+    int mixlen;
+
+    /* Support for audio timing using a timer, in addition to select() */
+    float frame_ticks;
+    float next_frame;
+};
+#define FUDGE_TICKS	10      /* The scheduler overhead ticks per frame */
+
+#endif /* _SDL_artscaudio_h */
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/baudio/SDL_beaudio.cc

@@ -0,0 +1,218 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* Allow access to the audio stream on BeOS */
+
+#include <SoundPlayer.h>
+
+#include "../../main/beos/SDL_BeApp.h"
+
+extern "C"
+{
+
+#include "SDL_audio.h"
+#include "../SDL_audio_c.h"
+#include "../SDL_sysaudio.h"
+#include "../../thread/beos/SDL_systhread_c.h"
+#include "SDL_beaudio.h"
+
+}
+
+
+/* !!! FIXME: have the callback call the higher level to avoid code dupe. */
+/* The BeOS callback for handling the audio buffer */
+static void
+FillSound(void *device, void *stream, size_t len,
+          const media_raw_audio_format & format)
+{
+    SDL_AudioDevice *audio = (SDL_AudioDevice *) device;
+
+    /* Silence the buffer, since it's ours */
+    SDL_memset(stream, audio->spec.silence, len);
+
+    /* Only do soemthing if audio is enabled */
+    if (!audio->enabled)
+        return;
+
+    if (!audio->paused) {
+        if (audio->convert.needed) {
+            SDL_mutexP(audio->mixer_lock);
+            (*audio->spec.callback) (audio->spec.userdata,
+                                     (Uint8 *) audio->convert.buf,
+                                     audio->convert.len);
+            SDL_mutexV(audio->mixer_lock);
+            SDL_ConvertAudio(&audio->convert);
+            SDL_memcpy(stream, audio->convert.buf, audio->convert.len_cvt);
+        } else {
+            SDL_mutexP(audio->mixer_lock);
+            (*audio->spec.callback) (audio->spec.userdata,
+                                     (Uint8 *) stream, len);
+            SDL_mutexV(audio->mixer_lock);
+        }
+    }
+}
+
+static void
+BEOSAUDIO_CloseDevice(_THIS)
+{
+    if (_this->hidden != NULL) {
+        if (_this->hidden->audio_obj) {
+            _this->hidden->audio_obj->Stop();
+            delete _this->hidden->audio_obj;
+            _this->hidden->audio_obj = NULL;
+        }
+
+        delete _this->hidden;
+        _this->hidden = NULL;
+    }
+}
+
+static int
+BEOSAUDIO_OpenDevice(_THIS, const char *devname, int iscapture)
+{
+    int valid_datatype = 0;
+    media_raw_audio_format format;
+    SDL_AudioFormat test_format = SDL_FirstAudioFormat(_this->spec.format);
+
+    /* Initialize all variables that we clean on shutdown */
+    _this->hidden = new SDL_PrivateAudioData;
+    if (_this->hidden == NULL) {
+        SDL_OutOfMemory();
+        return 0;
+    }
+    SDL_memset(_this->hidden, 0, (sizeof *_this->hidden));
+
+    /* Parse the audio format and fill the Be raw audio format */
+    SDL_memset(&format, '\0', sizeof(media_raw_audio_format));
+    format.byte_order = B_MEDIA_LITTLE_ENDIAN;
+    format.frame_rate = (float) _this->spec.freq;
+    format.channel_count = _this->spec.channels;        /* !!! FIXME: support > 2? */
+    while ((!valid_datatype) && (test_format)) {
+        valid_datatype = 1;
+        _this->spec.format = test_format;
+        switch (test_format) {
+        case AUDIO_S8:
+            format.format = media_raw_audio_format::B_AUDIO_CHAR;
+            break;
+
+        case AUDIO_U8:
+            format.format = media_raw_audio_format::B_AUDIO_UCHAR;
+            break;
+
+        case AUDIO_S16LSB:
+            format.format = media_raw_audio_format::B_AUDIO_SHORT;
+            break;
+
+        case AUDIO_S16MSB:
+            format.format = media_raw_audio_format::B_AUDIO_SHORT;
+            format.byte_order = B_MEDIA_BIG_ENDIAN;
+            break;
+
+        case AUDIO_S32LSB:
+            format.format = media_raw_audio_format::B_AUDIO_INT;
+            break;
+
+        case AUDIO_S32MSB:
+            format.format = media_raw_audio_format::B_AUDIO_INT;
+            format.byte_order = B_MEDIA_BIG_ENDIAN;
+            break;
+
+        case AUDIO_F32LSB:
+            format.format = media_raw_audio_format::B_AUDIO_FLOAT;
+            break;
+
+        case AUDIO_F32MSB:
+            format.format = media_raw_audio_format::B_AUDIO_FLOAT;
+            format.byte_order = B_MEDIA_BIG_ENDIAN;
+            break;
+
+        default:
+            valid_datatype = 0;
+            test_format = SDL_NextAudioFormat();
+            break;
+        }
+    }
+
+    format.buffer_size = _this->spec.samples;
+
+    if (!valid_datatype) {      /* shouldn't happen, but just in case... */
+        BEOSAUDIO_CloseDevice(_this);
+        SDL_SetError("Unsupported audio format");
+        return 0;
+    }
+
+    /* Calculate the final parameters for this audio specification */
+    SDL_CalculateAudioSpec(&_this->spec);
+
+    /* Subscribe to the audio stream (creates a new thread) */
+    sigset_t omask;
+    SDL_MaskSignals(&omask);
+    _this->hidden->audio_obj = new BSoundPlayer(&format, "SDL Audio",
+                                                FillSound, NULL, _this);
+    SDL_UnmaskSignals(&omask);
+
+    if (_this->hidden->audio_obj->Start() == B_NO_ERROR) {
+        _this->hidden->audio_obj->SetHasData(true);
+    } else {
+        BEOSAUDIO_CloseDevice(_this);
+        SDL_SetError("Unable to start Be audio");
+        return 0;
+    }
+
+    /* We're running! */
+    return 1;
+}
+
+static void
+BEOSAUDIO_Deinitialize(void)
+{
+    SDL_QuitBeApp();
+}
+
+static int
+BEOSAUDIO_Init(SDL_AudioDriverImpl * impl)
+{
+    /* Initialize the Be Application, if it's not already started */
+    if (SDL_InitBeApp() < 0) {
+        return 0;
+    }
+
+    /* Set the function pointers */
+    impl->OpenDevice = BEOSAUDIO_OpenDevice;
+    impl->CloseDevice = BEOSAUDIO_CloseDevice;
+    impl->Deinitialize = BEOSAUDIO_Deinitialize;
+    impl->ProvidesOwnCallbackThread = 1;
+    impl->OnlyHasDefaultOutputDevice = 1;
+
+    return 1;
+}
+
+extern "C"
+{
+    extern AudioBootStrap BEOSAUDIO_bootstrap;
+}
+AudioBootStrap BEOSAUDIO_bootstrap = {
+    "baudio", "BeOS BSoundPlayer", BEOSAUDIO_Init, 0
+};
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/baudio/SDL_beaudio.h

@@ -0,0 +1,39 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifndef _SDL_beaudio_h
+#define _SDL_beaudio_h
+
+#include "../SDL_sysaudio.h"
+
+/* Hidden "this" pointer for the audio functions */
+#define _THIS	SDL_AudioDevice *_this
+
+struct SDL_PrivateAudioData
+{
+    BSoundPlayer *audio_obj;
+};
+
+#endif /* _SDL_beaudio_h */
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/bsd/SDL_bsdaudio.c

@@ -0,0 +1,455 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/*
+ * Driver for native OpenBSD/NetBSD audio(4).
+ * vedge@vedge.com.ar.
+ */
+
+#include <errno.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/time.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/audioio.h>
+
+#include "SDL_timer.h"
+#include "SDL_audio.h"
+#include "../SDL_audiomem.h"
+#include "../SDL_audio_c.h"
+#include "../SDL_audiodev_c.h"
+#include "SDL_bsdaudio.h"
+
+/* The tag name used by NetBSD/OpenBSD audio */
+#ifdef __NetBSD__
+#define BSD_AUDIO_DRIVER_NAME         "netbsd"
+#define BSD_AUDIO_DRIVER_DESC         "Native NetBSD audio"
+#else
+#define BSD_AUDIO_DRIVER_NAME         "openbsd"
+#define BSD_AUDIO_DRIVER_DESC         "Native OpenBSD audio"
+#endif
+
+/* Open the audio device for playback, and don't block if busy */
+/* #define USE_BLOCKING_WRITES */
+
+/* Use timer for synchronization */
+/* #define USE_TIMER_SYNC */
+
+/* #define DEBUG_AUDIO */
+/* #define DEBUG_AUDIO_STREAM */
+
+#ifdef USE_BLOCKING_WRITES
+#define OPEN_FLAGS_OUTPUT O_WRONLY
+#define OPEN_FLAGS_INPUT O_RDONLY
+#else
+#define OPEN_FLAGS_OUTPUT (O_WRONLY|O_NONBLOCK)
+#define OPEN_FLAGS_INPUT (O_RDONLY|O_NONBLOCK)
+#endif
+
+/* !!! FIXME: so much cut and paste with dsp/dma drivers... */
+static char **outputDevices = NULL;
+static int outputDeviceCount = 0;
+static char **inputDevices = NULL;
+static int inputDeviceCount = 0;
+
+static inline void
+free_device_list(char ***devs, int *count)
+{
+    SDL_FreeUnixAudioDevices(devs, count);
+}
+
+static inline void
+build_device_list(int iscapture, char ***devs, int *count)
+{
+    const int flags = ((iscapture) ? OPEN_FLAGS_INPUT : OPEN_FLAGS_OUTPUT);
+    free_device_list(devs, count);
+    SDL_EnumUnixAudioDevices(flags, 0, NULL, devs, count);
+}
+
+static inline void
+build_device_lists(void)
+{
+    build_device_list(0, &outputDevices, &outputDeviceCount);
+    build_device_list(1, &inputDevices, &inputDeviceCount);
+}
+
+
+static inline void
+free_device_lists(void)
+{
+    free_device_list(&outputDevices, &outputDeviceCount);
+    free_device_list(&inputDevices, &inputDeviceCount);
+}
+
+
+static void
+BSDAUDIO_Deinitialize(void)
+{
+    free_device_lists();
+}
+
+
+static int
+BSDAUDIO_DetectDevices(int iscapture)
+{
+    if (iscapture) {
+        build_device_list(1, &inputDevices, &inputDeviceCount);
+        return inputDeviceCount;
+    } else {
+        build_device_list(0, &outputDevices, &outputDeviceCount);
+        return outputDeviceCount;
+    }
+
+    return 0;                   /* shouldn't ever hit this. */
+}
+
+static const char *
+BSDAUDIO_GetDeviceName(int index, int iscapture)
+{
+    if ((iscapture) && (index < inputDeviceCount)) {
+        return inputDevices[index];
+    } else if ((!iscapture) && (index < outputDeviceCount)) {
+        return outputDevices[index];
+    }
+
+    SDL_SetError("No such device");
+    return NULL;
+}
+
+
+static void
+BSDAUDIO_Status(_THIS)
+{
+#ifdef DEBUG_AUDIO
+    /* *INDENT-OFF* */
+    audio_info_t info;
+
+    if (ioctl(this->hidden->audio_fd, AUDIO_GETINFO, &info) < 0) {
+        fprintf(stderr, "AUDIO_GETINFO failed.\n");
+        return;
+    }
+    fprintf(stderr, "\n"
+            "[play/record info]\n"
+            "buffer size	:   %d bytes\n"
+            "sample rate	:   %i Hz\n"
+            "channels	:   %i\n"
+            "precision	:   %i-bit\n"
+            "encoding	:   0x%x\n"
+            "seek		:   %i\n"
+            "sample count	:   %i\n"
+            "EOF count	:   %i\n"
+            "paused		:   %s\n"
+            "error occured	:   %s\n"
+            "waiting		:   %s\n"
+            "active		:   %s\n"
+            "",
+            info.play.buffer_size,
+            info.play.sample_rate,
+            info.play.channels,
+            info.play.precision,
+            info.play.encoding,
+            info.play.seek,
+            info.play.samples,
+            info.play.eof,
+            info.play.pause ? "yes" : "no",
+            info.play.error ? "yes" : "no",
+            info.play.waiting ? "yes" : "no",
+            info.play.active ? "yes" : "no");
+
+    fprintf(stderr, "\n"
+            "[audio info]\n"
+            "monitor_gain	:   %i\n"
+            "hw block size	:   %d bytes\n"
+            "hi watermark	:   %i\n"
+            "lo watermark	:   %i\n"
+            "audio mode	:   %s\n"
+            "",
+            info.monitor_gain,
+            info.blocksize,
+            info.hiwat, info.lowat,
+            (info.mode == AUMODE_PLAY) ? "PLAY"
+            : (info.mode = AUMODE_RECORD) ? "RECORD"
+            : (info.mode == AUMODE_PLAY_ALL ? "PLAY_ALL" : "?"));
+    /* *INDENT-ON* */
+#endif /* DEBUG_AUDIO */
+}
+
+
+/* This function waits until it is possible to write a full sound buffer */
+static void
+BSDAUDIO_WaitDevice(_THIS)
+{
+#ifndef USE_BLOCKING_WRITES     /* Not necessary when using blocking writes */
+    /* See if we need to use timed audio synchronization */
+    if (this->hidden->frame_ticks) {
+        /* Use timer for general audio synchronization */
+        Sint32 ticks;
+
+        ticks =
+            ((Sint32) (this->hidden->next_frame - SDL_GetTicks())) -
+            FUDGE_TICKS;
+        if (ticks > 0) {
+            SDL_Delay(ticks);
+        }
+    } else {
+        /* Use select() for audio synchronization */
+        fd_set fdset;
+        struct timeval timeout;
+
+        FD_ZERO(&fdset);
+        FD_SET(this->hidden->audio_fd, &fdset);
+        timeout.tv_sec = 10;
+        timeout.tv_usec = 0;
+#ifdef DEBUG_AUDIO
+        fprintf(stderr, "Waiting for audio to get ready\n");
+#endif
+        if (select(this->hidden->audio_fd + 1, NULL, &fdset, NULL, &timeout)
+            <= 0) {
+            const char *message =
+                "Audio timeout - buggy audio driver? (disabled)";
+            /* In general we should never print to the screen,
+               but in this case we have no other way of letting
+               the user know what happened.
+             */
+            fprintf(stderr, "SDL: %s\n", message);
+            this->enabled = 0;
+            /* Don't try to close - may hang */
+            this->hidden->audio_fd = -1;
+#ifdef DEBUG_AUDIO
+            fprintf(stderr, "Done disabling audio\n");
+#endif
+        }
+#ifdef DEBUG_AUDIO
+        fprintf(stderr, "Ready!\n");
+#endif
+    }
+#endif /* !USE_BLOCKING_WRITES */
+}
+
+static void
+BSDAUDIO_PlayDevice(_THIS)
+{
+    int written, p = 0;
+
+    /* Write the audio data, checking for EAGAIN on broken audio drivers */
+    do {
+        written = write(this->hidden->audio_fd,
+                        &this->hidden->mixbuf[p], this->hidden->mixlen - p);
+
+        if (written > 0)
+            p += written;
+        if (written == -1 && errno != 0 && errno != EAGAIN && errno != EINTR) {
+            /* Non recoverable error has occurred. It should be reported!!! */
+            perror("audio");
+            break;
+        }
+
+        if (p < written
+            || ((written < 0) && ((errno == 0) || (errno == EAGAIN)))) {
+            SDL_Delay(1);       /* Let a little CPU time go by */
+        }
+    } while (p < written);
+
+    /* If timer synchronization is enabled, set the next write frame */
+    if (this->hidden->frame_ticks) {
+        this->hidden->next_frame += this->hidden->frame_ticks;
+    }
+
+    /* If we couldn't write, assume fatal error for now */
+    if (written < 0) {
+        this->enabled = 0;
+    }
+#ifdef DEBUG_AUDIO
+    fprintf(stderr, "Wrote %d bytes of audio data\n", written);
+#endif
+}
+
+static Uint8 *
+BSDAUDIO_GetDeviceBuf(_THIS)
+{
+    return (this->hidden->mixbuf);
+}
+
+static void
+BSDAUDIO_CloseDevice(_THIS)
+{
+    if (this->hidden != NULL) {
+        if (this->hidden->mixbuf != NULL) {
+            SDL_FreeAudioMem(this->hidden->mixbuf);
+            this->hidden->mixbuf = NULL;
+        }
+        if (this->hidden->audio_fd >= 0) {
+            close(this->hidden->audio_fd);
+            this->hidden->audio_fd = -1;
+        }
+        SDL_free(this->hidden);
+        this->hidden = NULL;
+    }
+}
+
+static int
+BSDAUDIO_OpenDevice(_THIS, const char *devname, int iscapture)
+{
+    const int flags = ((iscapture) ? OPEN_FLAGS_INPUT : OPEN_FLAGS_OUTPUT);
+    SDL_AudioFormat format = 0;
+    audio_info_t info;
+
+    /* We don't care what the devname is...we'll try to open anything. */
+    /*  ...but default to first name in the list... */
+    if (devname == NULL) {
+        if (((iscapture) && (inputDeviceCount == 0)) ||
+            ((!iscapture) && (outputDeviceCount == 0))) {
+            SDL_SetError("No such audio device");
+            return 0;
+        }
+        devname = ((iscapture) ? inputDevices[0] : outputDevices[0]);
+    }
+
+    /* Initialize all variables that we clean on shutdown */
+    this->hidden = (struct SDL_PrivateAudioData *)
+        SDL_malloc((sizeof *this->hidden));
+    if (this->hidden == NULL) {
+        SDL_OutOfMemory();
+        return 0;
+    }
+    SDL_memset(this->hidden, 0, (sizeof *this->hidden));
+
+    /* Open the audio device */
+    this->hidden->audio_fd = open(devname, flags, 0);
+    if (this->hidden->audio_fd < 0) {
+        SDL_SetError("Couldn't open %s: %s", devname, strerror(errno));
+        return 0;
+    }
+
+    AUDIO_INITINFO(&info);
+
+    /* Calculate the final parameters for this audio specification */
+    SDL_CalculateAudioSpec(&this->spec);
+
+    /* Set to play mode */
+    info.mode = AUMODE_PLAY;
+    if (ioctl(this->hidden->audio_fd, AUDIO_SETINFO, &info) < 0) {
+        BSDAUDIO_CloseDevice(this);
+        SDL_SetError("Couldn't put device into play mode");
+        return 0;
+    }
+
+    AUDIO_INITINFO(&info);
+    for (format = SDL_FirstAudioFormat(this->spec.format);
+         format; format = SDL_NextAudioFormat()) {
+        switch (format) {
+        case AUDIO_U8:
+            info.play.encoding = AUDIO_ENCODING_ULINEAR;
+            info.play.precision = 8;
+            break;
+        case AUDIO_S8:
+            info.play.encoding = AUDIO_ENCODING_SLINEAR;
+            info.play.precision = 8;
+            break;
+        case AUDIO_S16LSB:
+            info.play.encoding = AUDIO_ENCODING_SLINEAR_LE;
+            info.play.precision = 16;
+            break;
+        case AUDIO_S16MSB:
+            info.play.encoding = AUDIO_ENCODING_SLINEAR_BE;
+            info.play.precision = 16;
+            break;
+        case AUDIO_U16LSB:
+            info.play.encoding = AUDIO_ENCODING_ULINEAR_LE;
+            info.play.precision = 16;
+            break;
+        case AUDIO_U16MSB:
+            info.play.encoding = AUDIO_ENCODING_ULINEAR_BE;
+            info.play.precision = 16;
+            break;
+        default:
+            continue;
+        }
+
+        if (ioctl(this->hidden->audio_fd, AUDIO_SETINFO, &info) == 0) {
+            break;
+        }
+    }
+
+    if (!format) {
+        BSDAUDIO_CloseDevice(this);
+        SDL_SetError("No supported encoding for 0x%x", this->spec.format);
+        return 0;
+    }
+
+    this->spec.format = format;
+
+    AUDIO_INITINFO(&info);
+    info.play.channels = this->spec.channels;
+    if (ioctl(this->hidden->audio_fd, AUDIO_SETINFO, &info) == -1) {
+        this->spec.channels = 1;
+    }
+    AUDIO_INITINFO(&info);
+    info.play.sample_rate = this->spec.freq;
+    info.blocksize = this->spec.size;
+    info.hiwat = 5;
+    info.lowat = 3;
+    (void) ioctl(this->hidden->audio_fd, AUDIO_SETINFO, &info);
+    (void) ioctl(this->hidden->audio_fd, AUDIO_GETINFO, &info);
+    this->spec.freq = info.play.sample_rate;
+    /* Allocate mixing buffer */
+    this->hidden->mixlen = this->spec.size;
+    this->hidden->mixbuf = (Uint8 *) SDL_AllocAudioMem(this->hidden->mixlen);
+    if (this->hidden->mixbuf == NULL) {
+        BSDAUDIO_CloseDevice(this);
+        SDL_OutOfMemory();
+        return 0;
+    }
+    SDL_memset(this->hidden->mixbuf, this->spec.silence, this->spec.size);
+
+    BSDAUDIO_Status(this);
+
+    /* We're ready to rock and roll. :-) */
+    return (0);
+}
+
+static int
+BSDAUDIO_Init(SDL_AudioDriverImpl * impl)
+{
+    /* Set the function pointers */
+    impl->DetectDevices = BSDAUDIO_DetectDevices;
+    impl->GetDeviceName = BSDAUDIO_GetDeviceName;
+    impl->OpenDevice = BSDAUDIO_OpenDevice;
+    impl->PlayDevice = BSDAUDIO_PlayDevice;
+    impl->WaitDevice = BSDAUDIO_WaitDevice;
+    impl->GetDeviceBuf = BSDAUDIO_GetDeviceBuf;
+    impl->CloseDevice = BSDAUDIO_CloseDevice;
+    impl->Deinitialize = BSDAUDIO_Deinitialize;
+
+    build_device_lists();
+    return (outputDeviceCount > 0) ? 2 : 1;
+}
+
+
+AudioBootStrap BSD_AUDIO_bootstrap = {
+    BSD_AUDIO_DRIVER_NAME, BSD_AUDIO_DRIVER_DESC, BSDAUDIO_Init, 0
+};
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/bsd/SDL_bsdaudio.h

@@ -0,0 +1,52 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifndef _SDL_bsdaudio_h
+#define _SDL_bsdaudio_h
+
+#include "../SDL_sysaudio.h"
+
+#define _THIS	SDL_AudioDevice *this
+
+struct SDL_PrivateAudioData
+{
+    /* The file descriptor for the audio device */
+    int audio_fd;
+
+    /* The parent process id, to detect when application quits */
+    pid_t parent;
+
+    /* Raw mixing buffer */
+    Uint8 *mixbuf;
+    int mixlen;
+
+    /* Support for audio timing using a timer, in addition to select() */
+    float frame_ticks;
+    float next_frame;
+};
+
+#define FUDGE_TICKS	10      /* The scheduler overhead ticks per frame */
+
+#endif /* _SDL_bsdaudio_h */
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/disk/SDL_diskaudio.c

@@ -0,0 +1,168 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+
+    This file written by Ryan C. Gordon (icculus@icculus.org)
+*/
+#include "SDL_config.h"
+
+/* Output raw audio data to a file. */
+
+#if HAVE_STDIO_H
+#include <stdio.h>
+#endif
+
+#include "SDL_rwops.h"
+#include "SDL_timer.h"
+#include "SDL_audio.h"
+#include "../SDL_audiomem.h"
+#include "../SDL_audio_c.h"
+#include "SDL_diskaudio.h"
+
+/* The tag name used by DISK audio */
+#define DISKAUD_DRIVER_NAME         "disk"
+
+/* environment variables and defaults. */
+#define DISKENVR_OUTFILE         "SDL_DISKAUDIOFILE"
+#define DISKDEFAULT_OUTFILE      "sdlaudio.raw"
+#define DISKENVR_WRITEDELAY      "SDL_DISKAUDIODELAY"
+#define DISKDEFAULT_WRITEDELAY   150
+
+static const char *
+DISKAUD_GetOutputFilename(const char *devname)
+{
+    if (devname == NULL) {
+        devname = SDL_getenv(DISKENVR_OUTFILE);
+        if (devname == NULL) {
+            devname = DISKDEFAULT_OUTFILE;
+        }
+    }
+    return devname;
+}
+
+/* This function waits until it is possible to write a full sound buffer */
+static void
+DISKAUD_WaitDevice(_THIS)
+{
+    SDL_Delay(this->hidden->write_delay);
+}
+
+static void
+DISKAUD_PlayDevice(_THIS)
+{
+    size_t written;
+
+    /* Write the audio data */
+    written = SDL_RWwrite(this->hidden->output,
+                          this->hidden->mixbuf, 1, this->hidden->mixlen);
+
+    /* If we couldn't write, assume fatal error for now */
+    if (written != this->hidden->mixlen) {
+        this->enabled = 0;
+    }
+#ifdef DEBUG_AUDIO
+    fprintf(stderr, "Wrote %d bytes of audio data\n", written);
+#endif
+}
+
+static Uint8 *
+DISKAUD_GetDeviceBuf(_THIS)
+{
+    return (this->hidden->mixbuf);
+}
+
+static void
+DISKAUD_CloseDevice(_THIS)
+{
+    if (this->hidden != NULL) {
+        if (this->hidden->mixbuf != NULL) {
+            SDL_FreeAudioMem(this->hidden->mixbuf);
+            this->hidden->mixbuf = NULL;
+        }
+        if (this->hidden->output != NULL) {
+            SDL_RWclose(this->hidden->output);
+            this->hidden->output = NULL;
+        }
+        SDL_free(this->hidden);
+        this->hidden = NULL;
+    }
+}
+
+static int
+DISKAUD_OpenDevice(_THIS, const char *devname, int iscapture)
+{
+    const char *envr = SDL_getenv(DISKENVR_WRITEDELAY);
+    const char *fname = DISKAUD_GetOutputFilename(devname);
+
+    this->hidden = (struct SDL_PrivateAudioData *)
+        SDL_malloc(sizeof(*this->hidden));
+    if (this->hidden == NULL) {
+        SDL_OutOfMemory();
+        return 0;
+    }
+    SDL_memset(this->hidden, 0, sizeof(*this->hidden));
+
+    /* Open the audio device */
+    this->hidden->output = SDL_RWFromFile(fname, "wb");
+    if (this->hidden->output == NULL) {
+        DISKAUD_CloseDevice(this);
+        return 0;
+    }
+
+    /* Allocate mixing buffer */
+    this->hidden->mixbuf = (Uint8 *) SDL_AllocAudioMem(this->hidden->mixlen);
+    if (this->hidden->mixbuf == NULL) {
+        DISKAUD_CloseDevice(this);
+        return 0;
+    }
+    SDL_memset(this->hidden->mixbuf, this->spec.silence, this->spec.size);
+
+    this->hidden->mixlen = this->spec.size;
+    this->hidden->write_delay =
+        (envr) ? SDL_atoi(envr) : DISKDEFAULT_WRITEDELAY;
+
+#if HAVE_STDIO_H
+    fprintf(stderr,
+            "WARNING: You are using the SDL disk writer audio driver!\n"
+            " Writing to file [%s].\n", fname);
+#endif
+
+    /* We're ready to rock and roll. :-) */
+    return 1;
+}
+
+static int
+DISKAUD_Init(SDL_AudioDriverImpl * impl)
+{
+    /* Set the function pointers */
+    impl->OpenDevice = DISKAUD_OpenDevice;
+    impl->WaitDevice = DISKAUD_WaitDevice;
+    impl->PlayDevice = DISKAUD_PlayDevice;
+    impl->GetDeviceBuf = DISKAUD_GetDeviceBuf;
+    impl->CloseDevice = DISKAUD_CloseDevice;
+
+    return 1;
+}
+
+AudioBootStrap DISKAUD_bootstrap = {
+    DISKAUD_DRIVER_NAME, "direct-to-disk audio", DISKAUD_Init, 1
+};
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/disk/SDL_diskaudio.h

@@ -0,0 +1,43 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifndef _SDL_diskaudio_h
+#define _SDL_diskaudio_h
+
+#include "SDL_rwops.h"
+#include "../SDL_sysaudio.h"
+
+/* Hidden "this" pointer for the audio functions */
+#define _THIS	SDL_AudioDevice *this
+
+struct SDL_PrivateAudioData
+{
+    /* The file descriptor for the audio device */
+    SDL_RWops *output;
+    Uint8 *mixbuf;
+    Uint32 mixlen;
+    Uint32 write_delay;
+};
+
+#endif /* _SDL_diskaudio_h */
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/dma/SDL_dmaaudio.c

@@ -0,0 +1,534 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* !!! FIXME: merge this driver with "dsp". */
+
+/* Allow access to a raw mixing buffer */
+
+#include <stdio.h>
+#include <string.h>             /* For strerror() */
+#include <errno.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+
+#if SDL_AUDIO_DRIVER_OSS_SOUNDCARD_H
+/* This is installed on some systems */
+#include <soundcard.h>
+#else
+/* This is recommended by OSS */
+#include <sys/soundcard.h>
+#endif
+
+#ifndef MAP_FAILED
+#define MAP_FAILED	((Uint8 *)-1)
+#endif
+
+#include "SDL_timer.h"
+#include "SDL_audio.h"
+#include "../SDL_audio_c.h"
+#include "../SDL_audiodev_c.h"
+#include "SDL_dmaaudio.h"
+
+/* The tag name used by DMA audio */
+#define DMA_DRIVER_NAME         "dma"
+
+/* Open the audio device for playback, and don't block if busy */
+#define OPEN_FLAGS_INPUT    (O_RDWR|O_NONBLOCK)
+#define OPEN_FLAGS_OUTPUT   (O_RDWR|O_NONBLOCK)
+
+static char **outputDevices = NULL;
+static int outputDeviceCount = 0;
+static char **inputDevices = NULL;
+static int inputDeviceCount = 0;
+
+static int
+test_for_mmap(int fd)
+{
+    int caps = 0;
+    struct audio_buf_info info;
+    if ((ioctl(fd, SNDCTL_DSP_GETCAPS, &caps) == 0) &&
+        (caps & DSP_CAP_TRIGGER) && (caps & DSP_CAP_MMAP) &&
+        (ioctl(fd, SNDCTL_DSP_GETOSPACE, &info) == 0)) {
+        size_t len = info.fragstotal * info.fragsize;
+        Uint8 *buf = (Uint8 *) mmap(NULL, len, PROT_WRITE, MAP_SHARED, fd, 0);
+        if (buf != MAP_FAILED) {
+            munmap(buf, len);
+            return 1;
+        }
+    }
+    return 0;
+}
+
+
+static inline void
+free_device_list(char ***devs, int *count)
+{
+    SDL_FreeUnixAudioDevices(devs, count);
+}
+
+static inline void
+build_device_list(int iscapture, char ***devs, int *count)
+{
+    const int flags = ((iscapture) ? OPEN_FLAGS_INPUT : OPEN_FLAGS_OUTPUT);
+    free_device_list(devs, count);
+    SDL_EnumUnixAudioDevices(flags, 0, test_for_mmap, devs, count);
+}
+
+static inline void
+build_device_lists(void)
+{
+    build_device_list(0, &outputDevices, &outputDeviceCount);
+    build_device_list(1, &inputDevices, &inputDeviceCount);
+}
+
+
+static inline void
+free_device_lists(void)
+{
+    free_device_list(&outputDevices, &outputDeviceCount);
+    free_device_list(&inputDevices, &inputDeviceCount);
+}
+
+
+static void
+DMA_Deinitialize(void)
+{
+    free_device_lists();
+}
+
+static int
+DMA_DetectDevices(int iscapture)
+{
+    if (iscapture) {
+        build_device_list(1, &inputDevices, &inputDeviceCount);
+        return inputDeviceCount;
+    } else {
+        build_device_list(0, &outputDevices, &outputDeviceCount);
+        return outputDeviceCount;
+    }
+
+    return 0;                   /* shouldn't ever hit this. */
+}
+
+
+static const char *
+DMA_GetDeviceName(int index, int iscapture)
+{
+    if ((iscapture) && (index < inputDeviceCount)) {
+        return inputDevices[index];
+    } else if ((!iscapture) && (index < outputDeviceCount)) {
+        return outputDevices[index];
+    }
+
+    SDL_SetError("No such device");
+    return NULL;
+}
+
+
+static int
+DMA_ReopenAudio(_THIS, const char *audiodev, int format, int stereo)
+{
+    int frag_spec;
+    int value;
+
+    /* Close and then reopen the audio device */
+    close(audio_fd);
+    audio_fd = open(audiodev, O_RDWR, 0);
+    if (audio_fd < 0) {
+        SDL_SetError("Couldn't open %s: %s", audiodev, strerror(errno));
+        return (-1);
+    }
+
+    /* Calculate the final parameters for this audio specification */
+    SDL_CalculateAudioSpec(&this->spec);
+
+    /* Determine the power of two of the fragment size */
+    for (frag_spec = 0; (0x01 << frag_spec) < this->spec.size; ++frag_spec);
+    if ((0x01 << frag_spec) != this->spec.size) {
+        SDL_SetError("Fragment size must be a power of two");
+        return (-1);
+    }
+
+    /* Set the audio buffering parameters */
+    if (ioctl(audio_fd, SNDCTL_DSP_SETFRAGMENT, &frag_spec) < 0) {
+        SDL_SetError("Couldn't set audio fragment spec");
+        return (-1);
+    }
+
+    /* Set the audio format */
+    value = format;
+    if ((ioctl(audio_fd, SNDCTL_DSP_SETFMT, &value) < 0) || (value != format)) {
+        SDL_SetError("Couldn't set audio format");
+        return (-1);
+    }
+
+    /* Set mono or stereo audio */
+    value = (this->spec.channels > 1);
+    if ((ioctl(audio_fd, SNDCTL_DSP_STEREO, &stereo) < 0) ||
+        (value != stereo)) {
+        SDL_SetError("Couldn't set audio channels");
+        return (-1);
+    }
+
+    /* Set the DSP frequency */
+    value = this->spec.freq;
+    if (ioctl(audio_fd, SNDCTL_DSP_SPEED, &value) < 0) {
+        SDL_SetError("Couldn't set audio frequency");
+        return (-1);
+    }
+    this->spec.freq = value;
+
+    /* We successfully re-opened the audio */
+    return (0);
+}
+
+
+static void
+DMA_CloseDevice(_THIS)
+{
+    if (this->hidden != NULL) {
+        if (dma_buf != NULL) {
+            munmap(dma_buf, dma_len);
+            dma_buf = NULL;
+        }
+        if (audio_fd >= 0) {
+            close(audio_fd);
+            audio_fd = -1;
+        }
+        SDL_free(this->hidden);
+        this->hidden = NULL;
+    }
+}
+
+
+static int
+DMA_OpenDevice(_THIS, const char *devname, int iscapture)
+{
+    const int flags = ((iscapture) ? OPEN_FLAGS_INPUT : OPEN_FLAGS_OUTPUT);
+    int format;
+    int stereo;
+    int value;
+    SDL_AudioFormat test_format;
+    struct audio_buf_info info;
+
+    /* We don't care what the devname is...we'll try to open anything. */
+    /*  ...but default to first name in the list... */
+    if (devname == NULL) {
+        if (((iscapture) && (inputDeviceCount == 0)) ||
+            ((!iscapture) && (outputDeviceCount == 0))) {
+            SDL_SetError("No such audio device");
+            return 0;
+        }
+        devname = ((iscapture) ? inputDevices[0] : outputDevices[0]);
+    }
+
+    /* Initialize all variables that we clean on shutdown */
+    this->hidden = (struct SDL_PrivateAudioData *)
+        SDL_malloc((sizeof *this->hidden));
+    if (this->hidden == NULL) {
+        SDL_OutOfMemory();
+        return 0;
+    }
+    SDL_memset(this->hidden, 0, (sizeof *this->hidden));
+
+    /* Open the audio device */
+    audio_fd = open(devname, flags, 0);
+    if (audio_fd < 0) {
+        DMA_CloseDevice(this);
+        SDL_SetError("Couldn't open %s: %s", devname, strerror(errno));
+        return 0;
+    }
+    dma_buf = NULL;
+    ioctl(audio_fd, SNDCTL_DSP_RESET, 0);
+
+    /* Get a list of supported hardware formats */
+    if (ioctl(audio_fd, SNDCTL_DSP_GETFMTS, &value) < 0) {
+        DMA_CloseDevice(this);
+        SDL_SetError("Couldn't get audio format list");
+        return 0;
+    }
+
+    /* Try for a closest match on audio format */
+    format = 0;
+    for (test_format = SDL_FirstAudioFormat(this->spec.format);
+         !format && test_format;) {
+#ifdef DEBUG_AUDIO
+        fprintf(stderr, "Trying format 0x%4.4x\n", test_format);
+#endif
+        switch (test_format) {
+        case AUDIO_U8:
+            if (value & AFMT_U8) {
+                format = AFMT_U8;
+            }
+            break;
+        case AUDIO_S8:
+            if (value & AFMT_S8) {
+                format = AFMT_S8;
+            }
+            break;
+        case AUDIO_S16LSB:
+            if (value & AFMT_S16_LE) {
+                format = AFMT_S16_LE;
+            }
+            break;
+        case AUDIO_S16MSB:
+            if (value & AFMT_S16_BE) {
+                format = AFMT_S16_BE;
+            }
+            break;
+        case AUDIO_U16LSB:
+            if (value & AFMT_U16_LE) {
+                format = AFMT_U16_LE;
+            }
+            break;
+        case AUDIO_U16MSB:
+            if (value & AFMT_U16_BE) {
+                format = AFMT_U16_BE;
+            }
+            break;
+        default:
+            format = 0;
+            break;
+        }
+        if (!format) {
+            test_format = SDL_NextAudioFormat();
+        }
+    }
+    if (format == 0) {
+        DMA_CloseDevice(this);
+        SDL_SetError("Couldn't find any hardware audio formats");
+        return 0;
+    }
+    this->spec.format = test_format;
+
+    /* Set the audio format */
+    value = format;
+    if ((ioctl(audio_fd, SNDCTL_DSP_SETFMT, &value) < 0) || (value != format)) {
+        DMA_CloseDevice(this);
+        SDL_SetError("Couldn't set audio format");
+        return 0;
+    }
+
+    /* Set mono or stereo audio (currently only two channels supported) */
+    stereo = (this->spec.channels > 1);
+    ioctl(audio_fd, SNDCTL_DSP_STEREO, &stereo);
+    if (stereo) {
+        this->spec.channels = 2;
+    } else {
+        this->spec.channels = 1;
+    }
+
+    /* Because some drivers don't allow setting the buffer size
+       after setting the format, we must re-open the audio device
+       once we know what format and channels are supported
+     */
+    if (DMA_ReopenAudio(this, devname, format, stereo) < 0) {
+        DMA_CloseDevice(this);
+        /* Error is set by DMA_ReopenAudio() */
+        return 0;
+    }
+
+    /* Memory map the audio buffer */
+    if (ioctl(audio_fd, SNDCTL_DSP_GETOSPACE, &info) < 0) {
+        DMA_CloseDevice(this);
+        SDL_SetError("Couldn't get OSPACE parameters");
+        return 0;
+    }
+    this->spec.size = info.fragsize;
+    this->spec.samples = this->spec.size / ((this->spec.format & 0xFF) / 8);
+    this->spec.samples /= this->spec.channels;
+    num_buffers = info.fragstotal;
+    dma_len = num_buffers * this->spec.size;
+    dma_buf = (Uint8 *) mmap(NULL, dma_len, PROT_WRITE, MAP_SHARED,
+                             audio_fd, 0);
+    if (dma_buf == MAP_FAILED) {
+        DMA_CloseDevice(this);
+        SDL_SetError("DMA memory map failed");
+        dma_buf = NULL;
+        return 0;
+    }
+    SDL_memset(dma_buf, this->spec.silence, dma_len);
+
+    /* Check to see if we need to use select() workaround */
+    {
+        char *workaround;
+        workaround = SDL_getenv("SDL_DSP_NOSELECT");
+        if (workaround) {
+            frame_ticks =
+                (float) (this->spec.samples * 1000) / this->spec.freq;
+            next_frame = SDL_GetTicks() + frame_ticks;
+        }
+    }
+
+    /* Trigger audio playback */
+    value = 0;
+    ioctl(audio_fd, SNDCTL_DSP_SETTRIGGER, &value);
+    value = PCM_ENABLE_OUTPUT;
+    if (ioctl(audio_fd, SNDCTL_DSP_SETTRIGGER, &value) < 0) {
+        DMA_CloseDevice(this);
+        SDL_SetError("Couldn't trigger audio output");
+        return 0;
+    }
+
+    /* Get the parent process id (we're the parent of the audio thread) */
+    parent = getpid();
+
+    /* We're ready to rock and roll. :-) */
+    return 1;
+}
+
+
+/* This function waits until it is possible to write a full sound buffer */
+static void
+DMA_WaitDevice(_THIS)
+{
+    fd_set fdset;
+
+    /* Check to see if the thread-parent process is still alive */
+    {
+        static int cnt = 0;
+        /* Note that this only works with thread implementations 
+           that use a different process id for each thread.
+         */
+        if (parent && (((++cnt) % 10) == 0)) {  /* Check every 10 loops */
+            if (kill(parent, 0) < 0 && errno == ESRCH) {
+                this->enabled = 0;
+            }
+        }
+    }
+
+    /* See if we need to use timed audio synchronization */
+    if (frame_ticks) {
+        /* Use timer for general audio synchronization */
+        Sint32 ticks;
+
+        ticks = ((Sint32) (next_frame - SDL_GetTicks())) - FUDGE_TICKS;
+        if (ticks > 0) {
+            SDL_Delay(ticks);
+        }
+    } else {
+        /* Use select() for audio synchronization */
+        struct timeval timeout;
+        FD_ZERO(&fdset);
+        FD_SET(audio_fd, &fdset);
+        timeout.tv_sec = 10;
+        timeout.tv_usec = 0;
+#ifdef DEBUG_AUDIO
+        fprintf(stderr, "Waiting for audio to get ready\n");
+#endif
+        if (select(audio_fd + 1, NULL, &fdset, NULL, &timeout) <= 0) {
+            const char *message =
+#ifdef AUDIO_OSPACE_HACK
+                "Audio timeout - buggy audio driver? (trying ospace)";
+#else
+                "Audio timeout - buggy audio driver? (disabled)";
+#endif
+            /* In general we should never print to the screen,
+               but in this case we have no other way of letting
+               the user know what happened.
+             */
+            fprintf(stderr, "SDL: %s\n", message);
+#ifdef AUDIO_OSPACE_HACK
+            /* We may be able to use GET_OSPACE trick */
+            frame_ticks = (float) (this->spec.samples * 1000) /
+                this->spec.freq;
+            next_frame = SDL_GetTicks() + frame_ticks;
+#else
+            this->enabled = 0;
+            /* Don't try to close - may hang */
+            audio_fd = -1;
+#ifdef DEBUG_AUDIO
+            fprintf(stderr, "Done disabling audio\n");
+#endif
+#endif /* AUDIO_OSPACE_HACK */
+        }
+#ifdef DEBUG_AUDIO
+        fprintf(stderr, "Ready!\n");
+#endif
+    }
+}
+
+static void
+DMA_PlayDevice(_THIS)
+{
+    /* If timer synchronization is enabled, set the next write frame */
+    if (frame_ticks) {
+        next_frame += frame_ticks;
+    }
+    return;
+}
+
+static Uint8 *
+DMA_GetDeviceBuf(_THIS)
+{
+    count_info info;
+    int playing;
+    int filling;
+
+    /* Get number of blocks, looping if we're not using select() */
+    do {
+        if (ioctl(audio_fd, SNDCTL_DSP_GETOPTR, &info) < 0) {
+            /* Uh oh... */
+            this->enabled = 0;
+            return (NULL);
+        }
+    } while (frame_ticks && (info.blocks < 1));
+#ifdef DEBUG_AUDIO
+    if (info.blocks > 1) {
+        printf("Warning: audio underflow (%d frags)\n", info.blocks - 1);
+    }
+#endif
+    playing = info.ptr / this->spec.size;
+    filling = (playing + 1) % num_buffers;
+    return (dma_buf + (filling * this->spec.size));
+}
+
+
+static int
+DMA_Init(SDL_AudioDriverImpl * impl)
+{
+    /* Set the function pointers */
+    impl->DetectDevices = DMA_DetectDevices;
+    impl->GetDeviceName = DMA_GetDeviceName;
+    impl->OpenDevice = DMA_OpenDevice;
+    impl->WaitDevice = DMA_WaitDevice;
+    impl->PlayDevice = DMA_PlayDevice;
+    impl->GetDeviceBuf = DMA_GetDeviceBuf;
+    impl->CloseDevice = DMA_CloseDevice;
+    impl->Deinitialize = DMA_Deinitialize;
+
+    build_device_lists();
+    return (outputDeviceCount > 0) ? 2 : 1;
+}
+
+AudioBootStrap DMA_bootstrap = {
+    DMA_DRIVER_NAME, "OSS /dev/dsp DMA audio", DMA_Init, 0
+};
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/dma/SDL_dmaaudio.h

@@ -0,0 +1,63 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifndef _SDL_dmaaudio_h
+#define _SDL_dmaaudio_h
+
+#include "../SDL_sysaudio.h"
+
+/* Hidden "this" pointer for the audio functions */
+#define _THIS	SDL_AudioDevice *this
+
+struct SDL_PrivateAudioData
+{
+    /* The file descriptor for the audio device */
+    int audio_fd;
+
+    /* The parent process id, to detect when application quits */
+    pid_t parent;
+
+    /* Raw mixing buffer */
+    Uint8 *dma_buf;
+    int dma_len;
+    int num_buffers;
+
+    /* Support for audio timing using a timer, in addition to select() */
+    float frame_ticks;
+    float next_frame;
+};
+#define FUDGE_TICKS	10      /* The scheduler overhead ticks per frame */
+
+/* Old variable names */
+/* !!! FIXME: remove these. */
+#define audio_fd		(this->hidden->audio_fd)
+#define parent			(this->hidden->parent)
+#define dma_buf			(this->hidden->dma_buf)
+#define dma_len			(this->hidden->dma_len)
+#define num_buffers		(this->hidden->num_buffers)
+#define frame_ticks		(this->hidden->frame_ticks)
+#define next_frame		(this->hidden->next_frame)
+
+#endif /* _SDL_dmaaudio_h */
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/dmedia/SDL_irixaudio.c

@@ -0,0 +1,238 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include <errno.h>
+#include "SDL_config.h"
+
+/* Allow access to a raw mixing buffer (For IRIX 6.5 and higher) */
+/* patch for IRIX 5 by Georg Schwarz 18/07/2004 */
+
+#include "SDL_timer.h"
+#include "SDL_audio.h"
+#include "../SDL_audiomem.h"
+#include "../SDL_audio_c.h"
+#include "SDL_irixaudio.h"
+
+
+#ifndef AL_RESOURCE             /* as a test whether we use the old IRIX audio libraries */
+#define OLD_IRIX_AUDIO
+#define alClosePort(x) ALcloseport(x)
+#define alFreeConfig(x) ALfreeconfig(x)
+#define alGetFillable(x) ALgetfillable(x)
+#define alNewConfig() ALnewconfig()
+#define alOpenPort(x,y,z) ALopenport(x,y,z)
+#define alSetChannels(x,y) ALsetchannels(x,y)
+#define alSetQueueSize(x,y) ALsetqueuesize(x,y)
+#define alSetSampFmt(x,y) ALsetsampfmt(x,y)
+#define alSetWidth(x,y) ALsetwidth(x,y)
+#endif
+
+void static
+IRIXAUDIO_WaitDevice(_THIS)
+{
+    Sint32 timeleft;
+
+    timeleft = this->spec.samples - alGetFillable(this->hidden->audio_port);
+    if (timeleft > 0) {
+        timeleft /= (this->spec.freq / 1000);
+        SDL_Delay((Uint32) timeleft);
+    }
+}
+
+static void
+IRIXAUDIO_PlayDevice(_THIS)
+{
+    /* Write the audio data out */
+    ALport port = this->hidden->audio_port;
+    Uint8 *mixbuf = this->hidden->mixbuf;
+    if (alWriteFrames(port, mixbuf, this->spec.samples) < 0) {
+        /* Assume fatal error, for now */
+        this->enabled = 0;
+    }
+}
+
+static Uint8 *
+IRIXAUDIO_GetDeviceBuf(_THIS)
+{
+    return (this->hidden->mixbuf);
+}
+
+static void
+IRIXAUDIO_CloseDevice(_THIS)
+{
+    if (this->hidden != NULL) {
+        if (this->hidden->mixbuf != NULL) {
+            SDL_FreeAudioMem(this->hidden->mixbuf);
+            this->hidden->mixbuf = NULL;
+        }
+        if (this->hidden->audio_port != NULL) {
+            alClosePort(this->hidden->audio_port);
+            this->hidden->audio_port = NULL;
+        }
+        SDL_free(this->hidden);
+        this->hidden = NULL;
+    }
+}
+
+static int
+IRIXAUDIO_OpenDevice(_THIS, const char *devname, int iscapture)
+{
+    SDL_AudioFormat test_format = SDL_FirstAudioFormat(this->spec.format);
+    long width = 0;
+    long fmt = 0;
+    int valid = 0;
+
+    /* !!! FIXME: Handle multiple devices and capture? */
+
+    /* Initialize all variables that we clean on shutdown */
+    this->hidden = (struct SDL_PrivateAudioData *)
+        SDL_malloc((sizeof *this->hidden));
+    if (this->hidden == NULL) {
+        SDL_OutOfMemory();
+        return 0;
+    }
+    SDL_memset(this->hidden, 0, (sizeof *this->hidden));
+
+#ifdef OLD_IRIX_AUDIO
+    {
+        long audio_param[2];
+        audio_param[0] = AL_OUTPUT_RATE;
+        audio_param[1] = this->spec.freq;
+        valid = (ALsetparams(AL_DEFAULT_DEVICE, audio_param, 2) < 0);
+    }
+#else
+    {
+        ALpv audio_param;
+        audio_param.param = AL_RATE;
+        audio_param.value.i = this->spec.freq;
+        valid = (alSetParams(AL_DEFAULT_OUTPUT, &audio_param, 1) < 0);
+    }
+#endif
+
+    while ((!valid) && (test_format)) {
+        valid = 1;
+        this->spec.format = test_format;
+
+        switch (test_format) {
+        case AUDIO_S8:
+            width = AL_SAMPLE_8;
+            fmt = AL_SAMPFMT_TWOSCOMP;
+            break;
+
+        case AUDIO_S16SYS:
+            width = AL_SAMPLE_16;
+            fmt = AL_SAMPFMT_TWOSCOMP;
+            break;
+
+        case AUDIO_F32SYS:
+            width = 0;          /* not used here... */
+            fmt = AL_SAMPFMT_FLOAT;
+            break;
+
+            /* Docs say there is int24, but not int32.... */
+
+        default:
+            valid = 0;
+            test_format = SDL_NextAudioFormat();
+            break;
+        }
+
+        if (valid) {
+            ALconfig audio_config = alNewConfig();
+            valid = 0;
+            if (audio_config) {
+                if (alSetChannels(audio_config, this->spec.channels) < 0) {
+                    if (this->spec.channels > 2) {      /* can't handle > stereo? */
+                        this->spec.channels = 2;        /* try again below. */
+                    }
+                }
+
+                if ((alSetSampFmt(audio_config, fmt) >= 0) &&
+                    ((!width) || (alSetWidth(audio_config, width) >= 0)) &&
+                    (alSetQueueSize(audio_config, this->spec.samples * 2) >=
+                     0)
+                    && (alSetChannels(audio_config, this->spec.channels) >=
+                        0)) {
+
+                    this->hidden->audio_port = alOpenPort("SDL audio", "w",
+                                                          audio_config);
+                    if (this->hidden->audio_port == NULL) {
+                        /* docs say AL_BAD_CHANNELS happens here, too. */
+                        int err = oserror();
+                        if (err == AL_BAD_CHANNELS) {
+                            this->spec.channels = 2;
+                            alSetChannels(audio_config, this->spec.channels);
+                            this->hidden->audio_port =
+                                alOpenPort("SDL audio", "w", audio_config);
+                        }
+                    }
+
+                    if (this->hidden->audio_port != NULL) {
+                        valid = 1;
+                    }
+                }
+
+                alFreeConfig(audio_config);
+            }
+        }
+    }
+
+    if (!valid) {
+        IRIXAUDIO_CloseDevice(this);
+        SDL_SetError("Unsupported audio format");
+        return 0;
+    }
+
+    /* Update the fragment size as size in bytes */
+    SDL_CalculateAudioSpec(&this->spec);
+
+    /* Allocate mixing buffer */
+    this->hidden->mixbuf = (Uint8 *) SDL_AllocAudioMem(this->spec.size);
+    if (this->hidden->mixbuf == NULL) {
+        IRIXAUDIO_CloseDevice(this);
+        SDL_OutOfMemory();
+        return 0;
+    }
+    SDL_memset(this->hidden->mixbuf, this->spec.silence, this->spec.size);
+
+    /* We're ready to rock and roll. :-) */
+    return 1;
+}
+
+static int
+IRIXAUDIO_Init(SDL_AudioDriverImpl * impl)
+{
+    /* Set the function pointers */
+    impl->OpenDevice = DSP_OpenDevice;
+    impl->PlayDevice = DSP_PlayDevice;
+    impl->WaitDevice = DSP_WaitDevice;
+    impl->GetDeviceBuf = DSP_GetDeviceBuf;
+    impl->CloseDevice = DSP_CloseDevice;
+    impl->OnlyHasDefaultOutputDevice = 1;       /* !!! FIXME: not true, I think. */
+
+    return 1;
+}
+
+AudioBootStrap IRIXAUDIO_bootstrap = {
+    "AL", "IRIX DMedia audio", IRIXAUDIO_Init, 0
+};
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/dmedia/SDL_irixaudio.h

@@ -0,0 +1,42 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifndef _SDL_irixaudio_h
+#define _SDL_irixaudio_h
+
+#include <dmedia/audio.h>
+
+#include "../SDL_sysaudio.h"
+
+/* Hidden "this" pointer for the audio functions */
+#define _THIS	SDL_AudioDevice *this
+
+struct SDL_PrivateAudioData
+{
+    ALport audio_port;          /* The handle for the audio device */
+    Uint8 *mixbuf;              /* The app mixing buffer */
+};
+
+#endif /* _SDL_irixaudio_h */
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/dsp/SDL_dspaudio.c

@@ -0,0 +1,392 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+
+    Modified in Oct 2004 by Hannu Savolainen 
+    hannu@opensound.com
+*/
+#include "SDL_config.h"
+
+/* Allow access to a raw mixing buffer */
+
+#include <stdio.h>              /* For perror() */
+#include <string.h>             /* For strerror() */
+#include <errno.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <sys/time.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+
+#if SDL_AUDIO_DRIVER_OSS_SOUNDCARD_H
+/* This is installed on some systems */
+#include <soundcard.h>
+#else
+/* This is recommended by OSS */
+#include <sys/soundcard.h>
+#endif
+
+#include "SDL_timer.h"
+#include "SDL_audio.h"
+#include "../SDL_audiomem.h"
+#include "../SDL_audio_c.h"
+#include "../SDL_audiodev_c.h"
+#include "SDL_dspaudio.h"
+
+/* The tag name used by DSP audio */
+#define DSP_DRIVER_NAME         "dsp"
+
+/* Open the audio device for playback, and don't block if busy */
+#define OPEN_FLAGS_OUTPUT    (O_WRONLY|O_NONBLOCK)
+#define OPEN_FLAGS_INPUT    (O_RDONLY|O_NONBLOCK)
+
+static char **outputDevices = NULL;
+static int outputDeviceCount = 0;
+static char **inputDevices = NULL;
+static int inputDeviceCount = 0;
+
+static inline void
+free_device_list(char ***devs, int *count)
+{
+    SDL_FreeUnixAudioDevices(devs, count);
+}
+
+static inline void
+build_device_list(int iscapture, char ***devs, int *count)
+{
+    const int flags = ((iscapture) ? OPEN_FLAGS_INPUT : OPEN_FLAGS_OUTPUT);
+    free_device_list(devs, count);
+    SDL_EnumUnixAudioDevices(flags, 0, NULL, devs, count);
+}
+
+static inline void
+build_device_lists(void)
+{
+    build_device_list(0, &outputDevices, &outputDeviceCount);
+    build_device_list(1, &inputDevices, &inputDeviceCount);
+}
+
+
+static inline void
+free_device_lists(void)
+{
+    free_device_list(&outputDevices, &outputDeviceCount);
+    free_device_list(&inputDevices, &inputDeviceCount);
+}
+
+
+static void
+DSP_Deinitialize(void)
+{
+    free_device_lists();
+}
+
+
+static int
+DSP_DetectDevices(int iscapture)
+{
+    if (iscapture) {
+        build_device_list(1, &inputDevices, &inputDeviceCount);
+        return inputDeviceCount;
+    } else {
+        build_device_list(0, &outputDevices, &outputDeviceCount);
+        return outputDeviceCount;
+    }
+
+    return 0;                   /* shouldn't ever hit this. */
+}
+
+static const char *
+DSP_GetDeviceName(int index, int iscapture)
+{
+    if ((iscapture) && (index < inputDeviceCount)) {
+        return inputDevices[index];
+    } else if ((!iscapture) && (index < outputDeviceCount)) {
+        return outputDevices[index];
+    }
+
+    SDL_SetError("No such device");
+    return NULL;
+}
+
+
+static void
+DSP_CloseDevice(_THIS)
+{
+    if (this->hidden != NULL) {
+        if (this->hidden->mixbuf != NULL) {
+            SDL_FreeAudioMem(this->hidden->mixbuf);
+            this->hidden->mixbuf = NULL;
+        }
+        if (this->hidden->audio_fd >= 0) {
+            close(this->hidden->audio_fd);
+            this->hidden->audio_fd = -1;
+        }
+        SDL_free(this->hidden);
+        this->hidden = NULL;
+    }
+}
+
+
+static int
+DSP_OpenDevice(_THIS, const char *devname, int iscapture)
+{
+    const int flags = ((iscapture) ? OPEN_FLAGS_INPUT : OPEN_FLAGS_OUTPUT);
+    int format;
+    int value;
+    int frag_spec;
+    SDL_AudioFormat test_format;
+
+    /* We don't care what the devname is...we'll try to open anything. */
+    /*  ...but default to first name in the list... */
+    if (devname == NULL) {
+        if (((iscapture) && (inputDeviceCount == 0)) ||
+            ((!iscapture) && (outputDeviceCount == 0))) {
+            SDL_SetError("No such audio device");
+            return 0;
+        }
+        devname = ((iscapture) ? inputDevices[0] : outputDevices[0]);
+    }
+
+    /* Make sure fragment size stays a power of 2, or OSS fails. */
+    /* I don't know which of these are actually legal values, though... */
+    if (this->spec.channels > 8)
+        this->spec.channels = 8;
+    else if (this->spec.channels > 4)
+        this->spec.channels = 4;
+    else if (this->spec.channels > 2)
+        this->spec.channels = 2;
+
+    /* Initialize all variables that we clean on shutdown */
+    this->hidden = (struct SDL_PrivateAudioData *)
+        SDL_malloc((sizeof *this->hidden));
+    if (this->hidden == NULL) {
+        SDL_OutOfMemory();
+        return 0;
+    }
+    SDL_memset(this->hidden, 0, (sizeof *this->hidden));
+
+    /* Open the audio device */
+    this->hidden->audio_fd = open(devname, flags, 0);
+    if (this->hidden->audio_fd < 0) {
+        DSP_CloseDevice(this);
+        SDL_SetError("Couldn't open %s: %s", devname, strerror(errno));
+        return 0;
+    }
+    this->hidden->mixbuf = NULL;
+
+    /* Make the file descriptor use blocking writes with fcntl() */
+    {
+        long ctlflags;
+        ctlflags = fcntl(this->hidden->audio_fd, F_GETFL);
+        ctlflags &= ~O_NONBLOCK;
+        if (fcntl(this->hidden->audio_fd, F_SETFL, ctlflags) < 0) {
+            DSP_CloseDevice(this);
+            SDL_SetError("Couldn't set audio blocking mode");
+            return 0;
+        }
+    }
+
+    /* Get a list of supported hardware formats */
+    if (ioctl(this->hidden->audio_fd, SNDCTL_DSP_GETFMTS, &value) < 0) {
+        perror("SNDCTL_DSP_GETFMTS");
+        DSP_CloseDevice(this);
+        SDL_SetError("Couldn't get audio format list");
+        return 0;
+    }
+
+    /* Try for a closest match on audio format */
+    format = 0;
+    for (test_format = SDL_FirstAudioFormat(this->spec.format);
+         !format && test_format;) {
+#ifdef DEBUG_AUDIO
+        fprintf(stderr, "Trying format 0x%4.4x\n", test_format);
+#endif
+        switch (test_format) {
+        case AUDIO_U8:
+            if (value & AFMT_U8) {
+                format = AFMT_U8;
+            }
+            break;
+        case AUDIO_S16LSB:
+            if (value & AFMT_S16_LE) {
+                format = AFMT_S16_LE;
+            }
+            break;
+        case AUDIO_S16MSB:
+            if (value & AFMT_S16_BE) {
+                format = AFMT_S16_BE;
+            }
+            break;
+#if 0
+/*
+ * These formats are not used by any real life systems so they are not 
+ * needed here.
+ */
+        case AUDIO_S8:
+            if (value & AFMT_S8) {
+                format = AFMT_S8;
+            }
+            break;
+        case AUDIO_U16LSB:
+            if (value & AFMT_U16_LE) {
+                format = AFMT_U16_LE;
+            }
+            break;
+        case AUDIO_U16MSB:
+            if (value & AFMT_U16_BE) {
+                format = AFMT_U16_BE;
+            }
+            break;
+#endif
+        default:
+            format = 0;
+            break;
+        }
+        if (!format) {
+            test_format = SDL_NextAudioFormat();
+        }
+    }
+    if (format == 0) {
+        DSP_CloseDevice(this);
+        SDL_SetError("Couldn't find any hardware audio formats");
+        return 0;
+    }
+    this->spec.format = test_format;
+
+    /* Set the audio format */
+    value = format;
+    if ((ioctl(this->hidden->audio_fd, SNDCTL_DSP_SETFMT, &value) < 0) ||
+        (value != format)) {
+        perror("SNDCTL_DSP_SETFMT");
+        DSP_CloseDevice(this);
+        SDL_SetError("Couldn't set audio format");
+        return 0;
+    }
+
+    /* Set the number of channels of output */
+    value = this->spec.channels;
+    if (ioctl(this->hidden->audio_fd, SNDCTL_DSP_CHANNELS, &value) < 0) {
+        perror("SNDCTL_DSP_CHANNELS");
+        DSP_CloseDevice(this);
+        SDL_SetError("Cannot set the number of channels");
+        return 0;
+    }
+    this->spec.channels = value;
+
+    /* Set the DSP frequency */
+    value = this->spec.freq;
+    if (ioctl(this->hidden->audio_fd, SNDCTL_DSP_SPEED, &value) < 0) {
+        perror("SNDCTL_DSP_SPEED");
+        DSP_CloseDevice(this);
+        SDL_SetError("Couldn't set audio frequency");
+        return 0;
+    }
+    this->spec.freq = value;
+
+    /* Calculate the final parameters for this audio specification */
+    SDL_CalculateAudioSpec(&this->spec);
+
+    /* Determine the power of two of the fragment size */
+    for (frag_spec = 0; (0x01U << frag_spec) < this->spec.size; ++frag_spec);
+    if ((0x01U << frag_spec) != this->spec.size) {
+        DSP_CloseDevice(this);
+        SDL_SetError("Fragment size must be a power of two");
+        return 0;
+    }
+    frag_spec |= 0x00020000;    /* two fragments, for low latency */
+
+    /* Set the audio buffering parameters */
+#ifdef DEBUG_AUDIO
+    fprintf(stderr, "Requesting %d fragments of size %d\n",
+            (frag_spec >> 16), 1 << (frag_spec & 0xFFFF));
+#endif
+    if (ioctl(this->hidden->audio_fd, SNDCTL_DSP_SETFRAGMENT, &frag_spec) < 0) {
+        perror("SNDCTL_DSP_SETFRAGMENT");
+    }
+#ifdef DEBUG_AUDIO
+    {
+        audio_buf_info info;
+        ioctl(this->hidden->audio_fd, SNDCTL_DSP_GETOSPACE, &info);
+        fprintf(stderr, "fragments = %d\n", info.fragments);
+        fprintf(stderr, "fragstotal = %d\n", info.fragstotal);
+        fprintf(stderr, "fragsize = %d\n", info.fragsize);
+        fprintf(stderr, "bytes = %d\n", info.bytes);
+    }
+#endif
+
+    /* Allocate mixing buffer */
+    this->hidden->mixlen = this->spec.size;
+    this->hidden->mixbuf = (Uint8 *) SDL_AllocAudioMem(this->hidden->mixlen);
+    if (this->hidden->mixbuf == NULL) {
+        DSP_CloseDevice(this);
+        SDL_OutOfMemory();
+        return 0;
+    }
+    SDL_memset(this->hidden->mixbuf, this->spec.silence, this->spec.size);
+
+    /* We're ready to rock and roll. :-) */
+    return 1;
+}
+
+
+static void
+DSP_PlayDevice(_THIS)
+{
+    const Uint8 *mixbuf = this->hidden->mixbuf;
+    const int mixlen = this->hidden->mixlen;
+    if (write(this->hidden->audio_fd, mixbuf, mixlen) == -1) {
+        perror("Audio write");
+        this->enabled = 0;
+    }
+#ifdef DEBUG_AUDIO
+    fprintf(stderr, "Wrote %d bytes of audio data\n", mixlen);
+#endif
+}
+
+static Uint8 *
+DSP_GetDeviceBuf(_THIS)
+{
+    return (this->hidden->mixbuf);
+}
+
+static int
+DSP_Init(SDL_AudioDriverImpl * impl)
+{
+    /* Set the function pointers */
+    impl->DetectDevices = DSP_DetectDevices;
+    impl->GetDeviceName = DSP_GetDeviceName;
+    impl->OpenDevice = DSP_OpenDevice;
+    impl->PlayDevice = DSP_PlayDevice;
+    impl->GetDeviceBuf = DSP_GetDeviceBuf;
+    impl->CloseDevice = DSP_CloseDevice;
+    impl->Deinitialize = DSP_Deinitialize;
+
+    build_device_lists();
+    return (outputDeviceCount > 0) ? 2 : 1;
+}
+
+
+AudioBootStrap DSP_bootstrap = {
+    DSP_DRIVER_NAME, "OSS /dev/dsp standard audio", DSP_Init, 0
+};
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/dsp/SDL_dspaudio.h

@@ -0,0 +1,44 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifndef _SDL_dspaudio_h
+#define _SDL_dspaudio_h
+
+#include "../SDL_sysaudio.h"
+
+/* Hidden "this" pointer for the audio functions */
+#define _THIS	SDL_AudioDevice *this
+
+struct SDL_PrivateAudioData
+{
+    /* The file descriptor for the audio device */
+    int audio_fd;
+
+    /* Raw mixing buffer */
+    Uint8 *mixbuf;
+    int mixlen;
+};
+#define FUDGE_TICKS	10      /* The scheduler overhead ticks per frame */
+
+#endif /* _SDL_dspaudio_h */
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/dummy/SDL_dummyaudio.c

@@ -0,0 +1,51 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+
+    This file written by Ryan C. Gordon (icculus@icculus.org)
+*/
+#include "SDL_config.h"
+
+/* Output audio to nowhere... */
+
+#include "SDL_audio.h"
+#include "../SDL_audio_c.h"
+#include "SDL_dummyaudio.h"
+
+static int
+DUMMYAUD_OpenDevice(_THIS, const char *devname, int iscapture)
+{
+    return 1;                   /* always succeeds. */
+}
+
+static int
+DUMMYAUD_Init(SDL_AudioDriverImpl * impl)
+{
+    /* Set the function pointers */
+    impl->OpenDevice = DUMMYAUD_OpenDevice;
+    impl->OnlyHasDefaultOutputDevice = 1;
+    return 1;
+}
+
+AudioBootStrap DUMMYAUD_bootstrap = {
+    "dummy", "SDL dummy audio driver", DUMMYAUD_Init, 1
+};
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/dummy/SDL_dummyaudio.h

@@ -0,0 +1,42 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifndef _SDL_dummyaudio_h
+#define _SDL_dummyaudio_h
+
+#include "../SDL_sysaudio.h"
+
+/* Hidden "this" pointer for the audio functions */
+#define _THIS	SDL_AudioDevice *this
+
+struct SDL_PrivateAudioData
+{
+    /* The file descriptor for the audio device */
+    Uint8 *mixbuf;
+    Uint32 mixlen;
+    Uint32 write_delay;
+    Uint32 initial_calls;
+};
+
+#endif /* _SDL_dummyaudio_h */
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/esd/SDL_esdaudio.c

@@ -0,0 +1,354 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* Allow access to an ESD network stream mixing buffer */
+
+#include <sys/types.h>
+#include <unistd.h>
+#include <signal.h>
+#include <errno.h>
+#include <esd.h>
+
+#include "SDL_timer.h"
+#include "SDL_audio.h"
+#include "../SDL_audiomem.h"
+#include "../SDL_audio_c.h"
+#include "SDL_esdaudio.h"
+
+#ifdef SDL_AUDIO_DRIVER_ESD_DYNAMIC
+#include "SDL_name.h"
+#include "SDL_loadso.h"
+#else
+#define SDL_NAME(X)	X
+#endif
+
+/* The tag name used by ESD audio */
+#define ESD_DRIVER_NAME		"esd"
+
+#ifdef SDL_AUDIO_DRIVER_ESD_DYNAMIC
+
+static const char *esd_library = SDL_AUDIO_DRIVER_ESD_DYNAMIC;
+static void *esd_handle = NULL;
+
+static int (*SDL_NAME(esd_open_sound)) (const char *host);
+static int (*SDL_NAME(esd_close)) (int esd);
+static int (*SDL_NAME(esd_play_stream)) (esd_format_t format, int rate,
+                                         const char *host, const char *name);
+
+#define SDL_ESD_SYM(x) { #x, (void **) (char *) &SDL_NAME(x) }
+static struct
+{
+    const char *name;
+    void **func;
+} const esd_functions[] = {
+    SDL_ESD_SYM(esd_open_sound),
+    SDL_ESD_SYM(esd_close), SDL_ESD_SYM(esd_play_stream),
+};
+
+#undef SDL_ESD_SYM
+
+static void
+UnloadESDLibrary()
+{
+    if (esd_handle != NULL) {
+        SDL_UnloadObject(esd_handle);
+        esd_handle = NULL;
+    }
+}
+
+static int
+LoadESDLibrary(void)
+{
+    int i, retval = -1;
+
+    if (esd_handle == NULL) {
+        esd_handle = SDL_LoadObject(esd_library);
+        if (esd_handle) {
+            retval = 0;
+            for (i = 0; i < SDL_arraysize(esd_functions); ++i) {
+                *esd_functions[i].func =
+                    SDL_LoadFunction(esd_handle, esd_functions[i].name);
+                if (!*esd_functions[i].func) {
+                    retval = -1;
+                    UnloadESDLibrary();
+                    break;
+                }
+            }
+        }
+    }
+    return retval;
+}
+
+#else
+
+static void
+UnloadESDLibrary()
+{
+    return;
+}
+
+static int
+LoadESDLibrary(void)
+{
+    return 0;
+}
+
+#endif /* SDL_AUDIO_DRIVER_ESD_DYNAMIC */
+
+
+/* This function waits until it is possible to write a full sound buffer */
+static void
+ESD_WaitDevice(_THIS)
+{
+    Sint32 ticks;
+
+    /* Check to see if the thread-parent process is still alive */
+    {
+        static int cnt = 0;
+        /* Note that this only works with thread implementations 
+           that use a different process id for each thread.
+         */
+        /* Check every 10 loops */
+        if (this->hidden->parent && (((++cnt) % 10) == 0)) {
+            if (kill(this->hidden->parent, 0) < 0 && errno == ESRCH) {
+                this->enabled = 0;
+            }
+        }
+    }
+
+    /* Use timer for general audio synchronization */
+    ticks =
+        ((Sint32) (this->hidden->next_frame - SDL_GetTicks())) - FUDGE_TICKS;
+    if (ticks > 0) {
+        SDL_Delay(ticks);
+    }
+}
+
+static void
+ESD_PlayDevice(_THIS)
+{
+    int written = 0;
+
+    /* Write the audio data, checking for EAGAIN on broken audio drivers */
+    do {
+        written = write(this->hidden->audio_fd,
+                        this->hidden->mixbuf, this->hidden->mixlen);
+        if ((written < 0) && ((errno == 0) || (errno == EAGAIN))) {
+            SDL_Delay(1);       /* Let a little CPU time go by */
+        }
+    } while ((written < 0) &&
+             ((errno == 0) || (errno == EAGAIN) || (errno == EINTR)));
+
+    /* Set the next write frame */
+    this->hidden->next_frame += this->hidden->frame_ticks;
+
+    /* If we couldn't write, assume fatal error for now */
+    if (written < 0) {
+        this->enabled = 0;
+    }
+}
+
+static Uint8 *
+ESD_GetDeviceBuf(_THIS)
+{
+    return (this->hidden->mixbuf);
+}
+
+static void
+ESD_CloseDevice(_THIS)
+{
+    if (this->hidden != NULL) {
+        if (this->hidden->mixbuf != NULL) {
+            SDL_FreeAudioMem(this->hidden->mixbuf);
+            this->hidden->mixbuf = NULL;
+        }
+        if (this->hidden->audio_fd >= 0) {
+            SDL_NAME(esd_close) (this->hidden->audio_fd);
+            this->hidden->audio_fd = -1;
+        }
+
+        SDL_free(this->hidden);
+        this->hidden = NULL;
+    }
+}
+
+/* Try to get the name of the program */
+static char *
+get_progname(void)
+{
+    char *progname = NULL;
+#ifdef __LINUX__
+    FILE *fp;
+    static char temp[BUFSIZ];
+
+    SDL_snprintf(temp, SDL_arraysize(temp), "/proc/%d/cmdline", getpid());
+    fp = fopen(temp, "r");
+    if (fp != NULL) {
+        if (fgets(temp, sizeof(temp) - 1, fp)) {
+            progname = SDL_strrchr(temp, '/');
+            if (progname == NULL) {
+                progname = temp;
+            } else {
+                progname = progname + 1;
+            }
+        }
+        fclose(fp);
+    }
+#endif
+    return (progname);
+}
+
+
+static int
+ESD_OpenDevice(_THIS, const char *devname, int iscapture)
+{
+    esd_format_t format = (ESD_STREAM | ESD_PLAY);
+    SDL_AudioFormat test_format = 0;
+    int found = 0;
+
+    /* Initialize all variables that we clean on shutdown */
+    this->hidden = (struct SDL_PrivateAudioData *)
+        SDL_malloc((sizeof *this->hidden));
+    if (this->hidden == NULL) {
+        SDL_OutOfMemory();
+        return 0;
+    }
+    SDL_memset(this->hidden, 0, (sizeof *this->hidden));
+    this->hidden->audio_fd = -1;
+
+    /* Convert audio spec to the ESD audio format */
+    /* Try for a closest match on audio format */
+    for (test_format = SDL_FirstAudioFormat(this->spec.format);
+         !found && test_format; test_format = SDL_NextAudioFormat()) {
+#ifdef DEBUG_AUDIO
+        fprintf(stderr, "Trying format 0x%4.4x\n", test_format);
+#endif
+        found = 1;
+        switch (test_format) {
+        case AUDIO_U8:
+            format |= ESD_BITS8;
+            break;
+        case AUDIO_S16SYS:
+            format |= ESD_BITS16;
+            break;
+        default:
+            found = 0;
+            break;
+        }
+    }
+
+    if (!found) {
+        ESD_CloseDevice(this);
+        SDL_SetError("Couldn't find any hardware audio formats");
+        return 0;
+    }
+
+    if (this->spec.channels == 1) {
+        format |= ESD_MONO;
+    } else {
+        format |= ESD_STEREO;
+    }
+#if 0
+    this->spec.samples = ESD_BUF_SIZE;  /* Darn, no way to change this yet */
+#endif
+
+    /* Open a connection to the ESD audio server */
+    this->hidden->audio_fd =
+        SDL_NAME(esd_play_stream) (format, this->spec.freq, NULL,
+                                   get_progname());
+
+    if (this->hidden->audio_fd < 0) {
+        ESD_CloseDevice(this);
+        SDL_SetError("Couldn't open ESD connection");
+        return 0;
+    }
+
+    /* Calculate the final parameters for this audio specification */
+    SDL_CalculateAudioSpec(&this->spec);
+    this->hidden->frame_ticks =
+        (float) (this->spec.samples * 1000) / this->spec.freq;
+    this->hidden->next_frame = SDL_GetTicks() + this->hidden->frame_ticks;
+
+    /* Allocate mixing buffer */
+    this->hidden->mixlen = this->spec.size;
+    this->hidden->mixbuf = (Uint8 *) SDL_AllocAudioMem(this->hidden->mixlen);
+    if (this->hidden->mixbuf == NULL) {
+        ESD_CloseDevice(this);
+        SDL_OutOfMemory();
+        return 0;
+    }
+    SDL_memset(this->hidden->mixbuf, this->spec.silence, this->spec.size);
+
+    /* Get the parent process id (we're the parent of the audio thread) */
+    this->hidden->parent = getpid();
+
+    /* We're ready to rock and roll. :-) */
+    return 1;
+}
+
+static void
+ESD_Deinitialize(void)
+{
+    UnloadESDLibrary();
+}
+
+static int
+ESD_Init(SDL_AudioDriverImpl * impl)
+{
+    if (LoadESDLibrary() < 0) {
+        return 0;
+    } else {
+        int connection = 0;
+
+        /* Don't start ESD if it's not running */
+        if (SDL_getenv("ESD_NO_SPAWN") == NULL) {
+            SDL_putenv("ESD_NO_SPAWN=1");
+        }
+
+        connection = SDL_NAME(esd_open_sound) (NULL);
+        if (connection < 0) {
+            UnloadESDLibrary();
+            SDL_SetError("ESD: esd_open_sound failed (no audio server?)");
+            return 0;
+        }
+        SDL_NAME(esd_close) (connection);
+    }
+
+    /* Set the function pointers */
+    impl->OpenDevice = ESD_OpenDevice;
+    impl->PlayDevice = ESD_PlayDevice;
+    impl->WaitDevice = ESD_WaitDevice;
+    impl->GetDeviceBuf = ESD_GetDeviceBuf;
+    impl->CloseDevice = ESD_CloseDevice;
+    impl->Deinitialize = ESD_Deinitialize;
+    impl->OnlyHasDefaultOutputDevice = 1;
+
+    return 2;                   /* return 2 (definitely have a "device"). */
+}
+
+
+AudioBootStrap ESD_bootstrap = {
+    ESD_DRIVER_NAME, "Enlightened Sound Daemon", ESD_Init, 0
+};
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/esd/SDL_esdaudio.h

@@ -0,0 +1,51 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifndef _SDL_esdaudio_h
+#define _SDL_esdaudio_h
+
+#include "../SDL_sysaudio.h"
+
+/* Hidden "this" pointer for the audio functions */
+#define _THIS	SDL_AudioDevice *this
+
+struct SDL_PrivateAudioData
+{
+    /* The file descriptor for the audio device */
+    int audio_fd;
+
+    /* The parent process id, to detect when application quits */
+    pid_t parent;
+
+    /* Raw mixing buffer */
+    Uint8 *mixbuf;
+    int mixlen;
+
+    /* Support for audio timing using a timer */
+    float frame_ticks;
+    float next_frame;
+};
+#define FUDGE_TICKS	10      /* The scheduler overhead ticks per frame */
+
+#endif /* _SDL_esdaudio_h */
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/fusionsound/SDL_fsaudio.c

@@ -0,0 +1,351 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* Allow access to a raw mixing buffer */
+
+#ifdef HAVE_SIGNAL_H
+#include <signal.h>
+#endif
+#include <unistd.h>
+
+#include "SDL_timer.h"
+#include "SDL_audio.h"
+#include "../SDL_audiomem.h"
+#include "../SDL_audio_c.h"
+#include "SDL_fsaudio.h"
+
+#include <fusionsound/fusionsound_version.h>
+
+//#define SDL_AUDIO_DRIVER_FUSIONSOUND_DYNAMIC "libfusionsound.so"
+
+#ifdef SDL_AUDIO_DRIVER_FUSIONSOUND_DYNAMIC
+#include "SDL_name.h"
+#include "SDL_loadso.h"
+#else
+#define SDL_NAME(X)	X
+#endif
+
+#if (FUSIONSOUND_MAJOR_VERSION == 1) && (FUSIONSOUND_MINOR_VERSION < 1)
+typedef DFBResult DirectResult;
+#endif
+
+/* The tag name used by fusionsoundc audio */
+#define SDL_FS_DRIVER_NAME         "fusionsound"
+/* Buffers to use - more than 2 gives a lot of latency */
+#define FUSION_BUFFERS				(2)
+
+#ifdef SDL_AUDIO_DRIVER_FUSIONSOUND_DYNAMIC
+
+static const char *fs_library = SDL_AUDIO_DRIVER_FUSIONSOUND_DYNAMIC;
+static void *fs_handle = NULL;
+
+static DirectResult (*SDL_NAME(FusionSoundInit)) (int *argc, char *(*argv[]));
+static DirectResult (*SDL_NAME(FusionSoundCreate)) (IFusionSound **
+                                                   ret_interface);
+
+#define SDL_FS_SYM(x) { #x, (void **) (char *) &SDL_NAME(x) }
+static struct
+{
+    const char *name;
+    void **func;
+} fs_functions[] = {
+/* *INDENT-OFF* */
+    SDL_FS_SYM(FusionSoundInit),
+    SDL_FS_SYM(FusionSoundCreate),
+/* *INDENT-ON* */
+};
+
+#undef SDL_FS_SYM
+
+static void
+UnloadFusionSoundLibrary()
+{
+    if (fs_handle != NULL) {
+        SDL_UnloadObject(fs_handle);
+        fs_handle = NULL;
+    }
+}
+
+static int
+LoadFusionSoundLibrary(void)
+{
+    int i, retval = -1;
+
+    if (fs_handle == NULL) {
+        fs_handle = SDL_LoadObject(fs_library);
+        if (fs_handle != NULL) {
+            retval = 0;
+            for (i = 0; i < SDL_arraysize(fs_functions); ++i) {
+                *fs_functions[i].func =
+                    SDL_LoadFunction(fs_handle, fs_functions[i].name);
+                if (!*fs_functions[i].func) {
+                    retval = -1;
+                    UnloadFusionSoundLibrary();
+                    break;
+                }
+            }
+        }
+    }
+
+    return retval;
+}
+
+#else
+
+static void
+UnloadFusionSoundLibrary()
+{
+    return;
+}
+
+static int
+LoadFusionSoundLibrary(void)
+{
+    return 0;
+}
+
+#endif /* SDL_AUDIO_DRIVER_FUSIONSOUND_DYNAMIC */
+
+/* This function waits until it is possible to write a full sound buffer */
+static void
+SDL_FS_WaitDevice(_THIS)
+{
+    this->hidden->stream->Wait(this->hidden->stream,
+                               this->hidden->mixsamples);
+}
+
+static void
+SDL_FS_PlayDevice(_THIS)
+{
+    DirectResult ret;
+
+    ret = this->hidden->stream->Write(this->hidden->stream,
+                                      this->hidden->mixbuf,
+                                      this->hidden->mixsamples);
+    /* If we couldn't write, assume fatal error for now */
+    if (ret) {
+        this->enabled = 0;
+    }
+#ifdef DEBUG_AUDIO
+    fprintf(stderr, "Wrote %d bytes of audio data\n", this->hidden->mixlen);
+#endif
+}
+
+static void
+SDL_FS_WaitDone(_THIS)
+{
+    this->hidden->stream->Wait(this->hidden->stream,
+                               this->hidden->mixsamples * FUSION_BUFFERS);
+}
+
+
+static Uint8 *
+SDL_FS_GetDeviceBuf(_THIS)
+{
+    return (this->hidden->mixbuf);
+}
+
+
+static void
+SDL_FS_CloseDevice(_THIS)
+{
+    if (this->hidden != NULL) {
+        if (this->hidden->mixbuf != NULL) {
+            SDL_FreeAudioMem(this->hidden->mixbuf);
+            this->hidden->mixbuf = NULL;
+        }
+        if (this->hidden->stream) {
+            this->hidden->stream->Release(this->hidden->stream);
+            this->hidden->stream = NULL;
+        }
+        if (this->hidden->fs) {
+            this->hidden->fs->Release(this->hidden->fs);
+            this->hidden->fs = NULL;
+        }
+        SDL_free(this->hidden);
+        this->hidden = NULL;
+    }
+}
+
+
+static int
+SDL_FS_OpenDevice(_THIS, const char *devname, int iscapture)
+{
+    int bytes;
+    SDL_AudioFormat test_format = 0, format = 0;
+    FSSampleFormat fs_format;
+    FSStreamDescription desc;
+    DirectResult ret;
+
+    /* Initialize all variables that we clean on shutdown */
+    this->hidden = (struct SDL_PrivateAudioData *)
+        SDL_malloc((sizeof *this->hidden));
+    if (this->hidden == NULL) {
+        SDL_OutOfMemory();
+        return 0;
+    }
+    SDL_memset(this->hidden, 0, (sizeof *this->hidden));
+
+    /* Try for a closest match on audio format */
+    for (test_format = SDL_FirstAudioFormat(this->spec.format);
+         !format && test_format;) {
+#ifdef DEBUG_AUDIO
+        fprintf(stderr, "Trying format 0x%4.4x\n", test_format);
+#endif
+        switch (test_format) {
+        case AUDIO_U8:
+            fs_format = FSSF_U8;
+            bytes = 1;
+            format = 1;
+            break;
+        case AUDIO_S16SYS:
+            fs_format = FSSF_S16;
+            bytes = 2;
+            format = 1;
+            break;
+        case AUDIO_S32SYS:
+            fs_format = FSSF_S32;
+            bytes = 4;
+            format = 1;
+            break;
+        case AUDIO_F32SYS:
+            fs_format = FSSF_FLOAT;
+            bytes = 4;
+            format = 1;
+            break;
+        default:
+            format = 0;
+            break;
+        }
+        if (!format) {
+            test_format = SDL_NextAudioFormat();
+        }
+    }
+
+    if (format == 0) {
+        SDL_FS_CloseDevice(this);
+        SDL_SetError("Couldn't find any hardware audio formats");
+        return 0;
+    }
+    this->spec.format = test_format;
+
+    /* Retrieve the main sound interface. */
+    ret = SDL_NAME(FusionSoundCreate) (&this->hidden->fs);
+    if (ret) {
+        SDL_FS_CloseDevice(this);
+        SDL_SetError("Unable to initialize FusionSound: %d", ret);
+        return 0;
+    }
+
+    this->hidden->mixsamples = this->spec.size / bytes / this->spec.channels;
+
+    /* Fill stream description. */
+    desc.flags = FSSDF_SAMPLERATE | FSSDF_BUFFERSIZE |
+        FSSDF_CHANNELS | FSSDF_SAMPLEFORMAT | FSSDF_PREBUFFER;
+    desc.samplerate = this->spec.freq;
+    desc.buffersize = this->spec.size * FUSION_BUFFERS;
+    desc.channels = this->spec.channels;
+    desc.prebuffer = 10;
+    desc.sampleformat = fs_format;
+
+    ret =
+        this->hidden->fs->CreateStream(this->hidden->fs, &desc,
+                                       &this->hidden->stream);
+    if (ret) {
+        SDL_FS_CloseDevice(this);
+        SDL_SetError("Unable to create FusionSoundStream: %d", ret);
+        return 0;
+    }
+
+    /* See what we got */
+    desc.flags = FSSDF_SAMPLERATE | FSSDF_BUFFERSIZE |
+        FSSDF_CHANNELS | FSSDF_SAMPLEFORMAT;
+    ret = this->hidden->stream->GetDescription(this->hidden->stream, &desc);
+
+    this->spec.freq = desc.samplerate;
+    this->spec.size =
+        desc.buffersize / FUSION_BUFFERS * bytes * desc.channels;
+    this->spec.channels = desc.channels;
+
+    /* Calculate the final parameters for this audio specification */
+    SDL_CalculateAudioSpec(&this->spec);
+
+    /* Allocate mixing buffer */
+    this->hidden->mixlen = this->spec.size;
+    this->hidden->mixbuf = (Uint8 *) SDL_AllocAudioMem(this->hidden->mixlen);
+    if (this->hidden->mixbuf == NULL) {
+        SDL_FS_CloseDevice(this);
+        SDL_OutOfMemory();
+        return 0;
+    }
+    SDL_memset(this->hidden->mixbuf, this->spec.silence, this->spec.size);
+
+    /* We're ready to rock and roll. :-) */
+    return 1;
+}
+
+
+static void
+SDL_FS_Deinitialize(void)
+{
+    UnloadFusionSoundLibrary();
+}
+
+
+static int
+SDL_FS_Init(SDL_AudioDriverImpl * impl)
+{
+    if (LoadFusionSoundLibrary() < 0) {
+        return 0;
+    } else {
+        DirectResult ret;
+
+        ret = SDL_NAME(FusionSoundInit) (NULL, NULL);
+        if (ret) {
+            UnloadFusionSoundLibrary();
+            SDL_SetError
+                ("FusionSound: SDL_FS_init failed (FusionSoundInit: %d)",
+                 ret);
+            return 0;
+        }
+    }
+
+    /* Set the function pointers */
+    impl->OpenDevice = SDL_FS_OpenDevice;
+    impl->PlayDevice = SDL_FS_PlayDevice;
+    impl->WaitDevice = SDL_FS_WaitDevice;
+    impl->GetDeviceBuf = SDL_FS_GetDeviceBuf;
+    impl->CloseDevice = SDL_FS_CloseDevice;
+    impl->WaitDone = SDL_FS_WaitDone;
+    impl->Deinitialize = SDL_FS_Deinitialize;
+    impl->OnlyHasDefaultOutputDevice = 1;
+
+    return 1;
+}
+
+
+AudioBootStrap FUSIONSOUND_bootstrap = {
+    SDL_FS_DRIVER_NAME, "FusionSound", SDL_FS_Init, 0
+};
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/fusionsound/SDL_fsaudio.h

@@ -0,0 +1,50 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifndef _SDL_fsaudio_h
+#define _SDL_fsaudio_h
+
+#include <fusionsound/fusionsound.h>
+
+#include "../SDL_sysaudio.h"
+
+/* Hidden "this" pointer for the audio functions */
+#define _THIS	SDL_AudioDevice *this
+
+struct SDL_PrivateAudioData
+{
+    /* Interface */
+    IFusionSound *fs;
+
+    /* The stream interface for the audio device */
+    IFusionSoundStream *stream;
+
+    /* Raw mixing buffer */
+    Uint8 *mixbuf;
+    int mixlen;
+    int mixsamples;
+
+};
+
+#endif /* _SDL_fsaudio_h */
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/iphoneos/SDL_coreaudio_iphone.c

@@ -0,0 +1,340 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#include <AudioUnit/AudioUnit.h>
+
+#include "SDL_audio.h"
+#include "../SDL_audio_c.h"
+#include "../SDL_sysaudio.h"
+#include "SDL_coreaudio_iphone.h"
+
+#define DEBUG_COREAUDIO 0
+
+static void
+COREAUDIO_Deinitialize(void)
+{
+}
+
+/* The CoreAudio callback */
+static OSStatus
+outputCallback(void *inRefCon,
+               AudioUnitRenderActionFlags * ioActionFlags,
+               const AudioTimeStamp * inTimeStamp,
+               UInt32 inBusNumber, UInt32 inNumberFrames,
+               AudioBufferList * ioDataList)
+{
+    SDL_AudioDevice *this = (SDL_AudioDevice *) inRefCon;
+    AudioBuffer *ioData = &ioDataList->mBuffers[0];
+    UInt32 remaining, len;
+    void *ptr;
+
+    /* Is there ever more than one buffer, and what do you do with it? */
+    if (ioDataList->mNumberBuffers != 1) {
+        return noErr;
+    }
+
+    /* Only do anything if audio is enabled and not paused */
+    if (!this->enabled || this->paused) {
+        SDL_memset(ioData->mData, this->spec.silence, ioData->mDataByteSize);
+        return 0;
+    }
+
+    /* No SDL conversion should be needed here, ever, since we accept
+       any input format in OpenAudio, and leave the conversion to CoreAudio.
+     */
+    /*
+       assert(!this->convert.needed);
+       assert(this->spec.channels == ioData->mNumberChannels);
+     */
+
+    remaining = ioData->mDataByteSize;
+    ptr = ioData->mData;
+    while (remaining > 0) {
+        if (this->hidden->bufferOffset >= this->hidden->bufferSize) {
+            /* Generate the data */
+            SDL_memset(this->hidden->buffer, this->spec.silence,
+                       this->hidden->bufferSize);
+            SDL_mutexP(this->mixer_lock);
+            (*this->spec.callback) (this->spec.userdata, this->hidden->buffer,
+                                    this->hidden->bufferSize);
+            SDL_mutexV(this->mixer_lock);
+            this->hidden->bufferOffset = 0;
+        }
+
+        len = this->hidden->bufferSize - this->hidden->bufferOffset;
+        if (len > remaining)
+            len = remaining;
+        SDL_memcpy(ptr,
+                   (char *) this->hidden->buffer + this->hidden->bufferOffset,
+                   len);
+        ptr = (char *) ptr + len;
+        remaining -= len;
+        this->hidden->bufferOffset += len;
+    }
+
+    return 0;
+}
+
+static OSStatus
+inputCallback(void *inRefCon,
+              AudioUnitRenderActionFlags * ioActionFlags,
+              const AudioTimeStamp * inTimeStamp,
+              UInt32 inBusNumber, UInt32 inNumberFrames,
+              AudioBufferList * ioData)
+{
+    //err = AudioUnitRender(afr->fAudioUnit, ioActionFlags, inTimeStamp, inBusNumber, inNumberFrames, afr->fAudioBuffer);
+    // !!! FIXME: write me!
+    return noErr;
+}
+
+
+static void
+COREAUDIO_CloseDevice(_THIS)
+{
+    if (this->hidden != NULL) {
+        if (this->hidden->audioUnitOpened) {
+            OSStatus result = noErr;
+            AURenderCallbackStruct callback;
+            const AudioUnitElement output_bus = 0;
+            const AudioUnitElement input_bus = 1;
+            const int iscapture = this->iscapture;
+            const AudioUnitElement bus =
+                ((iscapture) ? input_bus : output_bus);
+            const AudioUnitScope scope =
+                ((iscapture) ? kAudioUnitScope_Output :
+                 kAudioUnitScope_Input);
+
+            /* stop processing the audio unit */
+            result = AudioOutputUnitStop(this->hidden->audioUnit);
+
+            /* Remove the input callback */
+            SDL_memset(&callback, '\0', sizeof(AURenderCallbackStruct));
+            result = AudioUnitSetProperty(this->hidden->audioUnit,
+                                          kAudioUnitProperty_SetRenderCallback,
+                                          scope, bus, &callback,
+                                          sizeof(callback));
+
+            //CloseComponent(this->hidden->audioUnit);
+            this->hidden->audioUnitOpened = 0;
+        }
+        SDL_free(this->hidden->buffer);
+        SDL_free(this->hidden);
+        this->hidden = NULL;
+    }
+}
+
+
+#define CHECK_RESULT(msg) \
+    if (result != noErr) { \
+        COREAUDIO_CloseDevice(this); \
+        SDL_SetError("CoreAudio error (%s): %d", msg, result); \
+        return 0; \
+    }
+
+static int
+prepare_audiounit(_THIS, const char *devname, int iscapture,
+                  const AudioStreamBasicDescription * strdesc)
+{
+    OSStatus result = noErr;
+    AURenderCallbackStruct callback;
+    AudioComponentDescription desc;
+    AudioComponent comp = NULL;
+
+    UInt32 enableIO = 0;
+    const AudioUnitElement output_bus = 0;
+    const AudioUnitElement input_bus = 1;
+    const AudioUnitElement bus = ((iscapture) ? input_bus : output_bus);
+    const AudioUnitScope scope = ((iscapture) ? kAudioUnitScope_Output :
+                                  kAudioUnitScope_Input);
+
+    SDL_memset(&desc, '\0', sizeof(AudioComponentDescription));
+    desc.componentType = kAudioUnitType_Output;
+    desc.componentSubType = kAudioUnitSubType_RemoteIO;
+    desc.componentManufacturer = kAudioUnitManufacturer_Apple;
+
+    comp = AudioComponentFindNext(NULL, &desc);
+    if (comp == NULL) {
+        SDL_SetError("Couldn't find requested CoreAudio component");
+        return 0;
+    }
+
+    /* Open & initialize the audio unit */
+    /*
+       AudioComponentInstanceNew only available on iPhone OS 2.0 and Mac OS X 10.6  
+       We can't use OpenAComponent on iPhone because it is not present
+     */
+    result = AudioComponentInstanceNew(comp, &this->hidden->audioUnit);
+    CHECK_RESULT("AudioComponentInstanceNew");
+
+    this->hidden->audioUnitOpened = 1;
+
+    // !!! FIXME: this is wrong?
+    enableIO = ((iscapture) ? 1 : 0);
+    result = AudioUnitSetProperty(this->hidden->audioUnit,
+                                  kAudioOutputUnitProperty_EnableIO,
+                                  kAudioUnitScope_Input, input_bus,
+                                  &enableIO, sizeof(enableIO));
+    CHECK_RESULT("AudioUnitSetProperty (kAudioUnitProperty_EnableIO input)");
+
+    // !!! FIXME: this is wrong?
+    enableIO = ((iscapture) ? 0 : 1);
+    result = AudioUnitSetProperty(this->hidden->audioUnit,
+                                  kAudioOutputUnitProperty_EnableIO,
+                                  kAudioUnitScope_Output, output_bus,
+                                  &enableIO, sizeof(enableIO));
+    CHECK_RESULT("AudioUnitSetProperty (kAudioUnitProperty_EnableIO output)");
+
+    /*result = AudioUnitSetProperty(this->hidden->audioUnit,
+       kAudioOutputUnitProperty_CurrentDevice,
+       kAudioUnitScope_Global, 0,
+       &this->hidden->deviceID,
+       sizeof(AudioDeviceID));
+
+       CHECK_RESULT("AudioUnitSetProperty (kAudioOutputUnitProperty_CurrentDevice)"); */
+
+    /* Set the data format of the audio unit. */
+    result = AudioUnitSetProperty(this->hidden->audioUnit,
+                                  kAudioUnitProperty_StreamFormat,
+                                  scope, bus, strdesc, sizeof(*strdesc));
+    CHECK_RESULT("AudioUnitSetProperty (kAudioUnitProperty_StreamFormat)");
+
+    /* Set the audio callback */
+    SDL_memset(&callback, '\0', sizeof(AURenderCallbackStruct));
+    callback.inputProc = ((iscapture) ? inputCallback : outputCallback);
+    callback.inputProcRefCon = this;
+    result = AudioUnitSetProperty(this->hidden->audioUnit,
+                                  kAudioUnitProperty_SetRenderCallback,
+                                  scope, bus, &callback, sizeof(callback));
+    CHECK_RESULT
+        ("AudioUnitSetProperty (kAudioUnitProperty_SetInputCallback)");
+
+    /* Calculate the final parameters for this audio specification */
+    SDL_CalculateAudioSpec(&this->spec);
+
+    /* Allocate a sample buffer */
+    this->hidden->bufferOffset = this->hidden->bufferSize = this->spec.size;
+    this->hidden->buffer = SDL_malloc(this->hidden->bufferSize);
+
+    result = AudioUnitInitialize(this->hidden->audioUnit);
+    CHECK_RESULT("AudioUnitInitialize");
+
+    /* Finally, start processing of the audio unit */
+    result = AudioOutputUnitStart(this->hidden->audioUnit);
+    CHECK_RESULT("AudioOutputUnitStart");
+    /* We're running! */
+    return 1;
+}
+
+static int
+COREAUDIO_OpenDevice(_THIS, const char *devname, int iscapture)
+{
+    AudioStreamBasicDescription strdesc;
+    SDL_AudioFormat test_format = SDL_FirstAudioFormat(this->spec.format);
+    int valid_datatype = 0;
+
+    /* Initialize all variables that we clean on shutdown */
+    this->hidden = (struct SDL_PrivateAudioData *)
+        SDL_malloc((sizeof *this->hidden));
+    if (this->hidden == NULL) {
+        SDL_OutOfMemory();
+        return (0);
+    }
+    SDL_memset(this->hidden, 0, (sizeof *this->hidden));
+
+    /* Setup a AudioStreamBasicDescription with the requested format */
+    SDL_memset(&strdesc, '\0', sizeof(AudioStreamBasicDescription));
+    strdesc.mFormatID = kAudioFormatLinearPCM;
+    strdesc.mFormatFlags = kLinearPCMFormatFlagIsPacked;
+    strdesc.mChannelsPerFrame = this->spec.channels;
+    strdesc.mSampleRate = this->spec.freq;
+    strdesc.mFramesPerPacket = 1;
+
+    while ((!valid_datatype) && (test_format)) {
+        this->spec.format = test_format;
+        /* Just a list of valid SDL formats, so people don't pass junk here. */
+        switch (test_format) {
+        case AUDIO_U8:
+        case AUDIO_S8:
+        case AUDIO_U16LSB:
+        case AUDIO_S16LSB:
+        case AUDIO_U16MSB:
+        case AUDIO_S16MSB:
+        case AUDIO_S32LSB:
+        case AUDIO_S32MSB:
+        case AUDIO_F32LSB:
+        case AUDIO_F32MSB:
+            valid_datatype = 1;
+            strdesc.mBitsPerChannel = SDL_AUDIO_BITSIZE(this->spec.format);
+            if (SDL_AUDIO_ISBIGENDIAN(this->spec.format))
+                strdesc.mFormatFlags |= kLinearPCMFormatFlagIsBigEndian;
+
+            if (SDL_AUDIO_ISFLOAT(this->spec.format))
+                strdesc.mFormatFlags |= kLinearPCMFormatFlagIsFloat;
+            else if (SDL_AUDIO_ISSIGNED(this->spec.format))
+                strdesc.mFormatFlags |= kLinearPCMFormatFlagIsSignedInteger;
+            break;
+        }
+    }
+
+    if (!valid_datatype) {      /* shouldn't happen, but just in case... */
+        COREAUDIO_CloseDevice(this);
+        SDL_SetError("Unsupported audio format");
+        return 0;
+    }
+
+    strdesc.mBytesPerFrame =
+        strdesc.mBitsPerChannel * strdesc.mChannelsPerFrame / 8;
+    strdesc.mBytesPerPacket =
+        strdesc.mBytesPerFrame * strdesc.mFramesPerPacket;
+
+    if (!prepare_audiounit(this, devname, iscapture, &strdesc)) {
+        COREAUDIO_CloseDevice(this);
+        return 0;               /* prepare_audiounit() will call SDL_SetError()... */
+    }
+
+    return 1;                   /* good to go. */
+}
+
+static int
+COREAUDIO_Init(SDL_AudioDriverImpl * impl)
+{
+    /* Set the function pointers */
+    impl->OpenDevice = COREAUDIO_OpenDevice;
+    impl->CloseDevice = COREAUDIO_CloseDevice;
+    impl->Deinitialize = COREAUDIO_Deinitialize;
+    impl->ProvidesOwnCallbackThread = 1;
+
+    /* added for iPhone */
+    impl->OnlyHasDefaultInputDevice = 1;
+    impl->OnlyHasDefaultOutputDevice = 1;
+    impl->HasCaptureSupport = 0;        /* still needs to be written */
+
+    return 2;                   /* defitely have an audio device. */
+}
+
+AudioBootStrap COREAUDIOIPHONE_bootstrap = {
+    "coreaudio-iphoneos", "SDL CoreAudio (iPhone OS) audio driver",
+    COREAUDIO_Init, 0
+};
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/iphoneos/SDL_coreaudio_iphone.h

@@ -0,0 +1,43 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifndef _SDL_coreaudio_h
+#define _SDL_coreaudio_h
+
+#include "../SDL_sysaudio.h"
+
+/* Hidden "this" pointer for the audio functions */
+#define _THIS	SDL_AudioDevice *this
+
+struct SDL_PrivateAudioData
+{
+    AudioUnit audioUnit;
+    int audioUnitOpened;
+    void *buffer;
+    UInt32 bufferOffset;
+    UInt32 bufferSize;
+    //  AudioDeviceID deviceID;
+};
+
+#endif /* _SDL_coreaudio_h */
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/macosx/SDL_coreaudio.c

@@ -0,0 +1,600 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#include <CoreAudio/CoreAudio.h>
+#include <CoreServices/CoreServices.h>
+#include <AudioUnit/AudioUnit.h>
+#if MAC_OS_X_VERSION_MAX_ALLOWED == 1050
+#include <AudioUnit/AUNTComponent.h>
+#endif
+
+#include "SDL_audio.h"
+#include "../SDL_audio_c.h"
+#include "../SDL_sysaudio.h"
+#include "SDL_coreaudio.h"
+
+#define DEBUG_COREAUDIO 0
+
+typedef struct COREAUDIO_DeviceList
+{
+    AudioDeviceID id;
+    const char *name;
+} COREAUDIO_DeviceList;
+
+static COREAUDIO_DeviceList *inputDevices = NULL;
+static int inputDeviceCount = 0;
+static COREAUDIO_DeviceList *outputDevices = NULL;
+static int outputDeviceCount = 0;
+
+static void
+free_device_list(COREAUDIO_DeviceList ** devices, int *devCount)
+{
+    if (*devices) {
+        int i = *devCount;
+        while (i--)
+            SDL_free((void *) (*devices)[i].name);
+        SDL_free(*devices);
+        *devices = NULL;
+    }
+    *devCount = 0;
+}
+
+
+static void
+build_device_list(int iscapture, COREAUDIO_DeviceList ** devices,
+                  int *devCount)
+{
+    Boolean outWritable = 0;
+    OSStatus result = noErr;
+    UInt32 size = 0;
+    AudioDeviceID *devs = NULL;
+    UInt32 i = 0;
+    UInt32 max = 0;
+
+    free_device_list(devices, devCount);
+
+    result = AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDevices,
+                                          &size, &outWritable);
+
+    if (result != kAudioHardwareNoError)
+        return;
+
+    devs = (AudioDeviceID *) alloca(size);
+    if (devs == NULL)
+        return;
+
+    max = size / sizeof(AudioDeviceID);
+    *devices = (COREAUDIO_DeviceList *) SDL_malloc(max * sizeof(**devices));
+    if (*devices == NULL)
+        return;
+
+    result = AudioHardwareGetProperty(kAudioHardwarePropertyDevices,
+                                      &size, devs);
+    if (result != kAudioHardwareNoError)
+        return;
+
+    for (i = 0; i < max; i++) {
+        CFStringRef cfstr = NULL;
+        char *ptr = NULL;
+        AudioDeviceID dev = devs[i];
+        AudioBufferList *buflist = NULL;
+        int usable = 0;
+        CFIndex len = 0;
+
+        result = AudioDeviceGetPropertyInfo(dev, 0, iscapture,
+                                            kAudioDevicePropertyStreamConfiguration,
+                                            &size, &outWritable);
+        if (result != noErr)
+            continue;
+
+        buflist = (AudioBufferList *) SDL_malloc(size);
+        if (buflist == NULL)
+            continue;
+
+        result = AudioDeviceGetProperty(dev, 0, iscapture,
+                                        kAudioDevicePropertyStreamConfiguration,
+                                        &size, buflist);
+
+        if (result == noErr) {
+            UInt32 j;
+            for (j = 0; j < buflist->mNumberBuffers; j++) {
+                if (buflist->mBuffers[j].mNumberChannels > 0) {
+                    usable = 1;
+                    break;
+                }
+            }
+        }
+
+        SDL_free(buflist);
+
+        if (!usable)
+            continue;
+
+        size = sizeof(CFStringRef);
+        result = AudioDeviceGetProperty(dev, 0, iscapture,
+                                        kAudioDevicePropertyDeviceNameCFString,
+                                        &size, &cfstr);
+
+        if (result != kAudioHardwareNoError)
+            continue;
+
+        len = CFStringGetMaximumSizeForEncoding(CFStringGetLength(cfstr),
+                                                kCFStringEncodingUTF8);
+
+        ptr = (char *) SDL_malloc(len + 1);
+        usable = ((ptr != NULL) &&
+                  (CFStringGetCString
+                   (cfstr, ptr, len + 1, kCFStringEncodingUTF8)));
+
+        CFRelease(cfstr);
+
+        if (usable) {
+            len = strlen(ptr);
+            /* Some devices have whitespace at the end...trim it. */
+            while ((len > 0) && (ptr[len - 1] == ' ')) {
+                len--;
+            }
+            usable = (len > 0);
+        }
+
+        if (!usable) {
+            SDL_free(ptr);
+        } else {
+            ptr[len] = '\0';
+
+#if DEBUG_COREAUDIO
+            printf("COREAUDIO: Found %s device #%d: '%s' (devid %d)\n",
+                   ((iscapture) ? "capture" : "output"),
+                   (int) *devCount, ptr, (int) dev);
+#endif
+
+            (*devices)[*devCount].id = dev;
+            (*devices)[*devCount].name = ptr;
+            (*devCount)++;
+        }
+    }
+}
+
+static inline void
+build_device_lists(void)
+{
+    build_device_list(0, &outputDevices, &outputDeviceCount);
+    build_device_list(1, &inputDevices, &inputDeviceCount);
+}
+
+
+static inline void
+free_device_lists(void)
+{
+    free_device_list(&outputDevices, &outputDeviceCount);
+    free_device_list(&inputDevices, &inputDeviceCount);
+}
+
+
+static int
+find_device_id(const char *devname, int iscapture, AudioDeviceID * id)
+{
+    int i = ((iscapture) ? inputDeviceCount : outputDeviceCount);
+    COREAUDIO_DeviceList *devs = ((iscapture) ? inputDevices : outputDevices);
+    while (i--) {
+        if (SDL_strcmp(devname, devs->name) == 0) {
+            *id = devs->id;
+            return 1;
+        }
+        devs++;
+    }
+
+    return 0;
+}
+
+
+static int
+COREAUDIO_DetectDevices(int iscapture)
+{
+    if (iscapture) {
+        build_device_list(1, &inputDevices, &inputDeviceCount);
+        return inputDeviceCount;
+    } else {
+        build_device_list(0, &outputDevices, &outputDeviceCount);
+        return outputDeviceCount;
+    }
+
+    return 0;                   /* shouldn't ever hit this. */
+}
+
+
+static const char *
+COREAUDIO_GetDeviceName(int index, int iscapture)
+{
+    if ((iscapture) && (index < inputDeviceCount)) {
+        return inputDevices[index].name;
+    } else if ((!iscapture) && (index < outputDeviceCount)) {
+        return outputDevices[index].name;
+    }
+
+    SDL_SetError("No such device");
+    return NULL;
+}
+
+
+static void
+COREAUDIO_Deinitialize(void)
+{
+    free_device_lists();
+}
+
+
+/* The CoreAudio callback */
+static OSStatus
+outputCallback(void *inRefCon,
+               AudioUnitRenderActionFlags * ioActionFlags,
+               const AudioTimeStamp * inTimeStamp,
+               UInt32 inBusNumber, UInt32 inNumberFrames,
+               AudioBufferList * ioDataList)
+{
+    SDL_AudioDevice *this = (SDL_AudioDevice *) inRefCon;
+    AudioBuffer *ioData = &ioDataList->mBuffers[0];
+    UInt32 remaining, len;
+    void *ptr;
+
+    /* Is there ever more than one buffer, and what do you do with it? */
+    if (ioDataList->mNumberBuffers != 1) {
+        return noErr;
+    }
+
+    /* Only do anything if audio is enabled and not paused */
+    if (!this->enabled || this->paused) {
+        SDL_memset(ioData->mData, this->spec.silence, ioData->mDataByteSize);
+        return 0;
+    }
+
+    /* No SDL conversion should be needed here, ever, since we accept
+       any input format in OpenAudio, and leave the conversion to CoreAudio.
+     */
+    /*
+       assert(!this->convert.needed);
+       assert(this->spec.channels == ioData->mNumberChannels);
+     */
+
+    remaining = ioData->mDataByteSize;
+    ptr = ioData->mData;
+    while (remaining > 0) {
+        if (this->hidden->bufferOffset >= this->hidden->bufferSize) {
+            /* Generate the data */
+            SDL_memset(this->hidden->buffer, this->spec.silence,
+                       this->hidden->bufferSize);
+            SDL_mutexP(this->mixer_lock);
+            (*this->spec.callback) (this->spec.userdata, this->hidden->buffer,
+                                    this->hidden->bufferSize);
+            SDL_mutexV(this->mixer_lock);
+            this->hidden->bufferOffset = 0;
+        }
+
+        len = this->hidden->bufferSize - this->hidden->bufferOffset;
+        if (len > remaining)
+            len = remaining;
+        SDL_memcpy(ptr,
+                   (char *) this->hidden->buffer + this->hidden->bufferOffset,
+                   len);
+        ptr = (char *) ptr + len;
+        remaining -= len;
+        this->hidden->bufferOffset += len;
+    }
+
+    return 0;
+}
+
+static OSStatus
+inputCallback(void *inRefCon,
+              AudioUnitRenderActionFlags * ioActionFlags,
+              const AudioTimeStamp * inTimeStamp,
+              UInt32 inBusNumber, UInt32 inNumberFrames,
+              AudioBufferList * ioData)
+{
+    //err = AudioUnitRender(afr->fAudioUnit, ioActionFlags, inTimeStamp, inBusNumber, inNumberFrames, afr->fAudioBuffer);
+    // !!! FIXME: write me!
+    return noErr;
+}
+
+
+static void
+COREAUDIO_CloseDevice(_THIS)
+{
+    if (this->hidden != NULL) {
+        if (this->hidden->audioUnitOpened) {
+            OSStatus result = noErr;
+            AURenderCallbackStruct callback;
+            const AudioUnitElement output_bus = 0;
+            const AudioUnitElement input_bus = 1;
+            const int iscapture = this->iscapture;
+            const AudioUnitElement bus =
+                ((iscapture) ? input_bus : output_bus);
+            const AudioUnitScope scope =
+                ((iscapture) ? kAudioUnitScope_Output :
+                 kAudioUnitScope_Input);
+
+            /* stop processing the audio unit */
+            result = AudioOutputUnitStop(this->hidden->audioUnit);
+
+            /* Remove the input callback */
+            SDL_memset(&callback, '\0', sizeof(AURenderCallbackStruct));
+            result = AudioUnitSetProperty(this->hidden->audioUnit,
+                                          kAudioUnitProperty_SetRenderCallback,
+                                          scope, bus, &callback,
+                                          sizeof(callback));
+
+            CloseComponent(this->hidden->audioUnit);
+            this->hidden->audioUnitOpened = 0;
+        }
+        SDL_free(this->hidden->buffer);
+        SDL_free(this->hidden);
+        this->hidden = NULL;
+    }
+}
+
+
+#define CHECK_RESULT(msg) \
+    if (result != noErr) { \
+        COREAUDIO_CloseDevice(this); \
+        SDL_SetError("CoreAudio error (%s): %d", msg, (int) result); \
+        return 0; \
+    }
+
+static int
+find_device_by_name(_THIS, const char *devname, int iscapture)
+{
+    AudioDeviceID devid = 0;
+    OSStatus result = noErr;
+    UInt32 size = 0;
+    UInt32 alive = 0;
+    pid_t pid = 0;
+
+    if (devname == NULL) {
+        size = sizeof(AudioDeviceID);
+        const AudioHardwarePropertyID propid =
+            ((iscapture) ? kAudioHardwarePropertyDefaultInputDevice :
+             kAudioHardwarePropertyDefaultOutputDevice);
+
+        result = AudioHardwareGetProperty(propid, &size, &devid);
+        CHECK_RESULT("AudioHardwareGetProperty (default device)");
+    } else {
+        if (!find_device_id(devname, iscapture, &devid)) {
+            SDL_SetError("CoreAudio: No such audio device.");
+            return 0;
+        }
+    }
+
+    size = sizeof(alive);
+    result = AudioDeviceGetProperty(devid, 0, iscapture,
+                                    kAudioDevicePropertyDeviceIsAlive,
+                                    &size, &alive);
+    CHECK_RESULT
+        ("AudioDeviceGetProperty (kAudioDevicePropertyDeviceIsAlive)");
+
+    if (!alive) {
+        SDL_SetError("CoreAudio: requested device exists, but isn't alive.");
+        return 0;
+    }
+
+    size = sizeof(pid);
+    result = AudioDeviceGetProperty(devid, 0, iscapture,
+                                    kAudioDevicePropertyHogMode, &size, &pid);
+
+    /* some devices don't support this property, so errors are fine here. */
+    if ((result == noErr) && (pid != -1)) {
+        SDL_SetError("CoreAudio: requested device is being hogged.");
+        return 0;
+    }
+
+    this->hidden->deviceID = devid;
+    return 1;
+}
+
+
+static int
+prepare_audiounit(_THIS, const char *devname, int iscapture,
+                  const AudioStreamBasicDescription * strdesc)
+{
+    OSStatus result = noErr;
+    AURenderCallbackStruct callback;
+    ComponentDescription desc;
+    Component comp = NULL;
+    UInt32 enableIO = 0;
+    const AudioUnitElement output_bus = 0;
+    const AudioUnitElement input_bus = 1;
+    const AudioUnitElement bus = ((iscapture) ? input_bus : output_bus);
+    const AudioUnitScope scope = ((iscapture) ? kAudioUnitScope_Output :
+                                  kAudioUnitScope_Input);
+
+    if (!find_device_by_name(this, devname, iscapture)) {
+        SDL_SetError("Couldn't find requested CoreAudio device");
+        return 0;
+    }
+
+    SDL_memset(&desc, '\0', sizeof(ComponentDescription));
+    desc.componentType = kAudioUnitType_Output;
+    desc.componentSubType = kAudioUnitSubType_HALOutput;
+    desc.componentManufacturer = kAudioUnitManufacturer_Apple;
+
+    comp = FindNextComponent(NULL, &desc);
+    if (comp == NULL) {
+        SDL_SetError("Couldn't find requested CoreAudio component");
+        return 0;
+    }
+
+    /* Open & initialize the audio unit */
+    result = OpenAComponent(comp, &this->hidden->audioUnit);
+    CHECK_RESULT("OpenAComponent");
+
+    this->hidden->audioUnitOpened = 1;
+
+    // !!! FIXME: this is wrong?
+    enableIO = ((iscapture) ? 1 : 0);
+    result = AudioUnitSetProperty(this->hidden->audioUnit,
+                                  kAudioOutputUnitProperty_EnableIO,
+                                  kAudioUnitScope_Input, input_bus,
+                                  &enableIO, sizeof(enableIO));
+    CHECK_RESULT("AudioUnitSetProperty (kAudioUnitProperty_EnableIO input)");
+
+    // !!! FIXME: this is wrong?
+    enableIO = ((iscapture) ? 0 : 1);
+    result = AudioUnitSetProperty(this->hidden->audioUnit,
+                                  kAudioOutputUnitProperty_EnableIO,
+                                  kAudioUnitScope_Output, output_bus,
+                                  &enableIO, sizeof(enableIO));
+    CHECK_RESULT("AudioUnitSetProperty (kAudioUnitProperty_EnableIO output)");
+
+    result = AudioUnitSetProperty(this->hidden->audioUnit,
+                                  kAudioOutputUnitProperty_CurrentDevice,
+                                  kAudioUnitScope_Global, 0,
+                                  &this->hidden->deviceID,
+                                  sizeof(AudioDeviceID));
+    CHECK_RESULT
+        ("AudioUnitSetProperty (kAudioOutputUnitProperty_CurrentDevice)");
+
+    /* Set the data format of the audio unit. */
+    result = AudioUnitSetProperty(this->hidden->audioUnit,
+                                  kAudioUnitProperty_StreamFormat,
+                                  scope, bus, strdesc, sizeof(*strdesc));
+    CHECK_RESULT("AudioUnitSetProperty (kAudioUnitProperty_StreamFormat)");
+
+    /* Set the audio callback */
+    SDL_memset(&callback, '\0', sizeof(AURenderCallbackStruct));
+    callback.inputProc = ((iscapture) ? inputCallback : outputCallback);
+    callback.inputProcRefCon = this;
+    result = AudioUnitSetProperty(this->hidden->audioUnit,
+                                  kAudioUnitProperty_SetRenderCallback,
+                                  scope, bus, &callback, sizeof(callback));
+    CHECK_RESULT
+        ("AudioUnitSetProperty (kAudioUnitProperty_SetInputCallback)");
+
+    /* Calculate the final parameters for this audio specification */
+    SDL_CalculateAudioSpec(&this->spec);
+
+    /* Allocate a sample buffer */
+    this->hidden->bufferOffset = this->hidden->bufferSize = this->spec.size;
+    this->hidden->buffer = SDL_malloc(this->hidden->bufferSize);
+
+    result = AudioUnitInitialize(this->hidden->audioUnit);
+    CHECK_RESULT("AudioUnitInitialize");
+
+    /* Finally, start processing of the audio unit */
+    result = AudioOutputUnitStart(this->hidden->audioUnit);
+    CHECK_RESULT("AudioOutputUnitStart");
+
+    /* We're running! */
+    return 1;
+}
+
+
+static int
+COREAUDIO_OpenDevice(_THIS, const char *devname, int iscapture)
+{
+    AudioStreamBasicDescription strdesc;
+    SDL_AudioFormat test_format = SDL_FirstAudioFormat(this->spec.format);
+    int valid_datatype = 0;
+
+    /* Initialize all variables that we clean on shutdown */
+    this->hidden = (struct SDL_PrivateAudioData *)
+        SDL_malloc((sizeof *this->hidden));
+    if (this->hidden == NULL) {
+        SDL_OutOfMemory();
+        return (0);
+    }
+    SDL_memset(this->hidden, 0, (sizeof *this->hidden));
+
+    /* Setup a AudioStreamBasicDescription with the requested format */
+    SDL_memset(&strdesc, '\0', sizeof(AudioStreamBasicDescription));
+    strdesc.mFormatID = kAudioFormatLinearPCM;
+    strdesc.mFormatFlags = kLinearPCMFormatFlagIsPacked;
+    strdesc.mChannelsPerFrame = this->spec.channels;
+    strdesc.mSampleRate = this->spec.freq;
+    strdesc.mFramesPerPacket = 1;
+
+    while ((!valid_datatype) && (test_format)) {
+        this->spec.format = test_format;
+        /* Just a list of valid SDL formats, so people don't pass junk here. */
+        switch (test_format) {
+        case AUDIO_U8:
+        case AUDIO_S8:
+        case AUDIO_U16LSB:
+        case AUDIO_S16LSB:
+        case AUDIO_U16MSB:
+        case AUDIO_S16MSB:
+        case AUDIO_S32LSB:
+        case AUDIO_S32MSB:
+        case AUDIO_F32LSB:
+        case AUDIO_F32MSB:
+            valid_datatype = 1;
+            strdesc.mBitsPerChannel = SDL_AUDIO_BITSIZE(this->spec.format);
+            if (SDL_AUDIO_ISBIGENDIAN(this->spec.format))
+                strdesc.mFormatFlags |= kLinearPCMFormatFlagIsBigEndian;
+
+            if (SDL_AUDIO_ISFLOAT(this->spec.format))
+                strdesc.mFormatFlags |= kLinearPCMFormatFlagIsFloat;
+            else if (SDL_AUDIO_ISSIGNED(this->spec.format))
+                strdesc.mFormatFlags |= kLinearPCMFormatFlagIsSignedInteger;
+            break;
+        }
+    }
+
+    if (!valid_datatype) {      /* shouldn't happen, but just in case... */
+        COREAUDIO_CloseDevice(this);
+        SDL_SetError("Unsupported audio format");
+        return 0;
+    }
+
+    strdesc.mBytesPerFrame =
+        strdesc.mBitsPerChannel * strdesc.mChannelsPerFrame / 8;
+    strdesc.mBytesPerPacket =
+        strdesc.mBytesPerFrame * strdesc.mFramesPerPacket;
+
+    if (!prepare_audiounit(this, devname, iscapture, &strdesc)) {
+        COREAUDIO_CloseDevice(this);
+        return 0;               /* prepare_audiounit() will call SDL_SetError()... */
+    }
+
+    return 1;                   /* good to go. */
+}
+
+static int
+COREAUDIO_Init(SDL_AudioDriverImpl * impl)
+{
+    /* Set the function pointers */
+    impl->DetectDevices = COREAUDIO_DetectDevices;
+    impl->GetDeviceName = COREAUDIO_GetDeviceName;
+    impl->OpenDevice = COREAUDIO_OpenDevice;
+    impl->CloseDevice = COREAUDIO_CloseDevice;
+    impl->Deinitialize = COREAUDIO_Deinitialize;
+    impl->ProvidesOwnCallbackThread = 1;
+
+    build_device_lists();       /* do an initial check for devices... */
+
+    return (outputDeviceCount > 0) ? 2 : 1;
+}
+
+AudioBootStrap COREAUDIO_bootstrap = {
+    "coreaudio", "Mac OS X CoreAudio", COREAUDIO_Init, 0
+};
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/macosx/SDL_coreaudio.h

@@ -0,0 +1,43 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifndef _SDL_coreaudio_h
+#define _SDL_coreaudio_h
+
+#include "../SDL_sysaudio.h"
+
+/* Hidden "this" pointer for the audio functions */
+#define _THIS	SDL_AudioDevice *this
+
+struct SDL_PrivateAudioData
+{
+    AudioUnit audioUnit;
+    int audioUnitOpened;
+    void *buffer;
+    UInt32 bufferOffset;
+    UInt32 bufferSize;
+    AudioDeviceID deviceID;
+};
+
+#endif /* _SDL_coreaudio_h */
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/mme/SDL_mmeaudio.c

@@ -0,0 +1,260 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* Tru64 UNIX MME support */
+#include <mme_api.h>
+
+#include "SDL_timer.h"
+#include "SDL_audio.h"
+#include "../SDL_audio_c.h"
+#include "SDL_mmeaudio.h"
+
+static BOOL inUse[NUM_BUFFERS];
+
+static void
+SetMMerror(char *function, MMRESULT code)
+{
+    int len;
+    char errbuf[MAXERRORLENGTH];
+
+    SDL_snprintf(errbuf, SDL_arraysize(errbuf), "%s: ", function);
+    len = SDL_strlen(errbuf);
+    waveOutGetErrorText(code, errbuf + len, MAXERRORLENGTH - len);
+    SDL_SetError("%s", errbuf);
+}
+
+static void CALLBACK
+MME_Callback(HWAVEOUT hwo,
+             UINT uMsg, DWORD dwInstance, LPARAM dwParam1, LPARAM dwParam2)
+{
+    WAVEHDR *wp = (WAVEHDR *) dwParam1;
+
+    if (uMsg == WOM_DONE)
+        inUse[wp->dwUser] = FALSE;
+}
+
+static int
+MME_OpenDevice(_THIS, const char *devname, int iscapture)
+{
+    int valid_format = 0;
+    MMRESULT result;
+    Uint8 *mixbuf = NULL;
+    int i;
+
+    /* Initialize all variables that we clean on shutdown */
+    this->hidden = (struct SDL_PrivateAudioData *)
+        SDL_malloc((sizeof *this->hidden));
+    if (this->hidden == NULL) {
+        SDL_OutOfMemory();
+        return 0;
+    }
+    SDL_memset(this->hidden, 0, (sizeof *this->hidden));
+
+    /* Set basic WAVE format parameters */
+    this->hidden->shm = mmeAllocMem(sizeof(*this->hidden->shm));
+    if (this->hidden->shm == NULL) {
+        MME_CloseDevice(this);
+        SDL_OutOfMemory();
+        return 0;
+    }
+
+    SDL_memset(this->hidden->shm, '\0', sizeof(*this->hidden->shm));
+    this->hidden->shm->sound = 0;
+    this->hidden->shm->wFmt.wf.wFormatTag = WAVE_FORMAT_PCM;
+
+    /* Determine the audio parameters from the AudioSpec */
+    /* Try for a closest match on audio format */
+    for (test_format = SDL_FirstAudioFormat(this->spec.format);
+         !valid_format && test_format;) {
+        valid_format = 1;
+        switch (test_format) {
+        case AUDIO_U8:
+        case AUDIO_S16:
+        case AUDIO_S32:
+            break;
+        default:
+            valid_format = 0;
+            test_format = SDL_NextAudioFormat();
+        }
+    }
+
+    if (!valid_format) {
+        MME_CloseDevice(this);
+        SDL_SetError("Unsupported audio format");
+        return 0;
+    }
+
+    this->spec.format = test_format;
+    this->hidden->shm->wFmt.wBitsPerSample = SDL_AUDIO_BITSIZE(test_format);
+
+    /* !!! FIXME: Can this handle more than stereo? */
+    this->hidden->shm->wFmt.wf.nChannels = this->spec.channels;
+    this->hidden->shm->wFmt.wf.nSamplesPerSec = this->spec.freq;
+    this->hidden->shm->wFmt.wf.nBlockAlign =
+        this->hidden->shm->wFmt.wf.nChannels *
+        this->hidden->shm->wFmt.wBitsPerSample / 8;
+    this->hidden->shm->wFmt.wf.nAvgBytesPerSec =
+        this->hidden->shm->wFmt.wf.nSamplesPerSec *
+        this->hidden->shm->wFmt.wf.nBlockAlign;
+
+    /* Check the buffer size -- minimum of 1/4 second (word aligned) */
+    if (this->spec.samples < (this->spec.freq / 4))
+        this->spec.samples = ((this->spec.freq / 4) + 3) & ~3;
+
+    /* Update the fragment size as size in bytes */
+    SDL_CalculateAudioSpec(&this->spec);
+
+    /* Open the audio device */
+    result = waveOutOpen(&(this->hidden->shm->sound),
+                         WAVE_MAPPER,
+                         &(this->hidden->shm->wFmt.wf),
+                         MME_Callback,
+                         NULL, (CALLBACK_FUNCTION | WAVE_OPEN_SHAREABLE));
+    if (result != MMSYSERR_NOERROR) {
+        MME_CloseDevice(this);
+        SetMMerror("waveOutOpen()", result);
+        return 0;
+    }
+
+    /* Create the sound buffers */
+    mixbuf = (Uint8 *) mmeAllocBuffer(NUM_BUFFERS * (this->spec.size));
+    if (mixbuf == NULL) {
+        MME_CloseDevice(this);
+        SDL_OutOfMemory();
+        return 0;
+    }
+    this->hidden->mixbuf = mixbuf;
+
+    for (i = 0; i < NUM_BUFFERS; i++) {
+        this->hidden->shm->wHdr[i].lpData = &mixbuf[i * (this->spec.size)];
+        this->hidden->shm->wHdr[i].dwBufferLength = this->spec.size;
+        this->hidden->shm->wHdr[i].dwFlags = 0;
+        this->hidden->shm->wHdr[i].dwUser = i;
+        this->hidden->shm->wHdr[i].dwLoops = 0; /* loop control counter */
+        this->hidden->shm->wHdr[i].lpNext = NULL;       /* reserved for driver */
+        this->hidden->shm->wHdr[i].reserved = 0;
+        inUse[i] = FALSE;
+    }
+    this->hidden->next_buffer = 0;
+
+    return 1;
+}
+
+static void
+MME_WaitDevice(_THIS)
+{
+    while (inUse[this->hidden->next_buffer]) {
+        mmeWaitForCallbacks();
+        mmeProcessCallbacks();
+    }
+}
+
+static Uint8 *
+MME_GetDeviceBuf(_THIS)
+{
+    void *retval = this->hidden->shm->wHdr[this->hidden->next_buffer].lpData;
+    inUse[this->hidden->next_buffer] = TRUE;
+    return (Uint8 *) retval;
+}
+
+static void
+MME_PlayDevice(_THIS)
+{
+    /* Queue it up */
+    waveOutWrite(this->hidden->shm->sound,
+                 &(this->hidden->shm->wHdr[this->hidden->next_buffer]),
+                 sizeof(WAVEHDR));
+    this->hidden->next_buffer = (this->hidden->next_buffer + 1) % NUM_BUFFERS;
+}
+
+static void
+MME_WaitDone(_THIS)
+{
+    MMRESULT result;
+    int i;
+
+    if (this->hidden->shm->sound) {
+        for (i = 0; i < NUM_BUFFERS; i++)
+            while (inUse[i]) {
+                mmeWaitForCallbacks();
+                mmeProcessCallbacks();
+            }
+        result = waveOutReset(this->hidden->shm->sound);
+        if (result != MMSYSERR_NOERROR)
+            SetMMerror("waveOutReset()", result);
+        mmeProcessCallbacks();
+    }
+}
+
+static void
+MME_CloseDevice(_THIS)
+{
+    if (this->hidden != NULL) {
+        MMRESULT result;
+
+        if (this->hidden->mixbuf) {
+            result = mmeFreeBuffer(this->hidden->mixbuf);
+            if (result != MMSYSERR_NOERROR)
+                SetMMerror("mmeFreeBuffer", result);
+            this->hidden->mixbuf = NULL;
+        }
+
+        if (this->hidden->shm) {
+            if (this->hidden->shm->sound) {
+                result = waveOutClose(this->hidden->shm->sound);
+                if (result != MMSYSERR_NOERROR)
+                    SetMMerror("waveOutClose()", result);
+                mmeProcessCallbacks();
+            }
+            result = mmeFreeMem(this->hidden->shm);
+            if (result != MMSYSERR_NOERROR)
+                SetMMerror("mmeFreeMem()", result);
+            this->hidden->shm = NULL;
+        }
+
+        SDL_free(this->hidden);
+        this->hidden = NULL;
+    }
+}
+
+static int
+MME_Init(SDL_AudioDriverImpl * impl)
+{
+    /* Set the function pointers */
+    impl->OpenDevice = MME_OpenDevice;
+    impl->WaitDevice = MME_WaitDevice;
+    impl->WaitDone = MME_WaitDone;
+    impl->PlayDevice = MME_PlayDevice;
+    impl->GetDeviceBuf = MME_GetDeviceBuf;
+    impl->CloseDevice = MME_CloseDevice;
+    impl->OnlyHasDefaultOutputDevice = 1;
+
+    return 1;
+}
+
+/* !!! FIXME: Windows "windib" driver is called waveout, too */
+AudioBootStrap MMEAUDIO_bootstrap = {
+    "waveout", "Tru64 MME WaveOut", MME_Init, 0
+};
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/mme/SDL_mmeaudio.h

@@ -0,0 +1,51 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* Allow access to a raw mixing buffer */
+
+#ifndef _SDL_mmeaudio_h
+#define _SDL_mmeaudio_h
+
+#include "../SDL_sysaudio.h"
+
+/* Hidden "this" pointer for the audio functions */
+#define _THIS	SDL_AudioDevice *this
+#define NUM_BUFFERS 2
+
+struct SharedMem
+{
+    HWAVEOUT sound;
+    WAVEHDR wHdr[NUM_BUFFERS];
+    PCMWAVEFORMAT wFmt;
+};
+
+struct SDL_PrivateAudioData
+{
+    Uint8 *mixbuf;              /* The raw allocated mixing buffer */
+    struct SharedMem *shm;
+    int next_buffer;
+};
+
+#endif /* _SDL_mmeaudio_h */
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/nas/SDL_nasaudio.c

@@ -0,0 +1,408 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+
+    This driver was written by:
+    Erik Inge Bols<6C>
+    knan@mo.himolde.no
+*/
+#include "SDL_config.h"
+
+/* Allow access to a raw mixing buffer */
+
+#include <signal.h>
+#include <unistd.h>
+
+#include "SDL_timer.h"
+#include "SDL_audio.h"
+#include "SDL_loadso.h"
+#include "../SDL_audiomem.h"
+#include "../SDL_audio_c.h"
+#include "SDL_nasaudio.h"
+
+/* The tag name used by nas audio */
+#define NAS_DRIVER_NAME         "nas"
+
+static struct SDL_PrivateAudioData *this2 = NULL;
+
+
+static void (*NAS_AuCloseServer) (AuServer *);
+static void (*NAS_AuNextEvent) (AuServer *, AuBool, AuEvent *);
+static AuBool(*NAS_AuDispatchEvent) (AuServer *, AuEvent *);
+static AuFlowID(*NAS_AuCreateFlow) (AuServer *, AuStatus *);
+static void (*NAS_AuStartFlow) (AuServer *, AuFlowID, AuStatus *);
+static void (*NAS_AuSetElements)
+  (AuServer *, AuFlowID, AuBool, int, AuElement *, AuStatus *);
+static void (*NAS_AuWriteElement)
+  (AuServer *, AuFlowID, int, AuUint32, AuPointer, AuBool, AuStatus *);
+static AuServer *(*NAS_AuOpenServer)
+  (_AuConst char *, int, _AuConst char *, int, _AuConst char *, char **);
+static AuEventHandlerRec *(*NAS_AuRegisterEventHandler)
+  (AuServer *, AuMask, int, AuID, AuEventHandlerCallback, AuPointer);
+
+
+#ifdef SDL_AUDIO_DRIVER_NAS_DYNAMIC
+
+static const char *nas_library = SDL_AUDIO_DRIVER_NAS_DYNAMIC;
+static void *nas_handle = NULL;
+
+static int
+load_nas_sym(const char *fn, void **addr)
+{
+    *addr = SDL_LoadFunction(nas_handle, fn);
+    if (*addr == NULL) {
+        return 0;
+    }
+    return 1;
+}
+
+/* cast funcs to char* first, to please GCC's strict aliasing rules. */
+#define SDL_NAS_SYM(x) \
+    if (!load_nas_sym(#x, (void **) (char *) &NAS_##x)) return -1
+#else
+#define SDL_NAS_SYM(x) NAS_##x = x
+#endif
+
+static int
+load_nas_syms(void)
+{
+    SDL_NAS_SYM(AuCloseServer);
+    SDL_NAS_SYM(AuNextEvent);
+    SDL_NAS_SYM(AuDispatchEvent);
+    SDL_NAS_SYM(AuCreateFlow);
+    SDL_NAS_SYM(AuStartFlow);
+    SDL_NAS_SYM(AuSetElements);
+    SDL_NAS_SYM(AuWriteElement);
+    SDL_NAS_SYM(AuOpenServer);
+    SDL_NAS_SYM(AuRegisterEventHandler);
+    return 0;
+}
+
+#undef SDL_NAS_SYM
+
+#ifdef SDL_AUDIO_DRIVER_NAS_DYNAMIC
+
+static void
+UnloadNASLibrary(void)
+{
+    if (nas_handle != NULL) {
+        SDL_UnloadObject(nas_handle);
+        nas_handle = NULL;
+    }
+}
+
+static int
+LoadNASLibrary(void)
+{
+    int retval = 0;
+    if (nas_handle == NULL) {
+        nas_handle = SDL_LoadObject(nas_library);
+        if (nas_handle == NULL) {
+            /* Copy error string so we can use it in a new SDL_SetError(). */
+            char *origerr = SDL_GetError();
+            size_t len = SDL_strlen(origerr) + 1;
+            char *err = (char *) alloca(len);
+            SDL_strlcpy(err, origerr, len);
+            retval = -1;
+            SDL_SetError("NAS: SDL_LoadObject('%s') failed: %s\n",
+                         nas_library, err);
+        } else {
+            retval = load_nas_syms();
+            if (retval < 0) {
+                UnloadNASLibrary();
+            }
+        }
+    }
+    return retval;
+}
+
+#else
+
+static void
+UnloadNASLibrary(void)
+{
+}
+
+static int
+LoadNASLibrary(void)
+{
+    load_nas_syms();
+    return 0;
+}
+
+#endif /* SDL_AUDIO_DRIVER_NAS_DYNAMIC */
+
+/* This function waits until it is possible to write a full sound buffer */
+static void
+NAS_WaitDevice(_THIS)
+{
+    while (this->hidden->buf_free < this->hidden->mixlen) {
+        AuEvent ev;
+        NAS_AuNextEvent(this->hidden->aud, AuTrue, &ev);
+        NAS_AuDispatchEvent(this->hidden->aud, &ev);
+    }
+}
+
+static void
+NAS_PlayDevice(_THIS)
+{
+    while (this->hidden->mixlen > this->hidden->buf_free) {
+        /*
+         * We think the buffer is full? Yikes! Ask the server for events,
+         *  in the hope that some of them is LowWater events telling us more
+         *  of the buffer is free now than what we think.
+         */
+        AuEvent ev;
+        NAS_AuNextEvent(this->hidden->aud, AuTrue, &ev);
+        NAS_AuDispatchEvent(this->hidden->aud, &ev);
+    }
+    this->hidden->buf_free -= this->hidden->mixlen;
+
+    /* Write the audio data */
+    NAS_AuWriteElement(this->hidden->aud, this->hidden->flow, 0,
+                       this->hidden->mixlen, this->hidden->mixbuf, AuFalse,
+                       NULL);
+
+    this->hidden->written += this->hidden->mixlen;
+
+#ifdef DEBUG_AUDIO
+    fprintf(stderr, "Wrote %d bytes of audio data\n", this->hidden->mixlen);
+#endif
+}
+
+static Uint8 *
+NAS_GetDeviceBuf(_THIS)
+{
+    return (this->hidden->mixbuf);
+}
+
+static void
+NAS_CloseDevice(_THIS)
+{
+    if (this->hidden != NULL) {
+        if (this->hidden->mixbuf != NULL) {
+            SDL_FreeAudioMem(this->hidden->mixbuf);
+            this->hidden->mixbuf = NULL;
+        }
+        if (this->hidden->aud) {
+            NAS_AuCloseServer(this->hidden->aud);
+            this->hidden->aud = 0;
+        }
+        SDL_free(this->hidden);
+        this2 = this->hidden = NULL;
+    }
+}
+
+static unsigned char
+sdlformat_to_auformat(unsigned int fmt)
+{
+    switch (fmt) {
+    case AUDIO_U8:
+        return AuFormatLinearUnsigned8;
+    case AUDIO_S8:
+        return AuFormatLinearSigned8;
+    case AUDIO_U16LSB:
+        return AuFormatLinearUnsigned16LSB;
+    case AUDIO_U16MSB:
+        return AuFormatLinearUnsigned16MSB;
+    case AUDIO_S16LSB:
+        return AuFormatLinearSigned16LSB;
+    case AUDIO_S16MSB:
+        return AuFormatLinearSigned16MSB;
+    }
+    return AuNone;
+}
+
+static AuBool
+event_handler(AuServer * aud, AuEvent * ev, AuEventHandlerRec * hnd)
+{
+    switch (ev->type) {
+    case AuEventTypeElementNotify:
+        {
+            AuElementNotifyEvent *event = (AuElementNotifyEvent *) ev;
+
+            switch (event->kind) {
+            case AuElementNotifyKindLowWater:
+                if (this2->buf_free >= 0) {
+                    this2->really += event->num_bytes;
+                    gettimeofday(&this2->last_tv, 0);
+                    this2->buf_free += event->num_bytes;
+                } else {
+                    this2->buf_free = event->num_bytes;
+                }
+                break;
+            case AuElementNotifyKindState:
+                switch (event->cur_state) {
+                case AuStatePause:
+                    if (event->reason != AuReasonUser) {
+                        if (this2->buf_free >= 0) {
+                            this2->really += event->num_bytes;
+                            gettimeofday(&this2->last_tv, 0);
+                            this2->buf_free += event->num_bytes;
+                        } else {
+                            this2->buf_free = event->num_bytes;
+                        }
+                    }
+                    break;
+                }
+            }
+        }
+    }
+    return AuTrue;
+}
+
+static AuDeviceID
+find_device(_THIS, int nch)
+{
+    /* These "Au" things are all macros, not functions... */
+    int i;
+    for (i = 0; i < AuServerNumDevices(this->hidden->aud); i++) {
+        if ((AuDeviceKind(AuServerDevice(this->hidden->aud, i)) ==
+             AuComponentKindPhysicalOutput) &&
+            AuDeviceNumTracks(AuServerDevice(this->hidden->aud, i)) == nch) {
+            return AuDeviceIdentifier(AuServerDevice(this->hidden->aud, i));
+        }
+    }
+    return AuNone;
+}
+
+static int
+NAS_OpenDevice(_THIS, const char *devname, int iscapture)
+{
+    AuElement elms[3];
+    int buffer_size;
+    SDL_AudioFormat test_format, format;
+
+    /* Initialize all variables that we clean on shutdown */
+    this->hidden = (struct SDL_PrivateAudioData *)
+        SDL_malloc((sizeof *this->hidden));
+    if (this->hidden == NULL) {
+        SDL_OutOfMemory();
+        return 0;
+    }
+    SDL_memset(this->hidden, 0, (sizeof *this->hidden));
+
+    /* Try for a closest match on audio format */
+    format = 0;
+    for (test_format = SDL_FirstAudioFormat(this->spec.format);
+         !format && test_format;) {
+        format = sdlformat_to_auformat(test_format);
+        if (format == AuNone) {
+            test_format = SDL_NextAudioFormat();
+        }
+    }
+    if (format == 0) {
+        NAS_CloseDevice(this);
+        SDL_SetError("NAS: Couldn't find any hardware audio formats");
+        return 0;
+    }
+    this->spec.format = test_format;
+
+    this->hidden->aud = NAS_AuOpenServer("", 0, NULL, 0, NULL, NULL);
+    if (this->hidden->aud == 0) {
+        NAS_CloseDevice(this);
+        SDL_SetError("NAS: Couldn't open connection to NAS server");
+        return 0;
+    }
+
+    this->hidden->dev = find_device(this, this->spec.channels);
+    if ((this->hidden->dev == AuNone)
+        || (!(this->hidden->flow = NAS_AuCreateFlow(this->hidden->aud, 0)))) {
+        NAS_CloseDevice(this);
+        SDL_SetError("NAS: Couldn't find a fitting device on NAS server");
+        return 0;
+    }
+
+    buffer_size = this->spec.freq;
+    if (buffer_size < 4096)
+        buffer_size = 4096;
+
+    if (buffer_size > 32768)
+        buffer_size = 32768;    /* So that the buffer won't get unmanageably big. */
+
+    /* Calculate the final parameters for this audio specification */
+    SDL_CalculateAudioSpec(&this->spec);
+
+    this2 = this->hidden;
+
+    AuMakeElementImportClient(elms, this->spec.freq, format,
+                              this->spec.channels, AuTrue, buffer_size,
+                              buffer_size / 4, 0, NULL);
+    AuMakeElementExportDevice(elms + 1, 0, this->hidden->dev, this->spec.freq,
+                              AuUnlimitedSamples, 0, NULL);
+    NAS_AuSetElements(this->hidden->aud, this->hidden->flow, AuTrue, 2, elms,
+                      NULL);
+    NAS_AuRegisterEventHandler(this->hidden->aud, AuEventHandlerIDMask, 0,
+                               this->hidden->flow, event_handler,
+                               (AuPointer) NULL);
+
+    NAS_AuStartFlow(this->hidden->aud, this->hidden->flow, NULL);
+
+    /* Allocate mixing buffer */
+    this->hidden->mixlen = this->spec.size;
+    this->hidden->mixbuf = (Uint8 *) SDL_AllocAudioMem(this->hidden->mixlen);
+    if (this->hidden->mixbuf == NULL) {
+        NAS_CloseDevice(this);
+        SDL_OutOfMemory();
+        return 0;
+    }
+    SDL_memset(this->hidden->mixbuf, this->spec.silence, this->spec.size);
+
+    /* We're ready to rock and roll. :-) */
+    return 1;
+}
+
+static void
+NAS_Deinitialize(void)
+{
+    UnloadNASLibrary();
+}
+
+static int
+NAS_Init(SDL_AudioDriverImpl * impl)
+{
+    if (LoadNASLibrary() < 0) {
+        return 0;
+    } else {
+        AuServer *aud = NAS_AuOpenServer("", 0, NULL, 0, NULL, NULL);
+        if (aud == NULL) {
+            SDL_SetError("NAS: AuOpenServer() failed (no audio server?)");
+            return 0;
+        }
+        NAS_AuCloseServer(aud);
+    }
+
+    /* Set the function pointers */
+    impl->OpenDevice = NAS_OpenDevice;
+    impl->PlayDevice = NAS_PlayDevice;
+    impl->WaitDevice = NAS_WaitDevice;
+    impl->GetDeviceBuf = NAS_GetDeviceBuf;
+    impl->CloseDevice = NAS_CloseDevice;
+    impl->Deinitialize = NAS_Deinitialize;
+    impl->OnlyHasDefaultOutputDevice = 1;       /* !!! FIXME: is this true? */
+
+    return 2;                   /* 2 == definitely has an audio device. */
+}
+
+AudioBootStrap NAS_bootstrap = {
+    NAS_DRIVER_NAME, "Network Audio System", NAS_Init, 0
+};
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/nas/SDL_nasaudio.h

@@ -0,0 +1,61 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+
+    This driver was written by:
+    Erik Inge Bols<6C>
+    knan@mo.himolde.no
+*/
+#include "SDL_config.h"
+
+#ifndef _SDL_nasaudio_h
+#define _SDL_nasaudio_h
+
+#ifdef __sgi
+#include <nas/audiolib.h>
+#else
+#include <audio/audiolib.h>
+#endif
+#include <sys/time.h>
+
+#include "../SDL_sysaudio.h"
+
+/* Hidden "this" pointer for the audio functions */
+#define _THIS	SDL_AudioDevice *this
+
+struct SDL_PrivateAudioData
+{
+    AuServer *aud;
+    AuFlowID flow;
+    AuDeviceID dev;
+
+    /* Raw mixing buffer */
+    Uint8 *mixbuf;
+    int mixlen;
+
+    int written;
+    int really;
+    int bps;
+    struct timeval last_tv;
+    int buf_free;
+};
+#endif /* _SDL_nasaudio_h */
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/nds/SDL_ndsaudio.c

@@ -0,0 +1,130 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+
+    This file written by Ryan C. Gordon (icculus@icculus.org)
+*/
+#include "SDL_config.h"
+
+/* Output audio to NDS */
+
+#include <nds.h>
+
+#include "SDL_audio.h"
+#include "../SDL_audio_c.h"
+#include "SDL_ndsaudio.h"
+
+static int
+NDSAUD_OpenDevice(_THIS, const char *devname, int iscapture)
+{
+    SDL_AudioFormat test_format = SDL_FirstAudioFormat(this->spec.format);
+    int valid_datatype = 0;
+
+    this->hidden = SDL_malloc(sizeof(*(this->hidden)));
+    if (!this->hidden) {
+        SDL_OutOfMemory();
+        return 0;
+    }
+    SDL_memset(this->hidden, 0, (sizeof *this->hidden));
+
+    while ((!valid_datatype) && (test_format)) {
+        this->spec.format = test_format;
+        switch (test_format) {
+        case AUDIO_S8:
+            /*case AUDIO_S16LSB: */
+            valid_datatype = 1;
+            break;
+        default:
+            test_format = SDL_NextAudioFormat();
+            break;
+        }
+    }
+
+    /* set the generic sound parameters */
+    setGenericSound(22050,      /* sample rate */
+                    127,        /* volume */
+                    64,         /* panning/balance */
+                    0);         /* sound format */
+
+    return 1;
+}
+
+static void
+NDSAUD_PlayDevice(_THIS)
+{
+    TransferSoundData *sound = SDL_malloc(sizeof(TransferSoundData));
+    if (!sound) {
+        SDL_OutOfMemory();
+    }
+
+    playGenericSound(this->hidden->mixbuf, this->hidden->mixlen);
+#if 0
+//    sound->data = this->hidden->mixbuf;/* pointer to raw audio data */
+//    sound->len = this->hidden->mixlen; /* size of raw data pointed to above */
+//    sound->rate = 22050; /* sample rate = 22050Hz */
+//    sound->vol = 127;    /* volume [0..127] for [min..max] */
+//    sound->pan = 64;     /* balance [0..127] for [left..right] */
+//    sound->format = 0;   /* 0 for 16-bit, 1 for 8-bit */
+//    playSound(sound);
+#endif
+}
+
+
+static Uint8 *
+NDSAUD_GetDeviceBuf(_THIS)
+{
+    return this->hidden->mixbuf;        /* is this right? */
+}
+
+static void
+NDSAUD_WaitDevice(_THIS)
+{
+    /* stub */
+}
+
+static void
+NDSAUD_CloseDevice(_THIS)
+{
+    /* stub */
+}
+
+static int
+NDSAUD_Init(SDL_AudioDriverImpl * impl)
+{
+    /* Set the function pointers */
+    impl->OpenDevice = NDSAUD_OpenDevice;
+    impl->PlayDevice = NDSAUD_PlayDevice;
+    impl->WaitDevice = NDSAUD_WaitDevice;
+    impl->GetDeviceBuf = NDSAUD_GetDeviceBuf;
+    impl->CloseDevice = NDSAUD_CloseDevice;
+
+    /* and the capabilities */
+    impl->HasCaptureSupport = 1;
+    impl->OnlyHasDefaultOutputDevice = 1;
+    impl->OnlyHasDefaultInputDevice = 1;
+
+    return 2;                   /* 2 == definitely has an audio device. */
+}
+
+AudioBootStrap NDSAUD_bootstrap = {
+    "nds", "SDL NDS audio driver", NDSAUD_Init, 0       /*1? */
+};
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/nds/SDL_ndsaudio.h

@@ -0,0 +1,44 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifndef _SDL_ndsaudio_h
+#define _SDL_ndsaudio_h
+
+#include "../SDL_sysaudio.h"
+#include <nds/arm9/sound.h>
+
+/* Hidden "this" pointer for the audio functions */
+#define _THIS	SDL_AudioDevice *this
+
+struct SDL_PrivateAudioData
+{
+    TransferSoundData *sound;
+    /* The file descriptor for the audio device */
+    Uint8 *mixbuf;
+    Uint32 mixlen;
+    Uint32 write_delay;
+    Uint32 initial_calls;
+};
+
+#endif /* _SDL_ndsaudio_h */
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/paudio/SDL_paudio.c

@@ -0,0 +1,555 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Carsten Griwodz
+    griff@kom.tu-darmstadt.de
+
+    based on linux/SDL_dspaudio.c by Sam Lantinga
+*/
+#include "SDL_config.h"
+
+/* Allow access to a raw mixing buffer */
+
+#include <errno.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/time.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include "SDL_timer.h"
+#include "SDL_audio.h"
+#include "SDL_stdinc.h"
+#include "../SDL_audiomem.h"
+#include "../SDL_audio_c.h"
+#include "SDL_paudio.h"
+
+#define DEBUG_AUDIO 0
+
+/* A conflict within AIX 4.3.3 <sys/> headers and probably others as well.
+ * I guess nobody ever uses audio... Shame over AIX header files.  */
+#include <sys/machine.h>
+#undef BIG_ENDIAN
+#include <sys/audio.h>
+
+/* The tag name used by paud audio */
+#define PAUDIO_DRIVER_NAME         "paud"
+
+/* Open the audio device for playback, and don't block if busy */
+/* #define OPEN_FLAGS	(O_WRONLY|O_NONBLOCK) */
+#define OPEN_FLAGS	O_WRONLY
+
+/* Get the name of the audio device we use for output */
+
+#ifndef _PATH_DEV_DSP
+#define _PATH_DEV_DSP	"/dev/%caud%c/%c"
+#endif
+
+static char devsettings[][3] = {
+    {'p', '0', '1'}, {'p', '0', '2'}, {'p', '0', '3'}, {'p', '0', '4'},
+    {'p', '1', '1'}, {'p', '1', '2'}, {'p', '1', '3'}, {'p', '1', '4'},
+    {'p', '2', '1'}, {'p', '2', '2'}, {'p', '2', '3'}, {'p', '2', '4'},
+    {'p', '3', '1'}, {'p', '3', '2'}, {'p', '3', '3'}, {'p', '3', '4'},
+    {'b', '0', '1'}, {'b', '0', '2'}, {'b', '0', '3'}, {'b', '0', '4'},
+    {'b', '1', '1'}, {'b', '1', '2'}, {'b', '1', '3'}, {'b', '1', '4'},
+    {'b', '2', '1'}, {'b', '2', '2'}, {'b', '2', '3'}, {'b', '2', '4'},
+    {'b', '3', '1'}, {'b', '3', '2'}, {'b', '3', '3'}, {'b', '3', '4'},
+    {'\0', '\0', '\0'}
+};
+
+static int
+OpenUserDefinedDevice(char *path, int maxlen, int flags)
+{
+    const char *audiodev;
+    int fd;
+
+    /* Figure out what our audio device is */
+    if ((audiodev = SDL_getenv("SDL_PATH_DSP")) == NULL) {
+        audiodev = SDL_getenv("AUDIODEV");
+    }
+    if (audiodev == NULL) {
+        return -1;
+    }
+    fd = open(audiodev, flags, 0);
+    if (path != NULL) {
+        SDL_strlcpy(path, audiodev, maxlen);
+        path[maxlen - 1] = '\0';
+    }
+    return fd;
+}
+
+static int
+OpenAudioPath(char *path, int maxlen, int flags, int classic)
+{
+    struct stat sb;
+    int cycle = 0;
+    int fd = OpenUserDefinedDevice(path, maxlen, flags);
+
+    if (fd != -1) {
+        return fd;
+    }
+
+    /* !!! FIXME: do we really need a table here? */
+    while (devsettings[cycle][0] != '\0') {
+        char audiopath[1024];
+        SDL_snprintf(audiopath, SDL_arraysize(audiopath),
+                     _PATH_DEV_DSP,
+                     devsettings[cycle][0],
+                     devsettings[cycle][1], devsettings[cycle][2]);
+
+        if (stat(audiopath, &sb) == 0) {
+            fd = open(audiopath, flags, 0);
+            if (fd > 0) {
+                if (path != NULL) {
+                    SDL_strlcpy(path, audiopath, maxlen);
+                }
+                return fd;
+            }
+        }
+    }
+    return -1;
+}
+
+/* This function waits until it is possible to write a full sound buffer */
+static void
+PAUDIO_WaitDevice(_THIS)
+{
+    fd_set fdset;
+
+    /* See if we need to use timed audio synchronization */
+    if (this->hidden->frame_ticks) {
+        /* Use timer for general audio synchronization */
+        Sint32 ticks;
+
+        ticks =
+            ((Sint32) (this->hidden->next_frame - SDL_GetTicks())) -
+            FUDGE_TICKS;
+        if (ticks > 0) {
+            SDL_Delay(ticks);
+        }
+    } else {
+        audio_buffer paud_bufinfo;
+
+        /* Use select() for audio synchronization */
+        struct timeval timeout;
+        FD_ZERO(&fdset);
+        FD_SET(this->hidden->audio_fd, &fdset);
+
+        if (ioctl(this->hidden->audio_fd, AUDIO_BUFFER, &paud_bufinfo) < 0) {
+#ifdef DEBUG_AUDIO
+            fprintf(stderr, "Couldn't get audio buffer information\n");
+#endif
+            timeout.tv_sec = 10;
+            timeout.tv_usec = 0;
+        } else {
+            long ms_in_buf = paud_bufinfo.write_buf_time;
+            timeout.tv_sec = ms_in_buf / 1000;
+            ms_in_buf = ms_in_buf - timeout.tv_sec * 1000;
+            timeout.tv_usec = ms_in_buf * 1000;
+#ifdef DEBUG_AUDIO
+            fprintf(stderr,
+                    "Waiting for write_buf_time=%ld,%ld\n",
+                    timeout.tv_sec, timeout.tv_usec);
+#endif
+        }
+
+#ifdef DEBUG_AUDIO
+        fprintf(stderr, "Waiting for audio to get ready\n");
+#endif
+        if (select(this->hidden->audio_fd + 1, NULL, &fdset, NULL, &timeout)
+            <= 0) {
+            const char *message =
+                "Audio timeout - buggy audio driver? (disabled)";
+            /*
+             * In general we should never print to the screen,
+             * but in this case we have no other way of letting
+             * the user know what happened.
+             */
+            fprintf(stderr, "SDL: %s - %s\n", strerror(errno), message);
+            this->enabled = 0;
+            /* Don't try to close - may hang */
+            this->hidden->audio_fd = -1;
+#ifdef DEBUG_AUDIO
+            fprintf(stderr, "Done disabling audio\n");
+#endif
+        }
+#ifdef DEBUG_AUDIO
+        fprintf(stderr, "Ready!\n");
+#endif
+    }
+}
+
+static void
+PAUDIO_PlayDevice(_THIS)
+{
+    int written = 0;
+    const Uint8 *mixbuf = this->hidden->mixbuf;
+    const size_t mixlen = this->hidden->mixlen;
+
+    /* Write the audio data, checking for EAGAIN on broken audio drivers */
+    do {
+        written = write(this->hidden->audio_fd, mixbuf, mixlen);
+        if ((written < 0) && ((errno == 0) || (errno == EAGAIN))) {
+            SDL_Delay(1);       /* Let a little CPU time go by */
+        }
+    } while ((written < 0) &&
+             ((errno == 0) || (errno == EAGAIN) || (errno == EINTR)));
+
+    /* If timer synchronization is enabled, set the next write frame */
+    if (this->hidden->frame_ticks) {
+        this->hidden->next_frame += this->hidden->frame_ticks;
+    }
+
+    /* If we couldn't write, assume fatal error for now */
+    if (written < 0) {
+        this->enabled = 0;
+    }
+#ifdef DEBUG_AUDIO
+    fprintf(stderr, "Wrote %d bytes of audio data\n", written);
+#endif
+}
+
+static Uint8 *
+PAUDIO_GetDeviceBuf(_THIS)
+{
+    return this->hidden->mixbuf;
+}
+
+static void
+PAUDIO_CloseDevice(_THIS)
+{
+    if (this->hidden != NULL) {
+        if (this->hidden->mixbuf != NULL) {
+            SDL_FreeAudioMem(this->hidden->mixbuf);
+            this->hidden->mixbuf = NULL;
+        }
+        if (this->hidden->audio_fd >= 0) {
+            close(this->hidden->audio_fd);
+            this->hidden->audio_fd = -1;
+        }
+        SDL_free(this->hidden);
+        this->hidden = NULL;
+    }
+}
+
+static int
+PAUDIO_OpenDevice(_THIS, const char *devname, int iscapture)
+{
+    const char *workaround = SDL_getenv("SDL_DSP_NOSELECT");
+    char audiodev[1024];
+    const char *err = NULL;
+    int format;
+    int bytes_per_sample;
+    SDL_AudioFormat test_format;
+    audio_init paud_init;
+    audio_buffer paud_bufinfo;
+    audio_status paud_status;
+    audio_control paud_control;
+    audio_change paud_change;
+    int fd = -1;
+
+    /* Initialize all variables that we clean on shutdown */
+    this->hidden = (struct SDL_PrivateAudioData *)
+        SDL_malloc((sizeof *this->hidden));
+    if (this->hidden == NULL) {
+        SDL_OutOfMemory();
+        return 0;
+    }
+    SDL_memset(this->hidden, 0, (sizeof *this->hidden));
+
+    /* Open the audio device */
+    fd = OpenAudioPath(audiodev, sizeof(audiodev), OPEN_FLAGS, 0);
+    this->hidden->audio_fd = fd;
+    if (fd < 0) {
+        PAUDIO_CloseDevice(this);
+        SDL_SetError("Couldn't open %s: %s", audiodev, strerror(errno));
+        return 0;
+    }
+
+    /*
+     * We can't set the buffer size - just ask the device for the maximum
+     * that we can have.
+     */
+    if (ioctl(fd, AUDIO_BUFFER, &paud_bufinfo) < 0) {
+        PAUDIO_CloseDevice(this);
+        SDL_SetError("Couldn't get audio buffer information");
+        return 0;
+    }
+
+    if (this->spec.channels > 1)
+        this->spec.channels = 2;
+    else
+        this->spec.channels = 1;
+
+    /*
+     * Fields in the audio_init structure:
+     *
+     * Ignored by us:
+     *
+     * paud.loadpath[LOAD_PATH]; * DSP code to load, MWave chip only?
+     * paud.slot_number;         * slot number of the adapter
+     * paud.device_id;           * adapter identification number
+     *
+     * Input:
+     *
+     * paud.srate;           * the sampling rate in Hz
+     * paud.bits_per_sample; * 8, 16, 32, ...
+     * paud.bsize;           * block size for this rate
+     * paud.mode;            * ADPCM, PCM, MU_LAW, A_LAW, SOURCE_MIX
+     * paud.channels;        * 1=mono, 2=stereo
+     * paud.flags;           * FIXED - fixed length data
+     *                       * LEFT_ALIGNED, RIGHT_ALIGNED (var len only)
+     *                       * TWOS_COMPLEMENT - 2's complement data
+     *                       * SIGNED - signed? comment seems wrong in sys/audio.h
+     *                       * BIG_ENDIAN
+     * paud.operation;       * PLAY, RECORD
+     *
+     * Output:
+     *
+     * paud.flags;           * PITCH            - pitch is supported
+     *                       * INPUT            - input is supported
+     *                       * OUTPUT           - output is supported
+     *                       * MONITOR          - monitor is supported
+     *                       * VOLUME           - volume is supported
+     *                       * VOLUME_DELAY     - volume delay is supported
+     *                       * BALANCE          - balance is supported
+     *                       * BALANCE_DELAY    - balance delay is supported
+     *                       * TREBLE           - treble control is supported
+     *                       * BASS             - bass control is supported
+     *                       * BESTFIT_PROVIDED - best fit returned
+     *                       * LOAD_CODE        - DSP load needed
+     * paud.rc;              * NO_PLAY         - DSP code can't do play requests
+     *                       * NO_RECORD       - DSP code can't do record requests
+     *                       * INVALID_REQUEST - request was invalid
+     *                       * CONFLICT        - conflict with open's flags
+     *                       * OVERLOADED      - out of DSP MIPS or memory
+     * paud.position_resolution; * smallest increment for position
+     */
+
+    paud_init.srate = this->spec.freq;
+    paud_init.mode = PCM;
+    paud_init.operation = PLAY;
+    paud_init.channels = this->spec.channels;
+
+    /* Try for a closest match on audio format */
+    format = 0;
+    for (test_format = SDL_FirstAudioFormat(this->spec.format);
+         !format && test_format;) {
+#ifdef DEBUG_AUDIO
+        fprintf(stderr, "Trying format 0x%4.4x\n", test_format);
+#endif
+        switch (test_format) {
+        case AUDIO_U8:
+            bytes_per_sample = 1;
+            paud_init.bits_per_sample = 8;
+            paud_init.flags = TWOS_COMPLEMENT | FIXED;
+            format = 1;
+            break;
+        case AUDIO_S8:
+            bytes_per_sample = 1;
+            paud_init.bits_per_sample = 8;
+            paud_init.flags = SIGNED | TWOS_COMPLEMENT | FIXED;
+            format = 1;
+            break;
+        case AUDIO_S16LSB:
+            bytes_per_sample = 2;
+            paud_init.bits_per_sample = 16;
+            paud_init.flags = SIGNED | TWOS_COMPLEMENT | FIXED;
+            format = 1;
+            break;
+        case AUDIO_S16MSB:
+            bytes_per_sample = 2;
+            paud_init.bits_per_sample = 16;
+            paud_init.flags = BIG_ENDIAN | SIGNED | TWOS_COMPLEMENT | FIXED;
+            format = 1;
+            break;
+        case AUDIO_U16LSB:
+            bytes_per_sample = 2;
+            paud_init.bits_per_sample = 16;
+            paud_init.flags = TWOS_COMPLEMENT | FIXED;
+            format = 1;
+            break;
+        case AUDIO_U16MSB:
+            bytes_per_sample = 2;
+            paud_init.bits_per_sample = 16;
+            paud_init.flags = BIG_ENDIAN | TWOS_COMPLEMENT | FIXED;
+            format = 1;
+            break;
+        default:
+            break;
+        }
+        if (!format) {
+            test_format = SDL_NextAudioFormat();
+        }
+    }
+    if (format == 0) {
+#ifdef DEBUG_AUDIO
+        fprintf(stderr, "Couldn't find any hardware audio formats\n");
+#endif
+        PAUDIO_CloseDevice(this);
+        SDL_SetError("Couldn't find any hardware audio formats");
+        return 0;
+    }
+    this->spec.format = test_format;
+
+    /*
+     * We know the buffer size and the max number of subsequent writes
+     *  that can be pending. If more than one can pend, allow the application
+     *  to do something like double buffering between our write buffer and
+     *  the device's own buffer that we are filling with write() anyway.
+     *
+     * We calculate this->spec.samples like this because
+     *  SDL_CalculateAudioSpec() will give put paud_bufinfo.write_buf_cap
+     *  (or paud_bufinfo.write_buf_cap/2) into this->spec.size in return.
+     */
+    if (paud_bufinfo.request_buf_cap == 1) {
+        this->spec.samples = paud_bufinfo.write_buf_cap
+            / bytes_per_sample / this->spec.channels;
+    } else {
+        this->spec.samples = paud_bufinfo.write_buf_cap
+            / bytes_per_sample / this->spec.channels / 2;
+    }
+    paud_init.bsize = bytes_per_sample * this->spec.channels;
+
+    SDL_CalculateAudioSpec(&this->spec);
+
+    /*
+     * The AIX paud device init can't modify the values of the audio_init
+     * structure that we pass to it. So we don't need any recalculation
+     * of this stuff and no reinit call as in linux dsp and dma code.
+     *
+     * /dev/paud supports all of the encoding formats, so we don't need
+     * to do anything like reopening the device, either.
+     */
+    if (ioctl(fd, AUDIO_INIT, &paud_init) < 0) {
+        switch (paud_init.rc) {
+        case 1:
+            err = "Couldn't set audio format: DSP can't do play requests";
+            break;
+        case 2:
+            err = "Couldn't set audio format: DSP can't do record requests";
+            break;
+        case 4:
+            err = "Couldn't set audio format: request was invalid";
+            break;
+        case 5:
+            err = "Couldn't set audio format: conflict with open's flags";
+            break;
+        case 6:
+            err = "Couldn't set audio format: out of DSP MIPS or memory";
+            break;
+        default:
+            err = "Couldn't set audio format: not documented in sys/audio.h";
+            break;
+        }
+    }
+
+    if (err != NULL) {
+        PAUDIO_CloseDevice(this);
+        SDL_SetError("Paudio: %s", err);
+        return 0;
+    }
+
+    /* Allocate mixing buffer */
+    this->hidden->mixlen = this->spec.size;
+    this->hidden->mixbuf = (Uint8 *) SDL_AllocAudioMem(this->hidden->mixlen);
+    if (this->hidden->mixbuf == NULL) {
+        PAUDIO_CloseDevice(this);
+        SDL_OutOfMemory();
+        return 0;
+    }
+    SDL_memset(this->hidden->mixbuf, this->spec.silence, this->spec.size);
+
+    /*
+     * Set some paramters: full volume, first speaker that we can find.
+     * Ignore the other settings for now.
+     */
+    paud_change.input = AUDIO_IGNORE;   /* the new input source */
+    paud_change.output = OUTPUT_1;      /* EXTERNAL_SPEAKER,INTERNAL_SPEAKER,OUTPUT_1 */
+    paud_change.monitor = AUDIO_IGNORE; /* the new monitor state */
+    paud_change.volume = 0x7fffffff;    /* volume level [0-0x7fffffff] */
+    paud_change.volume_delay = AUDIO_IGNORE;    /* the new volume delay */
+    paud_change.balance = 0x3fffffff;   /* the new balance */
+    paud_change.balance_delay = AUDIO_IGNORE;   /* the new balance delay */
+    paud_change.treble = AUDIO_IGNORE;  /* the new treble state */
+    paud_change.bass = AUDIO_IGNORE;    /* the new bass state */
+    paud_change.pitch = AUDIO_IGNORE;   /* the new pitch state */
+
+    paud_control.ioctl_request = AUDIO_CHANGE;
+    paud_control.request_info = (char *) &paud_change;
+    if (ioctl(fd, AUDIO_CONTROL, &paud_control) < 0) {
+#ifdef DEBUG_AUDIO
+        fprintf(stderr, "Can't change audio display settings\n");
+#endif
+    }
+
+    /*
+     * Tell the device to expect data. Actual start will wait for
+     * the first write() call.
+     */
+    paud_control.ioctl_request = AUDIO_START;
+    paud_control.position = 0;
+    if (ioctl(fd, AUDIO_CONTROL, &paud_control) < 0) {
+        PAUDIO_CloseDevice(this);
+#ifdef DEBUG_AUDIO
+        fprintf(stderr, "Can't start audio play\n");
+#endif
+        SDL_SetError("Can't start audio play");
+        return 0;
+    }
+
+    /* Check to see if we need to use select() workaround */
+    if (workaround != NULL) {
+        this->hidden->frame_ticks = (float) (this->spec.samples * 1000) /
+            this->spec.freq;
+        this->hidden->next_frame = SDL_GetTicks() + this->hidden->frame_ticks;
+    }
+
+    /* We're ready to rock and roll. :-) */
+    return 1;
+}
+
+static int
+PAUDIO_Init(SDL_AudioDriverImpl * impl)
+{
+    /* !!! FIXME: not right for device enum? */
+    int fd = OpenAudioPath(NULL, 0, OPEN_FLAGS, 0);
+    if (fd < 0) {
+        SDL_SetError("PAUDIO: Couldn't open audio device");
+        return 0;
+    }
+    close(fd);
+
+    /* Set the function pointers */
+    impl->OpenDevice = DSP_OpenDevice;
+    impl->PlayDevice = DSP_PlayDevice;
+    impl->PlayDevice = DSP_WaitDevice;
+    impl->GetDeviceBuf = DSP_GetDeviceBuf;
+    impl->CloseDevice = DSP_CloseDevice;
+    impl->OnlyHasDefaultOutputDevice = 1;       /* !!! FIXME: add device enum! */
+
+    /* !!! FIXME: device enum might make this 1. */
+    return 2;                   /* 2 == definitely has an audio device. */
+}
+
+AudioBootStrap PAUDIO_bootstrap = {
+    PAUDIO_DRIVER_NAME, "AIX Paudio", PAUDIO_Init, 0
+};
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/paudio/SDL_paudio.h

@@ -0,0 +1,48 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifndef _SDL_paudaudio_h
+#define _SDL_paudaudio_h
+
+#include "../SDL_sysaudio.h"
+
+/* Hidden "this" pointer for the audio functions */
+#define _THIS	SDL_AudioDevice *this
+
+struct SDL_PrivateAudioData
+{
+    /* The file descriptor for the audio device */
+    int audio_fd;
+
+    /* Raw mixing buffer */
+    Uint8 *mixbuf;
+    int mixlen;
+
+    /* Support for audio timing using a timer, in addition to select() */
+    float frame_ticks;
+    float next_frame;
+};
+#define FUDGE_TICKS	10      /* The scheduler overhead ticks per frame */
+
+#endif /* _SDL_paudaudio_h */
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/pulseaudio/SDL_pulseaudio.c

@@ -0,0 +1,392 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+/*
+  The PulseAudio target for SDL 1.3 is based on the 1.3 arts target, with
+   the appropriate parts replaced with the 1.2 PulseAudio target code. This
+   was the cleanest way to move it to 1.3. The 1.2 target was written by
+   Stéphan Kochen: stephan .a.t. kochen.nl
+*/
+
+#include "SDL_config.h"
+
+/* Allow access to a raw mixing buffer */
+
+#ifdef HAVE_SIGNAL_H
+#include <signal.h>
+#endif
+#include <unistd.h>
+#include <sys/types.h>
+#include <errno.h>
+#include <pulse/simple.h>
+
+#include "SDL_timer.h"
+#include "SDL_audio.h"
+#include "../SDL_audiomem.h"
+#include "../SDL_audio_c.h"
+#include "SDL_pulseaudio.h"
+
+#ifdef SDL_AUDIO_DRIVER_PULSEAUDIO_DYNAMIC
+#include "SDL_name.h"
+#include "SDL_loadso.h"
+#else
+#define SDL_NAME(X)	X
+#endif
+
+/* The tag name used by pulse audio */
+#define PULSEAUDIO_DRIVER_NAME         "pulseaudio"
+
+#ifdef SDL_AUDIO_DRIVER_PULSEAUDIO_DYNAMIC
+
+static const char *pulse_library = SDL_AUDIO_DRIVER_PULSEAUDIO_DYNAMIC;
+static void *pulse_handle = NULL;
+
+/* !!! FIXME: I hate this SDL_NAME clutter...it makes everything so messy! */
+static pa_simple *(*SDL_NAME(pa_simple_new)) (const char *server,
+                                              const char *name,
+                                              pa_stream_direction_t dir,
+                                              const char *dev,
+                                              const char *stream_name,
+                                              const pa_sample_spec * ss,
+                                              const pa_channel_map * map,
+                                              const pa_buffer_attr * attr,
+                                              int *error);
+static void (*SDL_NAME(pa_simple_free)) (pa_simple * s);
+static int (*SDL_NAME(pa_simple_drain)) (pa_simple * s, int *error);
+static int (*SDL_NAME(pa_simple_write)) (pa_simple * s,
+                                         const void *data,
+                                         size_t length, int *error);
+static pa_channel_map *(*SDL_NAME(pa_channel_map_init_auto)) (pa_channel_map *
+                                                              m,
+                                                              unsigned
+                                                              channels,
+                                                              pa_channel_map_def_t
+                                                              def);
+static const char *(*SDL_NAME(pa_strerror)) (int error);
+
+
+#define SDL_PULSEAUDIO_SYM(x) { #x, (void **) (char *) &SDL_NAME(x) }
+static struct
+{
+    const char *name;
+    void **func;
+} pulse_functions[] = {
+/* *INDENT-OFF* */
+    SDL_PULSEAUDIO_SYM(pa_simple_new),
+    SDL_PULSEAUDIO_SYM(pa_simple_free),
+    SDL_PULSEAUDIO_SYM(pa_simple_drain),
+    SDL_PULSEAUDIO_SYM(pa_simple_write),
+    SDL_PULSEAUDIO_SYM(pa_channel_map_init_auto),
+    SDL_PULSEAUDIO_SYM(pa_strerror),
+/* *INDENT-ON* */
+};
+
+#undef SDL_PULSEAUDIO_SYM
+
+static void
+UnloadPulseLibrary()
+{
+    if (pulse_handle != NULL) {
+        SDL_UnloadObject(pulse_handle);
+        pulse_handle = NULL;
+    }
+}
+
+static int
+LoadPulseLibrary(void)
+{
+    int i, retval = -1;
+
+    if (pulse_handle == NULL) {
+        pulse_handle = SDL_LoadObject(pulse_library);
+        if (pulse_handle != NULL) {
+            retval = 0;
+            for (i = 0; i < SDL_arraysize(pulse_functions); ++i) {
+                *pulse_functions[i].func =
+                    SDL_LoadFunction(pulse_handle, pulse_functions[i].name);
+                if (!*pulse_functions[i].func) {
+                    retval = -1;
+                    UnloadPulseLibrary();
+                    break;
+                }
+            }
+        }
+    }
+
+    return retval;
+}
+
+#else
+
+static void
+UnloadPulseLibrary()
+{
+    return;
+}
+
+static int
+LoadPulseLibrary(void)
+{
+    return 0;
+}
+
+#endif /* SDL_AUDIO_DRIVER_PULSEAUDIO_DYNAMIC */
+
+/* This function waits until it is possible to write a full sound buffer */
+static void
+PULSEAUDIO_WaitDevice(_THIS)
+{
+    Sint32 ticks;
+
+    /* Check to see if the thread-parent process is still alive */
+    {
+        static int cnt = 0;
+        /* Note that this only works with thread implementations
+           that use a different process id for each thread.
+         */
+        /* Check every 10 loops */
+        if (this->hidden->parent && (((++cnt) % 10) == 0)) {
+            if (kill(this->hidden->parent, 0) < 0 && errno == ESRCH) {
+                this->enabled = 0;
+            }
+        }
+    }
+
+    /* Use timer for general audio synchronization */
+    ticks =
+        ((Sint32) (this->hidden->next_frame - SDL_GetTicks())) - FUDGE_TICKS;
+    if (ticks > 0) {
+        SDL_Delay(ticks);
+    }
+}
+
+static void
+PULSEAUDIO_PlayDevice(_THIS)
+{
+    /* Write the audio data */
+    if (SDL_NAME(pa_simple_write) (this->hidden->stream, this->hidden->mixbuf,
+                                   this->hidden->mixlen, NULL) != 0) {
+        this->enabled = 0;
+    }
+}
+
+static void
+PULSEAUDIO_WaitDone(_THIS)
+{
+    SDL_NAME(pa_simple_drain) (this->hidden->stream, NULL);
+}
+
+
+static Uint8 *
+PULSEAUDIO_GetDeviceBuf(_THIS)
+{
+    return (this->hidden->mixbuf);
+}
+
+
+static void
+PULSEAUDIO_CloseDevice(_THIS)
+{
+    if (this->hidden != NULL) {
+        if (this->hidden->mixbuf != NULL) {
+            SDL_FreeAudioMem(this->hidden->mixbuf);
+            this->hidden->mixbuf = NULL;
+        }
+        if (this->hidden->stream) {
+            SDL_NAME(pa_simple_drain) (this->hidden->stream, NULL);
+            SDL_NAME(pa_simple_free) (this->hidden->stream);
+            this->hidden->stream = NULL;
+        }
+        SDL_free(this->hidden);
+        this->hidden = NULL;
+    }
+}
+
+
+/* !!! FIXME: this could probably be expanded. */
+/* Try to get the name of the program */
+static char *
+get_progname(void)
+{
+    char *progname = NULL;
+#ifdef __LINUX__
+    FILE *fp;
+    static char temp[BUFSIZ];
+
+    SDL_snprintf(temp, SDL_arraysize(temp), "/proc/%d/cmdline", getpid());
+    fp = fopen(temp, "r");
+    if (fp != NULL) {
+        if (fgets(temp, sizeof(temp) - 1, fp)) {
+            progname = SDL_strrchr(temp, '/');
+            if (progname == NULL) {
+                progname = temp;
+            } else {
+                progname = progname + 1;
+            }
+        }
+        fclose(fp);
+    }
+#endif
+    return (progname);
+}
+
+
+static int
+PULSEAUDIO_OpenDevice(_THIS, const char *devname, int iscapture)
+{
+    Uint16 test_format = 0;
+    pa_sample_spec paspec;
+    pa_buffer_attr paattr;
+    pa_channel_map pacmap;
+    int err = 0;
+
+    /* Initialize all variables that we clean on shutdown */
+    this->hidden = (struct SDL_PrivateAudioData *)
+        SDL_malloc((sizeof *this->hidden));
+    if (this->hidden == NULL) {
+        SDL_OutOfMemory();
+        return 0;
+    }
+    SDL_memset(this->hidden, 0, (sizeof *this->hidden));
+
+    paspec.format = PA_SAMPLE_INVALID;
+
+    /* Try for a closest match on audio format */
+    for (test_format = SDL_FirstAudioFormat(this->spec.format);
+         (paspec.format == PA_SAMPLE_INVALID) && test_format;) {
+#ifdef DEBUG_AUDIO
+        fprintf(stderr, "Trying format 0x%4.4x\n", test_format);
+#endif
+        switch (test_format) {
+        case AUDIO_U8:
+            paspec.format = PA_SAMPLE_U8;
+            break;
+        case AUDIO_S16LSB:
+            paspec.format = PA_SAMPLE_S16LE;
+            break;
+        case AUDIO_S16MSB:
+            paspec.format = PA_SAMPLE_S16BE;
+            break;
+        default:
+            paspec.format = PA_SAMPLE_INVALID;
+            break;
+        }
+        if (paspec.format == PA_SAMPLE_INVALID) {
+            test_format = SDL_NextAudioFormat();
+        }
+    }
+    if (paspec.format == PA_SAMPLE_INVALID) {
+        PULSEAUDIO_CloseDevice(this);
+        SDL_SetError("Couldn't find any hardware audio formats");
+        return 0;
+    }
+    this->spec.format = test_format;
+
+    /* Calculate the final parameters for this audio specification */
+    SDL_CalculateAudioSpec(&this->spec);
+
+    /* Allocate mixing buffer */
+    this->hidden->mixlen = this->spec.size;
+    this->hidden->mixbuf = (Uint8 *) SDL_AllocAudioMem(this->hidden->mixlen);
+    if (this->hidden->mixbuf == NULL) {
+        PULSEAUDIO_CloseDevice(this);
+        SDL_OutOfMemory();
+        return 0;
+    }
+    SDL_memset(this->hidden->mixbuf, this->spec.silence, this->spec.size);
+
+    paspec.channels = this->spec.channels;
+    paspec.rate = this->spec.freq;
+
+    /* Reduced prebuffering compared to the defaults. */
+    paattr.tlength = this->hidden->mixlen;
+    paattr.minreq = this->hidden->mixlen;
+    paattr.fragsize = this->hidden->mixlen;
+    paattr.prebuf = this->hidden->mixlen;
+    paattr.maxlength = this->hidden->mixlen * 4;
+
+    /* The SDL ALSA output hints us that we use Windows' channel mapping */
+    /* http://bugzilla.libsdl.org/show_bug.cgi?id=110 */
+    SDL_NAME(pa_channel_map_init_auto) (&pacmap, this->spec.channels,
+                                        PA_CHANNEL_MAP_WAVEEX);
+
+    /* Connect to the PulseAudio server */
+    this->hidden->stream = SDL_NAME(pa_simple_new) (SDL_getenv("PASERVER"),     /* server */
+                                                    get_progname(),     /* application name */
+                                                    PA_STREAM_PLAYBACK, /* playback mode */
+                                                    SDL_getenv("PADEVICE"),     /* device on the server */
+                                                    "Simple DirectMedia Layer", /* stream description */
+                                                    &paspec,    /* sample format spec */
+                                                    &pacmap,    /* channel map */
+                                                    &paattr,    /* buffering attributes */
+                                                    &err        /* error code */
+        );
+
+    if (this->hidden->stream == NULL) {
+        PULSEAUDIO_CloseDevice(this);
+        SDL_SetError("Could not connect to PulseAudio: %s",
+                     SDL_NAME(pa_strerror(err)));
+        return 0;
+    }
+
+    /* Get the parent process id (we're the parent of the audio thread) */
+    this->hidden->parent = getpid();
+
+    /* We're ready to rock and roll. :-) */
+    return 1;
+}
+
+
+static void
+PULSEAUDIO_Deinitialize(void)
+{
+    UnloadPulseLibrary();
+}
+
+
+static int
+PULSEAUDIO_Init(SDL_AudioDriverImpl * impl)
+{
+    if (LoadPulseLibrary() < 0) {
+        return 0;
+    }
+
+    /* Set the function pointers */
+    impl->OpenDevice = PULSEAUDIO_OpenDevice;
+    impl->PlayDevice = PULSEAUDIO_PlayDevice;
+    impl->WaitDevice = PULSEAUDIO_WaitDevice;
+    impl->GetDeviceBuf = PULSEAUDIO_GetDeviceBuf;
+    impl->CloseDevice = PULSEAUDIO_CloseDevice;
+    impl->WaitDone = PULSEAUDIO_WaitDone;
+    impl->Deinitialize = PULSEAUDIO_Deinitialize;
+    impl->OnlyHasDefaultOutputDevice = 1;
+
+    /* !!! FIXME: should test if server is available here, return 2 if so. */
+    return 1;
+}
+
+
+AudioBootStrap PULSEAUDIO_bootstrap = {
+    PULSEAUDIO_DRIVER_NAME, "PulseAudio", PULSEAUDIO_Init, 0
+};
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/pulseaudio/SDL_pulseaudio.h

@@ -0,0 +1,54 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifndef _SDL_pulseaudio_h
+#define _SDL_pulseaudio_h
+
+#include <pulse/simple.h>
+
+#include "../SDL_sysaudio.h"
+
+/* Hidden "this" pointer for the audio functions */
+#define _THIS	SDL_AudioDevice *this
+
+struct SDL_PrivateAudioData
+{
+    /* The audio stream handle */
+    pa_simple *stream;
+
+    /* The parent process id, to detect when application quits */
+    pid_t parent;
+
+    /* Raw mixing buffer */
+    Uint8 *mixbuf;
+    int mixlen;
+
+    /* Support for audio timing using a timer, in addition to select() */
+    float frame_ticks;
+    float next_frame;
+};
+#define FUDGE_TICKS	10      /* The scheduler overhead ticks per frame */
+
+#endif /* _SDL_pulseaudio_h */
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/qsa/SDL_qsa_audio.c

@@ -0,0 +1,898 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+
+    QNX Sound Architecture (QSA) SDL driver
+    Copyright (C) 2009 Mike Gorchak
+    (mike@malva.ua, lestat@i.com.ua)
+*/
+
+#include "SDL_config.h"
+
+#include <errno.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sched.h>
+#include <sys/select.h>
+#include <sys/neutrino.h>
+#include <sys/asoundlib.h>
+
+#include "SDL_timer.h"
+#include "SDL_audio.h"
+#include "../SDL_audiomem.h"
+#include "../SDL_audio_c.h"
+#include "SDL_qsa_audio.h"
+
+/* The tag name used by QSA audio framework */
+#define DRIVER_NAME "qsa"
+
+/* default channel communication parameters */
+#define DEFAULT_CPARAMS_RATE   44100
+#define DEFAULT_CPARAMS_VOICES 1
+
+#define DEFAULT_CPARAMS_FRAG_SIZE 4096
+#define DEFAULT_CPARAMS_FRAGS_MIN 1
+#define DEFAULT_CPARAMS_FRAGS_MAX 1
+
+#define QSA_NO_WORKAROUNDS  0x00000000
+#define QSA_MMAP_WORKAROUND 0x00000001
+
+struct BuggyCards
+{
+    char *cardname;
+    unsigned long bugtype;
+};
+
+#define QSA_WA_CARDS             3
+#define QSA_MAX_CARD_NAME_LENGTH 33
+
+struct BuggyCards buggycards[QSA_WA_CARDS] = {
+    {"Sound Blaster Live!", QSA_MMAP_WORKAROUND},
+    {"Vortex 8820", QSA_MMAP_WORKAROUND},
+    {"Vortex 8830", QSA_MMAP_WORKAROUND},
+};
+
+/* List of found devices */
+#define QSA_MAX_DEVICES       32
+#define QSA_MAX_NAME_LENGTH   81+16     /* Hardcoded in QSA, can't be changed */
+
+typedef struct _QSA_Device
+{
+    char name[QSA_MAX_NAME_LENGTH];     /* Long audio device name for SDL  */
+    int cardno;
+    int deviceno;
+} QSA_Device;
+
+QSA_Device qsa_playback_device[QSA_MAX_DEVICES];
+uint32_t qsa_playback_devices;
+
+QSA_Device qsa_capture_device[QSA_MAX_DEVICES];
+uint32_t qsa_capture_devices;
+
+static inline void
+QSA_SetError(const char *fn, int status)
+{
+    SDL_SetError("QSA: %s() failed: %s", fn, snd_strerror(status));
+}
+
+/* card names check to apply the workarounds */
+static int
+QSA_CheckBuggyCards(_THIS, unsigned long checkfor)
+{
+    char scardname[QSA_MAX_CARD_NAME_LENGTH];
+    int it;
+
+    if (snd_card_get_name
+        (this->hidden->cardno, scardname, QSA_MAX_CARD_NAME_LENGTH - 1) < 0) {
+        return 0;
+    }
+
+    for (it = 0; it < QSA_WA_CARDS; it++) {
+        if (SDL_strcmp(buggycards[it].cardname, scardname) == 0) {
+            if (buggycards[it].bugtype == checkfor) {
+                return 1;
+            }
+        }
+    }
+
+    return 0;
+}
+
+static void
+QSA_ThreadInit(_THIS)
+{
+    struct sched_param param;
+    int status;
+
+    /* Increase default 10 priority to 25 to avoid jerky sound */
+    status = SchedGet(0, 0, &param);
+    param.sched_priority = param.sched_curpriority + 15;
+    status = SchedSet(0, 0, SCHED_NOCHANGE, &param);
+}
+
+/* PCM channel parameters initialize function */
+static void
+QSA_InitAudioParams(snd_pcm_channel_params_t * cpars)
+{
+    SDL_memset(cpars, 0, sizeof(snd_pcm_channel_params_t));
+
+    cpars->channel = SND_PCM_CHANNEL_PLAYBACK;
+    cpars->mode = SND_PCM_MODE_BLOCK;
+    cpars->start_mode = SND_PCM_START_DATA;
+    cpars->stop_mode = SND_PCM_STOP_STOP;
+    cpars->format.format = SND_PCM_SFMT_S16_LE;
+    cpars->format.interleave = 1;
+    cpars->format.rate = DEFAULT_CPARAMS_RATE;
+    cpars->format.voices = DEFAULT_CPARAMS_VOICES;
+    cpars->buf.block.frag_size = DEFAULT_CPARAMS_FRAG_SIZE;
+    cpars->buf.block.frags_min = DEFAULT_CPARAMS_FRAGS_MIN;
+    cpars->buf.block.frags_max = DEFAULT_CPARAMS_FRAGS_MAX;
+}
+
+/* This function waits until it is possible to write a full sound buffer */
+static void
+QSA_WaitDevice(_THIS)
+{
+    fd_set wfds;
+    fd_set rfds;
+    int selectret;
+    struct timeval timeout;
+
+    if (!this->hidden->iscapture) {
+        FD_ZERO(&wfds);
+        FD_SET(this->hidden->audio_fd, &wfds);
+    } else {
+        FD_ZERO(&rfds);
+        FD_SET(this->hidden->audio_fd, &rfds);
+    }
+
+    do {
+        /* Setup timeout for playing one fragment equal to 2 seconds          */
+        /* If timeout occured than something wrong with hardware or driver    */
+        /* For example, Vortex 8820 audio driver stucks on second DAC because */
+        /* it doesn't exist !                                                 */
+        timeout.tv_sec = 2;
+        timeout.tv_usec = 0;
+        this->hidden->timeout_on_wait = 0;
+
+        if (!this->hidden->iscapture) {
+            selectret =
+                select(this->hidden->audio_fd + 1, NULL, &wfds, NULL,
+                       &timeout);
+        } else {
+            selectret =
+                select(this->hidden->audio_fd + 1, &rfds, NULL, NULL,
+                       &timeout);
+        }
+
+        switch (selectret) {
+        case -1:
+            {
+                SDL_SetError("QSA: select() failed: %s\n", strerror(errno));
+                return;
+            }
+            break;
+        case 0:
+            {
+                SDL_SetError("QSA: timeout on buffer waiting occured\n");
+                this->hidden->timeout_on_wait = 1;
+                return;
+            }
+            break;
+        default:
+            {
+                if (!this->hidden->iscapture) {
+                    if (FD_ISSET(this->hidden->audio_fd, &wfds)) {
+                        return;
+                    }
+                } else {
+                    if (FD_ISSET(this->hidden->audio_fd, &rfds)) {
+                        return;
+                    }
+                }
+            }
+            break;
+        }
+    } while (1);
+}
+
+static void
+QSA_PlayDevice(_THIS)
+{
+    snd_pcm_channel_status_t cstatus;
+    int written;
+    int status;
+    int towrite;
+    void *pcmbuffer;
+
+    if ((!this->enabled) || (!this->hidden)) {
+        return;
+    }
+
+    towrite = this->spec.size;
+    pcmbuffer = this->hidden->pcm_buf;
+
+    /* Write the audio data, checking for EAGAIN (buffer full) and underrun */
+    do {
+        written =
+            snd_pcm_plugin_write(this->hidden->audio_handle, pcmbuffer,
+                                 towrite);
+        if (written != towrite) {
+            /* Check if samples playback got stuck somewhere in hardware or in */
+            /* the audio device driver */
+            if ((errno == EAGAIN) && (written == 0)) {
+                if (this->hidden->timeout_on_wait != 0) {
+                    SDL_SetError("QSA: buffer playback timeout\n");
+                    return;
+                }
+            }
+
+            /* Check for errors or conditions */
+            if ((errno == EAGAIN) || (errno == EWOULDBLOCK)) {
+                /* Let a little CPU time go by and try to write again */
+                SDL_Delay(1);
+
+                /* if we wrote some data */
+                towrite -= written;
+                pcmbuffer += written * this->spec.channels;
+                continue;
+            } else {
+                if ((errno == EINVAL) || (errno == EIO)) {
+                    SDL_memset(&cstatus, 0, sizeof(cstatus));
+                    if (!this->hidden->iscapture) {
+                        cstatus.channel = SND_PCM_CHANNEL_PLAYBACK;
+                    } else {
+                        cstatus.channel = SND_PCM_CHANNEL_CAPTURE;
+                    }
+
+                    status =
+                        snd_pcm_plugin_status(this->hidden->audio_handle,
+                                              &cstatus);
+                    if (status < 0) {
+                        QSA_SetError("snd_pcm_plugin_status", status);
+                        return;
+                    }
+
+                    if ((cstatus.status == SND_PCM_STATUS_UNDERRUN) ||
+                        (cstatus.status == SND_PCM_STATUS_READY)) {
+                        if (!this->hidden->iscapture) {
+                            status =
+                                snd_pcm_plugin_prepare(this->hidden->
+                                                       audio_handle,
+                                                       SND_PCM_CHANNEL_PLAYBACK);
+                        } else {
+                            status =
+                                snd_pcm_plugin_prepare(this->hidden->
+                                                       audio_handle,
+                                                       SND_PCM_CHANNEL_CAPTURE);
+                        }
+                        if (status < 0) {
+                            QSA_SetError("snd_pcm_plugin_prepare", status);
+                            return;
+                        }
+                    }
+                    continue;
+                } else {
+                    return;
+                }
+            }
+        } else {
+            /* we wrote all remaining data */
+            towrite -= written;
+            pcmbuffer += written * this->spec.channels;
+        }
+    } while ((towrite > 0) && (this->enabled));
+
+    /* If we couldn't write, assume fatal error for now */
+    if (towrite != 0) {
+        this->enabled = 0;
+    }
+}
+
+static Uint8 *
+QSA_GetDeviceBuf(_THIS)
+{
+    return this->hidden->pcm_buf;
+}
+
+static void
+QSA_CloseDevice(_THIS)
+{
+    if (this->hidden != NULL) {
+        if (this->hidden->audio_handle != NULL) {
+            if (!this->hidden->iscapture) {
+                /* Finish playing available samples */
+                snd_pcm_plugin_flush(this->hidden->audio_handle,
+                                     SND_PCM_CHANNEL_PLAYBACK);
+            } else {
+                /* Cancel unread samples during capture */
+                snd_pcm_plugin_flush(this->hidden->audio_handle,
+                                     SND_PCM_CHANNEL_CAPTURE);
+            }
+            snd_pcm_close(this->hidden->audio_handle);
+            this->hidden->audio_handle = NULL;
+        }
+
+        if (this->hidden->pcm_buf != NULL) {
+            SDL_FreeAudioMem(this->hidden->pcm_buf);
+            this->hidden->pcm_buf = NULL;
+        }
+
+        SDL_free(this->hidden);
+        this->hidden = NULL;
+    }
+}
+
+static int
+QSA_OpenDevice(_THIS, const char *devname, int iscapture)
+{
+    int status = 0;
+    int format = 0;
+    SDL_AudioFormat test_format = 0;
+    int found = 0;
+    snd_pcm_channel_setup_t csetup;
+    snd_pcm_channel_params_t cparams;
+
+    /* Initialize all variables that we clean on shutdown */
+    this->hidden =
+        (struct SDL_PrivateAudioData *) SDL_calloc(1,
+                                                   (sizeof
+                                                    (struct
+                                                     SDL_PrivateAudioData)));
+    if (this->hidden == NULL) {
+        SDL_OutOfMemory();
+        return 0;
+    }
+    SDL_memset(this->hidden, 0, sizeof(struct SDL_PrivateAudioData));
+
+    /* Initialize channel transfer parameters to default */
+    QSA_InitAudioParams(&cparams);
+
+    /* Initialize channel direction: capture or playback */
+    this->hidden->iscapture = iscapture;
+
+    /* Find deviceid and cardid by device name for playback */
+    if ((!this->hidden->iscapture) && (devname != NULL)) {
+        uint32_t device;
+        int32_t status;
+
+        /* Search in the playback devices */
+        device = 0;
+        do {
+            status = SDL_strcmp(qsa_playback_device[device].name, devname);
+            if (status == 0) {
+                /* Found requested device */
+                this->hidden->deviceno = qsa_playback_device[device].deviceno;
+                this->hidden->cardno = qsa_playback_device[device].cardno;
+                break;
+            }
+            device++;
+            if (device >= qsa_playback_devices) {
+                QSA_CloseDevice(this);
+                SDL_SetError("No such playback device");
+                return 0;
+            }
+        } while (1);
+    }
+
+    /* Find deviceid and cardid by device name for capture */
+    if ((this->hidden->iscapture) && (devname != NULL)) {
+        /* Search in the capture devices */
+        uint32_t device;
+        int32_t status;
+
+        /* Searching in the playback devices */
+        device = 0;
+        do {
+            status = SDL_strcmp(qsa_capture_device[device].name, devname);
+            if (status == 0) {
+                /* Found requested device */
+                this->hidden->deviceno = qsa_capture_device[device].deviceno;
+                this->hidden->cardno = qsa_capture_device[device].cardno;
+                break;
+            }
+            device++;
+            if (device >= qsa_capture_devices) {
+                QSA_CloseDevice(this);
+                SDL_SetError("No such capture device");
+                return 0;
+            }
+        } while (1);
+    }
+
+    /* Check if SDL requested default audio device */
+    if (devname == NULL) {
+        /* Open system default audio device */
+        if (!this->hidden->iscapture) {
+            status = snd_pcm_open_preferred(&this->hidden->audio_handle,
+                                            &this->hidden->cardno,
+                                            &this->hidden->deviceno,
+                                            SND_PCM_OPEN_PLAYBACK);
+        } else {
+            status = snd_pcm_open_preferred(&this->hidden->audio_handle,
+                                            &this->hidden->cardno,
+                                            &this->hidden->deviceno,
+                                            SND_PCM_OPEN_CAPTURE);
+        }
+    } else {
+        /* Open requested audio device */
+        if (!this->hidden->iscapture) {
+            status =
+                snd_pcm_open(&this->hidden->audio_handle,
+                             this->hidden->cardno, this->hidden->deviceno,
+                             SND_PCM_OPEN_PLAYBACK);
+        } else {
+            status =
+                snd_pcm_open(&this->hidden->audio_handle,
+                             this->hidden->cardno, this->hidden->deviceno,
+                             SND_PCM_OPEN_CAPTURE);
+        }
+    }
+
+    /* Check if requested device is opened */
+    if (status < 0) {
+        this->hidden->audio_handle = NULL;
+        QSA_CloseDevice(this);
+        QSA_SetError("snd_pcm_open", status);
+        return 0;
+    }
+
+    if (!QSA_CheckBuggyCards(this, QSA_MMAP_WORKAROUND)) {
+        /* Disable QSA MMAP plugin for buggy audio drivers */
+        status =
+            snd_pcm_plugin_set_disable(this->hidden->audio_handle,
+                                       PLUGIN_DISABLE_MMAP);
+        if (status < 0) {
+            QSA_CloseDevice(this);
+            QSA_SetError("snd_pcm_plugin_set_disable", status);
+            return 0;
+        }
+    }
+
+    /* Try for a closest match on audio format */
+    format = 0;
+    /* can't use format as SND_PCM_SFMT_U8 = 0 in qsa */
+    found = 0;
+
+    for (test_format = SDL_FirstAudioFormat(this->spec.format); !found;) {
+        /* if match found set format to equivalent QSA format */
+        switch (test_format) {
+        case AUDIO_U8:
+            {
+                format = SND_PCM_SFMT_U8;
+                found = 1;
+            }
+            break;
+        case AUDIO_S8:
+            {
+                format = SND_PCM_SFMT_S8;
+                found = 1;
+            }
+            break;
+        case AUDIO_S16LSB:
+            {
+                format = SND_PCM_SFMT_S16_LE;
+                found = 1;
+            }
+            break;
+        case AUDIO_S16MSB:
+            {
+                format = SND_PCM_SFMT_S16_BE;
+                found = 1;
+            }
+            break;
+        case AUDIO_U16LSB:
+            {
+                format = SND_PCM_SFMT_U16_LE;
+                found = 1;
+            }
+            break;
+        case AUDIO_U16MSB:
+            {
+                format = SND_PCM_SFMT_U16_BE;
+                found = 1;
+            }
+            break;
+        case AUDIO_S32LSB:
+            {
+                format = SND_PCM_SFMT_S32_LE;
+                found = 1;
+            }
+            break;
+        case AUDIO_S32MSB:
+            {
+                format = SND_PCM_SFMT_S32_BE;
+                found = 1;
+            }
+            break;
+        case AUDIO_F32LSB:
+            {
+                format = SND_PCM_SFMT_FLOAT_LE;
+                found = 1;
+            }
+            break;
+        case AUDIO_F32MSB:
+            {
+                format = SND_PCM_SFMT_FLOAT_BE;
+                found = 1;
+            }
+            break;
+        default:
+            {
+                break;
+            }
+        }
+
+        if (!found) {
+            test_format = SDL_NextAudioFormat();
+        }
+    }
+
+    /* assumes test_format not 0 on success */
+    if (test_format == 0) {
+        QSA_CloseDevice(this);
+        SDL_SetError("QSA: Couldn't find any hardware audio formats");
+        return 0;
+    }
+
+    this->spec.format = test_format;
+
+    /* Set the audio format */
+    cparams.format.format = format;
+
+    /* Set mono/stereo/4ch/6ch/8ch audio */
+    cparams.format.voices = this->spec.channels;
+
+    /* Set rate */
+    cparams.format.rate = this->spec.freq;
+
+    /* Setup the transfer parameters according to cparams */
+    status = snd_pcm_plugin_params(this->hidden->audio_handle, &cparams);
+    if (status < 0) {
+        QSA_CloseDevice(this);
+        QSA_SetError("snd_pcm_channel_params", status);
+        return 0;
+    }
+
+    /* Make sure channel is setup right one last time */
+    SDL_memset(&csetup, '\0', sizeof(csetup));
+    if (!this->hidden->iscapture) {
+        csetup.channel = SND_PCM_CHANNEL_PLAYBACK;
+    } else {
+        csetup.channel = SND_PCM_CHANNEL_CAPTURE;
+    }
+
+    /* Setup an audio channel */
+    if (snd_pcm_plugin_setup(this->hidden->audio_handle, &csetup) < 0) {
+        QSA_CloseDevice(this);
+        SDL_SetError("QSA: Unable to setup channel\n");
+        return 0;
+    }
+
+    /* Calculate the final parameters for this audio specification */
+    SDL_CalculateAudioSpec(&this->spec);
+
+    this->hidden->pcm_len = this->spec.size;
+
+    if (this->hidden->pcm_len == 0) {
+        this->hidden->pcm_len =
+            csetup.buf.block.frag_size * this->spec.channels *
+            (snd_pcm_format_width(format) / 8);
+    }
+
+    /*
+     * Allocate memory to the audio buffer and initialize with silence
+     *  (Note that buffer size must be a multiple of fragment size, so find
+     *  closest multiple)
+     */
+    this->hidden->pcm_buf =
+        (Uint8 *) SDL_AllocAudioMem(this->hidden->pcm_len);
+    if (this->hidden->pcm_buf == NULL) {
+        QSA_CloseDevice(this);
+        SDL_OutOfMemory();
+        return 0;
+    }
+    SDL_memset(this->hidden->pcm_buf, this->spec.silence,
+               this->hidden->pcm_len);
+
+    /* get the file descriptor */
+    if (!this->hidden->iscapture) {
+        this->hidden->audio_fd =
+            snd_pcm_file_descriptor(this->hidden->audio_handle,
+                                    SND_PCM_CHANNEL_PLAYBACK);
+    } else {
+        this->hidden->audio_fd =
+            snd_pcm_file_descriptor(this->hidden->audio_handle,
+                                    SND_PCM_CHANNEL_CAPTURE);
+    }
+
+    if (this->hidden->audio_fd < 0) {
+        QSA_CloseDevice(this);
+        QSA_SetError("snd_pcm_file_descriptor", status);
+        return 0;
+    }
+
+    /* Prepare an audio channel */
+    if (!this->hidden->iscapture) {
+        /* Prepare audio playback */
+        status =
+            snd_pcm_plugin_prepare(this->hidden->audio_handle,
+                                   SND_PCM_CHANNEL_PLAYBACK);
+    } else {
+        /* Prepare audio capture */
+        status =
+            snd_pcm_plugin_prepare(this->hidden->audio_handle,
+                                   SND_PCM_CHANNEL_CAPTURE);
+    }
+
+    if (status < 0) {
+        QSA_CloseDevice(this);
+        QSA_SetError("snd_pcm_plugin_prepare", status);
+        return 0;
+    }
+
+    /* We're really ready to rock and roll. :-) */
+    return 1;
+}
+
+int
+QSA_DetectDevices(int iscapture)
+{
+    uint32_t it;
+    uint32_t cards;
+    uint32_t devices;
+    int32_t status;
+
+    /* Detect amount of available devices       */
+    /* this value can be changed in the runtime */
+    cards = snd_cards();
+
+    /* If io-audio manager is not running we will get 0 as number */
+    /* of available audio devices                                 */
+    if (cards == 0) {
+        /* We have no any available audio devices */
+        return 0;
+    }
+
+    /* Find requested devices by type */
+    if (!iscapture) {
+        /* Playback devices enumeration requested */
+        for (it = 0; it < cards; it++) {
+            devices = 0;
+            do {
+                status =
+                    snd_card_get_longname(it,
+                                          qsa_playback_device
+                                          [qsa_playback_devices].name,
+                                          QSA_MAX_NAME_LENGTH);
+                if (status == EOK) {
+                    snd_pcm_t *handle;
+
+                    /* Add device number to device name */
+                    sprintf(qsa_playback_device[qsa_playback_devices].name +
+                            SDL_strlen(qsa_playback_device
+                                       [qsa_playback_devices].name), " d%d",
+                            devices);
+
+                    /* Store associated card number id */
+                    qsa_playback_device[qsa_playback_devices].cardno = it;
+
+                    /* Check if this device id could play anything */
+                    status =
+                        snd_pcm_open(&handle, it, devices,
+                                     SND_PCM_OPEN_PLAYBACK);
+                    if (status == EOK) {
+                        qsa_playback_device[qsa_playback_devices].deviceno =
+                            devices;
+                        status = snd_pcm_close(handle);
+                        if (status == EOK) {
+                            qsa_playback_devices++;
+                        }
+                    } else {
+                        /* Check if we got end of devices list */
+                        if (status == -ENOENT) {
+                            break;
+                        }
+                    }
+                } else {
+                    break;
+                }
+
+                /* Check if we reached maximum devices count */
+                if (qsa_playback_devices >= QSA_MAX_DEVICES) {
+                    break;
+                }
+                devices++;
+            } while (1);
+
+            /* Check if we reached maximum devices count */
+            if (qsa_playback_devices >= QSA_MAX_DEVICES) {
+                break;
+            }
+        }
+    } else {
+        /* Capture devices enumeration requested */
+        for (it = 0; it < cards; it++) {
+            devices = 0;
+            do {
+                status =
+                    snd_card_get_longname(it,
+                                          qsa_capture_device
+                                          [qsa_capture_devices].name,
+                                          QSA_MAX_NAME_LENGTH);
+                if (status == EOK) {
+                    snd_pcm_t *handle;
+
+                    /* Add device number to device name */
+                    sprintf(qsa_capture_device[qsa_capture_devices].name +
+                            SDL_strlen(qsa_capture_device
+                                       [qsa_capture_devices].name), " d%d",
+                            devices);
+
+                    /* Store associated card number id */
+                    qsa_capture_device[qsa_capture_devices].cardno = it;
+
+                    /* Check if this device id could play anything */
+                    status =
+                        snd_pcm_open(&handle, it, devices,
+                                     SND_PCM_OPEN_CAPTURE);
+                    if (status == EOK) {
+                        qsa_capture_device[qsa_capture_devices].deviceno =
+                            devices;
+                        status = snd_pcm_close(handle);
+                        if (status == EOK) {
+                            qsa_capture_devices++;
+                        }
+                    } else {
+                        /* Check if we got end of devices list */
+                        if (status == -ENOENT) {
+                            break;
+                        }
+                    }
+
+                    /* Check if we reached maximum devices count */
+                    if (qsa_capture_devices >= QSA_MAX_DEVICES) {
+                        break;
+                    }
+                } else {
+                    break;
+                }
+                devices++;
+            } while (1);
+
+            /* Check if we reached maximum devices count */
+            if (qsa_capture_devices >= QSA_MAX_DEVICES) {
+                break;
+            }
+        }
+    }
+
+    /* Return amount of available playback or capture devices */
+    if (!iscapture) {
+        return qsa_playback_devices;
+    } else {
+        return qsa_capture_devices;
+    }
+}
+
+const char *
+QSA_GetDeviceName(int index, int iscapture)
+{
+    if (!iscapture) {
+        if (index >= qsa_playback_devices) {
+            return "No such playback device";
+        }
+
+        return qsa_playback_device[index].name;
+    } else {
+        if (index >= qsa_capture_devices) {
+            return "No such capture device";
+        }
+
+        return qsa_capture_device[index].name;
+    }
+}
+
+void
+QSA_WaitDone(_THIS)
+{
+    if (!this->hidden->iscapture) {
+        if (this->hidden->audio_handle != NULL) {
+            /* Wait till last fragment is played and stop channel */
+            snd_pcm_plugin_flush(this->hidden->audio_handle,
+                                 SND_PCM_CHANNEL_PLAYBACK);
+        }
+    } else {
+        if (this->hidden->audio_handle != NULL) {
+            /* Discard all unread data and stop channel */
+            snd_pcm_plugin_flush(this->hidden->audio_handle,
+                                 SND_PCM_CHANNEL_CAPTURE);
+        }
+    }
+}
+
+void
+QSA_Deinitialize(void)
+{
+    /* Clear devices array on shutdown */
+    SDL_memset(qsa_playback_device, 0x00,
+               sizeof(QSA_Device) * QSA_MAX_DEVICES);
+    SDL_memset(qsa_capture_device, 0x00,
+               sizeof(QSA_Device) * QSA_MAX_DEVICES);
+    qsa_playback_devices = 0;
+    qsa_capture_devices = 0;
+}
+
+static int
+QSA_Init(SDL_AudioDriverImpl * impl)
+{
+    snd_pcm_t *handle = NULL;
+    int32_t status = 0;
+
+    /* Clear devices array */
+    SDL_memset(qsa_playback_device, 0x00,
+               sizeof(QSA_Device) * QSA_MAX_DEVICES);
+    SDL_memset(qsa_capture_device, 0x00,
+               sizeof(QSA_Device) * QSA_MAX_DEVICES);
+    qsa_playback_devices = 0;
+    qsa_capture_devices = 0;
+
+    /* Set function pointers                                     */
+    /* DeviceLock and DeviceUnlock functions are used default,   */
+    /* provided by SDL, which uses pthread_mutex for lock/unlock */
+    impl->DetectDevices = QSA_DetectDevices;
+    impl->GetDeviceName = QSA_GetDeviceName;
+    impl->OpenDevice = QSA_OpenDevice;
+    impl->ThreadInit = QSA_ThreadInit;
+    impl->WaitDevice = QSA_WaitDevice;
+    impl->PlayDevice = QSA_PlayDevice;
+    impl->GetDeviceBuf = QSA_GetDeviceBuf;
+    impl->CloseDevice = QSA_CloseDevice;
+    impl->WaitDone = QSA_WaitDone;
+    impl->Deinitialize = QSA_Deinitialize;
+    impl->LockDevice = NULL;
+    impl->UnlockDevice = NULL;
+
+    impl->OnlyHasDefaultOutputDevice = 0;
+    impl->ProvidesOwnCallbackThread = 0;
+    impl->SkipMixerLock = 0;
+    impl->HasCaptureSupport = 1;
+    impl->OnlyHasDefaultOutputDevice = 0;
+    impl->OnlyHasDefaultInputDevice = 0;
+
+    /* Check if io-audio manager is running or not */
+    status = snd_cards();
+    if (status == 0) {
+        /* if no, return immediately */
+        return 1;
+    }
+
+    /* At this point we are definitely has an audio device */
+    return 2;
+}
+
+AudioBootStrap QSAAUDIO_bootstrap = {
+    DRIVER_NAME, "QNX QSA Audio", QSA_Init, 0
+};
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/qsa/SDL_qsa_audio.h

@@ -0,0 +1,62 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+
+    QNX Sound Architecture (QSA) SDL driver
+    Copyright (C) 2009 Mike Gorchak
+    (mike@malva.ua, lestat@i.com.ua)
+*/
+
+#include "SDL_config.h"
+
+#ifndef __SDL_QSA_AUDIO_H__
+#define __SDL_QSA_AUDIO_H__
+
+#include <sys/asoundlib.h>
+
+#include "../SDL_sysaudio.h"
+
+/* Hidden "this" pointer for the audio functions */
+#define _THIS SDL_AudioDevice* this
+
+struct SDL_PrivateAudioData
+{
+    /* SDL capture state */
+    int iscapture;
+
+    /* The audio device handle */
+    int cardno;
+    int deviceno;
+    snd_pcm_t *audio_handle;
+
+    /* The audio file descriptor */
+    int audio_fd;
+
+    /* Select timeout status */
+    uint32_t timeout_on_wait;
+
+    /* Raw mixing buffer */
+    Uint8 *pcm_buf;
+    Uint32 pcm_len;
+};
+
+#endif /* __SDL_QSA_AUDIO_H__ */
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/sdlgenaudiocvt.pl

@@ -0,0 +1,754 @@
+#!/usr/bin/perl -w
+
+use warnings;
+use strict;
+
+my @audiotypes = qw(
+    U8
+    S8
+    U16LSB
+    S16LSB
+    U16MSB
+    S16MSB
+    S32LSB
+    S32MSB
+    F32LSB
+    F32MSB
+);
+
+my @channels = ( 1, 2, 4, 6, 8 );
+my %funcs;
+my $custom_converters = 0;
+
+
+sub getTypeConvertHashId {
+    my ($from, $to) = @_;
+    return "TYPECONVERTER $from/$to";
+}
+
+
+sub getResamplerHashId {
+    my ($from, $channels, $upsample, $multiple) = @_;
+    return "RESAMPLER $from/$channels/$upsample/$multiple";
+}
+
+
+sub outputHeader {
+    print <<EOF;
+/* DO NOT EDIT!  This file is generated by sdlgenaudiocvt.pl */
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken\@libsdl.org
+*/
+
+#include "SDL_config.h"
+#include "SDL_audio.h"
+#include "SDL_audio_c.h"
+
+#ifndef DEBUG_CONVERT
+#define DEBUG_CONVERT 0
+#endif
+
+
+/* If you can guarantee your data and need space, you can eliminate code... */
+
+/* Just build the arbitrary resamplers if you're saving code space. */
+#ifndef LESS_RESAMPLERS
+#define LESS_RESAMPLERS 0
+#endif
+
+/* Don't build any resamplers if you're REALLY saving code space. */
+#ifndef NO_RESAMPLERS
+#define NO_RESAMPLERS 0
+#endif
+
+/* Don't build any type converters if you're saving code space. */
+#ifndef NO_CONVERTERS
+#define NO_CONVERTERS 0
+#endif
+
+
+/* *INDENT-OFF* */
+
+EOF
+
+    my @vals = ( 127, 32767, 2147483647 );
+    foreach (@vals) {
+        my $val = $_;
+        my $fval = 1.0 / $val;
+        print("#define DIVBY${val} ${fval}f\n");
+    }
+
+    print("\n");
+}
+
+sub outputFooter {
+    print <<EOF;
+/* $custom_converters converters generated. */
+
+/* *INDENT-ON* */
+
+/* vi: set ts=4 sw=4 expandtab: */
+EOF
+}
+
+sub splittype {
+    my $t = shift;
+    my ($signed, $size, $endian) = $t =~ /([USF])(\d+)([LM]SB|)/;
+    my $float = ($signed eq 'F') ? 1 : 0;
+    $signed = (($float) or ($signed eq 'S')) ? 1 : 0;
+    $endian = 'NONE' if ($endian eq '');
+
+    my $ctype = '';
+    if ($float) {
+        $ctype = (($size == 32) ? 'float' : 'double');
+    } else {
+        $ctype = (($signed) ? 'S' : 'U') . "int${size}";
+    }
+
+    return ($signed, $float, $size, $endian, $ctype);
+}
+
+sub getSwapFunc {
+    my ($size, $signed, $float, $endian, $val) = @_;
+    my $BEorLE = (($endian eq 'MSB') ? 'BE' : 'LE');
+    my $code = '';
+
+    if ($float) {
+        $code = "SDL_SwapFloat${BEorLE}($val)";
+    } else {
+        if ($size > 8) {
+            $code = "SDL_Swap${BEorLE}${size}($val)";
+        } else {
+            $code = $val;
+        }
+
+        if (($signed) and (!$float)) {
+            $code = "((Sint${size}) $code)";
+        }
+    }
+
+    return "${code}";
+}
+
+
+sub maxIntVal {
+    my $size = shift;
+    if ($size == 8) {
+        return 0x7F;
+    } elsif ($size == 16) {
+        return 0x7FFF;
+    } elsif ($size == 32) {
+        return 0x7FFFFFFF;
+    }
+
+    die("bug in script.\n");
+}
+
+sub getFloatToIntMult {
+    my $size = shift;
+    my $val = maxIntVal($size) . '.0';
+    $val .= 'f' if ($size < 32);
+    return $val;
+}
+
+sub getIntToFloatDivBy {
+    my $size = shift;
+    return 'DIVBY' . maxIntVal($size);
+}
+
+sub getSignFlipVal {
+    my $size = shift;
+    if ($size == 8) {
+        return '0x80';
+    } elsif ($size == 16) {
+        return '0x8000';
+    } elsif ($size == 32) {
+        return '0x80000000';
+    }
+
+    die("bug in script.\n");
+}
+
+sub buildCvtFunc {
+    my ($from, $to) = @_;
+    my ($fsigned, $ffloat, $fsize, $fendian, $fctype) = splittype($from);
+    my ($tsigned, $tfloat, $tsize, $tendian, $tctype) = splittype($to);
+    my $diffs = 0;
+    $diffs++ if ($fsize != $tsize);
+    $diffs++ if ($fsigned != $tsigned);
+    $diffs++ if ($ffloat != $tfloat);
+    $diffs++ if ($fendian ne $tendian);
+
+    return if ($diffs == 0);
+
+    my $hashid = getTypeConvertHashId($from, $to);
+    if (1) { # !!! FIXME: if ($diffs > 1) {
+        my $sym = "SDL_Convert_${from}_to_${to}";
+        $funcs{$hashid} = $sym;
+        $custom_converters++;
+
+        # Always unsigned for ints, for possible byteswaps.
+        my $srctype = (($ffloat) ? 'float' : "Uint${fsize}");
+
+        print <<EOF;
+static void SDLCALL
+${sym}(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const $srctype *src;
+    $tctype *dst;
+
+#if DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_${from} to AUDIO_${to}.\\n");
+#endif
+
+EOF
+
+        if ($fsize < $tsize) {
+            my $mult = $tsize / $fsize;
+            print <<EOF;
+    src = ((const $srctype *) (cvt->buf + cvt->len_cvt)) - 1;
+    dst = (($tctype *) (cvt->buf + cvt->len_cvt * $mult)) - 1;
+    for (i = cvt->len_cvt / sizeof ($srctype); i; --i, --src, --dst) {
+EOF
+        } else {
+            print <<EOF;
+    src = (const $srctype *) cvt->buf;
+    dst = ($tctype *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof ($srctype); i; --i, ++src, ++dst) {
+EOF
+        }
+
+        # Have to convert to/from float/int.
+        # !!! FIXME: cast through double for int32<->float?
+        my $code = getSwapFunc($fsize, $fsigned, $ffloat, $fendian, '*src');
+        if ($ffloat != $tfloat) {
+            if ($ffloat) {
+                my $mult = getFloatToIntMult($tsize);
+                if (!$tsigned) {   # bump from -1.0f/1.0f to 0.0f/2.0f
+                    $code = "($code + 1.0f)";
+                }
+                $code = "(($tctype) ($code * $mult))";
+            } else {
+                # $divby will be the reciprocal, to avoid pipeline stalls
+                #  from floating point division...so multiply it.
+                my $divby = getIntToFloatDivBy($fsize);
+                $code = "(((float) $code) * $divby)";
+                if (!$fsigned) {   # bump from 0.0f/2.0f to -1.0f/1.0f.
+                    $code = "($code - 1.0f)";
+                }
+            }
+        } else {
+            # All integer conversions here.
+            if ($fsigned != $tsigned) {
+                my $signflipval = getSignFlipVal($fsize);
+                $code = "(($code) ^ $signflipval)";
+            }
+
+            my $shiftval = abs($fsize - $tsize);
+            if ($fsize < $tsize) {
+                $code = "((($tctype) $code) << $shiftval)";
+            } elsif ($fsize > $tsize) {
+                $code = "(($tctype) ($code >> $shiftval))";
+            }
+        }
+
+        my $swap = getSwapFunc($tsize, $tsigned, $tfloat, $tendian, 'val');
+
+        print <<EOF;
+        const $tctype val = $code;
+        *dst = ${swap};
+    }
+
+EOF
+
+        if ($fsize > $tsize) {
+            my $divby = $fsize / $tsize;
+            print("    cvt->len_cvt /= $divby;\n");
+        } elsif ($fsize < $tsize) {
+            my $mult = $tsize / $fsize;
+            print("    cvt->len_cvt *= $mult;\n");
+        }
+
+        print <<EOF;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_$to);
+    }
+}
+
+EOF
+
+    } else {
+        if ($fsigned != $tsigned) {
+            $funcs{$hashid} = 'SDL_ConvertSigned';
+        } elsif ($ffloat != $tfloat) {
+            $funcs{$hashid} = 'SDL_ConvertFloat';
+        } elsif ($fsize != $tsize) {
+            $funcs{$hashid} = 'SDL_ConvertSize';
+        } elsif ($fendian ne $tendian) {
+            $funcs{$hashid} = 'SDL_ConvertEndian';
+        } else {
+            die("error in script.\n");
+        }
+    }
+}
+
+
+sub buildTypeConverters {
+    print "#if !NO_CONVERTERS\n\n";
+    foreach (@audiotypes) {
+        my $from = $_;
+        foreach (@audiotypes) {
+            my $to = $_;
+            buildCvtFunc($from, $to);
+        }
+    }
+    print "#endif  /* !NO_CONVERTERS */\n\n\n";
+
+    print "const SDL_AudioTypeFilters sdl_audio_type_filters[] =\n{\n";
+    print "#if !NO_CONVERTERS\n";
+    foreach (@audiotypes) {
+        my $from = $_;
+        foreach (@audiotypes) {
+            my $to = $_;
+            if ($from ne $to) {
+                my $hashid = getTypeConvertHashId($from, $to);
+                my $sym = $funcs{$hashid};
+                print("    { AUDIO_$from, AUDIO_$to, $sym },\n");
+            }
+        }
+    }
+    print "#endif  /* !NO_CONVERTERS */\n";
+
+    print("    { 0, 0, NULL }\n");
+    print "};\n\n\n";
+}
+
+sub getBiggerCtype {
+    my ($isfloat, $size) = @_;
+
+    if ($isfloat) {
+        if ($size == 32) {
+            return 'double';
+        }
+        die("bug in script.\n");
+    }
+
+    if ($size == 8) {
+        return 'Sint16';
+    } elsif ($size == 16) {
+        return 'Sint32'
+    } elsif ($size == 32) {
+        return 'Sint64'
+    }
+
+    die("bug in script.\n");
+}
+
+
+# These handle arbitrary resamples...44100Hz to 48000Hz, for example.
+# Man, this code is skanky.
+sub buildArbitraryResampleFunc {
+    # !!! FIXME: we do a lot of unnecessary and ugly casting in here, due to getSwapFunc().
+    my ($from, $channels, $upsample) = @_;
+    my ($fsigned, $ffloat, $fsize, $fendian, $fctype) = splittype($from);
+
+    my $bigger = getBiggerCtype($ffloat, $fsize);
+    my $interp = ($ffloat) ? '* 0.5' : '>> 1';
+
+    my $resample = ($upsample) ? 'Upsample' : 'Downsample';
+    my $hashid = getResamplerHashId($from, $channels, $upsample, 0);
+    my $sym = "SDL_${resample}_${from}_${channels}c";
+    $funcs{$hashid} = $sym;
+    $custom_converters++;
+
+    my $fudge = $fsize * $channels * 2;  # !!! FIXME
+    my $eps_adjust = ($upsample) ? 'dstsize' : 'srcsize';
+    my $incr = '';
+    my $incr2 = '';
+
+
+    # !!! FIXME: DEBUG_CONVERT should report frequencies.
+    print <<EOF;
+static void SDLCALL
+${sym}(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "$resample arbitrary (x%f) AUDIO_${from}, ${channels} channels.\\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - $fudge;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+EOF
+
+    # Upsampling (growing the buffer) needs to work backwards, since we
+    #  overwrite the buffer as we go.
+    if ($upsample) {
+        print <<EOF;
+    $fctype *dst = (($fctype *) (cvt->buf + dstsize)) - $channels;
+    const $fctype *src = (($fctype *) (cvt->buf + cvt->len_cvt)) - $channels;
+    const $fctype *target = ((const $fctype *) cvt->buf) - $channels;
+EOF
+    } else {
+        print <<EOF;
+    $fctype *dst = ($fctype *) cvt->buf;
+    const $fctype *src = ($fctype *) cvt->buf;
+    const $fctype *target = (const $fctype *) (cvt->buf + dstsize);
+EOF
+    }
+
+    for (my $i = 0; $i < $channels; $i++) {
+        my $idx = ($upsample) ? (($channels - $i) - 1) : $i;
+        my $val = getSwapFunc($fsize, $fsigned, $ffloat, $fendian, "src[$idx]");
+        print <<EOF;
+    $fctype sample${idx} = $val;
+EOF
+    }
+
+    for (my $i = 0; $i < $channels; $i++) {
+        my $idx = ($upsample) ? (($channels - $i) - 1) : $i;
+        print <<EOF;
+    $fctype last_sample${idx} = sample${idx};
+EOF
+    }
+
+    print <<EOF;
+    while (dst != target) {
+EOF
+
+    if ($upsample) {
+        for (my $i = 0; $i < $channels; $i++) {
+            # !!! FIXME: don't do this swap every write, just when the samples change.
+            my $idx = (($channels - $i) - 1);
+            my $val = getSwapFunc($fsize, $fsigned, $ffloat, $fendian, "sample${idx}");
+            print <<EOF;
+        dst[$idx] = $val;
+EOF
+        }
+
+        $incr = ($channels == 1) ? 'dst--' : "dst -= $channels";
+        $incr2 = ($channels == 1) ? 'src--' : "src -= $channels";
+
+        print <<EOF;
+        $incr;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            $incr2;
+EOF
+    } else {  # downsample.
+        $incr = ($channels == 1) ? 'src++' : "src += $channels";
+        print <<EOF;
+        $incr;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+EOF
+        for (my $i = 0; $i < $channels; $i++) {
+            my $val = getSwapFunc($fsize, $fsigned, $ffloat, $fendian, "sample${i}");
+            print <<EOF;
+            dst[$i] = $val;
+EOF
+        }
+
+        $incr = ($channels == 1) ? 'dst++' : "dst += $channels";
+        print <<EOF;
+            $incr;
+EOF
+    }
+
+    for (my $i = 0; $i < $channels; $i++) {
+        my $idx = ($upsample) ? (($channels - $i) - 1) : $i;
+        my $swapped = getSwapFunc($fsize, $fsigned, $ffloat, $fendian, "src[$idx]");
+        print <<EOF;
+            sample${idx} = ($fctype) (((($bigger) $swapped) + (($bigger) last_sample${idx})) $interp);
+EOF
+    }
+
+    for (my $i = 0; $i < $channels; $i++) {
+        my $idx = ($upsample) ? (($channels - $i) - 1) : $i;
+        print <<EOF;
+            last_sample${idx} = sample${idx};
+EOF
+    }
+
+    print <<EOF;
+            eps -= $eps_adjust;
+        }
+    }
+EOF
+
+        print <<EOF;
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+EOF
+
+}
+
+# These handle clean resamples...doubling and quadrupling the sample rate, etc.
+sub buildMultipleResampleFunc {
+    # !!! FIXME: we do a lot of unnecessary and ugly casting in here, due to getSwapFunc().
+    my ($from, $channels, $upsample, $multiple) = @_;
+    my ($fsigned, $ffloat, $fsize, $fendian, $fctype) = splittype($from);
+
+    my $bigger = getBiggerCtype($ffloat, $fsize);
+    my $interp = ($ffloat) ? '* 0.5' : '>> 1';
+    my $interp2 = ($ffloat) ? '* 0.25' : '>> 2';
+    my $mult3 = ($ffloat) ? '3.0' : '3';
+    my $lencvtop = ($upsample) ? '*' : '/';
+
+    my $resample = ($upsample) ? 'Upsample' : 'Downsample';
+    my $hashid = getResamplerHashId($from, $channels, $upsample, $multiple);
+    my $sym = "SDL_${resample}_${from}_${channels}c_x${multiple}";
+    $funcs{$hashid} = $sym;
+    $custom_converters++;
+
+    # !!! FIXME: DEBUG_CONVERT should report frequencies.
+    print <<EOF;
+static void SDLCALL
+${sym}(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "$resample (x${multiple}) AUDIO_${from}, ${channels} channels.\\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt $lencvtop $multiple;
+EOF
+
+    # Upsampling (growing the buffer) needs to work backwards, since we
+    #  overwrite the buffer as we go.
+    if ($upsample) {
+        print <<EOF;
+    $fctype *dst = (($fctype *) (cvt->buf + dstsize)) - $channels;
+    const $fctype *src = (($fctype *) (cvt->buf + cvt->len_cvt)) - $channels;
+    const $fctype *target = ((const $fctype *) cvt->buf) - $channels;
+EOF
+    } else {
+        print <<EOF;
+    $fctype *dst = ($fctype *) cvt->buf;
+    const $fctype *src = ($fctype *) cvt->buf;
+    const $fctype *target = (const $fctype *) (cvt->buf + dstsize);
+EOF
+    }
+
+    for (my $i = 0; $i < $channels; $i++) {
+        my $idx = ($upsample) ? (($channels - $i) - 1) : $i;
+        my $val = getSwapFunc($fsize, $fsigned, $ffloat, $fendian, "src[$idx]");
+        print <<EOF;
+    $bigger last_sample${idx} = ($bigger) $val;
+EOF
+    }
+
+    print <<EOF;
+    while (dst != target) {
+EOF
+
+    for (my $i = 0; $i < $channels; $i++) {
+        my $idx = ($upsample) ? (($channels - $i) - 1) : $i;
+        my $val = getSwapFunc($fsize, $fsigned, $ffloat, $fendian, "src[$idx]");
+        print <<EOF;
+        const $bigger sample${idx} = ($bigger) $val;
+EOF
+    }
+
+    my $incr = '';
+    if ($upsample) {
+        $incr = ($channels == 1) ? 'src--' : "src -= $channels";
+    } else {
+        my $amount = $channels * $multiple;
+        $incr = "src += $amount";  # can't ever be 1, so no "++" version.
+    }
+
+
+    print <<EOF;
+        $incr;
+EOF
+
+    # !!! FIXME: This really begs for some Altivec or SSE, etc.
+    if ($upsample) {
+        if ($multiple == 2) {
+            for (my $i = $channels-1; $i >= 0; $i--) {
+                my $dsti = $i + $channels;
+                print <<EOF;
+        dst[$dsti] = ($fctype) ((sample${i} + last_sample${i}) $interp);
+EOF
+            }
+            for (my $i = $channels-1; $i >= 0; $i--) {
+                my $dsti = $i;
+                print <<EOF;
+        dst[$dsti] = ($fctype) sample${i};
+EOF
+            }
+        } elsif ($multiple == 4) {
+            for (my $i = $channels-1; $i >= 0; $i--) {
+                my $dsti = $i + ($channels * 3);
+                print <<EOF;
+        dst[$dsti] = ($fctype) sample${i};
+EOF
+            }
+
+            for (my $i = $channels-1; $i >= 0; $i--) {
+                my $dsti = $i + ($channels * 2);
+                print <<EOF;
+        dst[$dsti] = ($fctype) ((($mult3 * sample${i}) + last_sample${i}) $interp2);
+EOF
+            }
+
+            for (my $i = $channels-1; $i >= 0; $i--) {
+                my $dsti = $i + ($channels * 1);
+                print <<EOF;
+        dst[$dsti] = ($fctype) ((sample${i} + last_sample${i}) $interp);
+EOF
+            }
+
+            for (my $i = $channels-1; $i >= 0; $i--) {
+                my $dsti = $i + ($channels * 0);
+                print <<EOF;
+        dst[$dsti] = ($fctype) ((sample${i} + ($mult3 * last_sample${i})) $interp2);
+EOF
+            }
+        } else {
+            die('bug in program.');  # we only handle x2 and x4.
+        }
+    } else {  # downsample.
+        if ($multiple == 2) {
+            for (my $i = 0; $i < $channels; $i++) {
+                print <<EOF;
+        dst[$i] = ($fctype) ((sample${i} + last_sample${i}) $interp);
+EOF
+            }
+        } elsif ($multiple == 4) {
+            # !!! FIXME: interpolate all 4 samples?
+            for (my $i = 0; $i < $channels; $i++) {
+                print <<EOF;
+        dst[$i] = ($fctype) ((sample${i} + last_sample${i}) $interp);
+EOF
+            }
+        } else {
+            die('bug in program.');  # we only handle x2 and x4.
+        }
+    }
+
+    for (my $i = 0; $i < $channels; $i++) {
+        my $idx = ($upsample) ? (($channels - $i) - 1) : $i;
+        print <<EOF;
+        last_sample${idx} = sample${idx};
+EOF
+    }
+
+    if ($upsample) {
+        my $amount = $channels * $multiple;
+        $incr = "dst -= $amount";  # can't ever be 1, so no "--" version.
+    } else {
+        $incr = ($channels == 1) ? 'dst++' : "dst += $channels";
+    }
+
+    print <<EOF;
+        $incr;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+EOF
+
+}
+
+sub buildResamplers {
+    print "#if !NO_RESAMPLERS\n\n";
+    foreach (@audiotypes) {
+        my $from = $_;
+        foreach (@channels) {
+            my $channel = $_;
+            buildArbitraryResampleFunc($from, $channel, 1);
+            buildArbitraryResampleFunc($from, $channel, 0);
+        }
+    }
+
+    print "\n#if !LESS_RESAMPLERS\n\n";
+    foreach (@audiotypes) {
+        my $from = $_;
+        foreach (@channels) {
+            my $channel = $_;
+            for (my $multiple = 2; $multiple <= 4; $multiple += 2) {
+                buildMultipleResampleFunc($from, $channel, 1, $multiple);
+                buildMultipleResampleFunc($from, $channel, 0, $multiple);
+            }
+        }
+    }
+
+    print "#endif  /* !LESS_RESAMPLERS */\n";
+    print "#endif  /* !NO_RESAMPLERS */\n\n\n";
+
+    print "const SDL_AudioRateFilters sdl_audio_rate_filters[] =\n{\n";
+    print "#if !NO_RESAMPLERS\n";
+    foreach (@audiotypes) {
+        my $from = $_;
+        foreach (@channels) {
+            my $channel = $_;
+            for (my $upsample = 0; $upsample <= 1; $upsample++) {
+                my $hashid = getResamplerHashId($from, $channel, $upsample, 0);
+                my $sym = $funcs{$hashid};
+                print("    { AUDIO_$from, $channel, $upsample, 0, $sym },\n");
+            }
+        }
+    }
+
+    print "#if !LESS_RESAMPLERS\n";
+    foreach (@audiotypes) {
+        my $from = $_;
+        foreach (@channels) {
+            my $channel = $_;
+            for (my $multiple = 2; $multiple <= 4; $multiple += 2) {
+                for (my $upsample = 0; $upsample <= 1; $upsample++) {
+                    my $hashid = getResamplerHashId($from, $channel, $upsample, $multiple);
+                    my $sym = $funcs{$hashid};
+                    print("    { AUDIO_$from, $channel, $upsample, $multiple, $sym },\n");
+                }
+            }
+        }
+    }
+
+    print "#endif  /* !LESS_RESAMPLERS */\n";
+    print "#endif  /* !NO_RESAMPLERS */\n";
+    print("    { 0, 0, 0, 0, NULL }\n");
+    print "};\n\n";
+}
+
+
+# mainline ...
+
+outputHeader();
+buildTypeConverters();
+buildResamplers();
+outputFooter();
+
+exit 0;
+
+# end of sdlgenaudiocvt.pl ...
+

Externals/SDL/src/audio/sun/SDL_sunaudio.c

@@ -0,0 +1,454 @@
+/* I'm gambling no one uses this audio backend...we'll see who emails.  :)  */
+#error this code has not been updated for SDL 1.3.
+#error if no one emails icculus at icculus.org and tells him that this
+#error  code is needed, this audio backend will eventually be removed from SDL.
+
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* Allow access to a raw mixing buffer */
+
+#include <fcntl.h>
+#include <errno.h>
+#ifdef __NETBSD__
+#include <sys/ioctl.h>
+#include <sys/audioio.h>
+#endif
+#ifdef __SVR4
+#include <sys/audioio.h>
+#else
+#include <sys/time.h>
+#include <sys/types.h>
+#endif
+#include <unistd.h>
+
+#include "SDL_timer.h"
+#include "SDL_audio.h"
+#include "../SDL_audiomem.h"
+#include "../SDL_audio_c.h"
+#include "../SDL_audiodev_c.h"
+#include "SDL_sunaudio.h"
+
+/* Open the audio device for playback, and don't block if busy */
+#define OPEN_FLAGS	(O_WRONLY|O_NONBLOCK)
+
+/* Audio driver functions */
+static int DSP_OpenAudio(_THIS, SDL_AudioSpec * spec);
+static void DSP_WaitAudio(_THIS);
+static void DSP_PlayAudio(_THIS);
+static Uint8 *DSP_GetAudioBuf(_THIS);
+static void DSP_CloseAudio(_THIS);
+
+static Uint8 snd2au(int sample);
+
+/* Audio driver bootstrap functions */
+
+static int
+Audio_Available(void)
+{
+    int fd;
+    int available;
+
+    available = 0;
+    fd = SDL_OpenAudioPath(NULL, 0, OPEN_FLAGS, 1);
+    if (fd >= 0) {
+        available = 1;
+        close(fd);
+    }
+    return (available);
+}
+
+static void
+Audio_DeleteDevice(SDL_AudioDevice * device)
+{
+    SDL_free(device->hidden);
+    SDL_free(device);
+}
+
+static SDL_AudioDevice *
+Audio_CreateDevice(int devindex)
+{
+    SDL_AudioDevice *this;
+
+    /* Initialize all variables that we clean on shutdown */
+    this = (SDL_AudioDevice *) SDL_malloc(sizeof(SDL_AudioDevice));
+    if (this) {
+        SDL_memset(this, 0, (sizeof *this));
+        this->hidden = (struct SDL_PrivateAudioData *)
+            SDL_malloc((sizeof *this->hidden));
+    }
+    if ((this == NULL) || (this->hidden == NULL)) {
+        SDL_OutOfMemory();
+        if (this) {
+            SDL_free(this);
+        }
+        return (0);
+    }
+    SDL_memset(this->hidden, 0, (sizeof *this->hidden));
+    audio_fd = -1;
+
+    /* Set the function pointers */
+    this->OpenAudio = DSP_OpenAudio;
+    this->WaitAudio = DSP_WaitAudio;
+    this->PlayAudio = DSP_PlayAudio;
+    this->GetAudioBuf = DSP_GetAudioBuf;
+    this->CloseAudio = DSP_CloseAudio;
+
+    this->free = Audio_DeleteDevice;
+
+    return this;
+}
+
+AudioBootStrap SUNAUDIO_bootstrap = {
+    "audio", "UNIX /dev/audio interface",
+    Audio_Available, Audio_CreateDevice, 0
+};
+
+#ifdef DEBUG_AUDIO
+void
+CheckUnderflow(_THIS)
+{
+#ifdef AUDIO_GETINFO
+    audio_info_t info;
+    int left;
+
+    ioctl(audio_fd, AUDIO_GETINFO, &info);
+    left = (written - info.play.samples);
+    if (written && (left == 0)) {
+        fprintf(stderr, "audio underflow!\n");
+    }
+#endif
+}
+#endif
+
+void
+DSP_WaitAudio(_THIS)
+{
+#ifdef AUDIO_GETINFO
+#define SLEEP_FUDGE	10      /* 10 ms scheduling fudge factor */
+    audio_info_t info;
+    Sint32 left;
+
+    ioctl(audio_fd, AUDIO_GETINFO, &info);
+    left = (written - info.play.samples);
+    if (left > fragsize) {
+        Sint32 sleepy;
+
+        sleepy = ((left - fragsize) / frequency);
+        sleepy -= SLEEP_FUDGE;
+        if (sleepy > 0) {
+            SDL_Delay(sleepy);
+        }
+    }
+#else
+    fd_set fdset;
+
+    FD_ZERO(&fdset);
+    FD_SET(audio_fd, &fdset);
+    select(audio_fd + 1, NULL, &fdset, NULL, NULL);
+#endif
+}
+
+void
+DSP_PlayAudio(_THIS)
+{
+    /* Write the audio data */
+    if (ulaw_only) {
+        /* Assuming that this->spec.freq >= 8000 Hz */
+        int accum, incr, pos;
+        Uint8 *aubuf;
+
+        accum = 0;
+        incr = this->spec.freq / 8;
+        aubuf = ulaw_buf;
+        switch (audio_fmt & 0xFF) {
+        case 8:
+            {
+                Uint8 *sndbuf;
+
+                sndbuf = mixbuf;
+                for (pos = 0; pos < fragsize; ++pos) {
+                    *aubuf = snd2au((0x80 - *sndbuf) * 64);
+                    accum += incr;
+                    while (accum > 0) {
+                        accum -= 1000;
+                        sndbuf += 1;
+                    }
+                    aubuf += 1;
+                }
+            }
+            break;
+        case 16:
+            {
+                Sint16 *sndbuf;
+
+                sndbuf = (Sint16 *) mixbuf;
+                for (pos = 0; pos < fragsize; ++pos) {
+                    *aubuf = snd2au(*sndbuf / 4);
+                    accum += incr;
+                    while (accum > 0) {
+                        accum -= 1000;
+                        sndbuf += 1;
+                    }
+                    aubuf += 1;
+                }
+            }
+            break;
+        }
+#ifdef DEBUG_AUDIO
+        CheckUnderflow(this);
+#endif
+        if (write(audio_fd, ulaw_buf, fragsize) < 0) {
+            /* Assume fatal error, for now */
+            this->enabled = 0;
+        }
+        written += fragsize;
+    } else {
+#ifdef DEBUG_AUDIO
+        CheckUnderflow(this);
+#endif
+        if (write(audio_fd, mixbuf, this->spec.size) < 0) {
+            /* Assume fatal error, for now */
+            this->enabled = 0;
+        }
+        written += fragsize;
+    }
+}
+
+Uint8 *
+DSP_GetAudioBuf(_THIS)
+{
+    return (mixbuf);
+}
+
+void
+DSP_CloseAudio(_THIS)
+{
+    if (mixbuf != NULL) {
+        SDL_FreeAudioMem(mixbuf);
+        mixbuf = NULL;
+    }
+    if (ulaw_buf != NULL) {
+        SDL_free(ulaw_buf);
+        ulaw_buf = NULL;
+    }
+    close(audio_fd);
+}
+
+int
+DSP_OpenAudio(_THIS, SDL_AudioSpec * spec)
+{
+    char audiodev[1024];
+#ifdef AUDIO_SETINFO
+    int enc;
+#endif
+    int desired_freq = spec->freq;
+
+    /* Initialize our freeable variables, in case we fail */
+    audio_fd = -1;
+    mixbuf = NULL;
+    ulaw_buf = NULL;
+
+    /* Determine the audio parameters from the AudioSpec */
+    switch (SDL_AUDIO_BITSIZE(spec->format)) {
+
+    case 8:
+        {                       /* Unsigned 8 bit audio data */
+            spec->format = AUDIO_U8;
+#ifdef AUDIO_SETINFO
+            enc = AUDIO_ENCODING_LINEAR8;
+#endif
+        }
+        break;
+
+    case 16:
+        {                       /* Signed 16 bit audio data */
+            spec->format = AUDIO_S16SYS;
+#ifdef AUDIO_SETINFO
+            enc = AUDIO_ENCODING_LINEAR;
+#endif
+        }
+        break;
+
+    default:
+        {
+            /* !!! FIXME: fallback to conversion on unsupported types! */
+            SDL_SetError("Unsupported audio format");
+            return (-1);
+        }
+    }
+    audio_fmt = spec->format;
+
+    /* Open the audio device */
+    audio_fd = SDL_OpenAudioPath(audiodev, sizeof(audiodev), OPEN_FLAGS, 1);
+    if (audio_fd < 0) {
+        SDL_SetError("Couldn't open %s: %s", audiodev, strerror(errno));
+        return (-1);
+    }
+
+    ulaw_only = 0;              /* modern Suns do support linear audio */
+#ifdef AUDIO_SETINFO
+    for (;;) {
+        audio_info_t info;
+        AUDIO_INITINFO(&info);  /* init all fields to "no change" */
+
+        /* Try to set the requested settings */
+        info.play.sample_rate = spec->freq;
+        info.play.channels = spec->channels;
+        info.play.precision = (enc == AUDIO_ENCODING_ULAW)
+            ? 8 : spec->format & 0xff;
+        info.play.encoding = enc;
+        if (ioctl(audio_fd, AUDIO_SETINFO, &info) == 0) {
+
+            /* Check to be sure we got what we wanted */
+            if (ioctl(audio_fd, AUDIO_GETINFO, &info) < 0) {
+                SDL_SetError("Error getting audio parameters: %s",
+                             strerror(errno));
+                return -1;
+            }
+            if (info.play.encoding == enc
+                && info.play.precision == (spec->format & 0xff)
+                && info.play.channels == spec->channels) {
+                /* Yow! All seems to be well! */
+                spec->freq = info.play.sample_rate;
+                break;
+            }
+        }
+
+        switch (enc) {
+        case AUDIO_ENCODING_LINEAR8:
+            /* unsigned 8bit apparently not supported here */
+            enc = AUDIO_ENCODING_LINEAR;
+            spec->format = AUDIO_S16SYS;
+            break;              /* try again */
+
+        case AUDIO_ENCODING_LINEAR:
+            /* linear 16bit didn't work either, resort to <20>-law */
+            enc = AUDIO_ENCODING_ULAW;
+            spec->channels = 1;
+            spec->freq = 8000;
+            spec->format = AUDIO_U8;
+            ulaw_only = 1;
+            break;
+
+        default:
+            /* oh well... */
+            SDL_SetError("Error setting audio parameters: %s",
+                         strerror(errno));
+            return -1;
+        }
+    }
+#endif /* AUDIO_SETINFO */
+    written = 0;
+
+    /* We can actually convert on-the-fly to U-Law */
+    if (ulaw_only) {
+        spec->freq = desired_freq;
+        fragsize = (spec->samples * 1000) / (spec->freq / 8);
+        frequency = 8;
+        ulaw_buf = (Uint8 *) SDL_malloc(fragsize);
+        if (ulaw_buf == NULL) {
+            SDL_OutOfMemory();
+            return (-1);
+        }
+        spec->channels = 1;
+    } else {
+        fragsize = spec->samples;
+        frequency = spec->freq / 1000;
+    }
+#ifdef DEBUG_AUDIO
+    fprintf(stderr, "Audio device %s U-Law only\n",
+            ulaw_only ? "is" : "is not");
+    fprintf(stderr, "format=0x%x chan=%d freq=%d\n",
+            spec->format, spec->channels, spec->freq);
+#endif
+
+    /* Update the fragment size as size in bytes */
+    SDL_CalculateAudioSpec(spec);
+
+    /* Allocate mixing buffer */
+    mixbuf = (Uint8 *) SDL_AllocAudioMem(spec->size);
+    if (mixbuf == NULL) {
+        SDL_OutOfMemory();
+        return (-1);
+    }
+    SDL_memset(mixbuf, spec->silence, spec->size);
+
+    /* We're ready to rock and roll. :-) */
+    return (0);
+}
+
+/************************************************************************/
+/* This function (snd2au()) copyrighted:                                */
+/************************************************************************/
+/*      Copyright 1989 by Rich Gopstein and Harris Corporation          */
+/*                                                                      */
+/*      Permission to use, copy, modify, and distribute this software   */
+/*      and its documentation for any purpose and without fee is        */
+/*      hereby granted, provided that the above copyright notice        */
+/*      appears in all copies and that both that copyright notice and   */
+/*      this permission notice appear in supporting documentation, and  */
+/*      that the name of Rich Gopstein and Harris Corporation not be    */
+/*      used in advertising or publicity pertaining to distribution     */
+/*      of the software without specific, written prior permission.     */
+/*      Rich Gopstein and Harris Corporation make no representations    */
+/*      about the suitability of this software for any purpose.  It     */
+/*      provided "as is" without express or implied warranty.           */
+/************************************************************************/
+
+static Uint8
+snd2au(int sample)
+{
+
+    int mask;
+
+    if (sample < 0) {
+        sample = -sample;
+        mask = 0x7f;
+    } else {
+        mask = 0xff;
+    }
+
+    if (sample < 32) {
+        sample = 0xF0 | (15 - sample / 2);
+    } else if (sample < 96) {
+        sample = 0xE0 | (15 - (sample - 32) / 4);
+    } else if (sample < 224) {
+        sample = 0xD0 | (15 - (sample - 96) / 8);
+    } else if (sample < 480) {
+        sample = 0xC0 | (15 - (sample - 224) / 16);
+    } else if (sample < 992) {
+        sample = 0xB0 | (15 - (sample - 480) / 32);
+    } else if (sample < 2016) {
+        sample = 0xA0 | (15 - (sample - 992) / 64);
+    } else if (sample < 4064) {
+        sample = 0x90 | (15 - (sample - 2016) / 128);
+    } else if (sample < 8160) {
+        sample = 0x80 | (15 - (sample - 4064) / 256);
+    } else {
+        sample = 0x80;
+    }
+    return (mask & sample);
+}
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/sun/SDL_sunaudio.h

@@ -0,0 +1,58 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifndef _SDL_sunaudio_h
+#define _SDL_sunaudio_h
+
+#include "../SDL_sysaudio.h"
+
+/* Hidden "this" pointer for the audio functions */
+#define _THIS	SDL_AudioDevice *this
+
+struct SDL_PrivateAudioData
+{
+    /* The file descriptor for the audio device */
+    int audio_fd;
+
+    SDL_AudioFormat audio_fmt;  /* The app audio format */
+    Uint8 *mixbuf;              /* The app mixing buffer */
+    int ulaw_only;              /* Flag -- does hardware only output U-law? */
+    Uint8 *ulaw_buf;            /* The U-law mixing buffer */
+    Sint32 written;             /* The number of samples written */
+    int fragsize;               /* The audio fragment size in samples */
+    int frequency;              /* The audio frequency in KHz */
+};
+
+/* Old variable names */
+#define audio_fd		(this->hidden->audio_fd)
+#define audio_fmt		(this->hidden->audio_fmt)
+#define mixbuf			(this->hidden->mixbuf)
+#define ulaw_only		(this->hidden->ulaw_only)
+#define ulaw_buf		(this->hidden->ulaw_buf)
+#define written			(this->hidden->written)
+#define fragsize		(this->hidden->fragsize)
+#define frequency		(this->hidden->frequency)
+
+#endif /* _SDL_sunaudio_h */
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/ums/SDL_umsaudio.c

@@ -0,0 +1,563 @@
+/* I'm gambling no one uses this audio backend...we'll see who emails.  :)  */
+#error this code has not been updated for SDL 1.3.
+#error if no one emails icculus at icculus.org and tells him that this
+#error  code is needed, this audio backend will eventually be removed from SDL.
+
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Carsten Griwodz
+    griff@kom.tu-darmstadt.de
+
+    based on linux/SDL_dspaudio.c by Sam Lantinga
+*/
+#include "SDL_config.h"
+
+/* Allow access to a raw mixing buffer */
+
+#include <errno.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+
+#include "SDL_audio.h"
+#include "../SDL_audio_c.h"
+#include "SDL_umsaudio.h"
+
+/* The tag name used by UMS audio */
+#define UMS_DRIVER_NAME         "ums"
+
+#define DEBUG_AUDIO 1
+
+/* Audio driver functions */
+static int UMS_OpenAudio(_THIS, SDL_AudioSpec * spec);
+static void UMS_PlayAudio(_THIS);
+static Uint8 *UMS_GetAudioBuf(_THIS);
+static void UMS_CloseAudio(_THIS);
+
+static UMSAudioDevice_ReturnCode UADOpen(_THIS, string device, string mode,
+                                         long flags);
+static UMSAudioDevice_ReturnCode UADClose(_THIS);
+static UMSAudioDevice_ReturnCode UADGetBitsPerSample(_THIS, long *bits);
+static UMSAudioDevice_ReturnCode UADSetBitsPerSample(_THIS, long bits);
+static UMSAudioDevice_ReturnCode UADSetSampleRate(_THIS, long rate,
+                                                  long *set_rate);
+static UMSAudioDevice_ReturnCode UADSetByteOrder(_THIS, string byte_order);
+static UMSAudioDevice_ReturnCode UADSetAudioFormatType(_THIS, string fmt);
+static UMSAudioDevice_ReturnCode UADSetNumberFormat(_THIS, string fmt);
+static UMSAudioDevice_ReturnCode UADInitialize(_THIS);
+static UMSAudioDevice_ReturnCode UADStart(_THIS);
+static UMSAudioDevice_ReturnCode UADStop(_THIS);
+static UMSAudioDevice_ReturnCode UADSetTimeFormat(_THIS,
+                                                  UMSAudioTypes_TimeFormat
+                                                  fmt);
+static UMSAudioDevice_ReturnCode UADWriteBuffSize(_THIS, long *buff_size);
+static UMSAudioDevice_ReturnCode UADWriteBuffRemain(_THIS, long *buff_size);
+static UMSAudioDevice_ReturnCode UADWriteBuffUsed(_THIS, long *buff_size);
+static UMSAudioDevice_ReturnCode UADSetDMABufferSize(_THIS, long bytes,
+                                                     long *bytes_ret);
+static UMSAudioDevice_ReturnCode UADSetVolume(_THIS, long volume);
+static UMSAudioDevice_ReturnCode UADSetBalance(_THIS, long balance);
+static UMSAudioDevice_ReturnCode UADSetChannels(_THIS, long channels);
+static UMSAudioDevice_ReturnCode UADPlayRemainingData(_THIS, boolean block);
+static UMSAudioDevice_ReturnCode UADEnableOutput(_THIS, string output,
+                                                 long *left_gain,
+                                                 long *right_gain);
+static UMSAudioDevice_ReturnCode UADWrite(_THIS, UMSAudioTypes_Buffer * buff,
+                                          long samples,
+                                          long *samples_written);
+
+/* Audio driver bootstrap functions */
+static int
+Audio_Available(void)
+{
+    return 1;
+}
+
+static void
+Audio_DeleteDevice(_THIS)
+{
+    if (this->hidden->playbuf._buffer)
+        SDL_free(this->hidden->playbuf._buffer);
+    if (this->hidden->fillbuf._buffer)
+        SDL_free(this->hidden->fillbuf._buffer);
+    _somFree(this->hidden->umsdev);
+    SDL_free(this->hidden);
+    SDL_free(this);
+}
+
+static SDL_AudioDevice *
+Audio_CreateDevice(int devindex)
+{
+    SDL_AudioDevice *this;
+
+    /*
+     * Allocate and initialize management storage and private management
+     * storage for this SDL-using library.
+     */
+    this = (SDL_AudioDevice *) SDL_malloc(sizeof(SDL_AudioDevice));
+    if (this) {
+        SDL_memset(this, 0, (sizeof *this));
+        this->hidden = (struct SDL_PrivateAudioData *)
+            SDL_malloc((sizeof *this->hidden));
+    }
+    if ((this == NULL) || (this->hidden == NULL)) {
+        SDL_OutOfMemory();
+        if (this) {
+            SDL_free(this);
+        }
+        return (0);
+    }
+    SDL_memset(this->hidden, 0, (sizeof *this->hidden));
+#ifdef DEBUG_AUDIO
+    fprintf(stderr, "Creating UMS Audio device\n");
+#endif
+
+    /*
+     * Calls for UMS env initialization and audio object construction.
+     */
+    this->hidden->ev = somGetGlobalEnvironment();
+    this->hidden->umsdev = UMSAudioDeviceNew();
+
+    /*
+     * Set the function pointers.
+     */
+    this->OpenAudio = UMS_OpenAudio;
+    this->WaitAudio = NULL;     /* we do blocking output */
+    this->PlayAudio = UMS_PlayAudio;
+    this->GetAudioBuf = UMS_GetAudioBuf;
+    this->CloseAudio = UMS_CloseAudio;
+    this->free = Audio_DeleteDevice;
+
+#ifdef DEBUG_AUDIO
+    fprintf(stderr, "done\n");
+#endif
+    return this;
+}
+
+AudioBootStrap UMS_bootstrap = {
+    UMS_DRIVER_NAME, "AIX UMS audio",
+    Audio_Available, Audio_CreateDevice, 0
+};
+
+static Uint8 *
+UMS_GetAudioBuf(_THIS)
+{
+#ifdef DEBUG_AUDIO
+    fprintf(stderr, "enter UMS_GetAudioBuf\n");
+#endif
+    return this->hidden->fillbuf._buffer;
+/*
+    long                      bufSize;
+    UMSAudioDevice_ReturnCode rc;
+
+    rc = UADSetTimeFormat(this, UMSAudioTypes_Bytes );
+    rc = UADWriteBuffSize(this,  bufSize );
+*/
+}
+
+static void
+UMS_CloseAudio(_THIS)
+{
+    UMSAudioDevice_ReturnCode rc;
+
+#ifdef DEBUG_AUDIO
+    fprintf(stderr, "enter UMS_CloseAudio\n");
+#endif
+    rc = UADPlayRemainingData(this, TRUE);
+    rc = UADStop(this);
+    rc = UADClose(this);
+}
+
+static void
+UMS_PlayAudio(_THIS)
+{
+    UMSAudioDevice_ReturnCode rc;
+    long samplesToWrite;
+    long samplesWritten;
+    UMSAudioTypes_Buffer swpbuf;
+
+#ifdef DEBUG_AUDIO
+    fprintf(stderr, "enter UMS_PlayAudio\n");
+#endif
+    samplesToWrite =
+        this->hidden->playbuf._length / this->hidden->bytesPerSample;
+    do {
+        rc = UADWrite(this, &this->hidden->playbuf,
+                      samplesToWrite, &samplesWritten);
+        samplesToWrite -= samplesWritten;
+
+        /* rc values: UMSAudioDevice_Success
+         *            UMSAudioDevice_Failure
+         *            UMSAudioDevice_Preempted
+         *            UMSAudioDevice_Interrupted
+         *            UMSAudioDevice_DeviceError
+         */
+        if (rc == UMSAudioDevice_DeviceError) {
+#ifdef DEBUG_AUDIO
+            fprintf(stderr, "Returning from PlayAudio with devices error\n");
+#endif
+            return;
+        }
+    } while (samplesToWrite > 0);
+
+    SDL_LockAudio();
+    SDL_memcpy(&swpbuf, &this->hidden->playbuf, sizeof(UMSAudioTypes_Buffer));
+    SDL_memcpy(&this->hidden->playbuf, &this->hidden->fillbuf,
+               sizeof(UMSAudioTypes_Buffer));
+    SDL_memcpy(&this->hidden->fillbuf, &swpbuf, sizeof(UMSAudioTypes_Buffer));
+    SDL_UnlockAudio();
+
+#ifdef DEBUG_AUDIO
+    fprintf(stderr, "Wrote audio data and swapped buffer\n");
+#endif
+}
+
+#if 0
+//      /* Set the DSP frequency */
+//      value = spec->freq;
+//      if ( ioctl(this->hidden->audio_fd, SOUND_PCM_WRITE_RATE, &value) < 0 ) {
+//              SDL_SetError("Couldn't set audio frequency");
+//              return(-1);
+//      }
+//      spec->freq = value;
+#endif
+
+static int
+UMS_OpenAudio(_THIS, SDL_AudioSpec * spec)
+{
+    char *audiodev = "/dev/paud0";
+    long lgain;
+    long rgain;
+    long outRate;
+    long outBufSize;
+    long bitsPerSample;
+    long samplesPerSec;
+    long success;
+    SDL_AudioFormat test_format;
+    int frag_spec;
+    UMSAudioDevice_ReturnCode rc;
+
+#ifdef DEBUG_AUDIO
+    fprintf(stderr, "enter UMS_OpenAudio\n");
+#endif
+    rc = UADOpen(this, audiodev, "PLAY", UMSAudioDevice_BlockingIO);
+    if (rc != UMSAudioDevice_Success) {
+        SDL_SetError("Couldn't open %s: %s", audiodev, strerror(errno));
+        return -1;
+    }
+
+    rc = UADSetAudioFormatType(this, "PCM");
+
+    success = 0;
+    test_format = SDL_FirstAudioFormat(spec->format);
+    do {
+#ifdef DEBUG_AUDIO
+        fprintf(stderr, "Trying format 0x%4.4x\n", test_format);
+#endif
+        switch (test_format) {
+        case AUDIO_U8:
+/* from the mac code: better ? */
+/* sample_bits = spec->size / spec->samples / spec->channels * 8; */
+            success = 1;
+            bitsPerSample = 8;
+            rc = UADSetSampleRate(this, spec->freq << 16, &outRate);
+            rc = UADSetByteOrder(this, "MSB");  /* irrelevant */
+            rc = UADSetNumberFormat(this, "UNSIGNED");
+            break;
+        case AUDIO_S8:
+            success = 1;
+            bitsPerSample = 8;
+            rc = UADSetSampleRate(this, spec->freq << 16, &outRate);
+            rc = UADSetByteOrder(this, "MSB");  /* irrelevant */
+            rc = UADSetNumberFormat(this, "SIGNED");
+            break;
+        case AUDIO_S16LSB:
+            success = 1;
+            bitsPerSample = 16;
+            rc = UADSetSampleRate(this, spec->freq << 16, &outRate);
+            rc = UADSetByteOrder(this, "LSB");
+            rc = UADSetNumberFormat(this, "SIGNED");
+            break;
+        case AUDIO_S16MSB:
+            success = 1;
+            bitsPerSample = 16;
+            rc = UADSetSampleRate(this, spec->freq << 16, &outRate);
+            rc = UADSetByteOrder(this, "MSB");
+            rc = UADSetNumberFormat(this, "SIGNED");
+            break;
+        case AUDIO_U16LSB:
+            success = 1;
+            bitsPerSample = 16;
+            rc = UADSetSampleRate(this, spec->freq << 16, &outRate);
+            rc = UADSetByteOrder(this, "LSB");
+            rc = UADSetNumberFormat(this, "UNSIGNED");
+            break;
+        case AUDIO_U16MSB:
+            success = 1;
+            bitsPerSample = 16;
+            rc = UADSetSampleRate(this, spec->freq << 16, &outRate);
+            rc = UADSetByteOrder(this, "MSB");
+            rc = UADSetNumberFormat(this, "UNSIGNED");
+            break;
+        default:
+            break;
+        }
+        if (!success) {
+            test_format = SDL_NextAudioFormat();
+        }
+    } while (!success && test_format);
+
+    if (success == 0) {
+        SDL_SetError("Couldn't find any hardware audio formats");
+        return -1;
+    }
+
+    spec->format = test_format;
+
+    for (frag_spec = 0; (0x01 << frag_spec) < spec->size; ++frag_spec);
+    if ((0x01 << frag_spec) != spec->size) {
+        SDL_SetError("Fragment size must be a power of two");
+        return -1;
+    }
+    if (frag_spec > 2048)
+        frag_spec = 2048;
+
+    this->hidden->bytesPerSample = (bitsPerSample / 8) * spec->channels;
+    samplesPerSec = this->hidden->bytesPerSample * outRate;
+
+    this->hidden->playbuf._length = 0;
+    this->hidden->playbuf._maximum = spec->size;
+    this->hidden->playbuf._buffer = (unsigned char *) SDL_malloc(spec->size);
+    this->hidden->fillbuf._length = 0;
+    this->hidden->fillbuf._maximum = spec->size;
+    this->hidden->fillbuf._buffer = (unsigned char *) SDL_malloc(spec->size);
+
+    rc = UADSetBitsPerSample(this, bitsPerSample);
+    rc = UADSetDMABufferSize(this, frag_spec, &outBufSize);
+    rc = UADSetChannels(this, spec->channels);  /* functions reduces to mono or stereo */
+
+    lgain = 100;                /*maximum left input gain */
+    rgain = 100;                /*maimum right input gain */
+    rc = UADEnableOutput(this, "LINE_OUT", &lgain, &rgain);
+    rc = UADInitialize(this);
+    rc = UADStart(this);
+    rc = UADSetVolume(this, 100);
+    rc = UADSetBalance(this, 0);
+
+    /* We're ready to rock and roll. :-) */
+    return 0;
+}
+
+
+static UMSAudioDevice_ReturnCode
+UADGetBitsPerSample(_THIS, long *bits)
+{
+    return UMSAudioDevice_get_bits_per_sample(this->hidden->umsdev,
+                                              this->hidden->ev, bits);
+}
+
+static UMSAudioDevice_ReturnCode
+UADSetBitsPerSample(_THIS, long bits)
+{
+    return UMSAudioDevice_set_bits_per_sample(this->hidden->umsdev,
+                                              this->hidden->ev, bits);
+}
+
+static UMSAudioDevice_ReturnCode
+UADSetSampleRate(_THIS, long rate, long *set_rate)
+{
+    /* from the mac code: sample rate = spec->freq << 16; */
+    return UMSAudioDevice_set_sample_rate(this->hidden->umsdev,
+                                          this->hidden->ev, rate, set_rate);
+}
+
+static UMSAudioDevice_ReturnCode
+UADSetByteOrder(_THIS, string byte_order)
+{
+    return UMSAudioDevice_set_byte_order(this->hidden->umsdev,
+                                         this->hidden->ev, byte_order);
+}
+
+static UMSAudioDevice_ReturnCode
+UADSetAudioFormatType(_THIS, string fmt)
+{
+    /* possible PCM, A_LAW or MU_LAW */
+    return UMSAudioDevice_set_audio_format_type(this->hidden->umsdev,
+                                                this->hidden->ev, fmt);
+}
+
+static UMSAudioDevice_ReturnCode
+UADSetNumberFormat(_THIS, string fmt)
+{
+    /* possible SIGNED, UNSIGNED, or TWOS_COMPLEMENT */
+    return UMSAudioDevice_set_number_format(this->hidden->umsdev,
+                                            this->hidden->ev, fmt);
+}
+
+static UMSAudioDevice_ReturnCode
+UADInitialize(_THIS)
+{
+    return UMSAudioDevice_initialize(this->hidden->umsdev, this->hidden->ev);
+}
+
+static UMSAudioDevice_ReturnCode
+UADStart(_THIS)
+{
+    return UMSAudioDevice_start(this->hidden->umsdev, this->hidden->ev);
+}
+
+static UMSAudioDevice_ReturnCode
+UADSetTimeFormat(_THIS, UMSAudioTypes_TimeFormat fmt)
+{
+    /*
+     * Switches the time format to the new format, immediately.
+     * possible UMSAudioTypes_Msecs, UMSAudioTypes_Bytes or UMSAudioTypes_Samples
+     */
+    return UMSAudioDevice_set_time_format(this->hidden->umsdev,
+                                          this->hidden->ev, fmt);
+}
+
+static UMSAudioDevice_ReturnCode
+UADWriteBuffSize(_THIS, long *buff_size)
+{
+    /*
+     * returns write buffer size in the current time format
+     */
+    return UMSAudioDevice_write_buff_size(this->hidden->umsdev,
+                                          this->hidden->ev, buff_size);
+}
+
+static UMSAudioDevice_ReturnCode
+UADWriteBuffRemain(_THIS, long *buff_size)
+{
+    /*
+     * returns amount of available space in the write buffer
+     * in the current time format
+     */
+    return UMSAudioDevice_write_buff_remain(this->hidden->umsdev,
+                                            this->hidden->ev, buff_size);
+}
+
+static UMSAudioDevice_ReturnCode
+UADWriteBuffUsed(_THIS, long *buff_size)
+{
+    /*
+     * returns amount of filled space in the write buffer
+     * in the current time format
+     */
+    return UMSAudioDevice_write_buff_used(this->hidden->umsdev,
+                                          this->hidden->ev, buff_size);
+}
+
+static UMSAudioDevice_ReturnCode
+UADSetDMABufferSize(_THIS, long bytes, long *bytes_ret)
+{
+    /*
+     * Request a new DMA buffer size, maximum requested size 2048.
+     * Takes effect with next initialize() call.
+     * Devices may or may not support DMA.
+     */
+    return UMSAudioDevice_set_DMA_buffer_size(this->hidden->umsdev,
+                                              this->hidden->ev,
+                                              bytes, bytes_ret);
+}
+
+static UMSAudioDevice_ReturnCode
+UADSetVolume(_THIS, long volume)
+{
+    /*
+     * Set the volume.
+     * Takes effect immediately.
+     */
+    return UMSAudioDevice_set_volume(this->hidden->umsdev,
+                                     this->hidden->ev, volume);
+}
+
+static UMSAudioDevice_ReturnCode
+UADSetBalance(_THIS, long balance)
+{
+    /*
+     * Set the balance.
+     * Takes effect immediately.
+     */
+    return UMSAudioDevice_set_balance(this->hidden->umsdev,
+                                      this->hidden->ev, balance);
+}
+
+static UMSAudioDevice_ReturnCode
+UADSetChannels(_THIS, long channels)
+{
+    /*
+     * Set mono or stereo.
+     * Takes effect with next initialize() call.
+     */
+    if (channels != 1)
+        channels = 2;
+    return UMSAudioDevice_set_number_of_channels(this->hidden->umsdev,
+                                                 this->hidden->ev, channels);
+}
+
+static UMSAudioDevice_ReturnCode
+UADOpen(_THIS, string device, string mode, long flags)
+{
+    return UMSAudioDevice_open(this->hidden->umsdev,
+                               this->hidden->ev, device, mode, flags);
+}
+
+static UMSAudioDevice_ReturnCode
+UADWrite(_THIS, UMSAudioTypes_Buffer * buff,
+         long samples, long *samples_written)
+{
+    return UMSAudioDevice_write(this->hidden->umsdev,
+                                this->hidden->ev,
+                                buff, samples, samples_written);
+}
+
+static UMSAudioDevice_ReturnCode
+UADPlayRemainingData(_THIS, boolean block)
+{
+    return UMSAudioDevice_play_remaining_data(this->hidden->umsdev,
+                                              this->hidden->ev, block);
+}
+
+static UMSAudioDevice_ReturnCode
+UADStop(_THIS)
+{
+    return UMSAudioDevice_stop(this->hidden->umsdev, this->hidden->ev);
+}
+
+static UMSAudioDevice_ReturnCode
+UADClose(_THIS)
+{
+    return UMSAudioDevice_close(this->hidden->umsdev, this->hidden->ev);
+}
+
+static UMSAudioDevice_ReturnCode
+UADEnableOutput(_THIS, string output, long *left_gain, long *right_gain)
+{
+    return UMSAudioDevice_enable_output(this->hidden->umsdev,
+                                        this->hidden->ev,
+                                        output, left_gain, right_gain);
+}
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/ums/SDL_umsaudio.h

@@ -0,0 +1,50 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Carsten Griwodz
+    griff@kom.tu-darmstadt.de
+
+    based on linux/SDL_dspaudio.h by Sam Lantinga
+*/
+#include "SDL_config.h"
+
+#ifndef _SDL_UMSaudio_h
+#define _SDL_UMSaudio_h
+
+#include <UMS/UMSAudioDevice.h>
+
+#include "../SDL_sysaudio.h"
+
+/* Hidden "this" pointer for the audio functions */
+#define _THIS	SDL_AudioDevice *this
+
+struct SDL_PrivateAudioData
+{
+    /* Pointer to the (open) UMS audio device */
+    Environment *ev;
+    UMSAudioDevice umsdev;
+
+    /* Raw mixing buffer */
+    UMSAudioTypes_Buffer playbuf;
+    UMSAudioTypes_Buffer fillbuf;
+
+    long bytesPerSample;
+};
+
+#endif /* _SDL_UMSaudio_h */
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/windib/SDL_dibaudio.c

@@ -0,0 +1,338 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* Allow access to a raw mixing buffer */
+
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <mmsystem.h>
+
+#include "SDL_timer.h"
+#include "SDL_audio.h"
+#include "../SDL_audio_c.h"
+#include "SDL_dibaudio.h"
+#if defined(_WIN32_WCE) && (_WIN32_WCE < 300)
+#include "win_ce_semaphore.h"
+#endif
+
+#if defined(_WIN32_WCE)
+#define WINDOWS_OS_NAME "Windows CE/PocketPC"
+#elif defined(WIN64)
+#define WINDOWS_OS_NAME "Win64"
+#else
+#define WINDOWS_OS_NAME "Win32"
+#endif
+
+/* The Win32 callback for filling the WAVE device */
+static void CALLBACK
+FillSound(HWAVEOUT hwo, UINT uMsg, DWORD_PTR dwInstance,
+          DWORD dwParam1, DWORD dwParam2)
+{
+    SDL_AudioDevice *this = (SDL_AudioDevice *) dwInstance;
+
+    /* Only service "buffer done playing" messages */
+    if (uMsg != WOM_DONE)
+        return;
+
+    /* Signal that we are done playing a buffer */
+#if defined(_WIN32_WCE) && (_WIN32_WCE < 300)
+    ReleaseSemaphoreCE(this->hidden->audio_sem, 1, NULL);
+#else
+    ReleaseSemaphore(this->hidden->audio_sem, 1, NULL);
+#endif
+}
+
+static void
+SetMMerror(char *function, MMRESULT code)
+{
+    size_t len;
+    char errbuf[MAXERRORLENGTH];
+#ifdef _WIN32_WCE
+    wchar_t werrbuf[MAXERRORLENGTH];
+#endif
+
+    SDL_snprintf(errbuf, SDL_arraysize(errbuf), "%s: ", function);
+    len = SDL_strlen(errbuf);
+
+#ifdef _WIN32_WCE
+    /* UNICODE version */
+    waveOutGetErrorText(code, werrbuf, MAXERRORLENGTH - len);
+    WideCharToMultiByte(CP_ACP, 0, werrbuf, -1, errbuf + len,
+                        MAXERRORLENGTH - len, NULL, NULL);
+#else
+    waveOutGetErrorText(code, errbuf + len, (UINT) (MAXERRORLENGTH - len));
+#endif
+
+    SDL_SetError("%s", errbuf);
+}
+
+/* Set high priority for the audio thread */
+static void
+WINWAVEOUT_ThreadInit(_THIS)
+{
+    SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_HIGHEST);
+}
+
+void
+WINWAVEOUT_WaitDevice(_THIS)
+{
+    /* Wait for an audio chunk to finish */
+#if defined(_WIN32_WCE) && (_WIN32_WCE < 300)
+    WaitForSemaphoreCE(this->hidden->audio_sem, INFINITE);
+#else
+    WaitForSingleObject(this->hidden->audio_sem, INFINITE);
+#endif
+}
+
+Uint8 *
+WINWAVEOUT_GetDeviceBuf(_THIS)
+{
+    return (Uint8 *) (this->hidden->
+                      wavebuf[this->hidden->next_buffer].lpData);
+}
+
+void
+WINWAVEOUT_PlayDevice(_THIS)
+{
+    /* Queue it up */
+    waveOutWrite(this->hidden->sound,
+                 &this->hidden->wavebuf[this->hidden->next_buffer],
+                 sizeof(this->hidden->wavebuf[0]));
+    this->hidden->next_buffer = (this->hidden->next_buffer + 1) % NUM_BUFFERS;
+}
+
+void
+WINWAVEOUT_WaitDone(_THIS)
+{
+    int i, left;
+
+    do {
+        left = NUM_BUFFERS;
+        for (i = 0; i < NUM_BUFFERS; ++i) {
+            if (this->hidden->wavebuf[i].dwFlags & WHDR_DONE) {
+                --left;
+            }
+        }
+        if (left > 0) {
+            SDL_Delay(100);
+        }
+    } while (left > 0);
+}
+
+void
+WINWAVEOUT_CloseDevice(_THIS)
+{
+    /* Close up audio */
+    if (this->hidden != NULL) {
+        int i;
+
+        if (this->hidden->audio_sem) {
+#if defined(_WIN32_WCE) && (_WIN32_WCE < 300)
+            CloseSynchHandle(this->hidden->audio_sem);
+#else
+            CloseHandle(this->hidden->audio_sem);
+#endif
+            this->hidden->audio_sem = 0;
+        }
+
+        if (this->hidden->sound) {
+            waveOutClose(this->hidden->sound);
+            this->hidden->sound = 0;
+        }
+
+        /* Clean up mixing buffers */
+        for (i = 0; i < NUM_BUFFERS; ++i) {
+            if (this->hidden->wavebuf[i].dwUser != 0xFFFF) {
+                waveOutUnprepareHeader(this->hidden->sound,
+                                       &this->hidden->wavebuf[i],
+                                       sizeof(this->hidden->wavebuf[i]));
+                this->hidden->wavebuf[i].dwUser = 0xFFFF;
+            }
+        }
+
+        if (this->hidden->mixbuf != NULL) {
+            /* Free raw mixing buffer */
+            SDL_free(this->hidden->mixbuf);
+            this->hidden->mixbuf = NULL;
+        }
+
+        SDL_free(this->hidden);
+        this->hidden = NULL;
+    }
+}
+
+int
+WINWAVEOUT_OpenDevice(_THIS, const char *devname, int iscapture)
+{
+    SDL_AudioFormat test_format = SDL_FirstAudioFormat(this->spec.format);
+    int valid_datatype = 0;
+    MMRESULT result;
+    WAVEFORMATEX waveformat;
+    int i;
+
+    /* Initialize all variables that we clean on shutdown */
+    this->hidden = (struct SDL_PrivateAudioData *)
+        SDL_malloc((sizeof *this->hidden));
+    if (this->hidden == NULL) {
+        SDL_OutOfMemory();
+        return 0;
+    }
+    SDL_memset(this->hidden, 0, (sizeof *this->hidden));
+
+    /* Initialize the wavebuf structures for closing */
+    for (i = 0; i < NUM_BUFFERS; ++i)
+        this->hidden->wavebuf[i].dwUser = 0xFFFF;
+
+    while ((!valid_datatype) && (test_format)) {
+        valid_datatype = 1;
+        this->spec.format = test_format;
+        switch (test_format) {
+        case AUDIO_U8:
+        case AUDIO_S16:
+        case AUDIO_S32:
+            break;              /* valid. */
+
+        default:
+            valid_datatype = 0;
+            test_format = SDL_NextAudioFormat();
+            break;
+        }
+    }
+
+    if (!valid_datatype) {
+        WINWAVEOUT_CloseDevice(this);
+        SDL_SetError("Unsupported audio format");
+        return 0;
+    }
+
+    /* Set basic WAVE format parameters */
+    SDL_memset(&waveformat, '\0', sizeof(waveformat));
+    waveformat.wFormatTag = WAVE_FORMAT_PCM;
+    waveformat.wBitsPerSample = SDL_AUDIO_BITSIZE(this->spec.format);
+
+    if (this->spec.channels > 2)
+        this->spec.channels = 2;        /* !!! FIXME: is this right? */
+
+    waveformat.nChannels = this->spec.channels;
+    waveformat.nSamplesPerSec = this->spec.freq;
+    waveformat.nBlockAlign =
+        waveformat.nChannels * (waveformat.wBitsPerSample / 8);
+    waveformat.nAvgBytesPerSec =
+        waveformat.nSamplesPerSec * waveformat.nBlockAlign;
+
+    /* Check the buffer size -- minimum of 1/4 second (word aligned) */
+    if (this->spec.samples < (this->spec.freq / 4))
+        this->spec.samples = ((this->spec.freq / 4) + 3) & ~3;
+
+    /* Update the fragment size as size in bytes */
+    SDL_CalculateAudioSpec(&this->spec);
+
+    /* Open the audio device */
+    result = waveOutOpen(&this->hidden->sound, WAVE_MAPPER, &waveformat,
+                         (DWORD_PTR) FillSound, (DWORD_PTR) this,
+                         CALLBACK_FUNCTION);
+    if (result != MMSYSERR_NOERROR) {
+        WINWAVEOUT_CloseDevice(this);
+        SetMMerror("waveOutOpen()", result);
+        return 0;
+    }
+#ifdef SOUND_DEBUG
+    /* Check the sound device we retrieved */
+    {
+        WAVEOUTCAPS caps;
+
+        result = waveOutGetDevCaps((UINT) this->hidden->sound,
+                                   &caps, sizeof(caps));
+        if (result != MMSYSERR_NOERROR) {
+            WINWAVEOUT_CloseDevice(this);
+            SetMMerror("waveOutGetDevCaps()", result);
+            return 0;
+        }
+        printf("Audio device: %s\n", caps.szPname);
+    }
+#endif
+
+    /* Create the audio buffer semaphore */
+    this->hidden->audio_sem =
+#if defined(_WIN32_WCE) && (_WIN32_WCE < 300)
+        CreateSemaphoreCE(NULL, NUM_BUFFERS - 1, NUM_BUFFERS, NULL);
+#else
+        CreateSemaphore(NULL, NUM_BUFFERS - 1, NUM_BUFFERS, NULL);
+#endif
+    if (this->hidden->audio_sem == NULL) {
+        WINWAVEOUT_CloseDevice(this);
+        SDL_SetError("Couldn't create semaphore");
+        return 0;
+    }
+
+    /* Create the sound buffers */
+    this->hidden->mixbuf =
+        (Uint8 *) SDL_malloc(NUM_BUFFERS * this->spec.size);
+    if (this->hidden->mixbuf == NULL) {
+        WINWAVEOUT_CloseDevice(this);
+        SDL_OutOfMemory();
+        return 0;
+    }
+    for (i = 0; i < NUM_BUFFERS; ++i) {
+        SDL_memset(&this->hidden->wavebuf[i], '\0',
+                   sizeof(this->hidden->wavebuf[i]));
+        this->hidden->wavebuf[i].dwBufferLength = this->spec.size;
+        this->hidden->wavebuf[i].dwFlags = WHDR_DONE;
+        this->hidden->wavebuf[i].lpData =
+            (LPSTR) & this->hidden->mixbuf[i * this->spec.size];
+        result = waveOutPrepareHeader(this->hidden->sound,
+                                      &this->hidden->wavebuf[i],
+                                      sizeof(this->hidden->wavebuf[i]));
+        if (result != MMSYSERR_NOERROR) {
+            WINWAVEOUT_CloseDevice(this);
+            SetMMerror("waveOutPrepareHeader()", result);
+            return 0;
+        }
+    }
+
+    return 1;                   /* Ready to go! */
+}
+
+
+static int
+WINWAVEOUT_Init(SDL_AudioDriverImpl * impl)
+{
+    /* Set the function pointers */
+    impl->OpenDevice = WINWAVEOUT_OpenDevice;
+    impl->ThreadInit = WINWAVEOUT_ThreadInit;
+    impl->PlayDevice = WINWAVEOUT_PlayDevice;
+    impl->WaitDevice = WINWAVEOUT_WaitDevice;
+    impl->WaitDone = WINWAVEOUT_WaitDone;
+    impl->GetDeviceBuf = WINWAVEOUT_GetDeviceBuf;
+    impl->CloseDevice = WINWAVEOUT_CloseDevice;
+    impl->OnlyHasDefaultOutputDevice = 1;       /* !!! FIXME: Is this true? */
+
+    /* !!! FIXME: not right for device enum? */
+    return 1;
+}
+
+AudioBootStrap WINWAVEOUT_bootstrap = {
+    "waveout", WINDOWS_OS_NAME " WaveOut", WINWAVEOUT_Init, 0
+};
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/windib/SDL_dibaudio.h

@@ -0,0 +1,45 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifndef _SDL_dibaudio_h
+#define _SDL_dibaudio_h
+
+#include "../SDL_sysaudio.h"
+
+/* Hidden "this" pointer for the audio functions */
+#define _THIS	SDL_AudioDevice *this
+
+#define NUM_BUFFERS 2           /* -- Don't lower this! */
+
+struct SDL_PrivateAudioData
+{
+    HWAVEOUT sound;
+    HANDLE audio_sem;
+    Uint8 *mixbuf;              /* The raw allocated mixing buffer */
+    WAVEHDR wavebuf[NUM_BUFFERS];       /* Wave audio fragments */
+    int next_buffer;
+};
+
+#endif /* _SDL_dibaudio_h */
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/windx5/SDL_dx5audio.c

@@ -0,0 +1,519 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* Allow access to a raw mixing buffer */
+
+#include "SDL_timer.h"
+#include "SDL_audio.h"
+#include "../SDL_audio_c.h"
+#include "SDL_dx5audio.h"
+
+/* !!! FIXME: move this somewhere that other drivers can use it... */
+#if defined(_WIN32_WCE)
+#define WINDOWS_OS_NAME "Windows CE/PocketPC"
+#elif defined(WIN64)
+#define WINDOWS_OS_NAME "Win64"
+#else
+#define WINDOWS_OS_NAME "Win32"
+#endif
+
+/* DirectX function pointers for audio */
+static HINSTANCE DSoundDLL = NULL;
+static HRESULT(WINAPI * DSoundCreate) (LPGUID, LPDIRECTSOUND *, LPUNKNOWN) =
+    NULL;
+
+static void
+DSOUND_Unload(void)
+{
+    if (DSoundDLL != NULL) {
+        FreeLibrary(DSoundDLL);
+    }
+
+    DSoundCreate = NULL;
+    DSoundDLL = NULL;
+}
+
+
+static int
+DSOUND_Load(void)
+{
+    int loaded = 0;
+
+    DSOUND_Unload();
+
+    DSoundDLL = LoadLibrary(TEXT("DSOUND.DLL"));
+    if (DSoundDLL == NULL) {
+        SDL_SetError("DirectSound: failed to load DSOUND.DLL");
+    } else {
+        /* Now make sure we have DirectX 5 or better... */
+        /*  (DirectSoundCaptureCreate was added in DX5) */
+        if (!GetProcAddress(DSoundDLL, TEXT("DirectSoundCaptureCreate"))) {
+            SDL_SetError("DirectSound: System doesn't appear to have DX5.");
+        } else {
+            DSoundCreate = (void *) GetProcAddress(DSoundDLL,
+                                                   TEXT("DirectSoundCreate"));
+        }
+
+        if (!DSoundCreate) {
+            SDL_SetError("DirectSound: Failed to find DirectSoundCreate");
+        } else {
+            loaded = 1;
+        }
+    }
+
+    if (!loaded) {
+        DSOUND_Unload();
+    }
+
+    return loaded;
+}
+
+
+static void
+SetDSerror(const char *function, int code)
+{
+    static const char *error;
+    static char errbuf[1024];
+
+    errbuf[0] = 0;
+    switch (code) {
+    case E_NOINTERFACE:
+        error = "Unsupported interface -- Is DirectX 5.0 or later installed?";
+        break;
+    case DSERR_ALLOCATED:
+        error = "Audio device in use";
+        break;
+    case DSERR_BADFORMAT:
+        error = "Unsupported audio format";
+        break;
+    case DSERR_BUFFERLOST:
+        error = "Mixing buffer was lost";
+        break;
+    case DSERR_CONTROLUNAVAIL:
+        error = "Control requested is not available";
+        break;
+    case DSERR_INVALIDCALL:
+        error = "Invalid call for the current state";
+        break;
+    case DSERR_INVALIDPARAM:
+        error = "Invalid parameter";
+        break;
+    case DSERR_NODRIVER:
+        error = "No audio device found";
+        break;
+    case DSERR_OUTOFMEMORY:
+        error = "Out of memory";
+        break;
+    case DSERR_PRIOLEVELNEEDED:
+        error = "Caller doesn't have priority";
+        break;
+    case DSERR_UNSUPPORTED:
+        error = "Function not supported";
+        break;
+    default:
+        SDL_snprintf(errbuf, SDL_arraysize(errbuf),
+                     "%s: Unknown DirectSound error: 0x%x", function, code);
+        break;
+    }
+    if (!errbuf[0]) {
+        SDL_snprintf(errbuf, SDL_arraysize(errbuf), "%s: %s", function,
+                     error);
+    }
+    SDL_SetError("%s", errbuf);
+    return;
+}
+
+/* DirectSound needs to be associated with a window */
+static HWND mainwin = NULL;
+/* */
+
+void
+DSOUND_SoundFocus(HWND hwnd)
+{
+    /* !!! FIXME: probably broken with multi-window support in SDL 1.3 ... */
+    mainwin = hwnd;
+}
+
+static void
+DSOUND_ThreadInit(_THIS)
+{
+    SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_HIGHEST);
+}
+
+static void
+DSOUND_WaitDevice(_THIS)
+{
+    DWORD status = 0;
+    DWORD cursor = 0;
+    DWORD junk = 0;
+    HRESULT result = DS_OK;
+
+    /* Semi-busy wait, since we have no way of getting play notification
+       on a primary mixing buffer located in hardware (DirectX 5.0)
+     */
+    result = IDirectSoundBuffer_GetCurrentPosition(this->hidden->mixbuf,
+                                                   &junk, &cursor);
+    if (result != DS_OK) {
+        if (result == DSERR_BUFFERLOST) {
+            IDirectSoundBuffer_Restore(this->hidden->mixbuf);
+        }
+#ifdef DEBUG_SOUND
+        SetDSerror("DirectSound GetCurrentPosition", result);
+#endif
+        return;
+    }
+
+    while ((cursor / this->hidden->mixlen) == this->hidden->lastchunk) {
+        /* FIXME: find out how much time is left and sleep that long */
+        SDL_Delay(1);
+
+        /* Try to restore a lost sound buffer */
+        IDirectSoundBuffer_GetStatus(this->hidden->mixbuf, &status);
+        if ((status & DSBSTATUS_BUFFERLOST)) {
+            IDirectSoundBuffer_Restore(this->hidden->mixbuf);
+            IDirectSoundBuffer_GetStatus(this->hidden->mixbuf, &status);
+            if ((status & DSBSTATUS_BUFFERLOST)) {
+                break;
+            }
+        }
+        if (!(status & DSBSTATUS_PLAYING)) {
+            result = IDirectSoundBuffer_Play(this->hidden->mixbuf, 0, 0,
+                                             DSBPLAY_LOOPING);
+            if (result == DS_OK) {
+                continue;
+            }
+#ifdef DEBUG_SOUND
+            SetDSerror("DirectSound Play", result);
+#endif
+            return;
+        }
+
+        /* Find out where we are playing */
+        result = IDirectSoundBuffer_GetCurrentPosition(this->hidden->mixbuf,
+                                                       &junk, &cursor);
+        if (result != DS_OK) {
+            SetDSerror("DirectSound GetCurrentPosition", result);
+            return;
+        }
+    }
+}
+
+static void
+DSOUND_PlayDevice(_THIS)
+{
+    /* Unlock the buffer, allowing it to play */
+    if (this->hidden->locked_buf) {
+        IDirectSoundBuffer_Unlock(this->hidden->mixbuf,
+                                  this->hidden->locked_buf,
+                                  this->hidden->mixlen, NULL, 0);
+    }
+
+}
+
+static Uint8 *
+DSOUND_GetDeviceBuf(_THIS)
+{
+    DWORD cursor = 0;
+    DWORD junk = 0;
+    HRESULT result = DS_OK;
+    DWORD rawlen = 0;
+
+    /* Figure out which blocks to fill next */
+    this->hidden->locked_buf = NULL;
+    result = IDirectSoundBuffer_GetCurrentPosition(this->hidden->mixbuf,
+                                                   &junk, &cursor);
+    if (result == DSERR_BUFFERLOST) {
+        IDirectSoundBuffer_Restore(this->hidden->mixbuf);
+        result = IDirectSoundBuffer_GetCurrentPosition(this->hidden->mixbuf,
+                                                       &junk, &cursor);
+    }
+    if (result != DS_OK) {
+        SetDSerror("DirectSound GetCurrentPosition", result);
+        return (NULL);
+    }
+    cursor /= this->hidden->mixlen;
+#ifdef DEBUG_SOUND
+    /* Detect audio dropouts */
+    {
+        DWORD spot = cursor;
+        if (spot < this->hidden->lastchunk) {
+            spot += this->hidden->num_buffers;
+        }
+        if (spot > this->hidden->lastchunk + 1) {
+            fprintf(stderr, "Audio dropout, missed %d fragments\n",
+                    (spot - (this->hidden->lastchunk + 1)));
+        }
+    }
+#endif
+    this->hidden->lastchunk = cursor;
+    cursor = (cursor + 1) % this->hidden->num_buffers;
+    cursor *= this->hidden->mixlen;
+
+    /* Lock the audio buffer */
+    result = IDirectSoundBuffer_Lock(this->hidden->mixbuf, cursor,
+                                     this->hidden->mixlen,
+                                     (LPVOID *) & this->hidden->locked_buf,
+                                     &rawlen, NULL, &junk, 0);
+    if (result == DSERR_BUFFERLOST) {
+        IDirectSoundBuffer_Restore(this->hidden->mixbuf);
+        result = IDirectSoundBuffer_Lock(this->hidden->mixbuf, cursor,
+                                         this->hidden->mixlen,
+                                         (LPVOID *) & this->
+                                         hidden->locked_buf, &rawlen, NULL,
+                                         &junk, 0);
+    }
+    if (result != DS_OK) {
+        SetDSerror("DirectSound Lock", result);
+        return (NULL);
+    }
+    return (this->hidden->locked_buf);
+}
+
+static void
+DSOUND_WaitDone(_THIS)
+{
+    Uint8 *stream = DSOUND_GetDeviceBuf(this);
+
+    /* Wait for the playing chunk to finish */
+    if (stream != NULL) {
+        SDL_memset(stream, this->spec.silence, this->hidden->mixlen);
+        DSOUND_PlayDevice(this);
+    }
+    DSOUND_WaitDevice(this);
+
+    /* Stop the looping sound buffer */
+    IDirectSoundBuffer_Stop(this->hidden->mixbuf);
+}
+
+static void
+DSOUND_CloseDevice(_THIS)
+{
+    if (this->hidden != NULL) {
+        if (this->hidden->sound != NULL) {
+            if (this->hidden->mixbuf != NULL) {
+                /* Clean up the audio buffer */
+                IDirectSoundBuffer_Release(this->hidden->mixbuf);
+                this->hidden->mixbuf = NULL;
+            }
+            IDirectSound_Release(this->hidden->sound);
+            this->hidden->sound = NULL;
+        }
+
+        SDL_free(this->hidden);
+        this->hidden = NULL;
+    }
+}
+
+/* This function tries to create a secondary audio buffer, and returns the
+   number of audio chunks available in the created buffer.
+*/
+static int
+CreateSecondary(_THIS, HWND focus, WAVEFORMATEX * wavefmt)
+{
+    LPDIRECTSOUND sndObj = this->hidden->sound;
+    LPDIRECTSOUNDBUFFER *sndbuf = &this->hidden->mixbuf;
+    Uint32 chunksize = this->spec.size;
+    const int numchunks = 8;
+    HRESULT result = DS_OK;
+    DSBUFFERDESC format;
+    LPVOID pvAudioPtr1, pvAudioPtr2;
+    DWORD dwAudioBytes1, dwAudioBytes2;
+
+    /* Try to set primary mixing privileges */
+    if (focus) {
+        result = IDirectSound_SetCooperativeLevel(sndObj,
+                                                  focus, DSSCL_PRIORITY);
+    } else {
+        result = IDirectSound_SetCooperativeLevel(sndObj,
+                                                  GetDesktopWindow(),
+                                                  DSSCL_NORMAL);
+    }
+    if (result != DS_OK) {
+        SetDSerror("DirectSound SetCooperativeLevel", result);
+        return (-1);
+    }
+
+    /* Try to create the secondary buffer */
+    SDL_memset(&format, 0, sizeof(format));
+    format.dwSize = sizeof(format);
+    format.dwFlags = DSBCAPS_GETCURRENTPOSITION2;
+    if (!focus) {
+        format.dwFlags |= DSBCAPS_GLOBALFOCUS;
+    } else {
+        format.dwFlags |= DSBCAPS_STICKYFOCUS;
+    }
+    format.dwBufferBytes = numchunks * chunksize;
+    if ((format.dwBufferBytes < DSBSIZE_MIN) ||
+        (format.dwBufferBytes > DSBSIZE_MAX)) {
+        SDL_SetError("Sound buffer size must be between %d and %d",
+                     DSBSIZE_MIN / numchunks, DSBSIZE_MAX / numchunks);
+        return (-1);
+    }
+    format.dwReserved = 0;
+    format.lpwfxFormat = wavefmt;
+    result = IDirectSound_CreateSoundBuffer(sndObj, &format, sndbuf, NULL);
+    if (result != DS_OK) {
+        SetDSerror("DirectSound CreateSoundBuffer", result);
+        return (-1);
+    }
+    IDirectSoundBuffer_SetFormat(*sndbuf, wavefmt);
+
+    /* Silence the initial audio buffer */
+    result = IDirectSoundBuffer_Lock(*sndbuf, 0, format.dwBufferBytes,
+                                     (LPVOID *) & pvAudioPtr1, &dwAudioBytes1,
+                                     (LPVOID *) & pvAudioPtr2, &dwAudioBytes2,
+                                     DSBLOCK_ENTIREBUFFER);
+    if (result == DS_OK) {
+        SDL_memset(pvAudioPtr1, this->spec.silence, dwAudioBytes1);
+        IDirectSoundBuffer_Unlock(*sndbuf,
+                                  (LPVOID) pvAudioPtr1, dwAudioBytes1,
+                                  (LPVOID) pvAudioPtr2, dwAudioBytes2);
+    }
+
+    /* We're ready to go */
+    return (numchunks);
+}
+
+static int
+DSOUND_OpenDevice(_THIS, const char *devname, int iscapture)
+{
+    HRESULT result;
+    WAVEFORMATEX waveformat;
+    int valid_format = 0;
+    SDL_AudioFormat test_format = SDL_FirstAudioFormat(this->spec.format);
+
+    /* !!! FIXME: handle devname */
+    /* !!! FIXME: handle iscapture */
+
+    /* Initialize all variables that we clean on shutdown */
+    this->hidden = (struct SDL_PrivateAudioData *)
+        SDL_malloc((sizeof *this->hidden));
+    if (this->hidden == NULL) {
+        SDL_OutOfMemory();
+        return 0;
+    }
+    SDL_memset(this->hidden, 0, (sizeof *this->hidden));
+
+    while ((!valid_format) && (test_format)) {
+        switch (test_format) {
+        case AUDIO_U8:
+        case AUDIO_S16:
+        case AUDIO_S32:
+            this->spec.format = test_format;
+            valid_format = 1;
+            break;
+        }
+        test_format = SDL_NextAudioFormat();
+    }
+
+    if (!valid_format) {
+        DSOUND_CloseDevice(this);
+        SDL_SetError("DirectSound: Unsupported audio format");
+        return 0;
+    }
+
+    SDL_memset(&waveformat, 0, sizeof(waveformat));
+    waveformat.wFormatTag = WAVE_FORMAT_PCM;
+    waveformat.wBitsPerSample = SDL_AUDIO_BITSIZE(this->spec.format);
+    waveformat.nChannels = this->spec.channels;
+    waveformat.nSamplesPerSec = this->spec.freq;
+    waveformat.nBlockAlign =
+        waveformat.nChannels * (waveformat.wBitsPerSample / 8);
+    waveformat.nAvgBytesPerSec =
+        waveformat.nSamplesPerSec * waveformat.nBlockAlign;
+
+    /* Update the fragment size as size in bytes */
+    SDL_CalculateAudioSpec(&this->spec);
+
+    /* Open the audio device */
+    result = DSoundCreate(NULL, &this->hidden->sound, NULL);
+    if (result != DS_OK) {
+        DSOUND_CloseDevice(this);
+        SetDSerror("DirectSoundCreate", result);
+        return 0;
+    }
+
+    /* Create the audio buffer to which we write */
+    this->hidden->num_buffers = CreateSecondary(this, mainwin, &waveformat);
+    if (this->hidden->num_buffers < 0) {
+        DSOUND_CloseDevice(this);
+        return 0;
+    }
+
+    /* The buffer will auto-start playing in DSOUND_WaitDevice() */
+    this->hidden->mixlen = this->spec.size;
+
+    return 1;                   /* good to go. */
+}
+
+
+static void
+DSOUND_Deinitialize(void)
+{
+    DSOUND_Unload();
+}
+
+
+static int
+DSOUND_Init(SDL_AudioDriverImpl * impl)
+{
+    OSVERSIONINFO ver;
+
+    /*
+     * Unfortunately, the sound drivers on NT have higher latencies than the
+     *  audio buffers used by many SDL applications, so there are gaps in the
+     *  audio - it sounds terrible.  Punt for now.
+     */
+    SDL_memset(&ver, '\0', sizeof(OSVERSIONINFO));
+    ver.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
+    GetVersionEx(&ver);
+    if (ver.dwPlatformId == VER_PLATFORM_WIN32_NT) {
+        if (ver.dwMajorVersion <= 4) {
+            return 0;           /* NT4.0 or earlier. Disable dsound support. */
+        }
+    }
+
+    if (!DSOUND_Load()) {
+        return 0;
+    }
+
+    /* Set the function pointers */
+    impl->OpenDevice = DSOUND_OpenDevice;
+    impl->PlayDevice = DSOUND_PlayDevice;
+    impl->WaitDevice = DSOUND_WaitDevice;
+    impl->WaitDone = DSOUND_WaitDone;
+    impl->ThreadInit = DSOUND_ThreadInit;
+    impl->GetDeviceBuf = DSOUND_GetDeviceBuf;
+    impl->CloseDevice = DSOUND_CloseDevice;
+    impl->Deinitialize = DSOUND_Deinitialize;
+    impl->OnlyHasDefaultOutputDevice = 1;       /* !!! FIXME */
+
+    /* !!! FIXME: not right for device enum? */
+    return 1;
+}
+
+AudioBootStrap DSOUND_bootstrap = {
+    "dsound", WINDOWS_OS_NAME "DirectSound", DSOUND_Init, 0
+};
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/windx5/SDL_dx5audio.h

@@ -0,0 +1,47 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifndef _SDL_dx5audio_h
+#define _SDL_dx5audio_h
+
+#include "directx.h"
+
+#include "../SDL_sysaudio.h"
+
+/* Hidden "this" pointer for the audio functions */
+#define _THIS	SDL_AudioDevice *this
+
+/* The DirectSound objects */
+struct SDL_PrivateAudioData
+{
+    LPDIRECTSOUND sound;
+    LPDIRECTSOUNDBUFFER mixbuf;
+    int num_buffers;
+    int mixlen;
+    DWORD lastchunk;
+    Uint8 *locked_buf;
+};
+
+#endif /* _SDL_dx5audio_h */
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/audio/windx5/directx.h

@@ -0,0 +1,85 @@
+
+#ifndef _directx_h
+#define _directx_h
+
+/* Include all of the DirectX 5.0 headers and adds any necessary tweaks */
+
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <mmsystem.h>
+#ifndef WIN32
+#define WIN32
+#endif
+#undef  WINNT
+
+/* Far pointers don't exist in 32-bit code */
+#ifndef FAR
+#define FAR
+#endif
+
+/* Error codes not yet included in Win32 API header files */
+#ifndef MAKE_HRESULT
+#define MAKE_HRESULT(sev,fac,code) \
+	((HRESULT)(((unsigned long)(sev)<<31) | ((unsigned long)(fac)<<16) | ((unsigned long)(code))))
+#endif
+
+#ifndef S_OK
+#define S_OK		(HRESULT)0x00000000L
+#endif
+
+#ifndef SUCCEEDED
+#define SUCCEEDED(x)	((HRESULT)(x) >= 0)
+#endif
+#ifndef FAILED
+#define FAILED(x)	((HRESULT)(x)<0)
+#endif
+
+#ifndef E_FAIL
+#define E_FAIL		(HRESULT)0x80000008L
+#endif
+#ifndef E_NOINTERFACE
+#define E_NOINTERFACE	(HRESULT)0x80004002L
+#endif
+#ifndef E_OUTOFMEMORY
+#define E_OUTOFMEMORY	(HRESULT)0x8007000EL
+#endif
+#ifndef E_INVALIDARG
+#define E_INVALIDARG	(HRESULT)0x80070057L
+#endif
+#ifndef E_NOTIMPL
+#define E_NOTIMPL	(HRESULT)0x80004001L
+#endif
+#ifndef REGDB_E_CLASSNOTREG
+#define REGDB_E_CLASSNOTREG	(HRESULT)0x80040154L
+#endif
+
+/* Severity codes */
+#ifndef SEVERITY_ERROR
+#define SEVERITY_ERROR	1
+#endif
+
+/* Error facility codes */
+#ifndef FACILITY_WIN32
+#define FACILITY_WIN32	7
+#endif
+
+#ifndef FIELD_OFFSET
+#define FIELD_OFFSET(type, field)    ((LONG)&(((type *)0)->field))
+#endif
+
+/* DirectX headers (if it isn't included, I haven't tested it yet)
+ */
+/* We need these defines to mark what version of DirectX API we use */
+#define DIRECTDRAW_VERSION  0x0700
+#define DIRECTSOUND_VERSION 0x0500
+#define DIRECTINPUT_VERSION 0x0500
+
+#ifdef __GNUC__
+#define NONAMELESSUNION
+#endif
+#include <ddraw.h>
+#include <dsound.h>
+#include <dinput.h>
+
+#endif /* _directx_h */
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/cpuinfo/SDL_cpuinfo.c

@@ -0,0 +1,505 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* CPU feature detection for SDL */
+
+#include "SDL_cpuinfo.h"
+
+#if defined(__MACOSX__) && (defined(__ppc__) || defined(__ppc64__))
+#include <sys/sysctl.h>         /* For AltiVec check */
+#elif SDL_ALTIVEC_BLITTERS && HAVE_SETJMP
+#include <signal.h>
+#include <setjmp.h>
+#endif
+
+#define CPU_HAS_RDTSC	0x00000001
+#define CPU_HAS_MMX	0x00000002
+#define CPU_HAS_MMXEXT	0x00000004
+#define CPU_HAS_3DNOW	0x00000010
+#define CPU_HAS_3DNOWEXT 0x00000020
+#define CPU_HAS_SSE	0x00000040
+#define CPU_HAS_SSE2	0x00000080
+#define CPU_HAS_ALTIVEC	0x00000100
+
+#if SDL_ALTIVEC_BLITTERS && HAVE_SETJMP && !__MACOSX__
+/* This is the brute force way of detecting instruction sets...
+   the idea is borrowed from the libmpeg2 library - thanks!
+ */
+static jmp_buf jmpbuf;
+static void
+illegal_instruction(int sig)
+{
+    longjmp(jmpbuf, 1);
+}
+#endif /* HAVE_SETJMP */
+
+static __inline__ int
+CPU_haveCPUID(void)
+{
+    int has_CPUID = 0;
+/* *INDENT-OFF* */
+#if defined(__GNUC__) && defined(i386)
+	__asm__ (
+"        pushfl                      # Get original EFLAGS             \n"
+"        popl    %%eax                                                 \n"
+"        movl    %%eax,%%ecx                                           \n"
+"        xorl    $0x200000,%%eax     # Flip ID bit in EFLAGS           \n"
+"        pushl   %%eax               # Save new EFLAGS value on stack  \n"
+"        popfl                       # Replace current EFLAGS value    \n"
+"        pushfl                      # Get new EFLAGS                  \n"
+"        popl    %%eax               # Store new EFLAGS in EAX         \n"
+"        xorl    %%ecx,%%eax         # Can not toggle ID bit,          \n"
+"        jz      1f                  # Processor=80486                 \n"
+"        movl    $1,%0               # We have CPUID support           \n"
+"1:                                                                    \n"
+	: "=m" (has_CPUID)
+	:
+	: "%eax", "%ecx"
+	);
+#elif defined(__GNUC__) && defined(__x86_64__)
+/* Technically, if this is being compiled under __x86_64__ then it has 
+CPUid by definition.  But it's nice to be able to prove it.  :)      */
+	__asm__ (
+"        pushfq                      # Get original EFLAGS             \n"
+"        popq    %%rax                                                 \n"
+"        movq    %%rax,%%rcx                                           \n"
+"        xorl    $0x200000,%%eax     # Flip ID bit in EFLAGS           \n"
+"        pushq   %%rax               # Save new EFLAGS value on stack  \n"
+"        popfq                       # Replace current EFLAGS value    \n"
+"        pushfq                      # Get new EFLAGS                  \n"
+"        popq    %%rax               # Store new EFLAGS in EAX         \n"
+"        xorl    %%ecx,%%eax         # Can not toggle ID bit,          \n"
+"        jz      1f                  # Processor=80486                 \n"
+"        movl    $1,%0               # We have CPUID support           \n"
+"1:                                                                    \n"
+	: "=m" (has_CPUID)
+	:
+	: "%rax", "%rcx"
+	);
+#elif (defined(_MSC_VER) && defined(_M_IX86)) || defined(__WATCOMC__)
+	__asm {
+        pushfd                      ; Get original EFLAGS
+        pop     eax
+        mov     ecx, eax
+        xor     eax, 200000h        ; Flip ID bit in EFLAGS
+        push    eax                 ; Save new EFLAGS value on stack
+        popfd                       ; Replace current EFLAGS value
+        pushfd                      ; Get new EFLAGS
+        pop     eax                 ; Store new EFLAGS in EAX
+        xor     eax, ecx            ; Can not toggle ID bit,
+        jz      done                ; Processor=80486
+        mov     has_CPUID,1         ; We have CPUID support
+done:
+	}
+#elif defined(__sun) && defined(__i386)
+	__asm (
+"       pushfl                 \n"
+"	popl    %eax           \n"
+"	movl    %eax,%ecx      \n"
+"	xorl    $0x200000,%eax \n"
+"	pushl   %eax           \n"
+"	popfl                  \n"
+"	pushfl                 \n"
+"	popl    %eax           \n"
+"	xorl    %ecx,%eax      \n"
+"	jz      1f             \n"
+"	movl    $1,-8(%ebp)    \n"
+"1:                            \n"
+	);
+#elif defined(__sun) && defined(__amd64)
+	__asm (
+"       pushfq                 \n"
+"       popq    %rax           \n"
+"       movq    %rax,%rcx      \n"
+"       xorl    $0x200000,%eax \n"
+"       pushq   %rax           \n"
+"       popfq                  \n"
+"       pushfq                 \n"
+"       popq    %rax           \n"
+"       xorl    %ecx,%eax      \n"
+"       jz      1f             \n"
+"       movl    $1,-8(%rbp)    \n"
+"1:                            \n"
+	);
+#endif
+/* *INDENT-ON* */
+    return has_CPUID;
+}
+
+static __inline__ int
+CPU_getCPUIDFeatures(void)
+{
+    int features = 0;
+/* *INDENT-OFF* */
+#if defined(__GNUC__) && defined(i386)
+	__asm__ (
+"        pushl   %%ebx\n"
+"        xorl    %%eax,%%eax         # Set up for CPUID instruction    \n"
+"        cpuid                       # Get and save vendor ID          \n"
+"        cmpl    $1,%%eax            # Make sure 1 is valid input for CPUID\n"
+"        jl      1f                  # We dont have the CPUID instruction\n"
+"        xorl    %%eax,%%eax                                           \n"
+"        incl    %%eax                                                 \n"
+"        cpuid                       # Get family/model/stepping/features\n"
+"        movl    %%edx,%0                                              \n"
+"1:                                                                    \n"
+"        popl    %%ebx\n"
+	: "=m" (features)
+	:
+	: "%eax", "%ecx", "%edx"
+	);
+#elif defined(__GNUC__) && defined(__x86_64__)
+	__asm__ (
+"        pushq   %%rbx\n"
+"        xorl    %%eax,%%eax         # Set up for CPUID instruction    \n"
+"        cpuid                       # Get and save vendor ID          \n"
+"        cmpl    $1,%%eax            # Make sure 1 is valid input for CPUID\n"
+"        jl      1f                  # We dont have the CPUID instruction\n"
+"        xorl    %%eax,%%eax                                           \n"
+"        incl    %%eax                                                 \n"
+"        cpuid                       # Get family/model/stepping/features\n"
+"        movl    %%edx,%0                                              \n"
+"1:                                                                    \n"
+"        popq    %%rbx\n"
+	: "=m" (features)
+	:
+	: "%rax", "%rcx", "%rdx"
+	);
+#elif (defined(_MSC_VER) && defined(_M_IX86)) || defined(__WATCOMC__)
+	__asm {
+        xor     eax, eax            ; Set up for CPUID instruction
+        cpuid                       ; Get and save vendor ID
+        cmp     eax, 1              ; Make sure 1 is valid input for CPUID
+        jl      done                ; We dont have the CPUID instruction
+        xor     eax, eax
+        inc     eax
+        cpuid                       ; Get family/model/stepping/features
+        mov     features, edx
+done:
+	}
+#elif defined(__sun) && (defined(__i386) || defined(__amd64))
+	    __asm(
+"        movl    %ebx,%edi\n"
+"        xorl    %eax,%eax         \n"
+"        cpuid                     \n"
+"        cmpl    $1,%eax           \n"
+"        jl      1f                \n"
+"        xorl    %eax,%eax         \n"
+"        incl    %eax              \n"
+"        cpuid                     \n"
+#ifdef __i386
+"        movl    %edx,-8(%ebp)     \n"
+#else
+"        movl    %edx,-8(%rbp)     \n"
+#endif
+"1:                                \n"
+"        movl    %edi,%ebx\n" );
+#endif
+/* *INDENT-ON* */
+    return features;
+}
+
+static __inline__ int
+CPU_getCPUIDFeaturesExt(void)
+{
+    int features = 0;
+/* *INDENT-OFF* */
+#if defined(__GNUC__) && defined(i386)
+	__asm__ (
+"        pushl   %%ebx\n"
+"        movl    $0x80000000,%%eax   # Query for extended functions    \n"
+"        cpuid                       # Get extended function limit     \n"
+"        cmpl    $0x80000001,%%eax                                     \n"
+"        jl      1f                  # Nope, we dont have function 800000001h\n"
+"        movl    $0x80000001,%%eax   # Setup extended function 800000001h\n"
+"        cpuid                       # and get the information         \n"
+"        movl    %%edx,%0                                              \n"
+"1:                                                                    \n"
+"        popl    %%ebx\n"
+	: "=m" (features)
+	:
+	: "%eax", "%ecx", "%edx"
+	);
+#elif defined(__GNUC__) && defined (__x86_64__)
+	__asm__ (
+"        pushq   %%rbx\n"
+"        movl    $0x80000000,%%eax   # Query for extended functions    \n"
+"        cpuid                       # Get extended function limit     \n"
+"        cmpl    $0x80000001,%%eax                                     \n"
+"        jl      1f                  # Nope, we dont have function 800000001h\n"
+"        movl    $0x80000001,%%eax   # Setup extended function 800000001h\n"
+"        cpuid                       # and get the information         \n"
+"        movl    %%edx,%0                                              \n"
+"1:                                                                    \n"
+"        popq    %%rbx\n"
+	: "=m" (features)
+	:
+	: "%rax", "%rcx", "%rdx"
+	);
+#elif (defined(_MSC_VER) && defined(_M_IX86)) || defined(__WATCOMC__)
+	__asm {
+        mov     eax,80000000h       ; Query for extended functions
+        cpuid                       ; Get extended function limit
+        cmp     eax,80000001h
+        jl      done                ; Nope, we dont have function 800000001h
+        mov     eax,80000001h       ; Setup extended function 800000001h
+        cpuid                       ; and get the information
+        mov     features,edx
+done:
+	}
+#elif defined(__sun) && ( defined(__i386) || defined(__amd64) )
+	    __asm (
+"        movl    %ebx,%edi\n"
+"        movl    $0x80000000,%eax \n"
+"        cpuid                    \n"
+"        cmpl    $0x80000001,%eax \n"
+"        jl      1f               \n"
+"        movl    $0x80000001,%eax \n"
+"        cpuid                    \n"
+#ifdef __i386
+"        movl    %edx,-8(%ebp)   \n"
+#else
+"        movl    %edx,-8(%rbp)   \n"
+#endif
+"1:                               \n"
+"        movl    %edi,%ebx\n"
+	    );
+#endif
+/* *INDENT-ON* */
+    return features;
+}
+
+static __inline__ int
+CPU_haveRDTSC(void)
+{
+    if (CPU_haveCPUID()) {
+        return (CPU_getCPUIDFeatures() & 0x00000010);
+    }
+    return 0;
+}
+
+static __inline__ int
+CPU_haveMMX(void)
+{
+    if (CPU_haveCPUID()) {
+        return (CPU_getCPUIDFeatures() & 0x00800000);
+    }
+    return 0;
+}
+
+static __inline__ int
+CPU_haveMMXExt(void)
+{
+    if (CPU_haveCPUID()) {
+        return (CPU_getCPUIDFeaturesExt() & 0x00400000);
+    }
+    return 0;
+}
+
+static __inline__ int
+CPU_have3DNow(void)
+{
+    if (CPU_haveCPUID()) {
+        return (CPU_getCPUIDFeaturesExt() & 0x80000000);
+    }
+    return 0;
+}
+
+static __inline__ int
+CPU_have3DNowExt(void)
+{
+    if (CPU_haveCPUID()) {
+        return (CPU_getCPUIDFeaturesExt() & 0x40000000);
+    }
+    return 0;
+}
+
+static __inline__ int
+CPU_haveSSE(void)
+{
+    if (CPU_haveCPUID()) {
+        return (CPU_getCPUIDFeatures() & 0x02000000);
+    }
+    return 0;
+}
+
+static __inline__ int
+CPU_haveSSE2(void)
+{
+    if (CPU_haveCPUID()) {
+        return (CPU_getCPUIDFeatures() & 0x04000000);
+    }
+    return 0;
+}
+
+static __inline__ int
+CPU_haveAltiVec(void)
+{
+    volatile int altivec = 0;
+#if defined(__MACOSX__) && (defined(__ppc__) || defined(__ppc64__))
+    int selectors[2] = { CTL_HW, HW_VECTORUNIT };
+    int hasVectorUnit = 0;
+    size_t length = sizeof(hasVectorUnit);
+    int error = sysctl(selectors, 2, &hasVectorUnit, &length, NULL, 0);
+    if (0 == error)
+        altivec = (hasVectorUnit != 0);
+#elif SDL_ALTIVEC_BLITTERS && HAVE_SETJMP
+    void (*handler) (int sig);
+    handler = signal(SIGILL, illegal_instruction);
+    if (setjmp(jmpbuf) == 0) {
+        asm volatile ("mtspr 256, %0\n\t" "vand %%v0, %%v0, %%v0"::"r" (-1));
+        altivec = 1;
+    }
+    signal(SIGILL, handler);
+#endif
+    return altivec;
+}
+
+static Uint32 SDL_CPUFeatures = 0xFFFFFFFF;
+
+static Uint32
+SDL_GetCPUFeatures(void)
+{
+    if (SDL_CPUFeatures == 0xFFFFFFFF) {
+        SDL_CPUFeatures = 0;
+        if (CPU_haveRDTSC()) {
+            SDL_CPUFeatures |= CPU_HAS_RDTSC;
+        }
+        if (CPU_haveMMX()) {
+            SDL_CPUFeatures |= CPU_HAS_MMX;
+        }
+        if (CPU_haveMMXExt()) {
+            SDL_CPUFeatures |= CPU_HAS_MMXEXT;
+        }
+        if (CPU_have3DNow()) {
+            SDL_CPUFeatures |= CPU_HAS_3DNOW;
+        }
+        if (CPU_have3DNowExt()) {
+            SDL_CPUFeatures |= CPU_HAS_3DNOWEXT;
+        }
+        if (CPU_haveSSE()) {
+            SDL_CPUFeatures |= CPU_HAS_SSE;
+        }
+        if (CPU_haveSSE2()) {
+            SDL_CPUFeatures |= CPU_HAS_SSE2;
+        }
+        if (CPU_haveAltiVec()) {
+            SDL_CPUFeatures |= CPU_HAS_ALTIVEC;
+        }
+    }
+    return SDL_CPUFeatures;
+}
+
+SDL_bool
+SDL_HasRDTSC(void)
+{
+    if (SDL_GetCPUFeatures() & CPU_HAS_RDTSC) {
+        return SDL_TRUE;
+    }
+    return SDL_FALSE;
+}
+
+SDL_bool
+SDL_HasMMX(void)
+{
+    if (SDL_GetCPUFeatures() & CPU_HAS_MMX) {
+        return SDL_TRUE;
+    }
+    return SDL_FALSE;
+}
+
+SDL_bool
+SDL_HasMMXExt(void)
+{
+    if (SDL_GetCPUFeatures() & CPU_HAS_MMXEXT) {
+        return SDL_TRUE;
+    }
+    return SDL_FALSE;
+}
+
+SDL_bool
+SDL_Has3DNow(void)
+{
+    if (SDL_GetCPUFeatures() & CPU_HAS_3DNOW) {
+        return SDL_TRUE;
+    }
+    return SDL_FALSE;
+}
+
+SDL_bool
+SDL_Has3DNowExt(void)
+{
+    if (SDL_GetCPUFeatures() & CPU_HAS_3DNOWEXT) {
+        return SDL_TRUE;
+    }
+    return SDL_FALSE;
+}
+
+SDL_bool
+SDL_HasSSE(void)
+{
+    if (SDL_GetCPUFeatures() & CPU_HAS_SSE) {
+        return SDL_TRUE;
+    }
+    return SDL_FALSE;
+}
+
+SDL_bool
+SDL_HasSSE2(void)
+{
+    if (SDL_GetCPUFeatures() & CPU_HAS_SSE2) {
+        return SDL_TRUE;
+    }
+    return SDL_FALSE;
+}
+
+SDL_bool
+SDL_HasAltiVec(void)
+{
+    if (SDL_GetCPUFeatures() & CPU_HAS_ALTIVEC) {
+        return SDL_TRUE;
+    }
+    return SDL_FALSE;
+}
+
+#ifdef TEST_MAIN
+
+#include <stdio.h>
+
+int
+main()
+{
+    printf("RDTSC: %d\n", SDL_HasRDTSC());
+    printf("MMX: %d\n", SDL_HasMMX());
+    printf("MMXExt: %d\n", SDL_HasMMXExt());
+    printf("3DNow: %d\n", SDL_Has3DNow());
+    printf("3DNowExt: %d\n", SDL_Has3DNowExt());
+    printf("SSE: %d\n", SDL_HasSSE());
+    printf("SSE2: %d\n", SDL_HasSSE2());
+    printf("AltiVec: %d\n", SDL_HasAltiVec());
+    return 0;
+}
+
+#endif /* TEST_MAIN */
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/events/SDL_events.c

@@ -0,0 +1,541 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* General event handling code for SDL */
+
+#include "SDL.h"
+#include "SDL_events.h"
+#include "SDL_syswm.h"
+#include "SDL_thread.h"
+#include "SDL_sysevents.h"
+#include "SDL_events_c.h"
+#include "../timer/SDL_timer_c.h"
+#if !SDL_JOYSTICK_DISABLED
+#include "../joystick/SDL_joystick_c.h"
+#endif
+
+/* Public data -- the event filter */
+SDL_EventFilter SDL_EventOK = NULL;
+void *SDL_EventOKParam;
+Uint8 SDL_ProcessEvents[SDL_NUMEVENTS];
+static Uint32 SDL_eventstate = 0;
+
+/* Private data -- event queue */
+#define MAXEVENTS	128
+static struct
+{
+    SDL_mutex *lock;
+    int active;
+    int head;
+    int tail;
+    SDL_Event event[MAXEVENTS];
+    int wmmsg_next;
+    struct SDL_SysWMmsg wmmsg[MAXEVENTS];
+} SDL_EventQ;
+
+/* Private data -- event locking structure */
+static struct
+{
+    SDL_mutex *lock;
+    int safe;
+} SDL_EventLock;
+
+/* Thread functions */
+static SDL_Thread *SDL_EventThread = NULL;      /* Thread handle */
+static Uint32 event_thread;     /* The event thread id */
+
+void
+SDL_Lock_EventThread(void)
+{
+    if (SDL_EventThread && (SDL_ThreadID() != event_thread)) {
+        /* Grab lock and spin until we're sure event thread stopped */
+        SDL_mutexP(SDL_EventLock.lock);
+        while (!SDL_EventLock.safe) {
+            SDL_Delay(1);
+        }
+    }
+}
+
+void
+SDL_Unlock_EventThread(void)
+{
+    if (SDL_EventThread && (SDL_ThreadID() != event_thread)) {
+        SDL_mutexV(SDL_EventLock.lock);
+    }
+}
+
+static int SDLCALL
+SDL_GobbleEvents(void *unused)
+{
+    event_thread = SDL_ThreadID();
+
+    while (SDL_EventQ.active) {
+        SDL_VideoDevice *_this = SDL_GetVideoDevice();
+
+        /* Get events from the video subsystem */
+        if (_this) {
+            _this->PumpEvents(_this);
+        }
+#if !SDL_JOYSTICK_DISABLED
+        /* Check for joystick state change */
+        if (SDL_numjoysticks && (SDL_eventstate & SDL_JOYEVENTMASK)) {
+            SDL_JoystickUpdate();
+        }
+#endif
+
+        /* Give up the CPU for the rest of our timeslice */
+        SDL_EventLock.safe = 1;
+        if (SDL_timer_running) {
+            SDL_ThreadedTimerCheck();
+        }
+        SDL_Delay(1);
+
+        /* Check for event locking.
+           On the P of the lock mutex, if the lock is held, this thread
+           will wait until the lock is released before continuing.  The
+           safe flag will be set, meaning that the other thread can go
+           about it's business.  The safe flag is reset before the V,
+           so as soon as the mutex is free, other threads can see that
+           it's not safe to interfere with the event thread.
+         */
+        SDL_mutexP(SDL_EventLock.lock);
+        SDL_EventLock.safe = 0;
+        SDL_mutexV(SDL_EventLock.lock);
+    }
+    SDL_SetTimerThreaded(0);
+    event_thread = 0;
+    return (0);
+}
+
+static int
+SDL_StartEventThread(Uint32 flags)
+{
+    /* Reset everything to zero */
+    SDL_EventThread = NULL;
+    SDL_memset(&SDL_EventLock, 0, sizeof(SDL_EventLock));
+
+    /* Create the lock and set ourselves active */
+#if !SDL_THREADS_DISABLED
+    SDL_EventQ.lock = SDL_CreateMutex();
+    if (SDL_EventQ.lock == NULL) {
+        return (-1);
+    }
+#endif /* !SDL_THREADS_DISABLED */
+    SDL_EventQ.active = 1;
+
+    if ((flags & SDL_INIT_EVENTTHREAD) == SDL_INIT_EVENTTHREAD) {
+        SDL_EventLock.lock = SDL_CreateMutex();
+        if (SDL_EventLock.lock == NULL) {
+            return (-1);
+        }
+        SDL_EventLock.safe = 0;
+
+        /* The event thread will handle timers too */
+        SDL_SetTimerThreaded(2);
+#if (defined(__WIN32__) && !defined(_WIN32_WCE)) && !defined(HAVE_LIBC)
+#undef SDL_CreateThread
+        SDL_EventThread =
+            SDL_CreateThread(SDL_GobbleEvents, NULL, NULL, NULL);
+#else
+        SDL_EventThread = SDL_CreateThread(SDL_GobbleEvents, NULL);
+#endif
+        if (SDL_EventThread == NULL) {
+            return (-1);
+        }
+    } else {
+        event_thread = 0;
+    }
+    return (0);
+}
+
+static void
+SDL_StopEventThread(void)
+{
+    SDL_EventQ.active = 0;
+    if (SDL_EventThread) {
+        SDL_WaitThread(SDL_EventThread, NULL);
+        SDL_EventThread = NULL;
+        SDL_DestroyMutex(SDL_EventLock.lock);
+    }
+    if (SDL_EventQ.lock) {
+        SDL_DestroyMutex(SDL_EventQ.lock);
+        SDL_EventQ.lock = NULL;
+    }
+}
+
+Uint32
+SDL_EventThreadID(void)
+{
+    return (event_thread);
+}
+
+/* Public functions */
+
+void
+SDL_StopEventLoop(void)
+{
+    /* Halt the event thread, if running */
+    SDL_StopEventThread();
+
+    /* Shutdown event handlers */
+    SDL_KeyboardQuit();
+    SDL_MouseQuit();
+    SDL_QuitQuit();
+
+    /* Clean out EventQ */
+    SDL_EventQ.head = 0;
+    SDL_EventQ.tail = 0;
+    SDL_EventQ.wmmsg_next = 0;
+}
+
+/* This function (and associated calls) may be called more than once */
+int
+SDL_StartEventLoop(Uint32 flags)
+{
+    int retcode;
+
+    /* Clean out the event queue */
+    SDL_EventThread = NULL;
+    SDL_EventQ.lock = NULL;
+    SDL_StopEventLoop();
+
+    /* No filter to start with, process most event types */
+    SDL_EventOK = NULL;
+    SDL_memset(SDL_ProcessEvents, SDL_ENABLE, sizeof(SDL_ProcessEvents));
+    SDL_eventstate = ~0;
+    /* It's not save to call SDL_EventState() yet */
+    SDL_eventstate &= ~(0x00000001 << SDL_SYSWMEVENT);
+    SDL_ProcessEvents[SDL_SYSWMEVENT] = SDL_IGNORE;
+
+    /* Initialize event handlers */
+    retcode = 0;
+    retcode += SDL_KeyboardInit();
+    retcode += SDL_MouseInit();
+    retcode += SDL_QuitInit();
+    if (retcode < 0) {
+        /* We don't expect them to fail, but... */
+        return (-1);
+    }
+
+    /* Create the lock and event thread */
+    if (SDL_StartEventThread(flags) < 0) {
+        SDL_StopEventLoop();
+        return (-1);
+    }
+    return (0);
+}
+
+
+/* Add an event to the event queue -- called with the queue locked */
+static int
+SDL_AddEvent(SDL_Event * event)
+{
+    int tail, added;
+
+    tail = (SDL_EventQ.tail + 1) % MAXEVENTS;
+    if (tail == SDL_EventQ.head) {
+        /* Overflow, drop event */
+        added = 0;
+    } else {
+        SDL_EventQ.event[SDL_EventQ.tail] = *event;
+        if (event->type == SDL_SYSWMEVENT) {
+            /* Note that it's possible to lose an event */
+            int next = SDL_EventQ.wmmsg_next;
+            SDL_EventQ.wmmsg[next] = *event->syswm.msg;
+            SDL_EventQ.event[SDL_EventQ.tail].syswm.msg =
+                &SDL_EventQ.wmmsg[next];
+            SDL_EventQ.wmmsg_next = (next + 1) % MAXEVENTS;
+        }
+        SDL_EventQ.tail = tail;
+        added = 1;
+    }
+    return (added);
+}
+
+/* Cut an event, and return the next valid spot, or the tail */
+/*                           -- called with the queue locked */
+static int
+SDL_CutEvent(int spot)
+{
+    if (spot == SDL_EventQ.head) {
+        SDL_EventQ.head = (SDL_EventQ.head + 1) % MAXEVENTS;
+        return (SDL_EventQ.head);
+    } else if ((spot + 1) % MAXEVENTS == SDL_EventQ.tail) {
+        SDL_EventQ.tail = spot;
+        return (SDL_EventQ.tail);
+    } else
+        /* We cut the middle -- shift everything over */
+    {
+        int here, next;
+
+        /* This can probably be optimized with SDL_memcpy() -- careful! */
+        if (--SDL_EventQ.tail < 0) {
+            SDL_EventQ.tail = MAXEVENTS - 1;
+        }
+        for (here = spot; here != SDL_EventQ.tail; here = next) {
+            next = (here + 1) % MAXEVENTS;
+            SDL_EventQ.event[here] = SDL_EventQ.event[next];
+        }
+        return (spot);
+    }
+    /* NOTREACHED */
+}
+
+/* Lock the event queue, take a peep at it, and unlock it */
+int
+SDL_PeepEvents(SDL_Event * events, int numevents, SDL_eventaction action,
+               Uint32 mask)
+{
+    int i, used;
+
+    /* Don't look after we've quit */
+    if (!SDL_EventQ.active) {
+        return (-1);
+    }
+    /* Lock the event queue */
+    used = 0;
+    if (SDL_mutexP(SDL_EventQ.lock) == 0) {
+        if (action == SDL_ADDEVENT) {
+            for (i = 0; i < numevents; ++i) {
+                used += SDL_AddEvent(&events[i]);
+            }
+        } else {
+            SDL_Event tmpevent;
+            int spot;
+
+            /* If 'events' is NULL, just see if they exist */
+            if (events == NULL) {
+                action = SDL_PEEKEVENT;
+                numevents = 1;
+                events = &tmpevent;
+            }
+            spot = SDL_EventQ.head;
+            while ((used < numevents) && (spot != SDL_EventQ.tail)) {
+                if (mask & SDL_EVENTMASK(SDL_EventQ.event[spot].type)) {
+                    events[used++] = SDL_EventQ.event[spot];
+                    if (action == SDL_GETEVENT) {
+                        spot = SDL_CutEvent(spot);
+                    } else {
+                        spot = (spot + 1) % MAXEVENTS;
+                    }
+                } else {
+                    spot = (spot + 1) % MAXEVENTS;
+                }
+            }
+        }
+        SDL_mutexV(SDL_EventQ.lock);
+    } else {
+        SDL_SetError("Couldn't lock event queue");
+        used = -1;
+    }
+    return (used);
+}
+
+SDL_bool
+SDL_HasEvent(Uint32 mask)
+{
+    return (SDL_PeepEvents(NULL, 0, SDL_PEEKEVENT, mask) > 0);
+}
+
+/* Run the system dependent event loops */
+void
+SDL_PumpEvents(void)
+{
+    if (!SDL_EventThread) {
+        SDL_VideoDevice *_this = SDL_GetVideoDevice();
+
+        /* Get events from the video subsystem */
+        if (_this) {
+            _this->PumpEvents(_this);
+        }
+#if !SDL_JOYSTICK_DISABLED
+        /* Check for joystick state change */
+        if (SDL_numjoysticks && (SDL_eventstate & SDL_JOYEVENTMASK)) {
+            SDL_JoystickUpdate();
+        }
+#endif
+    }
+}
+
+/* Public functions */
+
+int
+SDL_PollEvent(SDL_Event * event)
+{
+    return SDL_WaitEventTimeout(event, 0);
+}
+
+int
+SDL_WaitEvent(SDL_Event * event)
+{
+    return SDL_WaitEventTimeout(event, -1);
+}
+
+int
+SDL_WaitEventTimeout(SDL_Event * event, int timeout)
+{
+    Uint32 expiration = 0;
+
+    if (timeout > 0)
+        expiration = SDL_GetTicks() + timeout;
+
+    for (;;) {
+        SDL_PumpEvents();
+        switch (SDL_PeepEvents(event, 1, SDL_GETEVENT, SDL_ALLEVENTS)) {
+        case -1:
+            return 0;
+        case 1:
+            return 1;
+        case 0:
+            if (timeout == 0) {
+                /* Polling and no events, just return */
+                return 0;
+            }
+            if (timeout > 0 && ((int) (SDL_GetTicks() - expiration) >= 0)) {
+                /* Timeout expired and no events */
+                return 0;
+            }
+            SDL_Delay(10);
+            break;
+        }
+    }
+}
+
+int
+SDL_PushEvent(SDL_Event * event)
+{
+    if (SDL_EventOK && !SDL_EventOK(SDL_EventOKParam, event)) {
+        return 0;
+    }
+    if (SDL_PeepEvents(event, 1, SDL_ADDEVENT, 0) <= 0) {
+        return -1;
+    }
+    return 1;
+}
+
+void
+SDL_SetEventFilter(SDL_EventFilter filter, void *userdata)
+{
+    SDL_Event bitbucket;
+
+    /* Set filter and discard pending events */
+    SDL_EventOK = filter;
+    SDL_EventOKParam = userdata;
+    while (SDL_PollEvent(&bitbucket) > 0);
+}
+
+SDL_bool
+SDL_GetEventFilter(SDL_EventFilter * filter, void **userdata)
+{
+    if (filter) {
+        *filter = SDL_EventOK;
+    }
+    if (userdata) {
+        *userdata = SDL_EventOKParam;
+    }
+    return SDL_EventOK ? SDL_TRUE : SDL_FALSE;
+}
+
+void
+SDL_FilterEvents(SDL_EventFilter filter, void *userdata)
+{
+    if (SDL_mutexP(SDL_EventQ.lock) == 0) {
+        int spot;
+
+        spot = SDL_EventQ.head;
+        while (spot != SDL_EventQ.tail) {
+            if (filter(userdata, &SDL_EventQ.event[spot])) {
+                spot = (spot + 1) % MAXEVENTS;
+            } else {
+                spot = SDL_CutEvent(spot);
+            }
+        }
+    }
+    SDL_mutexV(SDL_EventQ.lock);
+}
+
+Uint8
+SDL_EventState(Uint8 type, int state)
+{
+    SDL_Event bitbucket;
+    Uint8 current_state;
+
+    /* If SDL_ALLEVENTS was specified... */
+    if (type == 0xFF) {
+        current_state = SDL_IGNORE;
+        for (type = 0; type < SDL_NUMEVENTS; ++type) {
+            if (SDL_ProcessEvents[type] != SDL_IGNORE) {
+                current_state = SDL_ENABLE;
+            }
+            SDL_ProcessEvents[type] = state;
+            if (state == SDL_ENABLE) {
+                SDL_eventstate |= (0x00000001 << (type));
+            } else {
+                SDL_eventstate &= ~(0x00000001 << (type));
+            }
+        }
+        while (SDL_PollEvent(&bitbucket) > 0);
+        return (current_state);
+    }
+
+    /* Just set the state for one event type */
+    current_state = SDL_ProcessEvents[type];
+    switch (state) {
+    case SDL_IGNORE:
+    case SDL_ENABLE:
+        /* Set state and discard pending events */
+        SDL_ProcessEvents[type] = state;
+        if (state == SDL_ENABLE) {
+            SDL_eventstate |= (0x00000001 << (type));
+        } else {
+            SDL_eventstate &= ~(0x00000001 << (type));
+        }
+        while (SDL_PollEvent(&bitbucket) > 0);
+        break;
+    default:
+        /* Querying state? */
+        break;
+    }
+    return (current_state);
+}
+
+/* This is a generic event handler.
+ */
+int
+SDL_SendSysWMEvent(SDL_SysWMmsg * message)
+{
+    int posted;
+
+    posted = 0;
+    if (SDL_ProcessEvents[SDL_SYSWMEVENT] == SDL_ENABLE) {
+        SDL_Event event;
+        SDL_memset(&event, 0, sizeof(event));
+        event.type = SDL_SYSWMEVENT;
+        event.syswm.msg = message;
+        posted = (SDL_PushEvent(&event) > 0);
+    }
+    /* Update internal event state */
+    return (posted);
+}
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/events/SDL_events_c.h

@@ -0,0 +1,52 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* Useful functions and variables from SDL_events.c */
+#include "SDL_events.h"
+#include "SDL_mouse_c.h"
+#include "SDL_keyboard_c.h"
+#include "SDL_windowevents_c.h"
+
+/* Start and stop the event processing loop */
+extern int SDL_StartEventLoop(Uint32 flags);
+extern void SDL_StopEventLoop(void);
+extern void SDL_QuitInterrupt(void);
+
+extern void SDL_Lock_EventThread(void);
+extern void SDL_Unlock_EventThread(void);
+extern Uint32 SDL_EventThreadID(void);
+
+extern int SDL_SendSysWMEvent(SDL_SysWMmsg * message);
+
+extern int SDL_QuitInit(void);
+extern int SDL_SendQuit(void);
+extern void SDL_QuitQuit(void);
+
+/* The event filter function */
+extern SDL_EventFilter SDL_EventOK;
+extern void *SDL_EventOKParam;
+
+/* The array of event processing states */
+extern Uint8 SDL_ProcessEvents[SDL_NUMEVENTS];
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/events/SDL_keyboard_c.h

@@ -0,0 +1,92 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifndef _SDL_keyboard_c_h
+#define _SDL_keyboard_c_h
+
+#include "SDL_keysym.h"
+#include "SDL_events.h"
+
+typedef struct SDL_Keyboard SDL_Keyboard;
+
+struct SDL_Keyboard
+{
+    /* Free the keyboard when it's time */
+    void (*FreeKeyboard) (SDL_Keyboard * keyboard);
+
+    /* Data common to all keyboards */
+    SDL_WindowID focus;
+    Uint16 modstate;
+    Uint8 keystate[SDL_NUM_SCANCODES];
+    SDLKey keymap[SDL_NUM_SCANCODES];
+
+    void *driverdata;
+};
+
+/* Initialize the keyboard subsystem */
+extern int SDL_KeyboardInit(void);
+
+/* Get the keyboard at an index */
+extern SDL_Keyboard *SDL_GetKeyboard(int index);
+
+/* Add a keyboard, possibly reattaching at a particular index (or -1),
+   returning the index of the keyboard, or -1 if there was an error.
+ */
+extern int SDL_AddKeyboard(const SDL_Keyboard * keyboard, int index);
+
+/* Remove a keyboard at an index, clearing the slot for later */
+extern void SDL_DelKeyboard(int index);
+
+/* Clear the state of a keyboard at an index */
+extern void SDL_ResetKeyboard(int index);
+
+/* Get the default keymap */
+extern void SDL_GetDefaultKeymap(SDLKey * keymap);
+
+/* Set the mapping of scancode to key codes for this keyboard */
+extern void SDL_SetKeymap(int index, int start, SDLKey * keys, int length);
+
+/* Set a platform-dependent key name, overriding the default platform-agnostic
+   name. Encoded as UTF-8. The string is not copied, thus the pointer given to
+   this function must stay valid forever (or at least until the call to
+   VideoQuit()). */
+extern void SDL_SetScancodeName(SDL_scancode scancode, const char *name);
+
+/* Set the keyboard focus window */
+extern void SDL_SetKeyboardFocus(int index, SDL_WindowID windowID);
+
+/* Send a keyboard event for a keyboard at an index */
+extern int SDL_SendKeyboardKey(int index, Uint8 state, SDL_scancode scancode);
+
+/* Send keyboard text input for a keyboard at an index */
+extern int SDL_SendKeyboardText(int index, const char *text);
+
+/* Send editing text for selected range from start to end */
+extern int SDL_SendEditingText(const char *text, int start, int end);
+
+/* Shutdown the keyboard subsystem */
+extern void SDL_KeyboardQuit(void);
+
+#endif /* _SDL_keyboard_c_h */
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/events/SDL_mouse.c

@@ -0,0 +1,805 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* General mouse handling code for SDL */
+
+#include "SDL_events.h"
+#include "SDL_events_c.h"
+#include "default_cursor.h"
+
+
+static int SDL_num_mice = 0;
+static int SDL_current_mouse = -1;
+static SDL_Mouse **SDL_mice = NULL;
+
+
+/* Public functions */
+int
+SDL_MouseInit(void)
+{
+    return (0);
+}
+
+SDL_Mouse *
+SDL_GetMouse(int index)
+{
+    if (index < 0 || index >= SDL_num_mice) {
+        return NULL;
+    }
+    return SDL_mice[index];
+}
+
+static int
+SDL_GetMouseIndexId(int id)
+{
+    int index;
+    SDL_Mouse *mouse;
+
+    for (index = 0; index < SDL_num_mice; ++index) {
+        mouse = SDL_GetMouse(index);
+        if (mouse->id == id) {
+            return index;
+        }
+    }
+    return -1;
+}
+
+int
+SDL_AddMouse(const SDL_Mouse * mouse, char *name, int pressure_max,
+             int pressure_min, int ends)
+{
+    SDL_Mouse **mice;
+    int selected_mouse;
+    int index;
+    size_t length;
+
+    if (SDL_GetMouseIndexId(mouse->id) != -1) {
+        SDL_SetError("Mouse ID already in use");
+    }
+
+    /* Add the mouse to the list of mice */
+    mice = (SDL_Mouse **) SDL_realloc(SDL_mice,
+                                      (SDL_num_mice + 1) * sizeof(*mice));
+    if (!mice) {
+        SDL_OutOfMemory();
+        return -1;
+    }
+
+    SDL_mice = mice;
+    index = SDL_num_mice++;
+
+    SDL_mice[index] = (SDL_Mouse *) SDL_malloc(sizeof(*SDL_mice[index]));
+    if (!SDL_mice[index]) {
+        SDL_OutOfMemory();
+        return -1;
+    }
+    *SDL_mice[index] = *mouse;
+
+    /* we're setting the mouse properties */
+    length = 0;
+    length = SDL_strlen(name);
+    SDL_mice[index]->focus = 0;
+    SDL_mice[index]->name = SDL_malloc((length + 2) * sizeof(char));
+    SDL_strlcpy(SDL_mice[index]->name, name, length + 1);
+    SDL_mice[index]->pressure_max = pressure_max;
+    SDL_mice[index]->pressure_min = pressure_min;
+    SDL_mice[index]->cursor_shown = SDL_TRUE;
+    selected_mouse = SDL_SelectMouse(index);
+    SDL_mice[index]->cur_cursor = NULL;
+    SDL_mice[index]->def_cursor =
+        SDL_CreateCursor(default_cdata, default_cmask, DEFAULT_CWIDTH,
+                         DEFAULT_CHEIGHT, DEFAULT_CHOTX, DEFAULT_CHOTY);
+    SDL_SetCursor(SDL_mice[index]->def_cursor);
+    /* we're assuming that all mice are in the computer sensing zone */
+    SDL_mice[index]->proximity = SDL_TRUE;
+    /* we're assuming that all mice are working in the absolute position mode
+       thanx to that, the users that don't want to use many mice don't have to
+       worry about anything */
+    SDL_mice[index]->relative_mode = SDL_FALSE;
+    SDL_mice[index]->current_end = 0;
+    SDL_mice[index]->total_ends = ends;
+    SDL_SelectMouse(selected_mouse);
+
+    return index;
+}
+
+void
+SDL_DelMouse(int index)
+{
+    SDL_Mouse *mouse = SDL_GetMouse(index);
+
+    if (!mouse) {
+        return;
+    }
+
+    mouse->def_cursor = NULL;
+    SDL_free(mouse->name);
+    while (mouse->cursors) {
+        SDL_FreeCursor(mouse->cursors);
+    }
+
+    if (mouse->FreeMouse) {
+        mouse->FreeMouse(mouse);
+    }
+    SDL_free(mouse);
+
+    SDL_mice[index] = NULL;
+}
+
+void
+SDL_ResetMouse(int index)
+{
+    SDL_Mouse *mouse = SDL_GetMouse(index);
+
+    if (!mouse) {
+        return;
+    }
+
+    /* FIXME */
+}
+
+void
+SDL_MouseQuit(void)
+{
+    int i;
+
+    for (i = 0; i < SDL_num_mice; ++i) {
+        SDL_DelMouse(i);
+    }
+    SDL_num_mice = 0;
+    SDL_current_mouse = -1;
+
+    if (SDL_mice) {
+        SDL_free(SDL_mice);
+        SDL_mice = NULL;
+    }
+}
+
+int
+SDL_GetNumMice(void)
+{
+    return SDL_num_mice;
+}
+
+int
+SDL_SelectMouse(int index)
+{
+    if (index >= 0 && index < SDL_num_mice) {
+        SDL_current_mouse = index;
+    }
+    return SDL_current_mouse;
+}
+
+SDL_WindowID
+SDL_GetMouseFocusWindow(int index)
+{
+    SDL_Mouse *mouse = SDL_GetMouse(index);
+
+    if (!mouse) {
+        return 0;
+    }
+    return mouse->focus;
+}
+
+static int SDLCALL
+FlushMouseMotion(void *param, SDL_Event * event)
+{
+    if (event->type == SDL_MOUSEMOTION
+        && event->motion.which == (Uint8) SDL_current_mouse) {
+        return 0;
+    } else {
+        return 1;
+    }
+}
+
+int
+SDL_SetRelativeMouseMode(int index, SDL_bool enabled)
+{
+    SDL_Mouse *mouse = SDL_GetMouse(index);
+
+    if (!mouse) {
+        return -1;
+    }
+
+    /* Flush pending mouse motion */
+    mouse->flush_motion = SDL_TRUE;
+    SDL_PumpEvents();
+    mouse->flush_motion = SDL_FALSE;
+    SDL_FilterEvents(FlushMouseMotion, mouse);
+
+    /* Set the relative mode */
+    mouse->relative_mode = enabled;
+
+    /* Update cursor visibility */
+    SDL_SetCursor(NULL);
+
+    if (!enabled) {
+        /* Restore the expected mouse position */
+        SDL_WarpMouseInWindow(mouse->focus, mouse->x, mouse->y);
+    }
+    return 0;
+}
+
+SDL_bool
+SDL_GetRelativeMouseMode(int index)
+{
+    SDL_Mouse *mouse = SDL_GetMouse(index);
+
+    if (!mouse) {
+        return SDL_FALSE;
+    }
+    return mouse->relative_mode;
+}
+
+Uint8
+SDL_GetMouseState(int index, int *x, int *y)
+{
+    SDL_Mouse *mouse = SDL_GetMouse(index);
+
+    if (!mouse) {
+        if (x) {
+            *x = 0;
+        }
+        if (y) {
+            *y = 0;
+        }
+        return 0;
+    }
+
+    if (x) {
+        *x = mouse->x;
+    }
+    if (y) {
+        *y = mouse->y;
+    }
+    return mouse->buttonstate;
+}
+
+Uint8
+SDL_GetRelativeMouseState(int index, int *x, int *y)
+{
+    SDL_Mouse *mouse = SDL_GetMouse(index);
+
+    if (!mouse) {
+        if (x) {
+            *x = 0;
+        }
+        if (y) {
+            *y = 0;
+        }
+        return 0;
+    }
+
+    if (x) {
+        *x = mouse->xdelta;
+    }
+    if (y) {
+        *y = mouse->ydelta;
+    }
+    mouse->xdelta = 0;
+    mouse->ydelta = 0;
+    return mouse->buttonstate;
+}
+
+void
+SDL_SetMouseFocus(int id, SDL_WindowID windowID)
+{
+    int index = SDL_GetMouseIndexId(id);
+    SDL_Mouse *mouse = SDL_GetMouse(index);
+    int i;
+    SDL_bool focus;
+
+    if (!mouse || (mouse->focus == windowID)) {
+        return;
+    }
+
+    /* See if the current window has lost focus */
+    if (mouse->focus) {
+        focus = SDL_FALSE;
+        for (i = 0; i < SDL_num_mice; ++i) {
+            SDL_Mouse *check;
+            if (i != index) {
+                check = SDL_GetMouse(i);
+                if (check && check->focus == mouse->focus) {
+                    focus = SDL_TRUE;
+                    break;
+                }
+            }
+        }
+        if (!focus) {
+            SDL_SendWindowEvent(mouse->focus, SDL_WINDOWEVENT_LEAVE, 0, 0);
+        }
+    }
+
+    mouse->focus = windowID;
+
+    if (mouse->focus) {
+        focus = SDL_FALSE;
+        for (i = 0; i < SDL_num_mice; ++i) {
+            SDL_Mouse *check;
+            if (i != index) {
+                check = SDL_GetMouse(i);
+                if (check && check->focus == mouse->focus) {
+                    focus = SDL_TRUE;
+                    break;
+                }
+            }
+        }
+        if (!focus) {
+            SDL_SendWindowEvent(mouse->focus, SDL_WINDOWEVENT_ENTER, 0, 0);
+        }
+    }
+}
+
+int
+SDL_SendProximity(int id, int x, int y, int type)
+{
+    int index = SDL_GetMouseIndexId(id);
+    SDL_Mouse *mouse = SDL_GetMouse(index);
+    int posted = 0;
+
+    if (!mouse) {
+        return 0;
+    }
+
+    mouse->last_x = x;
+    mouse->last_y = y;
+    if (SDL_ProcessEvents[type] == SDL_ENABLE) {
+        SDL_Event event;
+        event.proximity.which = (Uint8) index;
+        event.proximity.x = x;
+        event.proximity.y = y;
+        event.proximity.cursor = mouse->current_end;
+        event.proximity.type = type;
+        /* FIXME: is this right? */
+        event.proximity.windowID = mouse->focus;
+        posted = (SDL_PushEvent(&event) > 0);
+        if (type == SDL_PROXIMITYIN) {
+            mouse->proximity = SDL_TRUE;
+        } else {
+            mouse->proximity = SDL_FALSE;
+        }
+    }
+    return posted;
+}
+
+int
+SDL_SendMouseMotion(int id, int relative, int x, int y, int pressure)
+{
+    int index = SDL_GetMouseIndexId(id);
+    SDL_Mouse *mouse = SDL_GetMouse(index);
+    int posted;
+    int xrel;
+    int yrel;
+    int x_max = 0, y_max = 0;
+
+    if (!mouse || mouse->flush_motion) {
+        return 0;
+    }
+
+    /* if the mouse is out of proximity we don't to want to have any motion from it */
+    if (mouse->proximity == SDL_FALSE) {
+        mouse->last_x = x;
+        mouse->last_y = y;
+        return 0;
+    }
+
+    /* the relative motion is calculated regarding the system cursor last position */
+    if (relative) {
+        xrel = x;
+        yrel = y;
+        x = (mouse->last_x + x);
+        y = (mouse->last_y + y);
+    } else {
+        xrel = x - mouse->last_x;
+        yrel = y - mouse->last_y;
+    }
+
+    /* Drop events that don't change state */
+    if (!xrel && !yrel) {
+#if 0
+        printf("Mouse event didn't change state - dropped!\n");
+#endif
+        return 0;
+    }
+
+    /* Update internal mouse coordinates */
+    if (mouse->relative_mode == SDL_FALSE) {
+        mouse->x = x;
+        mouse->y = y;
+    } else {
+        mouse->x += xrel;
+        mouse->y += yrel;
+    }
+
+    SDL_GetWindowSize(mouse->focus, &x_max, &y_max);
+
+    /* make sure that the pointers find themselves inside the windows */
+    /* only check if mouse->xmax is set ! */
+    if (x_max && mouse->x > x_max) {
+        mouse->x = x_max;
+    } else if (mouse->x < 0) {
+        mouse->x = 0;
+    }
+
+    if (y_max && mouse->y > y_max) {
+        mouse->y = y_max;
+    } else if (mouse->y < 0) {
+        mouse->y = 0;
+    }
+
+    mouse->xdelta += xrel;
+    mouse->ydelta += yrel;
+    mouse->pressure = pressure;
+
+    /* Move the mouse cursor, if needed */
+    if (mouse->cursor_shown && !mouse->relative_mode &&
+        mouse->MoveCursor && mouse->cur_cursor) {
+        mouse->MoveCursor(mouse->cur_cursor);
+    }
+
+    /* Post the event, if desired */
+    posted = 0;
+    if (SDL_ProcessEvents[SDL_MOUSEMOTION] == SDL_ENABLE &&
+        mouse->proximity == SDL_TRUE) {
+        SDL_Event event;
+        event.motion.type = SDL_MOUSEMOTION;
+        event.motion.which = (Uint8) index;
+        event.motion.state = mouse->buttonstate;
+        event.motion.x = mouse->x;
+        event.motion.y = mouse->y;
+        event.motion.z = mouse->z;
+        event.motion.pressure = mouse->pressure;
+        event.motion.pressure_max = mouse->pressure_max;
+        event.motion.pressure_min = mouse->pressure_min;
+        event.motion.rotation = 0;
+        event.motion.tilt = 0;
+        event.motion.cursor = mouse->current_end;
+        event.motion.xrel = xrel;
+        event.motion.yrel = yrel;
+        event.motion.windowID = mouse->focus;
+        posted = (SDL_PushEvent(&event) > 0);
+    }
+    mouse->last_x = mouse->x;
+    mouse->last_y = mouse->y;
+    return posted;
+}
+
+int
+SDL_SendMouseButton(int id, Uint8 state, Uint8 button)
+{
+    int index = SDL_GetMouseIndexId(id);
+    SDL_Mouse *mouse = SDL_GetMouse(index);
+    int posted;
+    Uint8 type;
+
+    if (!mouse) {
+        return 0;
+    }
+
+    /* Figure out which event to perform */
+    switch (state) {
+    case SDL_PRESSED:
+        if (mouse->buttonstate & SDL_BUTTON(button)) {
+            /* Ignore this event, no state change */
+            return 0;
+        }
+        type = SDL_MOUSEBUTTONDOWN;
+        mouse->buttonstate |= SDL_BUTTON(button);
+        break;
+    case SDL_RELEASED:
+        if (!(mouse->buttonstate & SDL_BUTTON(button))) {
+            /* Ignore this event, no state change */
+            return 0;
+        }
+        type = SDL_MOUSEBUTTONUP;
+        mouse->buttonstate &= ~SDL_BUTTON(button);
+        break;
+    default:
+        /* Invalid state -- bail */
+        return 0;
+    }
+
+    /* Post the event, if desired */
+    posted = 0;
+    if (SDL_ProcessEvents[type] == SDL_ENABLE) {
+        SDL_Event event;
+        event.type = type;
+        event.button.which = (Uint8) index;
+        event.button.state = state;
+        event.button.button = button;
+        event.button.x = mouse->x;
+        event.button.y = mouse->y;
+        event.button.windowID = mouse->focus;
+        posted = (SDL_PushEvent(&event) > 0);
+    }
+    return posted;
+}
+
+int
+SDL_SendMouseWheel(int index, int x, int y)
+{
+    SDL_Mouse *mouse = SDL_GetMouse(index);
+    int posted;
+
+    if (!mouse || (!x && !y)) {
+        return 0;
+    }
+
+    /* Post the event, if desired */
+    posted = 0;
+    if (SDL_ProcessEvents[SDL_MOUSEWHEEL] == SDL_ENABLE) {
+        SDL_Event event;
+        event.type = SDL_MOUSEWHEEL;
+        event.wheel.which = (Uint8) index;
+        event.wheel.x = x;
+        event.wheel.y = y;
+        event.wheel.windowID = mouse->focus;
+        posted = (SDL_PushEvent(&event) > 0);
+    }
+    return posted;
+}
+
+void
+SDL_WarpMouseInWindow(SDL_WindowID windowID, int x, int y)
+{
+    SDL_Mouse *mouse = SDL_GetMouse(SDL_current_mouse);
+
+    if (!mouse) {
+        return;
+    }
+
+    if (mouse->WarpMouse) {
+        mouse->WarpMouse(mouse, windowID, x, y);
+    } else {
+        SDL_SetMouseFocus(SDL_current_mouse, windowID);
+        SDL_SendMouseMotion(SDL_current_mouse, 0, x, y, 0);
+    }
+}
+
+SDL_Cursor *
+SDL_CreateCursor(const Uint8 * data, const Uint8 * mask,
+                 int w, int h, int hot_x, int hot_y)
+{
+    SDL_Mouse *mouse = SDL_GetMouse(SDL_current_mouse);
+    SDL_Surface *surface;
+    SDL_Cursor *cursor;
+    int x, y;
+    Uint32 *pixel;
+    Uint8 datab, maskb;
+    const Uint32 black = 0xFF000000;
+    const Uint32 white = 0xFFFFFFFF;
+    const Uint32 transparent = 0x00000000;
+
+    if (!mouse) {
+        SDL_SetError("No mice are initialized");
+        return NULL;
+    }
+
+    if (!mouse->CreateCursor) {
+        SDL_SetError("Current mouse doesn't have cursor support");
+        return NULL;
+    }
+
+    /* Sanity check the hot spot */
+    if ((hot_x < 0) || (hot_y < 0) || (hot_x >= w) || (hot_y >= h)) {
+        SDL_SetError("Cursor hot spot doesn't lie within cursor");
+        return NULL;
+    }
+
+    /* Make sure the width is a multiple of 8 */
+    w = ((w + 7) & ~7);
+
+    /* Create the surface from a bitmap */
+    surface =
+        SDL_CreateRGBSurface(0, w, h, 32, 0x00FF0000, 0x0000FF00, 0x000000FF,
+                             0xFF000000);
+    if (!surface) {
+        return NULL;
+    }
+    for (y = 0; y < h; ++y) {
+        pixel = (Uint32 *) ((Uint8 *) surface->pixels + y * surface->pitch);
+        for (x = 0; x < w; ++x) {
+            if ((x % 8) == 0) {
+                datab = *data++;
+                maskb = *mask++;
+            }
+            if (maskb & 0x80) {
+                *pixel++ = (datab & 0x80) ? black : white;
+            } else {
+                *pixel++ = (datab & 0x80) ? black : transparent;
+            }
+            datab <<= 1;
+            maskb <<= 1;
+        }
+    }
+
+    cursor = mouse->CreateCursor(surface, hot_x, hot_y);
+    if (cursor) {
+        cursor->mouse = mouse;
+        cursor->next = mouse->cursors;
+        mouse->cursors = cursor;
+    }
+
+    SDL_FreeSurface(surface);
+
+    return cursor;
+}
+
+/* SDL_SetCursor(NULL) can be used to force the cursor redraw,
+   if this is desired for any reason.  This is used when setting
+   the video mode and when the SDL window gains the mouse focus.
+ */
+void
+SDL_SetCursor(SDL_Cursor * cursor)
+{
+    SDL_Mouse *mouse = SDL_GetMouse(SDL_current_mouse);
+
+    if (!mouse) {
+        SDL_SetError("No mice are initialized");
+        return;
+    }
+
+    /* Set the new cursor */
+    if (cursor) {
+        /* Make sure the cursor is still valid for this mouse */
+        SDL_Cursor *found;
+        for (found = mouse->cursors; found; found = found->next) {
+            if (found == cursor) {
+                break;
+            }
+        }
+        if (!found) {
+            SDL_SetError("Cursor not associated with the current mouse");
+            return;
+        }
+        mouse->cur_cursor = cursor;
+    } else {
+        cursor = mouse->cur_cursor;
+    }
+
+    if (cursor && mouse->cursor_shown && !mouse->relative_mode) {
+        if (mouse->ShowCursor) {
+            mouse->ShowCursor(cursor);
+        }
+    } else {
+        if (mouse->ShowCursor) {
+            mouse->ShowCursor(NULL);
+        }
+    }
+}
+
+SDL_Cursor *
+SDL_GetCursor(void)
+{
+    SDL_Mouse *mouse = SDL_GetMouse(SDL_current_mouse);
+
+    if (!mouse) {
+        return NULL;
+    }
+    return mouse->cur_cursor;
+}
+
+void
+SDL_FreeCursor(SDL_Cursor * cursor)
+{
+    SDL_Mouse *mouse;
+    SDL_Cursor *curr, *prev;
+
+    if (!cursor) {
+        return;
+    }
+    mouse = cursor->mouse;
+
+    if (cursor == mouse->def_cursor) {
+        return;
+    }
+    if (cursor == mouse->cur_cursor) {
+        SDL_SetCursor(mouse->def_cursor);
+    }
+
+    for (prev = NULL, curr = mouse->cursors; curr;
+         prev = curr, curr = curr->next) {
+        if (curr == cursor) {
+            if (prev) {
+                prev->next = curr->next;
+            } else {
+                mouse->cursors = curr->next;
+            }
+
+            if (mouse->FreeCursor) {
+                mouse->FreeCursor(curr);
+            }
+            return;
+        }
+    }
+}
+
+int
+SDL_ShowCursor(int toggle)
+{
+    SDL_Mouse *mouse = SDL_GetMouse(SDL_current_mouse);
+    SDL_bool shown;
+
+    if (!mouse) {
+        return 0;
+    }
+
+    shown = mouse->cursor_shown;
+    if (toggle >= 0) {
+        if (toggle) {
+            mouse->cursor_shown = SDL_TRUE;
+        } else {
+            mouse->cursor_shown = SDL_FALSE;
+        }
+        if (mouse->cursor_shown != shown) {
+            SDL_SetCursor(NULL);
+        }
+    }
+    return shown;
+}
+
+char *
+SDL_GetMouseName(int index)
+{
+    SDL_Mouse *mouse = SDL_GetMouse(index);
+    if (!mouse) {
+        return NULL;
+    }
+    return mouse->name;
+}
+
+void
+SDL_ChangeEnd(int id, int end)
+{
+    int index = SDL_GetMouseIndexId(id);
+    SDL_Mouse *mouse = SDL_GetMouse(index);
+
+    if (mouse) {
+        mouse->current_end = end;
+    }
+}
+
+int
+SDL_GetCursorsNumber(int index)
+{
+    SDL_Mouse *mouse = SDL_GetMouse(index);
+
+    if (!mouse) {
+        return -1;
+    }
+    return mouse->total_ends;
+}
+
+int
+SDL_GetCurrentCursor(int index)
+{
+    SDL_Mouse *mouse = SDL_GetMouse(index);
+
+    if (!mouse) {
+        return -1;
+    }
+    return mouse->current_end;
+}
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/events/SDL_mouse_c.h

@@ -0,0 +1,131 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifndef _SDL_mouse_c_h
+#define _SDL_mouse_c_h
+
+typedef struct SDL_Mouse SDL_Mouse;
+
+struct SDL_Cursor
+{
+    SDL_Mouse *mouse;
+    SDL_Cursor *next;
+    void *driverdata;
+};
+
+struct SDL_Mouse
+{
+    /* Create a cursor from a surface */
+    SDL_Cursor *(*CreateCursor) (SDL_Surface * surface, int hot_x, int hot_y);
+
+    /* Show the specified cursor, or hide if cursor is NULL */
+    int (*ShowCursor) (SDL_Cursor * cursor);
+
+    /* This is called when a mouse motion event occurs */
+    void (*MoveCursor) (SDL_Cursor * cursor);
+
+    /* Free a window manager cursor */
+    void (*FreeCursor) (SDL_Cursor * cursor);
+
+    /* Warp the mouse to (x,y) */
+    void (*WarpMouse) (SDL_Mouse * mouse, SDL_WindowID windowID, int x,
+                       int y);
+
+    /* Free the mouse when it's time */
+    void (*FreeMouse) (SDL_Mouse * mouse);
+
+    /* data common for tablets */
+    int pressure;
+    int pressure_max;
+    int pressure_min;
+    int tilt;                   /* for future use */
+    int rotation;               /* for future use */
+    int total_ends;
+    int current_end;
+
+    /* Data common to all mice */
+    int id;
+    SDL_WindowID focus;
+    int which;
+    int x;
+    int y;
+    int z;                      /* for future use */
+    int xdelta;
+    int ydelta;
+    int last_x, last_y;         /* the last reported x and y coordinates */
+    char *name;
+    Uint8 buttonstate;
+    SDL_bool relative_mode;
+    SDL_bool proximity;
+    SDL_bool flush_motion;
+
+    SDL_Cursor *cursors;
+    SDL_Cursor *def_cursor;
+    SDL_Cursor *cur_cursor;
+    SDL_bool cursor_shown;
+
+    void *driverdata;
+};
+
+/* Initialize the mouse subsystem */
+extern int SDL_MouseInit(void);
+
+/* Get the mouse at an index */
+extern SDL_Mouse *SDL_GetMouse(int index);
+
+/* Add a mouse, possibly reattaching at a particular index (or -1),
+   returning the index of the mouse, or -1 if there was an error.
+ */
+extern int SDL_AddMouse(const SDL_Mouse * mouse, char *name,
+                        int pressure_max, int pressure_min, int ends);
+
+/* Remove a mouse at an index, clearing the slot for later */
+extern void SDL_DelMouse(int index);
+
+/* Clear the button state of a mouse at an index */
+extern void SDL_ResetMouse(int index);
+
+/* Set the mouse focus window */
+extern void SDL_SetMouseFocus(int id, SDL_WindowID windowID);
+
+/* Send a mouse motion event for a mouse */
+extern int SDL_SendMouseMotion(int id, int relative, int x, int y, int z);
+
+/* Send a mouse button event for a mouse */
+extern int SDL_SendMouseButton(int id, Uint8 state, Uint8 button);
+
+/* Send a mouse wheel event for a mouse */
+extern int SDL_SendMouseWheel(int id, int x, int y);
+
+/* Send a proximity event for a mouse */
+extern int SDL_SendProximity(int id, int x, int y, int type);
+
+/* Shutdown the mouse subsystem */
+extern void SDL_MouseQuit(void);
+
+/* FIXME: Where do these functions go in this header? */
+extern void SDL_ChangeEnd(int id, int end);
+
+#endif /* _SDL_mouse_c_h */
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/events/SDL_quit.c

@@ -0,0 +1,96 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* General quit handling code for SDL */
+
+#ifdef HAVE_SIGNAL_H
+#include <signal.h>
+#endif
+
+#include "SDL_events.h"
+#include "SDL_events_c.h"
+
+
+#ifdef HAVE_SIGNAL_H
+static void
+SDL_HandleSIG(int sig)
+{
+    /* Reset the signal handler */
+    signal(sig, SDL_HandleSIG);
+
+    /* Signal a quit interrupt */
+    SDL_SendQuit();
+}
+#endif /* HAVE_SIGNAL_H */
+
+/* Public functions */
+int
+SDL_QuitInit(void)
+{
+#ifdef HAVE_SIGNAL_H
+    void (*ohandler) (int);
+
+    /* Both SIGINT and SIGTERM are translated into quit interrupts */
+    ohandler = signal(SIGINT, SDL_HandleSIG);
+    if (ohandler != SIG_DFL)
+        signal(SIGINT, ohandler);
+    ohandler = signal(SIGTERM, SDL_HandleSIG);
+    if (ohandler != SIG_DFL)
+        signal(SIGTERM, ohandler);
+#endif /* HAVE_SIGNAL_H */
+
+    /* That's it! */
+    return (0);
+}
+
+void
+SDL_QuitQuit(void)
+{
+#ifdef HAVE_SIGNAL_H
+    void (*ohandler) (int);
+
+    ohandler = signal(SIGINT, SIG_DFL);
+    if (ohandler != SDL_HandleSIG)
+        signal(SIGINT, ohandler);
+    ohandler = signal(SIGTERM, SIG_DFL);
+    if (ohandler != SDL_HandleSIG)
+        signal(SIGTERM, ohandler);
+#endif /* HAVE_SIGNAL_H */
+}
+
+/* This function returns 1 if it's okay to close the application window */
+int
+SDL_SendQuit(void)
+{
+    int posted;
+
+    posted = 0;
+    if (SDL_ProcessEvents[SDL_QUIT] == SDL_ENABLE) {
+        SDL_Event event;
+        event.type = SDL_QUIT;
+        posted = (SDL_PushEvent(&event) > 0);
+    }
+    return (posted);
+}
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/events/SDL_sysevents.h

@@ -0,0 +1,36 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is SDL_free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#include "../video/SDL_sysvideo.h"
+
+/* Useful functions and variables from SDL_sysevents.c */
+
+#ifdef __BEOS__                 /* The Be event loop runs in a separate thread */
+#define MUST_THREAD_EVENTS
+#endif
+
+#ifdef __WIN32__                /* Win32 doesn't allow a separate event thread */
+#define CANT_THREAD_EVENTS
+#endif
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/events/SDL_windowevents.c

@@ -0,0 +1,144 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* Window event handling code for SDL */
+
+#include "SDL_events.h"
+#include "SDL_events_c.h"
+#include "SDL_mouse_c.h"
+#include "../video/SDL_sysvideo.h"
+
+int
+SDL_SendWindowEvent(SDL_WindowID windowID, Uint8 windowevent, int data1,
+                    int data2)
+{
+    int posted;
+    SDL_Window *window;
+
+    window = SDL_GetWindowFromID(windowID);
+    if (!window) {
+        return 0;
+    }
+    switch (windowevent) {
+    case SDL_WINDOWEVENT_SHOWN:
+        if (window->flags & SDL_WINDOW_SHOWN) {
+            return 0;
+        }
+        window->flags |= SDL_WINDOW_SHOWN;
+        SDL_OnWindowShown(window);
+        break;
+    case SDL_WINDOWEVENT_HIDDEN:
+        if (!(window->flags & SDL_WINDOW_SHOWN)) {
+            return 0;
+        }
+        window->flags &= ~SDL_WINDOW_SHOWN;
+        SDL_OnWindowHidden(window);
+        break;
+    case SDL_WINDOWEVENT_MOVED:
+        if (window->flags & SDL_WINDOW_FULLSCREEN) {
+            return 0;
+        }
+        if (data1 == SDL_WINDOWPOS_UNDEFINED) {
+            data1 = window->x;
+        }
+        if (data2 == SDL_WINDOWPOS_UNDEFINED) {
+            data2 = window->y;
+        }
+        if (data1 == window->x && data2 == window->y) {
+            return 0;
+        }
+        window->x = data1;
+        window->y = data2;
+        break;
+    case SDL_WINDOWEVENT_RESIZED:
+        if (window->flags & SDL_WINDOW_FULLSCREEN) {
+            return 0;
+        }
+        if (data1 == window->w && data2 == window->h) {
+            return 0;
+        }
+        window->w = data1;
+        window->h = data2;
+        SDL_OnWindowResized(window);
+        break;
+    case SDL_WINDOWEVENT_MINIMIZED:
+        if (window->flags & SDL_WINDOW_MINIMIZED) {
+            return 0;
+        }
+        window->flags |= SDL_WINDOW_MINIMIZED;
+        break;
+    case SDL_WINDOWEVENT_MAXIMIZED:
+        if (window->flags & SDL_WINDOW_MAXIMIZED) {
+            return 0;
+        }
+        window->flags |= SDL_WINDOW_MAXIMIZED;
+        break;
+    case SDL_WINDOWEVENT_RESTORED:
+        if (!(window->flags & (SDL_WINDOW_MINIMIZED | SDL_WINDOW_MAXIMIZED))) {
+            return 0;
+        }
+        window->flags &= ~(SDL_WINDOW_MINIMIZED | SDL_WINDOW_MAXIMIZED);
+        break;
+    case SDL_WINDOWEVENT_ENTER:
+        if (window->flags & SDL_WINDOW_MOUSE_FOCUS) {
+            return 0;
+        }
+        window->flags |= SDL_WINDOW_MOUSE_FOCUS;
+        break;
+    case SDL_WINDOWEVENT_LEAVE:
+        if (!(window->flags & SDL_WINDOW_MOUSE_FOCUS)) {
+            return 0;
+        }
+        window->flags &= ~SDL_WINDOW_MOUSE_FOCUS;
+        break;
+    case SDL_WINDOWEVENT_FOCUS_GAINED:
+        if (window->flags & SDL_WINDOW_INPUT_FOCUS) {
+            return 0;
+        }
+        window->flags |= SDL_WINDOW_INPUT_FOCUS;
+        SDL_OnWindowFocusGained(window);
+        break;
+    case SDL_WINDOWEVENT_FOCUS_LOST:
+        if (!(window->flags & SDL_WINDOW_INPUT_FOCUS)) {
+            return 0;
+        }
+        window->flags &= ~SDL_WINDOW_INPUT_FOCUS;
+        SDL_OnWindowFocusLost(window);
+        break;
+    }
+
+    /* Post the event, if desired */
+    posted = 0;
+    if (SDL_ProcessEvents[SDL_WINDOWEVENT] == SDL_ENABLE) {
+        SDL_Event event;
+        event.type = SDL_WINDOWEVENT;
+        event.window.event = windowevent;
+        event.window.data1 = data1;
+        event.window.data2 = data2;
+        event.window.windowID = windowID;
+        posted = (SDL_PushEvent(&event) > 0);
+    }
+    return (posted);
+}
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/events/SDL_windowevents_c.h

@@ -0,0 +1,32 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifndef _SDL_windowevents_c_h
+#define _SDL_windowevents_c_h
+
+extern int SDL_SendWindowEvent(SDL_WindowID windowID, Uint8 windowevent,
+                               int data1, int data2);
+
+#endif /* _SDL_windowevents_c_h */
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/events/blank_cursor.h

@@ -0,0 +1,34 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
+ * A default blank 8x8 cursor                                                */
+
+#define BLANK_CWIDTH	8
+#define BLANK_CHEIGHT	8
+#define BLANK_CHOTX	0
+#define BLANK_CHOTY	0
+
+static const unsigned char blank_cdata[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
+static const unsigned char blank_cmask[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/events/default_cursor.h

@@ -0,0 +1,115 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
+ * Default cursor - it happens to be the Mac cursor, but could be anything   */
+
+#define DEFAULT_CWIDTH	16
+#define DEFAULT_CHEIGHT	16
+#define DEFAULT_CHOTX	0
+#define DEFAULT_CHOTY	0
+
+/* Added a real MacOS cursor, at the request of Luc-Olivier de Charri<72>re */
+#define USE_MACOS_CURSOR
+
+#ifdef USE_MACOS_CURSOR
+
+static const unsigned char default_cdata[] = {
+    0x00, 0x00,
+    0x40, 0x00,
+    0x60, 0x00,
+    0x70, 0x00,
+    0x78, 0x00,
+    0x7C, 0x00,
+    0x7E, 0x00,
+    0x7F, 0x00,
+    0x7F, 0x80,
+    0x7C, 0x00,
+    0x6C, 0x00,
+    0x46, 0x00,
+    0x06, 0x00,
+    0x03, 0x00,
+    0x03, 0x00,
+    0x00, 0x00
+};
+
+static const unsigned char default_cmask[] = {
+    0xC0, 0x00,
+    0xE0, 0x00,
+    0xF0, 0x00,
+    0xF8, 0x00,
+    0xFC, 0x00,
+    0xFE, 0x00,
+    0xFF, 0x00,
+    0xFF, 0x80,
+    0xFF, 0xC0,
+    0xFF, 0xE0,
+    0xFE, 0x00,
+    0xEF, 0x00,
+    0xCF, 0x00,
+    0x87, 0x80,
+    0x07, 0x80,
+    0x03, 0x00
+};
+
+#else
+
+static const unsigned char default_cdata[] = {
+    0x00, 0x00,
+    0x40, 0x00,
+    0x60, 0x00,
+    0x70, 0x00,
+    0x78, 0x00,
+    0x7C, 0x00,
+    0x7E, 0x00,
+    0x7F, 0x00,
+    0x7F, 0x80,
+    0x7C, 0x00,
+    0x6C, 0x00,
+    0x46, 0x00,
+    0x06, 0x00,
+    0x03, 0x00,
+    0x03, 0x00,
+    0x00, 0x00
+};
+
+static const unsigned char default_cmask[] = {
+    0x40, 0x00,
+    0xE0, 0x00,
+    0xF0, 0x00,
+    0xF8, 0x00,
+    0xFC, 0x00,
+    0xFE, 0x00,
+    0xFF, 0x00,
+    0xFF, 0x80,
+    0xFF, 0xC0,
+    0xFF, 0x80,
+    0xFE, 0x00,
+    0xEF, 0x00,
+    0x4F, 0x00,
+    0x07, 0x80,
+    0x07, 0x80,
+    0x03, 0x00
+};
+
+#endif /* TRUE_MACINTOSH_CURSOR */
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/events/scancodes_darwin.h

@@ -0,0 +1,160 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+/* Mac virtual key code to SDL scancode mapping table
+   Sources:
+   - Inside Macintosh: Text <http://developer.apple.com/documentation/mac/Text/Text-571.html>
+   - Apple USB keyboard driver source <http://darwinsource.opendarwin.org/10.4.6.ppc/IOHIDFamily-172.8/IOHIDFamily/Cosmo_USB2ADB.c>
+   - experimentation on various ADB and USB ISO keyboards and one ADB ANSI keyboard
+*/
+/* *INDENT-OFF* */
+static const SDL_scancode darwin_scancode_table[] = {
+    /*   0 */   SDL_SCANCODE_A,
+    /*   1 */   SDL_SCANCODE_S,
+    /*   2 */   SDL_SCANCODE_D,
+    /*   3 */   SDL_SCANCODE_F,
+    /*   4 */   SDL_SCANCODE_H,
+    /*   5 */   SDL_SCANCODE_G,
+    /*   6 */   SDL_SCANCODE_Z,
+    /*   7 */   SDL_SCANCODE_X,
+    /*   8 */   SDL_SCANCODE_C,
+    /*   9 */   SDL_SCANCODE_V,
+    /*  10 */   SDL_SCANCODE_NONUSBACKSLASH, /* SDL_SCANCODE_NONUSBACKSLASH on ANSI and JIS keyboards (if this key would exist there), SDL_SCANCODE_GRAVE on ISO. (The USB keyboard driver actually translates these usage codes to different virtual key codes depending on whether the keyboard is ISO/ANSI/JIS. That's why you have to help it identify the keyboard type when you plug in a PC USB keyboard. It's a historical thing - ADB keyboards are wired this way.) */
+    /*  11 */   SDL_SCANCODE_B,
+    /*  12 */   SDL_SCANCODE_Q,
+    /*  13 */   SDL_SCANCODE_W,
+    /*  14 */   SDL_SCANCODE_E,
+    /*  15 */   SDL_SCANCODE_R,
+    /*  16 */   SDL_SCANCODE_Y,
+    /*  17 */   SDL_SCANCODE_T,
+    /*  18 */   SDL_SCANCODE_1,
+    /*  19 */   SDL_SCANCODE_2,
+    /*  20 */   SDL_SCANCODE_3,
+    /*  21 */   SDL_SCANCODE_4,
+    /*  22 */   SDL_SCANCODE_6,
+    /*  23 */   SDL_SCANCODE_5,
+    /*  24 */   SDL_SCANCODE_EQUALS,
+    /*  25 */   SDL_SCANCODE_9,
+    /*  26 */   SDL_SCANCODE_7,
+    /*  27 */   SDL_SCANCODE_MINUS,
+    /*  28 */   SDL_SCANCODE_8,
+    /*  29 */   SDL_SCANCODE_0,
+    /*  30 */   SDL_SCANCODE_RIGHTBRACKET,
+    /*  31 */   SDL_SCANCODE_O,
+    /*  32 */   SDL_SCANCODE_U,
+    /*  33 */   SDL_SCANCODE_LEFTBRACKET,
+    /*  34 */   SDL_SCANCODE_I,
+    /*  35 */   SDL_SCANCODE_P,
+    /*  36 */   SDL_SCANCODE_RETURN,
+    /*  37 */   SDL_SCANCODE_L,
+    /*  38 */   SDL_SCANCODE_J,
+    /*  39 */   SDL_SCANCODE_APOSTROPHE,
+    /*  40 */   SDL_SCANCODE_K,
+    /*  41 */   SDL_SCANCODE_SEMICOLON,
+    /*  42 */   SDL_SCANCODE_BACKSLASH,
+    /*  43 */   SDL_SCANCODE_COMMA,
+    /*  44 */   SDL_SCANCODE_SLASH,
+    /*  45 */   SDL_SCANCODE_N,
+    /*  46 */   SDL_SCANCODE_M,
+    /*  47 */   SDL_SCANCODE_PERIOD,
+    /*  48 */   SDL_SCANCODE_TAB,
+    /*  49 */   SDL_SCANCODE_SPACE,
+    /*  50 */   SDL_SCANCODE_GRAVE, /* SDL_SCANCODE_GRAVE on ANSI and JIS keyboards, SDL_SCANCODE_NONUSBACKSLASH on ISO (see comment about virtual key code 10 above) */
+    /*  51 */   SDL_SCANCODE_BACKSPACE,
+    /*  52 */   SDL_SCANCODE_KP_ENTER, /* keyboard enter on portables */
+    /*  53 */   SDL_SCANCODE_ESCAPE,
+    /*  54 */   SDL_SCANCODE_RGUI,
+    /*  55 */   SDL_SCANCODE_LGUI,
+    /*  56 */   SDL_SCANCODE_LSHIFT,
+    /*  57 */   SDL_SCANCODE_CAPSLOCK,
+    /*  58 */   SDL_SCANCODE_LALT,
+    /*  59 */   SDL_SCANCODE_LCTRL,
+    /*  60 */   SDL_SCANCODE_RSHIFT,
+    /*  61 */   SDL_SCANCODE_RALT,
+    /*  62 */   SDL_SCANCODE_RCTRL,
+    /*  63 */   SDL_SCANCODE_RGUI, /* fn on portables, acts as a hardware-level modifier already, so we don't generate events for it, also XK_Meta_R */
+    /*  64 */   SDL_SCANCODE_UNKNOWN, /* unknown (unused?) */
+    /*  65 */   SDL_SCANCODE_KP_PERIOD,
+    /*  66 */   SDL_SCANCODE_UNKNOWN, /* unknown (unused?) */
+    /*  67 */   SDL_SCANCODE_KP_MULTIPLY,
+    /*  68 */   SDL_SCANCODE_UNKNOWN, /* unknown (unused?) */
+    /*  69 */   SDL_SCANCODE_KP_PLUS,
+    /*  70 */   SDL_SCANCODE_UNKNOWN, /* unknown (unused?) */
+    /*  71 */   SDL_SCANCODE_NUMLOCKCLEAR,
+    /*  72 */   SDL_SCANCODE_VOLUMEUP,
+    /*  73 */   SDL_SCANCODE_VOLUMEDOWN,
+    /*  74 */   SDL_SCANCODE_MUTE,
+    /*  75 */   SDL_SCANCODE_KP_DIVIDE,
+    /*  76 */   SDL_SCANCODE_KP_ENTER, /* keypad enter on external keyboards, fn-return on portables */
+    /*  77 */   SDL_SCANCODE_UNKNOWN, /* unknown (unused?) */
+    /*  78 */   SDL_SCANCODE_KP_MINUS,
+    /*  79 */   SDL_SCANCODE_UNKNOWN, /* unknown (unused?) */
+    /*  80 */   SDL_SCANCODE_UNKNOWN, /* unknown (unused?) */
+    /*  81 */   SDL_SCANCODE_KP_EQUALS,
+    /*  82 */   SDL_SCANCODE_KP_0,
+    /*  83 */   SDL_SCANCODE_KP_1,
+    /*  84 */   SDL_SCANCODE_KP_2,
+    /*  85 */   SDL_SCANCODE_KP_3,
+    /*  86 */   SDL_SCANCODE_KP_4,
+    /*  87 */   SDL_SCANCODE_KP_5,
+    /*  88 */   SDL_SCANCODE_KP_6,
+    /*  89 */   SDL_SCANCODE_KP_7,
+    /*  90 */   SDL_SCANCODE_UNKNOWN, /* unknown (unused?) */
+    /*  91 */   SDL_SCANCODE_KP_8,
+    /*  92 */   SDL_SCANCODE_KP_9,
+    /*  93 */   SDL_SCANCODE_INTERNATIONAL3, /* Cosmo_USB2ADB.c says "Yen (JIS)" */
+    /*  94 */   SDL_SCANCODE_INTERNATIONAL1, /* Cosmo_USB2ADB.c says "Ro (JIS)" */
+    /*  95 */   SDL_SCANCODE_KP_COMMA, /* Cosmo_USB2ADB.c says ", JIS only" */
+    /*  96 */   SDL_SCANCODE_F5,
+    /*  97 */   SDL_SCANCODE_F6,
+    /*  98 */   SDL_SCANCODE_F7,
+    /*  99 */   SDL_SCANCODE_F3,
+    /* 100 */   SDL_SCANCODE_F8,
+    /* 101 */   SDL_SCANCODE_F9,
+    /* 102 */   SDL_SCANCODE_LANG2, /* Cosmo_USB2ADB.c says "Eisu" */
+    /* 103 */   SDL_SCANCODE_F11,
+    /* 104 */   SDL_SCANCODE_LANG1, /* Cosmo_USB2ADB.c says "Kana" */
+    /* 105 */   SDL_SCANCODE_PRINTSCREEN, /* On ADB keyboards, this key is labeled "F13/print screen". Problem: USB has different usage codes for these two functions. On Apple USB keyboards, the key is labeled "F13" and sends the F13 usage code (SDL_SCANCODE_F13). I decided to use SDL_SCANCODE_PRINTSCREEN here nevertheless since SDL applications are more likely to assume the presence of a print screen key than an F13 key. */
+    /* 106 */   SDL_SCANCODE_F16,
+    /* 107 */   SDL_SCANCODE_SCROLLLOCK, /* F14/scroll lock, see comment about F13/print screen above */
+    /* 108 */   SDL_SCANCODE_UNKNOWN, /* unknown (unused?) */
+    /* 109 */   SDL_SCANCODE_F10,
+    /* 110 */   SDL_SCANCODE_APPLICATION, /* windows contextual menu key, fn-enter on portables */
+    /* 111 */   SDL_SCANCODE_F12,
+    /* 112 */   SDL_SCANCODE_UNKNOWN, /* unknown (unused?) */
+    /* 113 */   SDL_SCANCODE_PAUSE, /* F15/pause, see comment about F13/print screen above */
+    /* 114 */   SDL_SCANCODE_INSERT, /* the key is actually labeled "help" on Apple keyboards, and works as such in Mac OS, but it sends the "insert" usage code even on Apple USB keyboards */
+    /* 115 */   SDL_SCANCODE_HOME,
+    /* 116 */   SDL_SCANCODE_PAGEUP,
+    /* 117 */   SDL_SCANCODE_DELETE,
+    /* 118 */   SDL_SCANCODE_F4,
+    /* 119 */   SDL_SCANCODE_END,
+    /* 120 */   SDL_SCANCODE_F2,
+    /* 121 */   SDL_SCANCODE_PAGEDOWN,
+    /* 122 */   SDL_SCANCODE_F1,
+    /* 123 */   SDL_SCANCODE_LEFT,
+    /* 124 */   SDL_SCANCODE_RIGHT,
+    /* 125 */   SDL_SCANCODE_DOWN,
+    /* 126 */   SDL_SCANCODE_UP,
+    /* 127 */   SDL_SCANCODE_POWER
+};
+/* *INDENT-ON* */

Externals/SDL/src/events/scancodes_linux.h

@@ -0,0 +1,264 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "../../include/SDL_scancode.h"
+
+/* Linux virtual key code to SDLKey mapping table
+   Sources:
+   - Linux kernel source input.h
+*/
+/* *INDENT-OFF* */
+static SDL_scancode const linux_scancode_table[] = {
+    /*  0 */    SDL_SCANCODE_UNKNOWN,
+    /*  1 */    SDL_SCANCODE_ESCAPE,
+    /*  2 */    SDL_SCANCODE_1,
+    /*  3 */    SDL_SCANCODE_2,
+    /*  4 */    SDL_SCANCODE_3,
+    /*  5 */    SDL_SCANCODE_4,
+    /*  6 */    SDL_SCANCODE_5,
+    /*  7 */    SDL_SCANCODE_6,
+    /*  8 */    SDL_SCANCODE_7,
+    /*  9 */    SDL_SCANCODE_8,
+    /*  10 */    SDL_SCANCODE_9,
+    /*  11 */    SDL_SCANCODE_0,
+    /*  12 */    SDL_SCANCODE_MINUS,
+    /*  13 */    SDL_SCANCODE_EQUALS,
+    /*  14 */    SDL_SCANCODE_BACKSPACE,
+    /*  15 */    SDL_SCANCODE_TAB,
+    /*  16 */    SDL_SCANCODE_Q,
+    /*  17 */    SDL_SCANCODE_W,
+    /*  18 */    SDL_SCANCODE_E,
+    /*  19 */    SDL_SCANCODE_R,
+    /*  20 */    SDL_SCANCODE_T,
+    /*  21 */    SDL_SCANCODE_Y,
+    /*  22 */    SDL_SCANCODE_U,
+    /*  23 */    SDL_SCANCODE_I,
+    /*  24 */    SDL_SCANCODE_O,
+    /*  25 */    SDL_SCANCODE_P,
+    /*  26 */    SDL_SCANCODE_LEFTBRACKET,
+    /*  27 */    SDL_SCANCODE_RIGHTBRACKET,
+    /*  28 */    SDL_SCANCODE_RETURN,
+    /*  29 */    SDL_SCANCODE_LCTRL,
+    /*  30 */    SDL_SCANCODE_A,
+    /*  31 */    SDL_SCANCODE_S,
+    /*  32 */    SDL_SCANCODE_D,
+    /*  33 */    SDL_SCANCODE_F,
+    /*  34 */    SDL_SCANCODE_G,
+    /*  35 */    SDL_SCANCODE_H,
+    /*  36 */    SDL_SCANCODE_J,
+    /*  37 */    SDL_SCANCODE_K,
+    /*  38 */    SDL_SCANCODE_L,
+    /*  39 */    SDL_SCANCODE_SEMICOLON,
+    /*  40 */    SDL_SCANCODE_APOSTROPHE,
+    /*  41 */    SDL_SCANCODE_GRAVE,
+    /*  42 */    SDL_SCANCODE_LSHIFT,
+    /*  43 */    SDL_SCANCODE_BACKSLASH,
+    /*  44 */    SDL_SCANCODE_Z,
+    /*  45 */    SDL_SCANCODE_X,
+    /*  46 */    SDL_SCANCODE_C,
+    /*  47 */    SDL_SCANCODE_V,
+    /*  48 */    SDL_SCANCODE_B,
+    /*  49 */    SDL_SCANCODE_N,
+    /*  50 */    SDL_SCANCODE_M,
+    /*  51 */    SDL_SCANCODE_COMMA,
+    /*  52 */    SDL_SCANCODE_PERIOD,
+    /*  53 */    SDL_SCANCODE_SLASH,
+    /*  54 */    SDL_SCANCODE_RSHIFT,
+    /*  55 */    SDL_SCANCODE_KP_MULTIPLY,
+    /*  56 */    SDL_SCANCODE_LALT,
+    /*  57 */    SDL_SCANCODE_SPACE,
+    /*  58 */    SDL_SCANCODE_CAPSLOCK,
+    /*  59 */    SDL_SCANCODE_F1,
+    /*  60 */    SDL_SCANCODE_F2,
+    /*  61 */    SDL_SCANCODE_F3,
+    /*  62 */    SDL_SCANCODE_F4,
+    /*  63 */    SDL_SCANCODE_F5,
+    /*  64 */    SDL_SCANCODE_F6,
+    /*  65 */    SDL_SCANCODE_F7,
+    /*  66 */    SDL_SCANCODE_F8,
+    /*  67 */    SDL_SCANCODE_F9,
+    /*  68 */    SDL_SCANCODE_F10,
+    /*  69 */    SDL_SCANCODE_NUMLOCKCLEAR,
+    /*  70 */    SDL_SCANCODE_SCROLLLOCK,
+    /*  71 */    SDL_SCANCODE_KP_7,
+    /*  72 */    SDL_SCANCODE_KP_8,
+    /*  73 */    SDL_SCANCODE_KP_9,
+    /*  74 */    SDL_SCANCODE_KP_MINUS,
+    /*  75 */    SDL_SCANCODE_KP_4,
+    /*  76 */    SDL_SCANCODE_KP_5,
+    /*  77 */    SDL_SCANCODE_KP_6,
+    /*  78 */    SDL_SCANCODE_KP_PLUS,
+    /*  79 */    SDL_SCANCODE_KP_1,
+    /*  80 */    SDL_SCANCODE_KP_2,
+    /*  81 */    SDL_SCANCODE_KP_3,
+    /*  82 */    SDL_SCANCODE_KP_0,
+    /*  83 */    SDL_SCANCODE_KP_PERIOD,
+    0,
+    /*  85 */    SDL_SCANCODE_UNKNOWN, /* KEY_ZENKAKUHANKAKU */
+    /*  86 */    SDL_SCANCODE_NONUSBACKSLASH, /* KEY_102ND */
+    /*  87 */    SDL_SCANCODE_F11,
+    /*  88 */    SDL_SCANCODE_F12,
+    /*  89 */    SDL_SCANCODE_INTERNATIONAL1, /* KEY_RO */
+    /*  90 */    SDL_SCANCODE_LANG3, /* KEY_KATAKANA */
+    /*  91 */    SDL_SCANCODE_LANG4, /* KEY_HIRAGANA */
+    /*  92 */    SDL_SCANCODE_INTERNATIONAL4, /* KEY_HENKAN */
+    /*  93 */    SDL_SCANCODE_INTERNATIONAL2, /* KEY_KATAKANAHIRAGANA */
+    /*  94 */    SDL_SCANCODE_INTERNATIONAL5, /* KEY_MUHENKAN */
+    /*  95 */    SDL_SCANCODE_INTERNATIONAL5, /* KEY_KPJPCOMMA */
+    /*  96 */    SDL_SCANCODE_KP_ENTER,
+    /*  97 */    SDL_SCANCODE_RCTRL,
+    /*  98 */    SDL_SCANCODE_KP_DIVIDE,
+    /*  99 */    SDL_SCANCODE_SYSREQ,
+    /*  100 */    SDL_SCANCODE_RALT,
+    /*  101 */    SDL_SCANCODE_UNKNOWN, /* KEY_LINEFEED */
+    /*  102 */    SDL_SCANCODE_HOME,
+    /*  103 */    SDL_SCANCODE_UP,
+    /*  104 */    SDL_SCANCODE_PAGEUP,
+    /*  105 */    SDL_SCANCODE_LEFT,
+    /*  106 */    SDL_SCANCODE_RIGHT,
+    /*  107 */    SDL_SCANCODE_END,
+    /*  108 */    SDL_SCANCODE_DOWN,
+    /*  109 */    SDL_SCANCODE_PAGEDOWN,
+    /*  110 */    SDL_SCANCODE_INSERT,
+    /*  111 */    SDL_SCANCODE_DELETE,
+    /*  112 */    SDL_SCANCODE_UNKNOWN, /* KEY_MACRO */
+    /*  113 */    SDL_SCANCODE_MUTE,
+    /*  114 */    SDL_SCANCODE_VOLUMEDOWN,
+    /*  115 */    SDL_SCANCODE_VOLUMEUP,
+    /*  116 */    SDL_SCANCODE_POWER,
+    /*  117 */    SDL_SCANCODE_KP_EQUALS,
+    /*  118 */    SDL_SCANCODE_KP_PLUSMINUS,
+    /*  119 */    SDL_SCANCODE_PAUSE,
+    0,
+    /*  121 */    SDL_SCANCODE_KP_COMMA,
+    /*  122 */    SDL_SCANCODE_LANG1, /* KEY_HANGUEL */
+    /*  123 */    SDL_SCANCODE_LANG2, /* KEY_HANJA */
+    /*  124 */    SDL_SCANCODE_INTERNATIONAL3, /* KEY_YEN */
+    /*  125 */    SDL_SCANCODE_LGUI,
+    /*  126 */    SDL_SCANCODE_RGUI,
+    /*  127 */    SDL_SCANCODE_UNKNOWN, /* KEY_COMPOSE */
+    /*  128 */    SDL_SCANCODE_STOP,
+    /*  129 */    SDL_SCANCODE_AGAIN,
+    /*  130 */    SDL_SCANCODE_UNKNOWN, /* KEY_PROPS */
+    /*  131 */    SDL_SCANCODE_UNDO,
+    /*  132 */    SDL_SCANCODE_UNKNOWN, /* KEY_FRONT */
+    /*  133 */    SDL_SCANCODE_COPY,
+    /*  134 */    SDL_SCANCODE_UNKNOWN, /* KEY_OPEN */
+    /*  135 */    SDL_SCANCODE_PASTE,
+    /*  136 */    SDL_SCANCODE_FIND,
+    /*  137 */    SDL_SCANCODE_CUT,
+    /*  138 */    SDL_SCANCODE_HELP,
+    /*  139 */    SDL_SCANCODE_MENU,
+    /*  140 */    SDL_SCANCODE_CALCULATOR,
+    /*  141 */    SDL_SCANCODE_UNKNOWN, /* KEY_SETUP */
+    /*  142 */    SDL_SCANCODE_SLEEP,
+    /*  143 */    SDL_SCANCODE_UNKNOWN, /* KEY_WAKEUP */
+    /*  144 */    SDL_SCANCODE_UNKNOWN, /* KEY_FILE */
+    /*  145 */    SDL_SCANCODE_UNKNOWN, /* KEY_SENDFILE */
+    /*  146 */    SDL_SCANCODE_UNKNOWN, /* KEY_DELETEFILE */
+    /*  147 */    SDL_SCANCODE_UNKNOWN, /* KEY_XFER */
+    /*  148 */    SDL_SCANCODE_UNKNOWN, /* KEY_PROG1 */
+    /*  149 */    SDL_SCANCODE_UNKNOWN, /* KEY_PROG2 */
+    /*  150 */    SDL_SCANCODE_UNKNOWN, /* KEY_WWW */
+    /*  151 */    SDL_SCANCODE_UNKNOWN, /* KEY_MSDOS */
+    /*  152 */    SDL_SCANCODE_UNKNOWN, /* KEY_COFFEE */
+    /*  153 */    SDL_SCANCODE_UNKNOWN, /* KEY_DIRECTION */
+    /*  154 */    SDL_SCANCODE_UNKNOWN, /* KEY_CYCLEWINDOWS */
+    /*  155 */    SDL_SCANCODE_MAIL,
+    /*  156 */    SDL_SCANCODE_AC_BOOKMARKS,
+    /*  157 */    SDL_SCANCODE_COMPUTER,
+    /*  158 */    SDL_SCANCODE_AC_BACK,
+    /*  159 */    SDL_SCANCODE_AC_FORWARD,
+    /*  160 */    SDL_SCANCODE_UNKNOWN, /* KEY_CLOSECD */
+    /*  161 */    SDL_SCANCODE_EJECT, /* KEY_EJECTCD */
+    /*  162 */    SDL_SCANCODE_UNKNOWN, /* KEY_EJECTCLOSECD */
+    /*  163 */    SDL_SCANCODE_AUDIONEXT, /* KEY_NEXTSONG */
+    /*  164 */    SDL_SCANCODE_AUDIOPLAY, /* KEY_PLAYPAUSE */
+    /*  165 */    SDL_SCANCODE_AUDIOPREV, /* KEY_PREVIOUSSONG */
+    /*  166 */    SDL_SCANCODE_UNKNOWN, /* KEY_STOPCD */
+    /*  167 */    SDL_SCANCODE_UNKNOWN, /* KEY_RECORD */
+    /*  168 */    SDL_SCANCODE_UNKNOWN, /* KEY_REWIND */
+    /*  169 */    SDL_SCANCODE_UNKNOWN, /* KEY_PHONE */
+    /*  170 */    SDL_SCANCODE_UNKNOWN, /* KEY_ISO */
+    /*  171 */    SDL_SCANCODE_UNKNOWN, /* KEY_CONFIG */
+    /*  172 */    SDL_SCANCODE_AC_HOME,
+    /*  173 */    SDL_SCANCODE_AC_REFRESH,
+    /*  174 */    SDL_SCANCODE_UNKNOWN, /* KEY_EXIT */
+    /*  175 */    SDL_SCANCODE_UNKNOWN, /* KEY_MOVE */
+    /*  176 */    SDL_SCANCODE_UNKNOWN, /* KEY_EDIT */
+    /*  177 */    SDL_SCANCODE_UNKNOWN, /* KEY_SCROLLUP */
+    /*  178 */    SDL_SCANCODE_UNKNOWN, /* KEY_SCROLLDOWN */
+    /*  179 */    SDL_SCANCODE_KP_LEFTPAREN,
+    /*  180 */    SDL_SCANCODE_KP_RIGHTPAREN,
+    /*  181 */    SDL_SCANCODE_UNKNOWN, /* KEY_NEW */
+    /*  182 */    SDL_SCANCODE_UNKNOWN, /* KEY_REDO */
+    /*  183 */    SDL_SCANCODE_F13,
+    /*  184 */    SDL_SCANCODE_F14,
+    /*  185 */    SDL_SCANCODE_F15,
+    /*  186 */    SDL_SCANCODE_F16,
+    /*  187 */    SDL_SCANCODE_F17,
+    /*  188 */    SDL_SCANCODE_F18,
+    /*  189 */    SDL_SCANCODE_F19,
+    /*  190 */    SDL_SCANCODE_F20,
+    /*  191 */    SDL_SCANCODE_F21,
+    /*  192 */    SDL_SCANCODE_F22,
+    /*  193 */    SDL_SCANCODE_F23,
+    /*  194 */    SDL_SCANCODE_F24,
+    0, 0, 0, 0,
+    /*  200 */    SDL_SCANCODE_UNKNOWN, /* KEY_PLAYCD */
+    /*  201 */    SDL_SCANCODE_UNKNOWN, /* KEY_PAUSECD */
+    /*  202 */    SDL_SCANCODE_UNKNOWN, /* KEY_PROG3 */
+    /*  203 */    SDL_SCANCODE_UNKNOWN, /* KEY_PROG4 */
+    0,
+    /*  205 */    SDL_SCANCODE_UNKNOWN, /* KEY_SUSPEND */
+    /*  206 */    SDL_SCANCODE_UNKNOWN, /* KEY_CLOSE */
+    /*  207 */    SDL_SCANCODE_UNKNOWN, /* KEY_PLAY */
+    /*  208 */    SDL_SCANCODE_UNKNOWN, /* KEY_FASTFORWARD */
+    /*  209 */    SDL_SCANCODE_UNKNOWN, /* KEY_BASSBOOST */
+    /*  210 */    SDL_SCANCODE_UNKNOWN, /* KEY_PRINT */
+    /*  211 */    SDL_SCANCODE_UNKNOWN, /* KEY_HP */
+    /*  212 */    SDL_SCANCODE_UNKNOWN, /* KEY_CAMERA */
+    /*  213 */    SDL_SCANCODE_UNKNOWN, /* KEY_SOUND */
+    /*  214 */    SDL_SCANCODE_UNKNOWN, /* KEY_QUESTION */
+    /*  215 */    SDL_SCANCODE_UNKNOWN, /* KEY_EMAIL */
+    /*  216 */    SDL_SCANCODE_UNKNOWN, /* KEY_CHAT */
+    /*  217 */    SDL_SCANCODE_AC_SEARCH,
+    /*  218 */    SDL_SCANCODE_UNKNOWN, /* KEY_CONNECT */
+    /*  219 */    SDL_SCANCODE_UNKNOWN, /* KEY_FINANCE */
+    /*  220 */    SDL_SCANCODE_UNKNOWN, /* KEY_SPORT */
+    /*  221 */    SDL_SCANCODE_UNKNOWN, /* KEY_SHOP */
+    /*  222 */    SDL_SCANCODE_ALTERASE,
+    /*  223 */    SDL_SCANCODE_CANCEL,
+    /*  224 */    SDL_SCANCODE_BRIGHTNESSDOWN,
+    /*  225 */    SDL_SCANCODE_BRIGHTNESSUP,
+    /*  226 */    SDL_SCANCODE_UNKNOWN, /* KEY_MEDIA */
+    /*  227 */    SDL_SCANCODE_DISPLAYSWITCH, /* KEY_SWITCHVIDEOMODE */
+    /*  228 */    SDL_SCANCODE_KBDILLUMTOGGLE,
+    /*  229 */    SDL_SCANCODE_KBDILLUMDOWN,
+    /*  230 */    SDL_SCANCODE_KBDILLUMUP,
+    /*  231 */    SDL_SCANCODE_UNKNOWN, /* KEY_SEND */
+    /*  232 */    SDL_SCANCODE_UNKNOWN, /* KEY_REPLY */
+    /*  233 */    SDL_SCANCODE_UNKNOWN, /* KEY_FORWARDMAIL */
+    /*  234 */    SDL_SCANCODE_UNKNOWN, /* KEY_SAVE */
+    /*  235 */    SDL_SCANCODE_UNKNOWN, /* KEY_DOCUMENTS */
+    /*  236 */    SDL_SCANCODE_UNKNOWN, /* KEY_BATTERY */
+};
+/* *INDENT-ON* */

Externals/SDL/src/events/scancodes_win32.h

@@ -0,0 +1,287 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "../../include/SDL_scancode.h"
+
+/* Win32 virtual key code to SDL scancode mapping table
+   Sources:
+   - msdn.microsoft.com
+*/
+/* *INDENT-OFF* */
+static const SDL_scancode win32_scancode_table[] = {
+    /*  0, 0x00 */      SDL_SCANCODE_UNKNOWN,
+    /*  1, 0x01 */      SDL_SCANCODE_UNKNOWN,
+    /*  2, 0x02 */      SDL_SCANCODE_UNKNOWN,
+    /*  3, 0x03 */      SDL_SCANCODE_UNKNOWN,
+    /*  4, 0x04 */      SDL_SCANCODE_UNKNOWN,
+    /*  5, 0x05 */      SDL_SCANCODE_UNKNOWN,
+    /*  6, 0x06 */      SDL_SCANCODE_UNKNOWN,
+    /*  7, 0x07 */      SDL_SCANCODE_UNKNOWN,
+    /*  8, 0x08 */      SDL_SCANCODE_BACKSPACE,
+    /*  9, 0x09 */      SDL_SCANCODE_TAB,
+    /*  10, 0x0a */     SDL_SCANCODE_KP_ENTER, /* Not a VKEY, SDL specific */
+    /*  11, 0x0b */     SDL_SCANCODE_UNKNOWN,
+    /*  12, 0x0c */     SDL_SCANCODE_CLEAR,
+    /*  13, 0x0d */     SDL_SCANCODE_RETURN,
+    /*  14, 0x0e */     SDL_SCANCODE_UNKNOWN,
+    /*  15, 0x0f */     SDL_SCANCODE_UNKNOWN,
+    /*  16, 0x10 */     SDL_SCANCODE_UNKNOWN,
+    /*  17, 0x11 */     SDL_SCANCODE_UNKNOWN,
+    /*  18, 0x12 */     SDL_SCANCODE_APPLICATION,
+    /*  19, 0x13 */     SDL_SCANCODE_PAUSE,
+    /*  20, 0x14 */     SDL_SCANCODE_CAPSLOCK,
+    /*  21, 0x15 */     SDL_SCANCODE_UNKNOWN,
+    /*  22, 0x16 */     SDL_SCANCODE_UNKNOWN,
+    /*  23, 0x17 */     SDL_SCANCODE_UNKNOWN,
+    /*  24, 0x18 */     SDL_SCANCODE_UNKNOWN,
+    /*  25, 0x19 */     SDL_SCANCODE_UNKNOWN,
+    /*  26, 0x1a */     SDL_SCANCODE_UNKNOWN,
+    /*  27, 0x1b */     SDL_SCANCODE_ESCAPE,
+    /*  28, 0x1c */     SDL_SCANCODE_UNKNOWN,
+    /*  29, 0x1d */     SDL_SCANCODE_UNKNOWN,
+    /*  30, 0x1e */     SDL_SCANCODE_UNKNOWN,
+    /*  31, 0x1f */     SDL_SCANCODE_MODE,
+    /*  32, 0x20 */     SDL_SCANCODE_SPACE,
+    /*  33, 0x21 */     SDL_SCANCODE_PAGEUP,
+    /*  34, 0x22 */     SDL_SCANCODE_PAGEDOWN,
+    /*  35, 0x23 */     SDL_SCANCODE_END,
+    /*  36, 0x24 */     SDL_SCANCODE_HOME,
+    /*  37, 0x25 */     SDL_SCANCODE_LEFT,
+    /*  38, 0x26 */     SDL_SCANCODE_UP,
+    /*  39, 0x27 */     SDL_SCANCODE_RIGHT,
+    /*  40, 0x28 */     SDL_SCANCODE_DOWN,
+    /*  41, 0x29 */     SDL_SCANCODE_SELECT,
+    /*  42, 0x2a */     SDL_SCANCODE_UNKNOWN, /* VK_PRINT */
+    /*  43, 0x2b */     SDL_SCANCODE_EXECUTE,
+    /*  44, 0x2c */     SDL_SCANCODE_PRINTSCREEN,
+    /*  45, 0x2d */     SDL_SCANCODE_INSERT,
+    /*  46, 0x2e */     SDL_SCANCODE_DELETE,
+    /*  47, 0x2f */     SDL_SCANCODE_HELP,
+    /*  48, 0x30 */     SDL_SCANCODE_0,
+    /*  49, 0x31 */     SDL_SCANCODE_1,
+    /*  50, 0x32 */     SDL_SCANCODE_2,
+    /*  51, 0x33 */     SDL_SCANCODE_3,
+    /*  52, 0x34 */     SDL_SCANCODE_4,
+    /*  53, 0x35 */     SDL_SCANCODE_5,
+    /*  54, 0x36 */     SDL_SCANCODE_6,
+    /*  55, 0x37 */     SDL_SCANCODE_7,
+    /*  56, 0x38 */     SDL_SCANCODE_8,
+    /*  57, 0x39 */     SDL_SCANCODE_9,
+    /*  58, 0x3a */     SDL_SCANCODE_UNKNOWN,
+    /*  59, 0x3b */     SDL_SCANCODE_UNKNOWN,
+    /*  60, 0x3c */     SDL_SCANCODE_UNKNOWN,
+    /*  61, 0x3d */     SDL_SCANCODE_UNKNOWN,
+    /*  62, 0x3e */     SDL_SCANCODE_UNKNOWN,
+    /*  63, 0x3f */     SDL_SCANCODE_UNKNOWN,
+    /*  64, 0x40 */     SDL_SCANCODE_UNKNOWN,
+    /*  65, 0x41 */     SDL_SCANCODE_A,
+    /*  66, 0x42 */     SDL_SCANCODE_B,
+    /*  67, 0x43 */     SDL_SCANCODE_C,
+    /*  68, 0x44 */     SDL_SCANCODE_D,
+    /*  69, 0x45 */     SDL_SCANCODE_E,
+    /*  70, 0x46 */     SDL_SCANCODE_F,
+    /*  71, 0x47 */     SDL_SCANCODE_G,
+    /*  72, 0x48 */     SDL_SCANCODE_H,
+    /*  73, 0x49 */     SDL_SCANCODE_I,
+    /*  74, 0x4a */     SDL_SCANCODE_J,
+    /*  75, 0x4b */     SDL_SCANCODE_K,
+    /*  76, 0x4c */     SDL_SCANCODE_L,
+    /*  77, 0x4d */     SDL_SCANCODE_M,
+    /*  78, 0x4e */     SDL_SCANCODE_N,
+    /*  79, 0x4f */     SDL_SCANCODE_O,
+    /*  80, 0x50 */     SDL_SCANCODE_P,
+    /*  81, 0x51 */     SDL_SCANCODE_Q,
+    /*  82, 0x52 */     SDL_SCANCODE_R,
+    /*  83, 0x53 */     SDL_SCANCODE_S,
+    /*  84, 0x54 */     SDL_SCANCODE_T,
+    /*  85, 0x55 */     SDL_SCANCODE_U,
+    /*  86, 0x56 */     SDL_SCANCODE_V,
+    /*  87, 0x57 */     SDL_SCANCODE_W,
+    /*  88, 0x58 */     SDL_SCANCODE_X,
+    /*  89, 0x59 */     SDL_SCANCODE_Y,
+    /*  90, 0x5a */     SDL_SCANCODE_Z,
+    /*  91, 0x5b */     SDL_SCANCODE_LGUI,
+    /*  92, 0x5c */     SDL_SCANCODE_RGUI,
+    /*  93, 0x5d */     SDL_SCANCODE_APPLICATION,
+    /*  94, 0x5e */     SDL_SCANCODE_UNKNOWN,
+    /*  95, 0x5f */     SDL_SCANCODE_UNKNOWN,
+    /*  96, 0x60 */     SDL_SCANCODE_KP_0,
+    /*  97, 0x61 */     SDL_SCANCODE_KP_1,
+    /*  98, 0x62 */     SDL_SCANCODE_KP_2,
+    /*  99, 0x63 */     SDL_SCANCODE_KP_3,
+    /*  100, 0x64 */    SDL_SCANCODE_KP_4,
+    /*  101, 0x65 */    SDL_SCANCODE_KP_5,
+    /*  102, 0x66 */    SDL_SCANCODE_KP_6,
+    /*  103, 0x67 */    SDL_SCANCODE_KP_7,
+    /*  104, 0x68 */    SDL_SCANCODE_KP_8,
+    /*  105, 0x69 */    SDL_SCANCODE_KP_9,
+    /*  106, 0x6a */    SDL_SCANCODE_KP_MULTIPLY,
+    /*  107, 0x6b */    SDL_SCANCODE_KP_PLUS,
+    /*  108, 0x6c */    SDL_SCANCODE_SEPARATOR,
+    /*  109, 0x6d */    SDL_SCANCODE_KP_MINUS,
+    /*  110, 0x6e */    SDL_SCANCODE_KP_DECIMAL,
+    /*  111, 0x6f */    SDL_SCANCODE_KP_DIVIDE,
+    /*  112, 0x70 */    SDL_SCANCODE_F1,
+    /*  113, 0x71 */    SDL_SCANCODE_F2,
+    /*  114, 0x72 */    SDL_SCANCODE_F3,
+    /*  115, 0x73 */    SDL_SCANCODE_F4,
+    /*  116, 0x74 */    SDL_SCANCODE_F5,
+    /*  117, 0x75 */    SDL_SCANCODE_F6,
+    /*  118, 0x76 */    SDL_SCANCODE_F7,
+    /*  119, 0x77 */    SDL_SCANCODE_F8,
+    /*  120, 0x78 */    SDL_SCANCODE_F9,
+    /*  121, 0x79 */    SDL_SCANCODE_F10,
+    /*  122, 0x7a */    SDL_SCANCODE_F11,
+    /*  123, 0x7b */    SDL_SCANCODE_F12,
+    /*  124, 0x7c */    SDL_SCANCODE_F13,
+    /*  125, 0x7d */    SDL_SCANCODE_F14,
+    /*  126, 0x7e */    SDL_SCANCODE_F15,
+    /*  127, 0x7f */    SDL_SCANCODE_F16,
+    /*  128, 0x80 */    SDL_SCANCODE_F17, /* or SDL_SCANCODE_AUDIONEXT */
+    /*  129, 0x81 */    SDL_SCANCODE_F18, /* or SDL_SCANCODE_AUDIOPREV */
+    /*  130, 0x82 */    SDL_SCANCODE_F19, /* or SDL_SCANCODE_AUDIOSTOP */
+    /*  131, 0x83 */    SDL_SCANCODE_F20, /* or SDL_SCANCODE_AUDIOPLAY */
+    /*  132, 0x84 */    SDL_SCANCODE_F21, /* or SDL_SCANCODE_MAIL */
+    /*  133, 0x85 */    SDL_SCANCODE_F22, /* or SDL_SCANCODE_MEDIASELECT */
+    /*  134, 0x86 */    SDL_SCANCODE_F23, /* or SDL_SCANCODE_WWW */
+    /*  135, 0x87 */    SDL_SCANCODE_F24, /* or SDL_SCANCODE_CALCULATOR */
+    /*  136, 0x88 */    SDL_SCANCODE_UNKNOWN,
+    /*  137, 0x89 */    SDL_SCANCODE_UNKNOWN,
+    /*  138, 0x8a */    SDL_SCANCODE_UNKNOWN,
+    /*  139, 0x8b */    SDL_SCANCODE_UNKNOWN,
+    /*  140, 0x8c */    SDL_SCANCODE_UNKNOWN,
+    /*  141, 0x8d */    SDL_SCANCODE_UNKNOWN,
+    /*  142, 0x8e */    SDL_SCANCODE_UNKNOWN,
+    /*  143, 0x8f */    SDL_SCANCODE_UNKNOWN,
+    /*  144, 0x90 */    SDL_SCANCODE_NUMLOCKCLEAR,
+    /*  145, 0x91 */    SDL_SCANCODE_SCROLLLOCK,
+    /*  146, 0x92 */    SDL_SCANCODE_KP_EQUALS,
+    /*  147, 0x93 */    SDL_SCANCODE_UNKNOWN,
+    /*  148, 0x94 */    SDL_SCANCODE_UNKNOWN,
+    /*  149, 0x95 */    SDL_SCANCODE_UNKNOWN,
+    /*  150, 0x96 */    SDL_SCANCODE_UNKNOWN,
+    /*  151, 0x97 */    SDL_SCANCODE_UNKNOWN,
+    /*  152, 0x98 */    SDL_SCANCODE_UNKNOWN,
+    /*  153, 0x99 */    SDL_SCANCODE_UNKNOWN,
+    /*  154, 0x9a */    SDL_SCANCODE_UNKNOWN,
+    /*  155, 0x9b */    SDL_SCANCODE_UNKNOWN,
+    /*  156, 0x9c */    SDL_SCANCODE_UNKNOWN,
+    /*  157, 0x9d */    SDL_SCANCODE_UNKNOWN,
+    /*  158, 0x9e */    SDL_SCANCODE_UNKNOWN,
+    /*  159, 0x9f */    SDL_SCANCODE_UNKNOWN,
+    /*  160, 0xa0 */    SDL_SCANCODE_LSHIFT,
+    /*  161, 0xa1 */    SDL_SCANCODE_RSHIFT,
+    /*  162, 0xa2 */    SDL_SCANCODE_LCTRL,
+    /*  163, 0xa3 */    SDL_SCANCODE_RCTRL,
+    /*  164, 0xa4 */    SDL_SCANCODE_LALT,
+    /*  165, 0xa5 */    SDL_SCANCODE_RALT,
+    /*  166, 0xa6 */    SDL_SCANCODE_AC_BACK,
+    /*  167, 0xa7 */    SDL_SCANCODE_AC_FORWARD,
+    /*  168, 0xa8 */    SDL_SCANCODE_AC_REFRESH,
+    /*  169, 0xa9 */    SDL_SCANCODE_AC_STOP,
+    /*  170, 0xaa */    SDL_SCANCODE_AC_SEARCH,
+    /*  171, 0xab */    SDL_SCANCODE_AC_BOOKMARKS,
+    /*  172, 0xac */    SDL_SCANCODE_AC_HOME,
+    /*  173, 0xad */    SDL_SCANCODE_AUDIOMUTE,
+    /*  174, 0xae */    SDL_SCANCODE_VOLUMEDOWN,
+    /*  175, 0xaf */    SDL_SCANCODE_VOLUMEUP,
+    /*  176, 0xb0 */    SDL_SCANCODE_UNKNOWN,
+    /*  177, 0xb1 */    SDL_SCANCODE_KP_000,
+    /*  178, 0xb2 */    SDL_SCANCODE_KP_EQUALS,
+    /*  179, 0xb3 */    SDL_SCANCODE_KP_00,
+    /*  180, 0xb4 */    SDL_SCANCODE_UNKNOWN,
+    /*  181, 0xb5 */    SDL_SCANCODE_UNKNOWN,
+    /*  182, 0xb6 */    SDL_SCANCODE_UNKNOWN,
+    /*  183, 0xb7 */    SDL_SCANCODE_UNKNOWN,
+    /*  184, 0xb8 */    SDL_SCANCODE_UNKNOWN,
+    /*  185, 0xb9 */    SDL_SCANCODE_UNKNOWN,
+    /*  186, 0xba */    SDL_SCANCODE_SEMICOLON,
+    /*  187, 0xbb */    SDL_SCANCODE_EQUALS,
+    /*  188, 0xbc */    SDL_SCANCODE_COMMA,
+    /*  189, 0xbd */    SDL_SCANCODE_MINUS,
+    /*  190, 0xbe */    SDL_SCANCODE_PERIOD,
+    /*  191, 0xbf */    SDL_SCANCODE_SLASH,
+    /*  192, 0xc0 */    SDL_SCANCODE_GRAVE,
+    /*  193, 0xc1 */    SDL_SCANCODE_UNKNOWN,
+    /*  194, 0xc2 */    SDL_SCANCODE_UNKNOWN,
+    /*  195, 0xc3 */    SDL_SCANCODE_UNKNOWN,
+    /*  196, 0xc4 */    SDL_SCANCODE_UNKNOWN,
+    /*  197, 0xc5 */    SDL_SCANCODE_UNKNOWN,
+    /*  198, 0xc6 */    SDL_SCANCODE_UNKNOWN,
+    /*  199, 0xc7 */    SDL_SCANCODE_UNKNOWN,
+    /*  200, 0xc8 */    SDL_SCANCODE_UNKNOWN,
+    /*  201, 0xc9 */    SDL_SCANCODE_UNKNOWN,
+    /*  202, 0xca */    SDL_SCANCODE_UNKNOWN,
+    /*  203, 0xcb */    SDL_SCANCODE_UNKNOWN,
+    /*  204, 0xcc */    SDL_SCANCODE_UNKNOWN,
+    /*  205, 0xcd */    SDL_SCANCODE_UNKNOWN,
+    /*  206, 0xce */    SDL_SCANCODE_UNKNOWN,
+    /*  207, 0xcf */    SDL_SCANCODE_UNKNOWN,
+    /*  208, 0xd0 */    SDL_SCANCODE_UNKNOWN,
+    /*  209, 0xd1 */    SDL_SCANCODE_UNKNOWN,
+    /*  210, 0xd2 */    SDL_SCANCODE_UNKNOWN,
+    /*  211, 0xd3 */    SDL_SCANCODE_UNKNOWN,
+    /*  212, 0xd4 */    SDL_SCANCODE_UNKNOWN,
+    /*  213, 0xd5 */    SDL_SCANCODE_UNKNOWN,
+    /*  214, 0xd6 */    SDL_SCANCODE_UNKNOWN,
+    /*  215, 0xd7 */    SDL_SCANCODE_UNKNOWN,
+    /*  216, 0xd8 */    SDL_SCANCODE_UNKNOWN,
+    /*  217, 0xd9 */    SDL_SCANCODE_UNKNOWN,
+    /*  218, 0xda */    SDL_SCANCODE_UNKNOWN,
+    /*  219, 0xdb */    SDL_SCANCODE_LEFTBRACKET,
+    /*  220, 0xdc */    SDL_SCANCODE_BACKSLASH,
+    /*  221, 0xdd */    SDL_SCANCODE_RIGHTBRACKET,
+    /*  222, 0xde */    SDL_SCANCODE_APOSTROPHE,
+    /*  223, 0xdf */    SDL_SCANCODE_UNKNOWN,
+    /*  224, 0xe0 */    SDL_SCANCODE_UNKNOWN,
+    /*  225, 0xe1 */    SDL_SCANCODE_UNKNOWN,
+    /*  226, 0xe2 */    SDL_SCANCODE_NONUSBACKSLASH,
+    /*  227, 0xe3 */    SDL_SCANCODE_UNKNOWN,
+    /*  228, 0xe4 */    SDL_SCANCODE_UNKNOWN,
+    /*  229, 0xe5 */    SDL_SCANCODE_UNKNOWN,
+    /*  230, 0xe6 */    SDL_SCANCODE_UNKNOWN,
+    /*  231, 0xe7 */    SDL_SCANCODE_UNKNOWN,
+    /*  232, 0xe8 */    SDL_SCANCODE_UNKNOWN,
+    /*  233, 0xe9 */    SDL_SCANCODE_UNKNOWN,
+    /*  234, 0xea */    SDL_SCANCODE_UNKNOWN,
+    /*  235, 0xeb */    SDL_SCANCODE_UNKNOWN,
+    /*  236, 0xec */    SDL_SCANCODE_UNKNOWN,
+    /*  237, 0xed */    SDL_SCANCODE_UNKNOWN,
+    /*  238, 0xee */    SDL_SCANCODE_UNKNOWN,
+    /*  239, 0xef */    SDL_SCANCODE_UNKNOWN,
+    /*  240, 0xf0 */    SDL_SCANCODE_UNKNOWN,
+    /*  241, 0xf1 */    SDL_SCANCODE_UNKNOWN,
+    /*  242, 0xf2 */    SDL_SCANCODE_UNKNOWN,
+    /*  243, 0xf3 */    SDL_SCANCODE_UNKNOWN,
+    /*  244, 0xf4 */    SDL_SCANCODE_UNKNOWN,
+    /*  245, 0xf5 */    SDL_SCANCODE_UNKNOWN,
+    /*  246, 0xf6 */    SDL_SCANCODE_SYSREQ,
+    /*  247, 0xf7 */    SDL_SCANCODE_CRSEL,
+    /*  248, 0xf8 */    SDL_SCANCODE_EXSEL,
+    /*  249, 0xf9 */    SDL_SCANCODE_UNKNOWN, /* VK_EREOF */
+    /*  250, 0xfa */    SDL_SCANCODE_UNKNOWN, /* VK_PLAY */
+    /*  251, 0xfb */    SDL_SCANCODE_UNKNOWN, /* VK_ZOOM */
+    /*  252, 0xfc */    SDL_SCANCODE_UNKNOWN,
+    /*  253, 0xfd */    SDL_SCANCODE_UNKNOWN, /* VK_PA1 */
+    /*  254, 0xfe */    SDL_SCANCODE_CLEAR,
+    /*  255, 0xff */    SDL_SCANCODE_UNKNOWN,
+};
+/* *INDENT-ON* */

Externals/SDL/src/events/scancodes_xfree86.h

@@ -0,0 +1,330 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "../../include/SDL_scancode.h"
+
+/* XFree86 key code to SDL scancode mapping table
+   Sources:
+   - atKeyNames.h from XFree86 source code
+*/
+/* *INDENT-OFF* */
+static const SDL_scancode xfree86_scancode_table[] = {
+    /*  0 */    SDL_SCANCODE_UNKNOWN,
+    /*  1 */    SDL_SCANCODE_ESCAPE,
+    /*  2 */    SDL_SCANCODE_1,
+    /*  3 */    SDL_SCANCODE_2,
+    /*  4 */    SDL_SCANCODE_3,
+    /*  5 */    SDL_SCANCODE_4,
+    /*  6 */    SDL_SCANCODE_5,
+    /*  7 */    SDL_SCANCODE_6,
+    /*  8 */    SDL_SCANCODE_7,
+    /*  9 */    SDL_SCANCODE_8,
+    /*  10 */   SDL_SCANCODE_9,
+    /*  11 */   SDL_SCANCODE_0,
+    /*  12 */   SDL_SCANCODE_MINUS,
+    /*  13 */   SDL_SCANCODE_EQUALS,
+    /*  14 */   SDL_SCANCODE_BACKSPACE,
+    /*  15 */   SDL_SCANCODE_TAB,
+    /*  16 */   SDL_SCANCODE_Q,
+    /*  17 */   SDL_SCANCODE_W,
+    /*  18 */   SDL_SCANCODE_E,
+    /*  19 */   SDL_SCANCODE_R,
+    /*  20 */   SDL_SCANCODE_T,
+    /*  21 */   SDL_SCANCODE_Y,
+    /*  22 */   SDL_SCANCODE_U,
+    /*  23 */   SDL_SCANCODE_I,
+    /*  24 */   SDL_SCANCODE_O,
+    /*  25 */   SDL_SCANCODE_P,
+    /*  26 */   SDL_SCANCODE_LEFTBRACKET,
+    /*  27 */   SDL_SCANCODE_RIGHTBRACKET,
+    /*  28 */   SDL_SCANCODE_RETURN,
+    /*  29 */   SDL_SCANCODE_LCTRL,
+    /*  30 */   SDL_SCANCODE_A,
+    /*  31 */   SDL_SCANCODE_S,
+    /*  32 */   SDL_SCANCODE_D,
+    /*  33 */   SDL_SCANCODE_F,
+    /*  34 */   SDL_SCANCODE_G,
+    /*  35 */   SDL_SCANCODE_H,
+    /*  36 */   SDL_SCANCODE_J,
+    /*  37 */   SDL_SCANCODE_K,
+    /*  38 */   SDL_SCANCODE_L,
+    /*  39 */   SDL_SCANCODE_SEMICOLON,
+    /*  40 */   SDL_SCANCODE_APOSTROPHE,
+    /*  41 */   SDL_SCANCODE_GRAVE,
+    /*  42 */   SDL_SCANCODE_LSHIFT,
+    /*  43 */   SDL_SCANCODE_BACKSLASH,
+    /*  44 */   SDL_SCANCODE_Z,
+    /*  45 */   SDL_SCANCODE_X,
+    /*  46 */   SDL_SCANCODE_C,
+    /*  47 */   SDL_SCANCODE_V,
+    /*  48 */   SDL_SCANCODE_B,
+    /*  49 */   SDL_SCANCODE_N,
+    /*  50 */   SDL_SCANCODE_M,
+    /*  51 */   SDL_SCANCODE_COMMA,
+    /*  52 */   SDL_SCANCODE_PERIOD,
+    /*  53 */   SDL_SCANCODE_SLASH,
+    /*  54 */   SDL_SCANCODE_RSHIFT,
+    /*  55 */   SDL_SCANCODE_KP_MULTIPLY,
+    /*  56 */   SDL_SCANCODE_LALT,
+    /*  57 */   SDL_SCANCODE_SPACE,
+    /*  58 */   SDL_SCANCODE_CAPSLOCK,
+    /*  59 */   SDL_SCANCODE_F1,
+    /*  60 */   SDL_SCANCODE_F2,
+    /*  61 */   SDL_SCANCODE_F3,
+    /*  62 */   SDL_SCANCODE_F4,
+    /*  63 */   SDL_SCANCODE_F5,
+    /*  64 */   SDL_SCANCODE_F6,
+    /*  65 */   SDL_SCANCODE_F7,
+    /*  66 */   SDL_SCANCODE_F8,
+    /*  67 */   SDL_SCANCODE_F9,
+    /*  68 */   SDL_SCANCODE_F10,
+    /*  69 */   SDL_SCANCODE_NUMLOCKCLEAR,
+    /*  70 */   SDL_SCANCODE_SCROLLLOCK,
+    /*  71 */   SDL_SCANCODE_KP_7,
+    /*  72 */   SDL_SCANCODE_KP_8,
+    /*  73 */   SDL_SCANCODE_KP_9,
+    /*  74 */   SDL_SCANCODE_KP_MINUS,
+    /*  75 */   SDL_SCANCODE_KP_4,
+    /*  76 */   SDL_SCANCODE_KP_5,
+    /*  77 */   SDL_SCANCODE_KP_6,
+    /*  78 */   SDL_SCANCODE_KP_PLUS,
+    /*  79 */   SDL_SCANCODE_KP_1,
+    /*  80 */   SDL_SCANCODE_KP_2,
+    /*  81 */   SDL_SCANCODE_KP_3,
+    /*  82 */   SDL_SCANCODE_KP_0,
+    /*  83 */   SDL_SCANCODE_KP_PERIOD,
+    /*  84 */   SDL_SCANCODE_SYSREQ,
+    /*  85 */   SDL_SCANCODE_MODE,
+    /*  86 */   SDL_SCANCODE_NONUSBACKSLASH,
+    /*  87 */   SDL_SCANCODE_F11,
+    /*  88 */   SDL_SCANCODE_F12,
+    /*  89 */   SDL_SCANCODE_HOME,
+    /*  90 */   SDL_SCANCODE_UP,
+    /*  91 */   SDL_SCANCODE_PAGEUP,
+    /*  92 */   SDL_SCANCODE_LEFT,
+    /*  93 */   SDL_SCANCODE_BRIGHTNESSDOWN, /* on PowerBook G4 / KEY_Begin */
+    /*  94 */   SDL_SCANCODE_RIGHT,
+    /*  95 */   SDL_SCANCODE_END,
+    /*  96 */   SDL_SCANCODE_DOWN,
+    /*  97 */   SDL_SCANCODE_PAGEDOWN,
+    /*  98 */   SDL_SCANCODE_INSERT,
+    /*  99 */   SDL_SCANCODE_DELETE,
+    /*  100 */  SDL_SCANCODE_KP_ENTER,
+    /*  101 */  SDL_SCANCODE_RCTRL,
+    /*  102 */  SDL_SCANCODE_PAUSE,
+    /*  103 */  SDL_SCANCODE_PRINTSCREEN,
+    /*  104 */  SDL_SCANCODE_KP_DIVIDE,
+    /*  105 */  SDL_SCANCODE_RALT,
+    /*  106 */  SDL_SCANCODE_UNKNOWN, /* BREAK */
+    /*  107 */  SDL_SCANCODE_LGUI,
+    /*  108 */  SDL_SCANCODE_RGUI,
+    /*  109 */  SDL_SCANCODE_APPLICATION,
+    /*  110 */  SDL_SCANCODE_F13,
+    /*  111 */  SDL_SCANCODE_F14,
+    /*  112 */  SDL_SCANCODE_F15,
+    /*  113 */  SDL_SCANCODE_F16,
+    /*  114 */  SDL_SCANCODE_F17,
+    /*  115 */	SDL_SCANCODE_UNKNOWN,
+    /*	116 */  SDL_SCANCODE_UNKNOWN, /* is translated to XK_ISO_Level3_Shift by my X server, but I have no keyboard that generates this code, so I don't know what the correct SDL_SCANCODE_* for it is */
+    /*  117 */  SDL_SCANCODE_UNKNOWN,
+    /*  118 */  SDL_SCANCODE_KP_EQUALS,
+    /*  119 */  SDL_SCANCODE_UNKNOWN,
+    /*  120 */  SDL_SCANCODE_UNKNOWN,
+    /*  121 */  SDL_SCANCODE_UNKNOWN,
+    /*  122 */  SDL_SCANCODE_UNKNOWN,
+    /*  123 */  SDL_SCANCODE_UNKNOWN,
+    /*  124 */  SDL_SCANCODE_UNKNOWN,
+    /*  125 */  SDL_SCANCODE_INTERNATIONAL3, /* Yen */
+    /*  126 */  SDL_SCANCODE_UNKNOWN,
+    /*  127 */  SDL_SCANCODE_UNKNOWN,
+    /*  128 */  SDL_SCANCODE_UNKNOWN,
+    /*  129 */  SDL_SCANCODE_UNKNOWN,
+    /*  130 */  SDL_SCANCODE_UNKNOWN,
+    /*  131 */  SDL_SCANCODE_UNKNOWN,
+    /*  132 */  SDL_SCANCODE_POWER,
+    /*  133 */  SDL_SCANCODE_MUTE,
+    /*  134 */  SDL_SCANCODE_VOLUMEDOWN,
+    /*  135 */  SDL_SCANCODE_VOLUMEUP,
+    /*  136 */  SDL_SCANCODE_HELP,
+    /*  137 */  SDL_SCANCODE_STOP,
+    /*  138 */  SDL_SCANCODE_AGAIN,
+    /*  139 */  SDL_SCANCODE_UNKNOWN, /* PROPS */
+    /*  140 */  SDL_SCANCODE_UNDO,
+    /*  141 */  SDL_SCANCODE_UNKNOWN, /* FRONT */
+    /*  142 */  SDL_SCANCODE_COPY,
+    /*  143 */  SDL_SCANCODE_UNKNOWN, /* OPEN */
+    /*  144 */  SDL_SCANCODE_PASTE,
+    /*  145 */  SDL_SCANCODE_FIND,
+    /*  146 */  SDL_SCANCODE_CUT,
+};
+
+/* for wireless usb keyboard (manufacturer TRUST) without numpad. */
+static const SDL_scancode xfree86_scancode_table2[] = {
+    /*  0 */    SDL_SCANCODE_UNKNOWN,
+    /*  1 */    SDL_SCANCODE_ESCAPE,
+    /*  2 */    SDL_SCANCODE_1,
+    /*  3 */    SDL_SCANCODE_2,
+    /*  4 */    SDL_SCANCODE_3,
+    /*  5 */    SDL_SCANCODE_4,
+    /*  6 */    SDL_SCANCODE_5,
+    /*  7 */    SDL_SCANCODE_6,
+    /*  8 */    SDL_SCANCODE_7,
+    /*  9 */    SDL_SCANCODE_8,
+    /*  10 */   SDL_SCANCODE_9,
+    /*  11 */   SDL_SCANCODE_0,
+    /*  12 */   SDL_SCANCODE_MINUS,
+    /*  13 */   SDL_SCANCODE_EQUALS,
+    /*  14 */   SDL_SCANCODE_BACKSPACE,
+    /*  15 */   SDL_SCANCODE_TAB,
+    /*  16 */   SDL_SCANCODE_Q,
+    /*  17 */   SDL_SCANCODE_W,
+    /*  18 */   SDL_SCANCODE_E,
+    /*  19 */   SDL_SCANCODE_R,
+    /*  20 */   SDL_SCANCODE_T,
+    /*  21 */   SDL_SCANCODE_Y,
+    /*  22 */   SDL_SCANCODE_U,
+    /*  23 */   SDL_SCANCODE_I,
+    /*  24 */   SDL_SCANCODE_O,
+    /*  25 */   SDL_SCANCODE_P,
+    /*  26 */   SDL_SCANCODE_LEFTBRACKET,
+    /*  27 */   SDL_SCANCODE_RIGHTBRACKET,
+    /*  28 */   SDL_SCANCODE_RETURN,
+    /*  29 */   SDL_SCANCODE_LCTRL,
+    /*  30 */   SDL_SCANCODE_A,
+    /*  31 */   SDL_SCANCODE_S,
+    /*  32 */   SDL_SCANCODE_D,
+    /*  33 */   SDL_SCANCODE_F,
+    /*  34 */   SDL_SCANCODE_G,
+    /*  35 */   SDL_SCANCODE_H,
+    /*  36 */   SDL_SCANCODE_J,
+    /*  37 */   SDL_SCANCODE_K,
+    /*  38 */   SDL_SCANCODE_L,
+    /*  39 */   SDL_SCANCODE_SEMICOLON,
+    /*  40 */   SDL_SCANCODE_APOSTROPHE,
+    /*  41 */   SDL_SCANCODE_GRAVE,
+    /*  42 */   SDL_SCANCODE_LSHIFT,
+    /*  43 */   SDL_SCANCODE_BACKSLASH,
+    /*  44 */   SDL_SCANCODE_Z,
+    /*  45 */   SDL_SCANCODE_X,
+    /*  46 */   SDL_SCANCODE_C,
+    /*  47 */   SDL_SCANCODE_V,
+    /*  48 */   SDL_SCANCODE_B,
+    /*  49 */   SDL_SCANCODE_N,
+    /*  50 */   SDL_SCANCODE_M,
+    /*  51 */   SDL_SCANCODE_COMMA,
+    /*  52 */   SDL_SCANCODE_PERIOD,
+    /*  53 */   SDL_SCANCODE_SLASH,
+    /*  54 */   SDL_SCANCODE_RSHIFT,
+    /*  55 */   SDL_SCANCODE_KP_MULTIPLY,
+    /*  56 */   SDL_SCANCODE_LALT,
+    /*  57 */   SDL_SCANCODE_SPACE,
+    /*  58 */   SDL_SCANCODE_CAPSLOCK,
+    /*  59 */   SDL_SCANCODE_F1,
+    /*  60 */   SDL_SCANCODE_F2,
+    /*  61 */   SDL_SCANCODE_F3,
+    /*  62 */   SDL_SCANCODE_F4,
+    /*  63 */   SDL_SCANCODE_F5,
+    /*  64 */   SDL_SCANCODE_F6,
+    /*  65 */   SDL_SCANCODE_F7,
+    /*  66 */   SDL_SCANCODE_F8,
+    /*  67 */   SDL_SCANCODE_F9,
+    /*  68 */   SDL_SCANCODE_F10,
+    /*  69 */   SDL_SCANCODE_NUMLOCKCLEAR,
+    /*  70 */   SDL_SCANCODE_SCROLLLOCK,
+    /*  71 */   SDL_SCANCODE_KP_7,
+    /*  72 */   SDL_SCANCODE_KP_8,
+    /*  73 */   SDL_SCANCODE_KP_9,
+    /*  74 */   SDL_SCANCODE_KP_MINUS,
+    /*  75 */   SDL_SCANCODE_KP_4,
+    /*  76 */   SDL_SCANCODE_KP_5,
+    /*  77 */   SDL_SCANCODE_KP_6,
+    /*  78 */   SDL_SCANCODE_KP_PLUS,
+    /*  79 */   SDL_SCANCODE_KP_1,
+    /*  80 */   SDL_SCANCODE_KP_2,
+    /*  81 */   SDL_SCANCODE_KP_3,
+    /*  82 */   SDL_SCANCODE_KP_0,
+    /*  83 */   SDL_SCANCODE_KP_PERIOD,
+    /*  84 */   SDL_SCANCODE_SYSREQ,		/* ???? */
+    /*  85 */   SDL_SCANCODE_MODE,			/* ???? */
+    /*  86 */   SDL_SCANCODE_NONUSBACKSLASH,
+    /*  87 */   SDL_SCANCODE_F11,
+    /*  88 */   SDL_SCANCODE_F12,
+    /*  89 */   SDL_SCANCODE_UNKNOWN,
+    /*  90 */   SDL_SCANCODE_UNKNOWN,
+    /*  91 */   SDL_SCANCODE_UNKNOWN,
+    /*  92 */   SDL_SCANCODE_UNKNOWN,
+    /*  93 */   SDL_SCANCODE_UNKNOWN,
+    /*  94 */   SDL_SCANCODE_UNKNOWN,
+    /*  95 */   SDL_SCANCODE_UNKNOWN,
+    /*  96 */   SDL_SCANCODE_UNKNOWN,
+    /*  97 */   SDL_SCANCODE_RCTRL,
+    /*  98 */   SDL_SCANCODE_KP_DIVIDE,
+    /*  99 */   SDL_SCANCODE_UNKNOWN,
+    /* 100 */   SDL_SCANCODE_RALT,	 /* ISO_Level3_Shift, ALTGR, RALT */
+    /* 101 */   SDL_SCANCODE_UNKNOWN,
+    /* 102 */   SDL_SCANCODE_HOME,
+    /* 103 */   SDL_SCANCODE_UP,
+    /* 104 */   SDL_SCANCODE_PAGEUP,
+    /* 105 */   SDL_SCANCODE_LEFT,
+    /* 106 */   SDL_SCANCODE_RIGHT,
+    /* 107 */   SDL_SCANCODE_END,
+    /* 108 */   SDL_SCANCODE_DOWN,
+    /* 109 */   SDL_SCANCODE_PAGEDOWN,
+    /* 110 */   SDL_SCANCODE_INSERT,
+    /* 111 */   SDL_SCANCODE_DELETE,
+    /* 112 */   SDL_SCANCODE_UNKNOWN,
+    /* 113 */   SDL_SCANCODE_UNKNOWN,
+    /* 114 */   SDL_SCANCODE_UNKNOWN,
+    /* 115 */   SDL_SCANCODE_UNKNOWN,
+    /* 116 */   SDL_SCANCODE_UNKNOWN,
+    /* 117 */   SDL_SCANCODE_UNKNOWN,
+    /* 118 */   SDL_SCANCODE_UNKNOWN,
+    /* 119 */   SDL_SCANCODE_UNKNOWN,
+    /* 120 */   SDL_SCANCODE_UNKNOWN,
+    /* 121 */ 	SDL_SCANCODE_PAUSE,
+    /* 122 */   SDL_SCANCODE_UNKNOWN,
+    /* 123 */   SDL_SCANCODE_UNKNOWN,
+    /* 124 */   SDL_SCANCODE_UNKNOWN,
+    /* 125 */  SDL_SCANCODE_LGUI,
+    /* 126 */  SDL_SCANCODE_RGUI,
+    /* 127 */  SDL_SCANCODE_APPLICATION,
+    /* 128 */  SDL_SCANCODE_UNKNOWN,
+    /* 129 */  SDL_SCANCODE_UNKNOWN,
+    /* 130 */  SDL_SCANCODE_UNKNOWN,
+    /* 131 */  SDL_SCANCODE_UNKNOWN,
+    /* 132 */  SDL_SCANCODE_UNKNOWN,
+    /* 133 */  SDL_SCANCODE_UNKNOWN,
+    /* 134 */  SDL_SCANCODE_UNKNOWN,
+    /* 135 */  SDL_SCANCODE_UNKNOWN,
+    /* 136 */  SDL_SCANCODE_UNKNOWN,
+    /* 137 */  SDL_SCANCODE_UNKNOWN,
+    /* 138 */  SDL_SCANCODE_UNKNOWN,
+    /* 139 */  SDL_SCANCODE_UNKNOWN,
+    /* 140 */  SDL_SCANCODE_UNKNOWN,
+    /* 141 */  SDL_SCANCODE_UNKNOWN,
+    /* 142 */  SDL_SCANCODE_UNKNOWN,
+    /* 143 */  SDL_SCANCODE_UNKNOWN,
+    /* 144 */  SDL_SCANCODE_UNKNOWN,
+    /* 145 */  SDL_SCANCODE_UNKNOWN,
+    /* 146 */  SDL_SCANCODE_UNKNOWN,
+};
+
+/* *INDENT-ON* */

Externals/SDL/src/file/SDL_rwops.c

@@ -0,0 +1,654 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/* This file provides a general interface for SDL to read and write
+   data sources.  It can easily be extended to files, memory, etc.
+*/
+
+#include "SDL_endian.h"
+#include "SDL_rwops.h"
+
+#ifdef __NDS__
+/* include libfat headers for fatInitDefault(). */
+#include <fat.h>
+#endif /* __NDS__ */
+
+#ifdef __WIN32__
+
+/* Functions to read/write Win32 API file pointers */
+/* Will not use it on WinCE because stdio is buffered, it means
+   faster, and all stdio functions anyway are embedded in coredll.dll - 
+   the main wince dll*/
+
+#define WINDOWS_LEAN_AND_MEAN
+#include <windows.h>
+
+#ifndef INVALID_SET_FILE_POINTER
+#define INVALID_SET_FILE_POINTER 0xFFFFFFFF
+#endif
+
+#define READAHEAD_BUFFER_SIZE	1024
+
+static int SDLCALL
+win32_file_open(SDL_RWops * context, const char *filename, const char *mode)
+{
+#ifndef _WIN32_WCE
+    UINT old_error_mode;
+#endif
+    HANDLE h;
+    DWORD r_right, w_right;
+    DWORD must_exist, truncate;
+    int a_mode;
+
+    if (!context)
+        return -1;              /* failed (invalid call) */
+
+    context->hidden.win32io.h = INVALID_HANDLE_VALUE;   /* mark this as unusable */
+    context->hidden.win32io.buffer.data = NULL;
+    context->hidden.win32io.buffer.size = 0;
+    context->hidden.win32io.buffer.left = 0;
+
+    /* "r" = reading, file must exist */
+    /* "w" = writing, truncate existing, file may not exist */
+    /* "r+"= reading or writing, file must exist            */
+    /* "a" = writing, append file may not exist             */
+    /* "a+"= append + read, file may not exist              */
+    /* "w+" = read, write, truncate. file may not exist    */
+
+    must_exist = (SDL_strchr(mode, 'r') != NULL) ? OPEN_EXISTING : 0;
+    truncate = (SDL_strchr(mode, 'w') != NULL) ? CREATE_ALWAYS : 0;
+    r_right = (SDL_strchr(mode, '+') != NULL
+               || must_exist) ? GENERIC_READ : 0;
+    a_mode = (SDL_strchr(mode, 'a') != NULL) ? OPEN_ALWAYS : 0;
+    w_right = (a_mode || SDL_strchr(mode, '+')
+               || truncate) ? GENERIC_WRITE : 0;
+
+    if (!r_right && !w_right)   /* inconsistent mode */
+        return -1;              /* failed (invalid call) */
+
+    context->hidden.win32io.buffer.data =
+        (char *) SDL_malloc(READAHEAD_BUFFER_SIZE);
+    if (!context->hidden.win32io.buffer.data) {
+        SDL_OutOfMemory();
+        return -1;
+    }
+#ifdef _WIN32_WCE
+    {
+        size_t size = SDL_strlen(filename) + 1;
+        wchar_t *filenameW = SDL_stack_alloc(wchar_t, size);
+
+        if (MultiByteToWideChar(CP_UTF8, 0, filename, -1, filenameW, size) ==
+            0) {
+            SDL_stack_free(filenameW);
+            SDL_free(context->hidden.win32io.buffer.data);
+            context->hidden.win32io.buffer.data = NULL;
+            SDL_SetError("Unable to convert filename to Unicode");
+            return -1;
+        }
+        h = CreateFile(filenameW, (w_right | r_right),
+                       (w_right) ? 0 : FILE_SHARE_READ, NULL,
+                       (must_exist | truncate | a_mode),
+                       FILE_ATTRIBUTE_NORMAL, NULL);
+        SDL_stack_free(filenameW);
+    }
+#else
+    /* Do not open a dialog box if failure */
+    old_error_mode =
+        SetErrorMode(SEM_NOOPENFILEERRORBOX | SEM_FAILCRITICALERRORS);
+
+    h = CreateFile(filename, (w_right | r_right),
+                   (w_right) ? 0 : FILE_SHARE_READ, NULL,
+                   (must_exist | truncate | a_mode), FILE_ATTRIBUTE_NORMAL,
+                   NULL);
+
+    /* restore old behaviour */
+    SetErrorMode(old_error_mode);
+#endif /* _WIN32_WCE */
+
+    if (h == INVALID_HANDLE_VALUE) {
+        SDL_free(context->hidden.win32io.buffer.data);
+        context->hidden.win32io.buffer.data = NULL;
+        SDL_SetError("Couldn't open %s", filename);
+        return -2;              /* failed (CreateFile) */
+    }
+    context->hidden.win32io.h = h;
+    context->hidden.win32io.append = a_mode ? SDL_TRUE : SDL_FALSE;
+
+    return 0;                   /* ok */
+}
+
+static long SDLCALL
+win32_file_seek(SDL_RWops * context, long offset, int whence)
+{
+    DWORD win32whence;
+    long file_pos;
+
+    if (!context || context->hidden.win32io.h == INVALID_HANDLE_VALUE) {
+        SDL_SetError("win32_file_seek: invalid context/file not opened");
+        return -1;
+    }
+
+    /* FIXME: We may be able to satisfy the seek within buffered data */
+    if (whence == RW_SEEK_CUR && context->hidden.win32io.buffer.left) {
+        offset -= (long)context->hidden.win32io.buffer.left;
+    }
+    context->hidden.win32io.buffer.left = 0;
+
+    switch (whence) {
+    case RW_SEEK_SET:
+        win32whence = FILE_BEGIN;
+        break;
+    case RW_SEEK_CUR:
+        win32whence = FILE_CURRENT;
+        break;
+    case RW_SEEK_END:
+        win32whence = FILE_END;
+        break;
+    default:
+        SDL_SetError("win32_file_seek: Unknown value for 'whence'");
+        return -1;
+    }
+
+    file_pos =
+        SetFilePointer(context->hidden.win32io.h, offset, NULL, win32whence);
+
+    if (file_pos != INVALID_SET_FILE_POINTER)
+        return file_pos;        /* success */
+
+    SDL_Error(SDL_EFSEEK);
+    return -1;                  /* error */
+}
+
+static size_t SDLCALL
+win32_file_read(SDL_RWops * context, void *ptr, size_t size, size_t maxnum)
+{
+    size_t total_need;
+    size_t total_read = 0;
+    size_t read_ahead;
+    DWORD byte_read;
+
+    total_need = size * maxnum;
+
+    if (!context || context->hidden.win32io.h == INVALID_HANDLE_VALUE
+        || !total_need)
+        return 0;
+
+    if (context->hidden.win32io.buffer.left > 0) {
+        void *data = (char *) context->hidden.win32io.buffer.data +
+            context->hidden.win32io.buffer.size -
+            context->hidden.win32io.buffer.left;
+        read_ahead =
+            SDL_min(total_need, context->hidden.win32io.buffer.left);
+        SDL_memcpy(ptr, data, read_ahead);
+        context->hidden.win32io.buffer.left -= read_ahead;
+
+        if (read_ahead == total_need) {
+            return maxnum;
+        }
+        ptr = (char *) ptr + read_ahead;
+        total_need -= read_ahead;
+        total_read += read_ahead;
+    }
+
+    if (total_need < READAHEAD_BUFFER_SIZE) {
+        if (!ReadFile
+            (context->hidden.win32io.h, context->hidden.win32io.buffer.data,
+             READAHEAD_BUFFER_SIZE, &byte_read, NULL)) {
+            SDL_Error(SDL_EFREAD);
+            return 0;
+        }
+        read_ahead = SDL_min(total_need, (int) byte_read);
+        SDL_memcpy(ptr, context->hidden.win32io.buffer.data, read_ahead);
+        context->hidden.win32io.buffer.size = byte_read;
+        context->hidden.win32io.buffer.left = byte_read - read_ahead;
+        total_read += read_ahead;
+    } else {
+        if (!ReadFile
+            (context->hidden.win32io.h, ptr, (DWORD)total_need, &byte_read, NULL)) {
+            SDL_Error(SDL_EFREAD);
+            return 0;
+        }
+        total_read += byte_read;
+    }
+    return (total_read / size);
+}
+
+static size_t SDLCALL
+win32_file_write(SDL_RWops * context, const void *ptr, size_t size,
+                 size_t num)
+{
+
+    size_t total_bytes;
+    DWORD byte_written;
+    size_t nwritten;
+
+    total_bytes = size * num;
+
+    if (!context || context->hidden.win32io.h == INVALID_HANDLE_VALUE
+        || total_bytes <= 0 || !size)
+        return 0;
+
+    if (context->hidden.win32io.buffer.left) {
+        SetFilePointer(context->hidden.win32io.h,
+                       -(LONG)context->hidden.win32io.buffer.left, NULL,
+                       FILE_CURRENT);
+        context->hidden.win32io.buffer.left = 0;
+    }
+
+    /* if in append mode, we must go to the EOF before write */
+    if (context->hidden.win32io.append) {
+        if (SetFilePointer(context->hidden.win32io.h, 0L, NULL, FILE_END) ==
+            INVALID_SET_FILE_POINTER) {
+            SDL_Error(SDL_EFWRITE);
+            return 0;
+        }
+    }
+
+    if (!WriteFile
+        (context->hidden.win32io.h, ptr, (DWORD)total_bytes, &byte_written, NULL)) {
+        SDL_Error(SDL_EFWRITE);
+        return 0;
+    }
+
+    nwritten = byte_written / size;
+    return nwritten;
+}
+
+static int SDLCALL
+win32_file_close(SDL_RWops * context)
+{
+
+    if (context) {
+        if (context->hidden.win32io.h != INVALID_HANDLE_VALUE) {
+            CloseHandle(context->hidden.win32io.h);
+            context->hidden.win32io.h = INVALID_HANDLE_VALUE;   /* to be sure */
+        }
+        if (context->hidden.win32io.buffer.data) {
+            SDL_free(context->hidden.win32io.buffer.data);
+            context->hidden.win32io.buffer.data = NULL;
+        }
+        SDL_FreeRW(context);
+    }
+    return (0);
+}
+#endif /* __WIN32__ */
+
+#ifdef HAVE_STDIO_H
+
+/* Functions to read/write stdio file pointers */
+
+static long SDLCALL
+stdio_seek(SDL_RWops * context, long offset, int whence)
+{
+    if (fseek(context->hidden.stdio.fp, offset, whence) == 0) {
+        return (ftell(context->hidden.stdio.fp));
+    } else {
+        SDL_Error(SDL_EFSEEK);
+        return (-1);
+    }
+}
+
+static size_t SDLCALL
+stdio_read(SDL_RWops * context, void *ptr, size_t size, size_t maxnum)
+{
+    size_t nread;
+
+    nread = fread(ptr, size, maxnum, context->hidden.stdio.fp);
+    if (nread == 0 && ferror(context->hidden.stdio.fp)) {
+        SDL_Error(SDL_EFREAD);
+    }
+    return (nread);
+}
+
+static size_t SDLCALL
+stdio_write(SDL_RWops * context, const void *ptr, size_t size, size_t num)
+{
+    size_t nwrote;
+
+    nwrote = fwrite(ptr, size, num, context->hidden.stdio.fp);
+    if (nwrote == 0 && ferror(context->hidden.stdio.fp)) {
+        SDL_Error(SDL_EFWRITE);
+    }
+    return (nwrote);
+}
+
+static int SDLCALL
+stdio_close(SDL_RWops * context)
+{
+    int status = 0;
+    if (context) {
+        if (context->hidden.stdio.autoclose) {
+            /* WARNING:  Check the return value here! */
+            if (fclose(context->hidden.stdio.fp) != 0) {
+                SDL_Error(SDL_EFWRITE);
+                status = -1;
+            }
+        }
+        SDL_FreeRW(context);
+    }
+    return status;
+}
+#endif /* !HAVE_STDIO_H */
+
+/* Functions to read/write memory pointers */
+
+static long SDLCALL
+mem_seek(SDL_RWops * context, long offset, int whence)
+{
+    Uint8 *newpos;
+
+    switch (whence) {
+    case RW_SEEK_SET:
+        newpos = context->hidden.mem.base + offset;
+        break;
+    case RW_SEEK_CUR:
+        newpos = context->hidden.mem.here + offset;
+        break;
+    case RW_SEEK_END:
+        newpos = context->hidden.mem.stop + offset;
+        break;
+    default:
+        SDL_SetError("Unknown value for 'whence'");
+        return (-1);
+    }
+    if (newpos < context->hidden.mem.base) {
+        newpos = context->hidden.mem.base;
+    }
+    if (newpos > context->hidden.mem.stop) {
+        newpos = context->hidden.mem.stop;
+    }
+    context->hidden.mem.here = newpos;
+    return (long)(context->hidden.mem.here - context->hidden.mem.base);
+}
+
+static size_t SDLCALL
+mem_read(SDL_RWops * context, void *ptr, size_t size, size_t maxnum)
+{
+    size_t total_bytes;
+    size_t mem_available;
+
+    total_bytes = (maxnum * size);
+    if ((maxnum <= 0) || (size <= 0)
+        || ((total_bytes / maxnum) != (size_t) size)) {
+        return 0;
+    }
+
+    mem_available = (context->hidden.mem.stop - context->hidden.mem.here);
+    if (total_bytes > mem_available) {
+        total_bytes = mem_available;
+    }
+
+    SDL_memcpy(ptr, context->hidden.mem.here, total_bytes);
+    context->hidden.mem.here += total_bytes;
+
+    return (total_bytes / size);
+}
+
+static size_t SDLCALL
+mem_write(SDL_RWops * context, const void *ptr, size_t size, size_t num)
+{
+    if ((context->hidden.mem.here + (num * size)) > context->hidden.mem.stop) {
+        num = (context->hidden.mem.stop - context->hidden.mem.here) / size;
+    }
+    SDL_memcpy(context->hidden.mem.here, ptr, num * size);
+    context->hidden.mem.here += num * size;
+    return (num);
+}
+
+static size_t SDLCALL
+mem_writeconst(SDL_RWops * context, const void *ptr, size_t size, size_t num)
+{
+    SDL_SetError("Can't write to read-only memory");
+    return (-1);
+}
+
+static int SDLCALL
+mem_close(SDL_RWops * context)
+{
+    if (context) {
+        SDL_FreeRW(context);
+    }
+    return (0);
+}
+
+
+/* Functions to create SDL_RWops structures from various data sources */
+
+SDL_RWops *
+SDL_RWFromFile(const char *file, const char *mode)
+{
+    SDL_RWops *rwops = NULL;
+#ifdef HAVE_STDIO_H
+    FILE *fp = NULL;
+#endif
+    if (!file || !*file || !mode || !*mode) {
+        SDL_SetError("SDL_RWFromFile(): No file or no mode specified");
+        return NULL;
+    }
+#if defined(__WIN32__)
+    rwops = SDL_AllocRW();
+    if (!rwops)
+        return NULL;            /* SDL_SetError already setup by SDL_AllocRW() */
+    if (win32_file_open(rwops, file, mode) < 0) {
+        SDL_FreeRW(rwops);
+        return NULL;
+    }
+    rwops->seek = win32_file_seek;
+    rwops->read = win32_file_read;
+    rwops->write = win32_file_write;
+    rwops->close = win32_file_close;
+
+#elif HAVE_STDIO_H
+
+    fp = fopen(file, mode);
+    if (fp == NULL) {
+        SDL_SetError("Couldn't open %s", file);
+    } else {
+        rwops = SDL_RWFromFP(fp, 1);
+    }
+#else
+    SDL_SetError("SDL not compiled with stdio support");
+#endif /* !HAVE_STDIO_H */
+
+    return (rwops);
+}
+
+#ifdef HAVE_STDIO_H
+SDL_RWops *
+SDL_RWFromFP(FILE * fp, SDL_bool autoclose)
+{
+    SDL_RWops *rwops = NULL;
+
+#if 0
+/*#ifdef __NDS__*/
+    /* set it up so we can use stdio file function */
+    fatInitDefault();
+    printf("called fatInitDefault()");
+#endif /* __NDS__ */
+
+    rwops = SDL_AllocRW();
+    if (rwops != NULL) {
+        rwops->seek = stdio_seek;
+        rwops->read = stdio_read;
+        rwops->write = stdio_write;
+        rwops->close = stdio_close;
+        rwops->hidden.stdio.fp = fp;
+        rwops->hidden.stdio.autoclose = autoclose;
+    }
+    return (rwops);
+}
+#endif /* HAVE_STDIO_H */
+
+SDL_RWops *
+SDL_RWFromMem(void *mem, int size)
+{
+    SDL_RWops *rwops;
+
+    rwops = SDL_AllocRW();
+    if (rwops != NULL) {
+        rwops->seek = mem_seek;
+        rwops->read = mem_read;
+        rwops->write = mem_write;
+        rwops->close = mem_close;
+        rwops->hidden.mem.base = (Uint8 *) mem;
+        rwops->hidden.mem.here = rwops->hidden.mem.base;
+        rwops->hidden.mem.stop = rwops->hidden.mem.base + size;
+    }
+    return (rwops);
+}
+
+SDL_RWops *
+SDL_RWFromConstMem(const void *mem, int size)
+{
+    SDL_RWops *rwops;
+
+    rwops = SDL_AllocRW();
+    if (rwops != NULL) {
+        rwops->seek = mem_seek;
+        rwops->read = mem_read;
+        rwops->write = mem_writeconst;
+        rwops->close = mem_close;
+        rwops->hidden.mem.base = (Uint8 *) mem;
+        rwops->hidden.mem.here = rwops->hidden.mem.base;
+        rwops->hidden.mem.stop = rwops->hidden.mem.base + size;
+    }
+    return (rwops);
+}
+
+SDL_RWops *
+SDL_AllocRW(void)
+{
+    SDL_RWops *area;
+
+    area = (SDL_RWops *) SDL_malloc(sizeof *area);
+    if (area == NULL) {
+        SDL_OutOfMemory();
+    }
+    return (area);
+}
+
+void
+SDL_FreeRW(SDL_RWops * area)
+{
+    SDL_free(area);
+}
+
+/* Functions for dynamically reading and writing endian-specific values */
+
+Uint16
+SDL_ReadLE16(SDL_RWops * src)
+{
+    Uint16 value;
+
+    SDL_RWread(src, &value, (sizeof value), 1);
+    return (SDL_SwapLE16(value));
+}
+
+Uint16
+SDL_ReadBE16(SDL_RWops * src)
+{
+    Uint16 value;
+
+    SDL_RWread(src, &value, (sizeof value), 1);
+    return (SDL_SwapBE16(value));
+}
+
+Uint32
+SDL_ReadLE32(SDL_RWops * src)
+{
+    Uint32 value;
+
+    SDL_RWread(src, &value, (sizeof value), 1);
+    return (SDL_SwapLE32(value));
+}
+
+Uint32
+SDL_ReadBE32(SDL_RWops * src)
+{
+    Uint32 value;
+
+    SDL_RWread(src, &value, (sizeof value), 1);
+    return (SDL_SwapBE32(value));
+}
+
+Uint64
+SDL_ReadLE64(SDL_RWops * src)
+{
+    Uint64 value;
+
+    SDL_RWread(src, &value, (sizeof value), 1);
+    return (SDL_SwapLE64(value));
+}
+
+Uint64
+SDL_ReadBE64(SDL_RWops * src)
+{
+    Uint64 value;
+
+    SDL_RWread(src, &value, (sizeof value), 1);
+    return (SDL_SwapBE64(value));
+}
+
+size_t
+SDL_WriteLE16(SDL_RWops * dst, Uint16 value)
+{
+    value = SDL_SwapLE16(value);
+    return (SDL_RWwrite(dst, &value, (sizeof value), 1));
+}
+
+size_t
+SDL_WriteBE16(SDL_RWops * dst, Uint16 value)
+{
+    value = SDL_SwapBE16(value);
+    return (SDL_RWwrite(dst, &value, (sizeof value), 1));
+}
+
+size_t
+SDL_WriteLE32(SDL_RWops * dst, Uint32 value)
+{
+    value = SDL_SwapLE32(value);
+    return (SDL_RWwrite(dst, &value, (sizeof value), 1));
+}
+
+size_t
+SDL_WriteBE32(SDL_RWops * dst, Uint32 value)
+{
+    value = SDL_SwapBE32(value);
+    return (SDL_RWwrite(dst, &value, (sizeof value), 1));
+}
+
+size_t
+SDL_WriteLE64(SDL_RWops * dst, Uint64 value)
+{
+    value = SDL_SwapLE64(value);
+    return (SDL_RWwrite(dst, &value, (sizeof value), 1));
+}
+
+size_t
+SDL_WriteBE64(SDL_RWops * dst, Uint64 value)
+{
+    value = SDL_SwapBE64(value);
+    return (SDL_RWwrite(dst, &value, (sizeof value), 1));
+}
+
+/* vi: set ts=4 sw=4 expandtab: */

Externals/SDL/src/haptic/SDL_haptic.c

@@ -0,0 +1,707 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 2008 Edgar Simo
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#include "SDL_syshaptic.h"
+#include "../joystick/SDL_joystick_c.h" /* For SDL_PrivateJoystickValid */
+
+
+Uint8 SDL_numhaptics = 0;
+SDL_Haptic **SDL_haptics = NULL;
+
+
+/*
+ * Initializes the Haptic devices.
+ */
+int
+SDL_HapticInit(void)
+{
+    int arraylen;
+    int status;
+
+    SDL_numhaptics = 0;
+    status = SDL_SYS_HapticInit();
+    if (status >= 0) {
+        arraylen = (status + 1) * sizeof(*SDL_haptics);
+        SDL_haptics = (SDL_Haptic **) SDL_malloc(arraylen);
+        if (SDL_haptics == NULL) {      /* Out of memory. */
+            SDL_numhaptics = 0;
+        } else {
+            SDL_memset(SDL_haptics, 0, arraylen);
+            SDL_numhaptics = status;
+        }
+        status = 0;
+    }
+
+    return status;
+}
+
+
+/*
+ * Checks to see if the haptic device is valid
+ */
+static int
+ValidHaptic(SDL_Haptic * haptic)
+{
+    int i;
+    int valid;
+
+    valid = 0;
+    if (haptic != NULL) {
+        for (i = 0; i < SDL_numhaptics; i++) {
+            if (SDL_haptics[i] == haptic) {
+                valid = 1;
+                break;
+            }
+        }
+    }
+
+    /* Create the error here. */
+    if (valid == 0) {
+        SDL_SetError("Haptic: Invalid haptic device identifier");
+    }
+
+    return valid;
+}
+
+
+/*
+ * Returns the number of available devices.
+ */
+int
+SDL_NumHaptics(void)
+{
+    return SDL_numhaptics;
+}
+
+
+/*
+ * Gets the name of a Haptic device by index.
+ */
+const char *
+SDL_HapticName(int device_index)
+{
+    if ((device_index < 0) || (device_index >= SDL_numhaptics)) {
+        SDL_SetError("Haptic: There are %d haptic devices available",
+                     SDL_numhaptics);
+        return NULL;
+    }
+    return SDL_SYS_HapticName(device_index);
+}
+
+
+/*
+ * Opens a Haptic device.
+ */
+SDL_Haptic *
+SDL_HapticOpen(int device_index)
+{
+    int i;
+    SDL_Haptic *haptic;
+
+    if ((device_index < 0) || (device_index >= SDL_numhaptics)) {
+        SDL_SetError("Haptic: There are %d haptic devices available",
+                     SDL_numhaptics);
+        return NULL;
+    }
+
+    /* If the haptic is already open, return it */
+    for (i = 0; SDL_haptics[i]; i++) {
+        if (device_index == SDL_haptics[i]->index) {
+            haptic = SDL_haptics[i];
+            ++haptic->ref_count;
+            return haptic;
+        }
+    }
+
+    /* Create the haptic device */
+    haptic = (SDL_Haptic *) SDL_malloc((sizeof *haptic));
+    if (haptic == NULL) {
+        SDL_OutOfMemory();
+        return NULL;
+    }
+
+    /* Initialize the haptic device */
+    SDL_memset(haptic, 0, (sizeof *haptic));
+    haptic->index = device_index;
+    if (SDL_SYS_HapticOpen(haptic) < 0) {
+        SDL_free(haptic);
+        return NULL;
+    }
+
+    /* Disable autocenter and set gain to max. */
+    if (haptic->supported & SDL_HAPTIC_GAIN)
+        SDL_HapticSetGain(haptic, 100);
+    if (haptic->supported & SDL_HAPTIC_AUTOCENTER)
+        SDL_HapticSetAutocenter(haptic, 0);
+
+    /* Add haptic to list */
+    ++haptic->ref_count;
+    for (i = 0; SDL_haptics[i]; i++)
+        /* Skip to next haptic */ ;
+    SDL_haptics[i] = haptic;
+
+    return haptic;
+}
+
+
+/*
+ * Returns 1 if the device has been opened.
+ */
+int
+SDL_HapticOpened(int device_index)
+{
+    int i, opened;
+
+    opened = 0;
+    for (i = 0; SDL_haptics[i]; i++) {
+        if (SDL_haptics[i]->index == (Uint8) device_index) {
+            opened = 1;
+            break;
+        }
+    }
+    return opened;
+}
+
+
+/*
+ * Returns the index to a haptic device.
+ */
+int
+SDL_HapticIndex(SDL_Haptic * haptic)
+{
+    if (!ValidHaptic(haptic)) {
+        return -1;
+    }
+
+    return haptic->index;
+}
+
+
+/*
+ * Returns SDL_TRUE if mouse is haptic, SDL_FALSE if it isn't.
+ */
+int
+SDL_MouseIsHaptic(void)
+{
+    if (SDL_SYS_HapticMouse() < 0)
+        return SDL_FALSE;
+    return SDL_TRUE;
+}
+
+
+/*
+ * Returns the haptic device if mouse is haptic or NULL elsewise.
+ */
+SDL_Haptic *
+SDL_HapticOpenFromMouse(void)
+{
+    int device_index;
+
+    device_index = SDL_SYS_HapticMouse();
+
+    if (device_index < 0) {
+        SDL_SetError("Haptic: Mouse isn't a haptic device.");
+        return NULL;
+    }
+
+    return SDL_HapticOpen(device_index);
+}
+
+
+/*
+ * Returns SDL_TRUE if joystick has haptic features.
+ */
+int
+SDL_JoystickIsHaptic(SDL_Joystick * joystick)
+{
+    int ret;
+
+    /* Must be a valid joystick */
+    if (!SDL_PrivateJoystickValid(&joystick)) {
+        return -1;
+    }
+
+    ret = SDL_SYS_JoystickIsHaptic(joystick);
+
+    if (ret > 0)
+        return SDL_TRUE;
+    else if (ret == 0)
+        return SDL_FALSE;
+    else
+        return -1;
+}
+
+
+/*
+ * Opens a haptic device from a joystick.
+ */
+SDL_Haptic *
+SDL_HapticOpenFromJoystick(SDL_Joystick * joystick)
+{
+    int i;
+    SDL_Haptic *haptic;
+
+    /* Must be a valid joystick */
+    if (!SDL_PrivateJoystickValid(&joystick)) {
+        SDL_SetError("Haptic: Joystick isn't valid.");
+        return NULL;
+    }
+
+    /* Joystick must be haptic */
+    if (SDL_SYS_JoystickIsHaptic(joystick) <= 0) {
+        SDL_SetError("Haptic: Joystick isn't a haptic device.");
+        return NULL;
+    }
+
+    /* Check to see if joystick's haptic is already open */
+    for (i = 0; SDL_haptics[i]; i++) {
+        if (SDL_SYS_JoystickSameHaptic(SDL_haptics[i], joystick)) {
+            haptic = SDL_haptics[i];
+            ++haptic->ref_count;
+            return haptic;
+        }
+    }
+
+    /* Create the haptic device */
+    haptic = (SDL_Haptic *) SDL_malloc((sizeof *haptic));
+    if (haptic == NULL) {
+        SDL_OutOfMemory();
+        return NULL;
+    }
+
+    /* Initialize the haptic device */
+    SDL_memset(haptic, 0, sizeof(SDL_Haptic));
+    if (SDL_SYS_HapticOpenFromJoystick(haptic, joystick) < 0) {
+        SDL_free(haptic);
+        return NULL;
+    }
+
+    /* Add haptic to list */
+    ++haptic->ref_count;
+    for (i = 0; SDL_haptics[i]; i++)
+        /* Skip to next haptic */ ;
+    SDL_haptics[i] = haptic;
+
+    return haptic;
+}
+
+
+/*
+ * Closes a SDL_Haptic device.
+ */
+void
+SDL_HapticClose(SDL_Haptic * haptic)
+{
+    int i;
+
+    /* Must be valid */
+    if (!ValidHaptic(haptic)) {
+        return;
+    }
+
+    /* Check if it's still in use */
+    if (--haptic->ref_count < 0) {
+        return;
+    }
+
+    /* Close it, properly removing effects if needed */
+    for (i = 0; i < haptic->neffects; i++) {
+        if (haptic->effects[i].hweffect != NULL) {
+            SDL_HapticDestroyEffect(haptic, i);
+        }
+    }
+    SDL_SYS_HapticClose(haptic);
+
+    /* Remove from the list */
+    for (i = 0; SDL_haptics[i]; ++i) {
+        if (haptic == SDL_haptics[i]) {
+            SDL_haptics[i] = NULL;
+            SDL_memcpy(&SDL_haptics[i], &SDL_haptics[i + 1],
+                       (SDL_numhaptics - i) * sizeof(haptic));
+            break;
+        }
+    }
+
+    /* Free */
+    SDL_free(haptic);
+}
+
+/*
+ * Cleans up after the subsystem.
+ */
+void
+SDL_HapticQuit(void)
+{
+    SDL_SYS_HapticQuit();
+    if (SDL_haptics != NULL) {
+        SDL_free(SDL_haptics);
+        SDL_haptics = NULL;
+    }
+    SDL_numhaptics = 0;
+}
+
+/*
+ * Returns the number of effects a haptic device has.
+ */
+int
+SDL_HapticNumEffects(SDL_Haptic * haptic)
+{
+    if (!ValidHaptic(haptic)) {
+        return -1;
+    }
+
+    return haptic->neffects;
+}
+
+
+/*
+ * Returns the number of effects a haptic device can play.
+ */
+int
+SDL_HapticNumEffectsPlaying(SDL_Haptic * haptic)
+{
+    if (!ValidHaptic(haptic)) {
+        return -1;
+    }
+
+    return haptic->nplaying;
+}
+
+
+/*
+ * Returns supported effects by the device.
+ */
+unsigned int
+SDL_HapticQuery(SDL_Haptic * haptic)
+{
+    if (!ValidHaptic(haptic)) {
+        return -1;
+    }
+
+    return haptic->supported;
+}
+
+
+/*
+ * Returns the number of axis on the device.
+ */
+int
+SDL_HapticNumAxes(SDL_Haptic * haptic)
+{
+    if (!ValidHaptic(haptic)) {
+        return -1;
+    }
+
+    return haptic->naxes;
+}
+
+/*
+ * Checks to see if the device can support the effect.
+ */
+int
+SDL_HapticEffectSupported(SDL_Haptic * haptic, SDL_HapticEffect * effect)
+{
+    if (!ValidHaptic(haptic)) {
+        return -1;
+    }
+
+    if ((haptic->supported & effect->type) != 0)
+        return SDL_TRUE;
+    return SDL_FALSE;
+}
+
+/*
+ * Creates a new haptic effect.
+ */
+int
+SDL_HapticNewEffect(SDL_Haptic * haptic, SDL_HapticEffect * effect)
+{
+    int i;
+
+    /* Check for device validity. */
+    if (!ValidHaptic(haptic)) {
+        return -1;
+    }
+
+    /* Check to see if effect is supported */
+    if (SDL_HapticEffectSupported(haptic, effect) == SDL_FALSE) {
+        SDL_SetError("Haptic: Effect not supported by haptic device.");
+        return -1;
+    }
+
+    /* See if there's a free slot */
+    for (i = 0; i < haptic->neffects; i++) {
+        if (haptic->effects[i].hweffect == NULL) {
+
+            /* Now let the backend create the real effect */
+            if (SDL_SYS_HapticNewEffect(haptic, &haptic->effects[i], effect)
+                != 0) {
+                return -1;      /* Backend failed to create effect */
+            }
+
+            SDL_memcpy(&haptic->effects[i].effect, effect,
+                       sizeof(SDL_HapticEffect));
+            return i;
+        }
+    }
+
+    SDL_SetError("Haptic: Device has no free space left.");
+    return -1;
+}
+
+/*
+ * Checks to see if an effect is valid.
+ */
+static int
+ValidEffect(SDL_Haptic * haptic, int effect)
+{
+    if ((effect < 0) || (effect >= haptic->neffects)) {
+        SDL_SetError("Haptic: Invalid effect identifier.");
+        return 0;
+    }
+    return 1;
+}
+
+/*
+ * Updates an effect.
+ */
+int
+SDL_HapticUpdateEffect(SDL_Haptic * haptic, int effect,
+                       SDL_HapticEffect * data)
+{
+    if (!ValidHaptic(haptic) || !ValidEffect(haptic, effect)) {
+        return -1;
+    }
+
+    /* Can't change type dynamically. */
+    if (data->type != haptic->effects[effect].effect.type) {
+        SDL_SetError("Haptic: Updating effect type is illegal.");
+        return -1;
+    }
+
+    /* Updates the effect */
+    if (SDL_SYS_HapticUpdateEffect(haptic, &haptic->effects[effect], data) <
+        0) {
+        return -1;
+    }
+
+    SDL_memcpy(&haptic->effects[effect].effect, data,
+               sizeof(SDL_HapticEffect));
+    return 0;
+}
+
+
+/*
+ * Runs the haptic effect on the device.
+ */
+int
+SDL_HapticRunEffect(SDL_Haptic * haptic, int effect, Uint32 iterations)
+{
+    if (!ValidHaptic(haptic) || !ValidEffect(haptic, effect)) {
+        return -1;
+    }
+
+    /* Run the effect */
+    if (SDL_SYS_HapticRunEffect(haptic, &haptic->effects[effect], iterations)
+        < 0) {
+        return -1;
+    }
+
+    return 0;
+}
+
+/*
+ * Stops the haptic effect on the device.
+ */
+int
+SDL_HapticStopEffect(SDL_Haptic * haptic, int effect)
+{
+    if (!ValidHaptic(haptic) || !ValidEffect(haptic, effect)) {
+        return -1;
+    }
+
+    /* Stop the effect */
+    if (SDL_SYS_HapticStopEffect(haptic, &haptic->effects[effect]) < 0) {
+        return -1;
+    }
+
+    return 0;
+}
+
+/*
+ * Gets rid of a haptic effect.
+ */
+void
+SDL_HapticDestroyEffect(SDL_Haptic * haptic, int effect)
+{
+    if (!ValidHaptic(haptic) || !ValidEffect(haptic, effect)) {
+        return;
+    }
+
+    /* Not allocated */
+    if (haptic->effects[effect].hweffect == NULL) {
+        return;
+    }
+
+    SDL_SYS_HapticDestroyEffect(haptic, &haptic->effects[effect]);
+}
+
+/*
+ * Gets the status of a haptic effect.
+ */
+int
+SDL_HapticGetEffectStatus(SDL_Haptic * haptic, int effect)
+{
+    if (!ValidHaptic(haptic) || !ValidEffect(haptic, effect)) {
+        return -1;
+    }
+
+    if ((haptic->supported & SDL_HAPTIC_STATUS) == 0) {
+        SDL_SetError("Haptic: Device does not support status queries.");
+        return -1;
+    }
+
+    return SDL_SYS_HapticGetEffectStatus(haptic, &haptic->effects[effect]);
+}
+
+/*
+ * Sets the global gain of the device.
+ */
+int
+SDL_HapticSetGain(SDL_Haptic * haptic, int gain)
+{
+    const char *env;
+    int real_gain, max_gain;
+
+    if (!ValidHaptic(haptic)) {
+        return -1;
+    }
+
+    if ((haptic->supported & SDL_HAPTIC_GAIN) == 0) {
+        SDL_SetError("Haptic: Device does not support setting gain.");
+        return -1;
+    }
+
+    if ((gain < 0) || (gain > 100)) {
+        SDL_SetError("Haptic: Gain must be between 0 and 100.");
+        return -1;
+    }
+
+    /* We use the envvar to get the maximum gain. */
+    env = SDL_getenv("SDL_HAPTIC_GAIN_MAX");
+    if (env != NULL) {
+        max_gain = SDL_atoi(env);
+
+        /* Check for sanity. */
+        if (max_gain < 0)
+            max_gain = 0;
+        else if (max_gain > 100)
+            max_gain = 100;
+
+        /* We'll scale it linearly with SDL_HAPTIC_GAIN_MAX */
+        real_gain = (gain * max_gain) / 100;
+    } else {
+        real_gain = gain;
+    }
+
+    if (SDL_SYS_HapticSetGain(haptic, real_gain) < 0) {
+        return -1;
+    }
+
+    return 0;
+}
+
+/*
+ * Makes the device autocenter, 0 disables.
+ */
+int
+SDL_HapticSetAutocenter(SDL_Haptic * haptic, int autocenter)
+{
+    if (!ValidHaptic(haptic)) {
+        return -1;
+    }
+
+    if ((haptic->supported & SDL_HAPTIC_AUTOCENTER) == 0) {
+        SDL_SetError("Haptic: Device does not support setting autocenter.");
+        return -1;
+    }
+
+    if ((autocenter < 0) || (autocenter > 100)) {
+        SDL_SetError("Haptic: Autocenter must be between 0 and 100.");
+        return -1;
+    }
+
+    if (SDL_SYS_HapticSetAutocenter(haptic, autocenter) < 0) {
+        return -1;
+    }
+
+    return 0;
+}
+
+/*
+ * Pauses the haptic device.
+ */
+int
+SDL_HapticPause(SDL_Haptic * haptic)
+{
+    if (!ValidHaptic(haptic)) {
+        return -1;
+    }
+
+    if ((haptic->supported & SDL_HAPTIC_PAUSE) == 0) {
+        SDL_SetError("Haptic: Device does not support setting pausing.");
+        return -1;
+    }
+
+    return SDL_SYS_HapticPause(haptic);
+}
+
+/*
+ * Unpauses the haptic device.
+ */
+int
+SDL_HapticUnpause(SDL_Haptic * haptic)
+{
+    if (!ValidHaptic(haptic)) {
+        return -1;
+    }
+
+    if ((haptic->supported & SDL_HAPTIC_PAUSE) == 0) {
+        return 0;               /* Not going to be paused, so we pretend it's unpaused. */
+    }
+
+    return SDL_SYS_HapticUnpause(haptic);
+}
+
+/*
+ * Stops all the currently playing effects.
+ */
+int
+SDL_HapticStopAll(SDL_Haptic * haptic)
+{
+    if (!ValidHaptic(haptic)) {
+        return -1;
+    }
+
+    return SDL_SYS_HapticStopAll(haptic);
+}

Externals/SDL/src/haptic/SDL_syshaptic.h

@@ -0,0 +1,201 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 2008 Edgar Simo
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+#include "SDL_config.h"
+
+#include "SDL_haptic.h"
+
+
+/*
+ * Number of haptic devices on the system.
+ */
+extern Uint8 SDL_numhaptics;
+
+
+struct haptic_effect
+{
+    SDL_HapticEffect effect;    /* The current event */
+    struct haptic_hweffect *hweffect;   /* The hardware behind the event */
+};
+
+/*
+ * The real SDL_Haptic struct.
+ */
+struct _SDL_Haptic
+{
+    Uint8 index;                /* Stores index it is attached to */
+
+    struct haptic_effect *effects;      /* Allocated effects */
+    int neffects;               /* Maximum amount of effects */
+    int nplaying;               /* Maximum amount of effects to play at the same time */
+    unsigned int supported;     /* Supported effects */
+    int naxes;                  /* Number of axes on the device. */
+
+    struct haptic_hwdata *hwdata;       /* Driver dependent */
+    int ref_count;              /* Count for multiple opens */
+};
+
+/* 
+ * Scans the system for haptic devices.
+ *
+ * Returns 0 on success, -1 on error.
+ */
+extern int SDL_SYS_HapticInit(void);
+
+/*
+ * Gets the device dependent name of the haptic device
+ */
+extern const char *SDL_SYS_HapticName(int index);
+
+/*
+ * Opens the haptic device for usage.  The haptic device should have
+ * the index value set previously.
+ *
+ * Returns 0 on success, -1 on error.
+ */
+extern int SDL_SYS_HapticOpen(SDL_Haptic * haptic);
+
+/*
+ * Returns the index of the haptic core pointer or -1 if none is found.
+ */
+int SDL_SYS_HapticMouse(void);
+
+/*
+ * Checks to see if the joystick has haptic capabilities.
+ *
+ * Returns >0 if haptic capabilities are detected, 0 if haptic
+ * capabilities aren't detected and -1 on error.
+ */
+extern int SDL_SYS_JoystickIsHaptic(SDL_Joystick * joystick);
+
+/*
+ * Opens the haptic device for usage using the same device as
+ * the joystick.
+ *
+ * Returns 0 on success, -1 on error.
+ */
+extern int SDL_SYS_HapticOpenFromJoystick(SDL_Haptic * haptic,
+                                          SDL_Joystick * joystick);
+/*
+ * Checks to see if haptic device and joystick device are the same.
+ *
+ * Returns 1 if they are the same, 0 if they aren't.
+ */
+extern int SDL_SYS_JoystickSameHaptic(SDL_Haptic * haptic,
+                                      SDL_Joystick * joystick);
+
+/*
+ * Closes a haptic device after usage.
+ */
+extern void SDL_SYS_HapticClose(SDL_Haptic * haptic);
+
+/*
+ * Performs a cleanup on the haptic subsystem.
+ */
+extern void SDL_SYS_HapticQuit(void);
+
+/*
+ * Creates a new haptic effect on the haptic device using base
+ * as a template for the effect.
+ *
+ * Returns 0 on success, -1 on error.
+ */
+extern int SDL_SYS_HapticNewEffect(SDL_Haptic * haptic,
+                                   struct haptic_effect *effect,
+                                   SDL_HapticEffect * base);
+
+/*
+ * Updates the haptic effect on the haptic device using data
+ * as a template.
+ *
+ * Returns 0 on success, -1 on error.
+ */
+extern int SDL_SYS_HapticUpdateEffect(SDL_Haptic * haptic,
+                                      struct haptic_effect *effect,
+                                      SDL_HapticEffect * data);
+
+/*
+ * Runs the effect on the haptic device.
+ *
+ * Returns 0 on success, -1 on error.
+ */
+extern int SDL_SYS_HapticRunEffect(SDL_Haptic * haptic,
+                                   struct haptic_effect *effect,
+                                   Uint32 iterations);
+
+/*
+ * Stops the effect on the haptic device.
+ *
+ * Returns 0 on success, -1 on error.
+ */
+extern int SDL_SYS_HapticStopEffect(SDL_Haptic * haptic,
+                                    struct haptic_effect *effect);
+
+/*
+ * Cleanups up the effect on the haptic device.
+ */
+extern void SDL_SYS_HapticDestroyEffect(SDL_Haptic * haptic,
+                                        struct haptic_effect *effect);
+
+/*
+ * Queries the device for the status of effect.
+ *
+ * Returns 0 if device is stopped, >0 if device is playing and
+ * -1 on error.
+ */
+extern int SDL_SYS_HapticGetEffectStatus(SDL_Haptic * haptic,
+                                         struct haptic_effect *effect);
+
+/*
+ * Sets the global gain of the haptic device.
+ *
+ * Returns 0 on success, -1 on error.
+ */
+extern int SDL_SYS_HapticSetGain(SDL_Haptic * haptic, int gain);
+
+/*
+ * Sets the autocenter feature of the haptic device.
+ *
+ * Returns 0 on success, -1 on error.
+ */
+extern int SDL_SYS_HapticSetAutocenter(SDL_Haptic * haptic, int autocenter);
+
+/*
+ * Pauses the haptic device.
+ *
+ * Returns 0 on success, -1 on error.
+ */
+extern int SDL_SYS_HapticPause(SDL_Haptic * haptic);
+
+/*
+ * Unpauses the haptic device.
+ *
+ * Returns 0 on success, -1 on error.
+ */
+extern int SDL_SYS_HapticUnpause(SDL_Haptic * haptic);
+
+/*
+ * Stops all the currently playing haptic effects on the device.
+ *
+ * Returns 0 on success, -1 on error.
+ */
+extern int SDL_SYS_HapticStopAll(SDL_Haptic * haptic);

Externals/SDL/src/haptic/dummy/SDL_syshaptic.c

@@ -0,0 +1,195 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 2008 Edgar Simo
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#if defined(SDL_HAPTIC_DUMMY) || defined(SDL_HAPTIC_DISABLED)
+
+#include "SDL_haptic.h"
+#include "../SDL_syshaptic.h"
+
+
+static int
+SDL_SYS_LogicError(void)
+{
+    SDL_SetError("Logic error: No haptic devices available.");
+    return 0;
+}
+
+
+int
+SDL_SYS_HapticInit(void)
+{
+    return 0;
+}
+
+
+const char *
+SDL_SYS_HapticName(int index)
+{
+    SDL_SYS_LogicError();
+    return NULL;
+}
+
+
+int
+SDL_SYS_HapticOpen(SDL_Haptic * haptic)
+{
+    SDL_SYS_LogicError();
+    return -1;
+}
+
+
+int
+SDL_SYS_HapticMouse(void)
+{
+    return -1;
+}
+
+
+int
+SDL_SYS_JoystickIsHaptic(SDL_Joystick * joystick)
+{
+    return 0;
+}
+
+
+int
+SDL_SYS_HapticOpenFromJoystick(SDL_Haptic * haptic, SDL_Joystick * joystick)
+{
+    SDL_SYS_LogicError();
+    return -1;
+}
+
+
+int
+SDL_SYS_JoystickSameHaptic(SDL_Haptic * haptic, SDL_Joystick * joystick)
+{
+    return 0;
+}
+
+
+void
+SDL_SYS_HapticClose(SDL_Haptic * haptic)
+{
+    return;
+}
+
+
+void
+SDL_SYS_HapticQuit(void)
+{
+    return;
+}
+
+
+int
+SDL_SYS_HapticNewEffect(SDL_Haptic * haptic,
+                        struct haptic_effect *effect, SDL_HapticEffect * base)
+{
+    SDL_SYS_LogicError();
+    return -1;
+}
+
+
+int
+SDL_SYS_HapticUpdateEffect(SDL_Haptic * haptic,
+                           struct haptic_effect *effect,
+                           SDL_HapticEffect * data)
+{
+    SDL_SYS_LogicError();
+    return -1;
+}
+
+
+int
+SDL_SYS_HapticRunEffect(SDL_Haptic * haptic, struct haptic_effect *effect,
+                        Uint32 iterations)
+{
+    SDL_SYS_LogicError();
+    return -1;
+}
+
+
+int
+SDL_SYS_HapticStopEffect(SDL_Haptic * haptic, struct haptic_effect *effect)
+{
+    SDL_SYS_LogicError();
+    return -1;
+}
+
+
+void
+SDL_SYS_HapticDestroyEffect(SDL_Haptic * haptic, struct haptic_effect *effect)
+{
+    SDL_SYS_LogicError();
+    return;
+}
+
+
+int
+SDL_SYS_HapticGetEffectStatus(SDL_Haptic * haptic,
+                              struct haptic_effect *effect)
+{
+    SDL_SYS_LogicError();
+    return -1;
+}
+
+
+int
+SDL_SYS_HapticSetGain(SDL_Haptic * haptic, int gain)
+{
+    SDL_SYS_LogicError();
+    return -1;
+}
+
+
+int
+SDL_SYS_HapticSetAutocenter(SDL_Haptic * haptic, int autocenter)
+{
+    SDL_SYS_LogicError();
+    return -1;
+}
+
+int
+SDL_SYS_HapticPause(SDL_Haptic * haptic)
+{
+    SDL_SYS_LogicError();
+    return -1;
+}
+
+int
+SDL_SYS_HapticUnpause(SDL_Haptic * haptic)
+{
+    SDL_SYS_LogicError();
+    return -1;
+}
+
+int
+SDL_SYS_HapticStopAll(SDL_Haptic * haptic)
+{
+    SDL_SYS_LogicError();
+    return -1;
+}
+
+
+
+#endif /* SDL_HAPTIC_DUMMY || SDL_HAPTIC_DISABLED */

Externals/SDL/src/haptic/linux/SDL_syshaptic.c

@@ -0,0 +1,968 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 2008 Edgar Simo
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifdef SDL_HAPTIC_LINUX
+
+#include "SDL_haptic.h"
+#include "../SDL_syshaptic.h"
+#include "SDL_joystick.h"
+#include "../../joystick/SDL_sysjoystick.h"     /* For the real SDL_Joystick */
+#include "../../joystick/linux/SDL_sysjoystick_c.h"     /* For joystick hwdata */
+
+#include <unistd.h>             /* close */
+#include <linux/input.h>        /* Force feedback linux stuff. */
+#include <fcntl.h>              /* O_RDWR */
+#include <limits.h>             /* INT_MAX */
+#include <errno.h>              /* errno, strerror */
+#include <math.h>               /* atan2 */
+#include <sys/stat.h>           /* stat */
+
+/* Just in case. */
+#ifndef M_PI
+#  define M_PI     3.14159265358979323846
+#endif
+
+
+#define MAX_HAPTICS  32         /* It's doubtful someone has more then 32 evdev */
+
+
+/*
+ * List of available haptic devices.
+ */
+static struct
+{
+    char *fname;                /* Dev path name (like /dev/input/event1) */
+    SDL_Haptic *haptic;         /* Assosciated haptic. */
+} SDL_hapticlist[MAX_HAPTICS];
+
+
+/*
+ * Haptic system hardware data.
+ */
+struct haptic_hwdata
+{
+    int fd;                     /* File descriptor of the device. */
+    char *fname;                /* Points to the name in SDL_hapticlist. */
+};
+
+
+/*
+ * Haptic system effect data.
+ */
+struct haptic_hweffect
+{
+    struct ff_effect effect;    /* The linux kernel effect structure. */
+};
+
+
+
+#define test_bit(nr, addr) \
+   (((1UL << ((nr) & 31)) & (((const unsigned int *) addr)[(nr) >> 5])) != 0)
+#define EV_TEST(ev,f) \
+   if (test_bit((ev), features)) ret |= (f);
+/*
+ * Test whether a device has haptic properties.
+ * Returns available properties or 0 if there are none.
+ */
+static int
+EV_IsHaptic(int fd)
+{
+    unsigned int ret;
+    unsigned long features[1 + FF_MAX / sizeof(unsigned long)];
+
+    /* Ask device for what it has. */
+    ret = 0;
+    if (ioctl(fd, EVIOCGBIT(EV_FF, sizeof(features)), features) < 0) {
+        SDL_SetError("Haptic: Unable to get device's features: %s",
+                     strerror(errno));
+        return -1;
+    }
+
+    /* Convert supported features to SDL_HAPTIC platform-neutral features. */
+    EV_TEST(FF_CONSTANT, SDL_HAPTIC_CONSTANT);
+    EV_TEST(FF_SINE, SDL_HAPTIC_SINE);
+    EV_TEST(FF_SQUARE, SDL_HAPTIC_SQUARE);
+    EV_TEST(FF_TRIANGLE, SDL_HAPTIC_TRIANGLE);
+    EV_TEST(FF_SAW_UP, SDL_HAPTIC_SAWTOOTHUP);
+    EV_TEST(FF_SAW_DOWN, SDL_HAPTIC_SAWTOOTHDOWN);
+    EV_TEST(FF_RAMP, SDL_HAPTIC_RAMP);
+    EV_TEST(FF_SPRING, SDL_HAPTIC_SPRING);
+    EV_TEST(FF_FRICTION, SDL_HAPTIC_FRICTION);
+    EV_TEST(FF_DAMPER, SDL_HAPTIC_DAMPER);
+    EV_TEST(FF_INERTIA, SDL_HAPTIC_INERTIA);
+    EV_TEST(FF_CUSTOM, SDL_HAPTIC_CUSTOM);
+    EV_TEST(FF_GAIN, SDL_HAPTIC_GAIN);
+    EV_TEST(FF_AUTOCENTER, SDL_HAPTIC_AUTOCENTER);
+
+    /* Return what it supports. */
+    return ret;
+}
+
+
+/*
+ * Tests whether a device is a mouse or not.
+ */
+static int
+EV_IsMouse(int fd)
+{
+    unsigned long argp[40];
+
+    /* Ask for supported features. */
+    if (ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(argp)), argp) < 0) {
+        return -1;
+    }
+
+    /* Currently we only test for BTN_MOUSE which can give fake positives. */
+    if (test_bit(BTN_MOUSE, argp) != 0) {
+        return 1;
+    }
+
+    return 0;
+}
+
+/*
+ * Initializes the haptic subsystem by finding available devices.
+ */
+int
+SDL_SYS_HapticInit(void)
+{
+    const char joydev_pattern[] = "/dev/input/event%d";
+    dev_t dev_nums[MAX_HAPTICS];
+    char path[PATH_MAX];
+    struct stat sb;
+    int fd;
+    int i, j, k;
+    int duplicate;
+    int numhaptics;
+
+    numhaptics = 0;
+
+    /* 
+     * Limit amount of checks to MAX_HAPTICS since we may or may not have
+     * permission to some or all devices.
+     */
+    i = 0;
+    for (j = 0; j < MAX_HAPTICS; ++j) {
+
+        snprintf(path, PATH_MAX, joydev_pattern, i++);
+
+        /* check to see if file exists */
+        if (stat(path, &sb) != 0)
+            break;
+
+        /* check for duplicates */
+        duplicate = 0;
+        for (k = 0; (k < numhaptics) && !duplicate; ++k) {
+            if (sb.st_rdev == dev_nums[k]) {
+                duplicate = 1;
+            }
+        }
+        if (duplicate) {
+            continue;
+        }
+
+        /* try to open */
+        fd = open(path, O_RDWR, 0);
+        if (fd < 0)
+            continue;
+
+#ifdef DEBUG_INPUT_EVENTS
+        printf("Checking %s\n", path);
+#endif
+
+        /* see if it works */
+        if (EV_IsHaptic(fd) > 0) {
+            SDL_hapticlist[numhaptics].fname = SDL_strdup(path);
+            SDL_hapticlist[numhaptics].haptic = NULL;
+            dev_nums[numhaptics] = sb.st_rdev;
+            ++numhaptics;
+        }
+        close(fd);
+    }
+
+    return numhaptics;
+}
+
+
+/*
+ * Gets the name from a file descriptor.
+ */
+static const char *
+SDL_SYS_HapticNameFromFD(int fd)
+{
+    static char namebuf[128];
+
+    /* We use the evdev name ioctl. */
+    if (ioctl(fd, EVIOCGNAME(sizeof(namebuf)), namebuf) <= 0) {
+        return NULL;
+    }
+
+    return namebuf;
+}
+
+
+/*
+ * Return the name of a haptic device, does not need to be opened.
+ */
+const char *
+SDL_SYS_HapticName(int index)
+{
+    int fd;
+    const char *name;
+
+    /* Open the haptic device. */
+    name = NULL;
+    fd = open(SDL_hapticlist[index].fname, O_RDONLY, 0);
+
+    if (fd >= 0) {
+
+        name = SDL_SYS_HapticNameFromFD(fd);
+        if (name == NULL) {
+            /* No name found, return device character device */
+            name = SDL_hapticlist[index].fname;
+        }
+    }
+    close(fd);
+
+    return name;
+}
+
+
+/*
+ * Opens the haptic device from the file descriptor.
+ */
+static int
+SDL_SYS_HapticOpenFromFD(SDL_Haptic * haptic, int fd)
+{
+    const char *name;
+
+    /* Allocate the hwdata */
+    haptic->hwdata = (struct haptic_hwdata *)
+        SDL_malloc(sizeof(*haptic->hwdata));
+    if (haptic->hwdata == NULL) {
+        SDL_OutOfMemory();
+        goto open_err;
+    }
+    SDL_memset(haptic->hwdata, 0, sizeof(*haptic->hwdata));
+
+    /* Set the data. */
+    haptic->hwdata->fd = fd;
+    haptic->supported = EV_IsHaptic(fd);
+    haptic->naxes = 2;          /* Hardcoded for now, not sure if it's possible to find out. */
+
+    /* Set the effects */
+    if (ioctl(fd, EVIOCGEFFECTS, &haptic->neffects) < 0) {
+        SDL_SetError("Haptic: Unable to query device memory: %s",
+                     strerror(errno));
+        goto open_err;
+    }
+    haptic->nplaying = haptic->neffects;        /* Linux makes no distinction. */
+    haptic->effects = (struct haptic_effect *)
+        SDL_malloc(sizeof(struct haptic_effect) * haptic->neffects);
+    if (haptic->effects == NULL) {
+        SDL_OutOfMemory();
+        goto open_err;
+    }
+    /* Clear the memory */
+    SDL_memset(haptic->effects, 0,
+               sizeof(struct haptic_effect) * haptic->neffects);
+
+    return 0;
+
+    /* Error handling */
+  open_err:
+    close(fd);
+    if (haptic->hwdata != NULL) {
+        free(haptic->hwdata);
+        haptic->hwdata = NULL;
+    }
+    return -1;
+}
+
+
+/*
+ * Opens a haptic device for usage.
+ */
+int
+SDL_SYS_HapticOpen(SDL_Haptic * haptic)
+{
+    int fd;
+    int ret;
+
+    /* Open the character device */
+    fd = open(SDL_hapticlist[haptic->index].fname, O_RDWR, 0);
+    if (fd < 0) {
+        SDL_SetError("Haptic: Unable to open %s: %s",
+                     SDL_hapticlist[haptic->index], strerror(errno));
+        return -1;
+    }
+
+    /* Try to create the haptic. */
+    ret = SDL_SYS_HapticOpenFromFD(haptic, fd); /* Already closes on error. */
+    if (ret < 0) {
+        return -1;
+    }
+
+    /* Set the fname. */
+    haptic->hwdata->fname = SDL_hapticlist[haptic->index].fname;
+    return 0;
+}
+
+
+/*
+ * Opens a haptic device from first mouse it finds for usage.
+ */
+int
+SDL_SYS_HapticMouse(void)
+{
+    int fd;
+    int i;
+
+    for (i = 0; i < SDL_numhaptics; i++) {
+
+        /* Open the device. */
+        fd = open(SDL_hapticlist[i].fname, O_RDWR, 0);
+        if (fd < 0) {
+            SDL_SetError("Haptic: Unable to open %s: %s",
+                         SDL_hapticlist[i], strerror(errno));
+            return -1;
+        }
+
+        /* Is it a mouse? */
+        if (EV_IsMouse(fd)) {
+            close(fd);
+            return i;
+        }
+
+        close(fd);
+    }
+
+    return -1;
+}
+
+
+/*
+ * Checks to see if a joystick has haptic features.
+ */
+int
+SDL_SYS_JoystickIsHaptic(SDL_Joystick * joystick)
+{
+    return EV_IsHaptic(joystick->hwdata->fd);
+}
+
+
+/*
+ * Checks to see if the haptic device and joystick and in reality the same.
+ */
+int
+SDL_SYS_JoystickSameHaptic(SDL_Haptic * haptic, SDL_Joystick * joystick)
+{
+    /* We are assuming linux is using evdev which should trump the old
+     * joystick methods. */
+    if (SDL_strcmp(joystick->hwdata->fname, haptic->hwdata->fname) == 0) {
+        return 1;
+    }
+    return 0;
+}
+
+
+/*
+ * Opens a SDL_Haptic from a SDL_Joystick.
+ */
+int
+SDL_SYS_HapticOpenFromJoystick(SDL_Haptic * haptic, SDL_Joystick * joystick)
+{
+    int i;
+    int fd;
+    int ret;
+
+
+    /* Find the joystick in the haptic list. */
+    for (i = 0; i < MAX_HAPTICS; i++) {
+        if (SDL_hapticlist[i].fname != NULL) {
+            if (SDL_strcmp(SDL_hapticlist[i].fname, joystick->hwdata->fname)
+                == 0) {
+                haptic->index = i;
+                break;
+            }
+        }
+    }
+    if (i >= MAX_HAPTICS) {
+        SDL_SetError("Haptic: Joystick doesn't have Haptic capabilities");
+        return -1;
+    }
+
+    fd = open(joystick->hwdata->fname, O_RDWR, 0);
+    if (fd < 0) {
+        SDL_SetError("Haptic: Unable to open %s: %s",
+                     joystick->hwdata->fname, strerror(errno));
+        return -1;
+    }
+    ret = SDL_SYS_HapticOpenFromFD(haptic, fd); /* Already closes on error. */
+    if (ret < 0) {
+        return -1;
+    }
+
+    haptic->hwdata->fname = SDL_hapticlist[haptic->index].fname;
+    return 0;
+}
+
+
+/*
+ * Closes the haptic device.
+ */
+void
+SDL_SYS_HapticClose(SDL_Haptic * haptic)
+{
+    if (haptic->hwdata) {
+
+        /* Free effects. */
+        SDL_free(haptic->effects);
+        haptic->effects = NULL;
+        haptic->neffects = 0;
+
+        /* Clean up */
+        close(haptic->hwdata->fd);
+
+        /* Free */
+        SDL_free(haptic->hwdata);
+        haptic->hwdata = NULL;
+    }
+
+    /* Clear the rest. */
+    SDL_memset(haptic, 0, sizeof(SDL_Haptic));
+}
+
+
+/* 
+ * Clean up after system specific haptic stuff
+ */
+void
+SDL_SYS_HapticQuit(void)
+{
+    int i;
+
+    for (i = 0; SDL_hapticlist[i].fname != NULL; i++) {
+        /* Opened and not closed haptics are leaked, this is on purpose.
+         * Close your haptic devices after usage. */
+
+        SDL_free(SDL_hapticlist[i].fname);
+    }
+    SDL_hapticlist[0].fname = NULL;
+}
+
+
+/*
+ * Converts an SDL button to a ff_trigger button.
+ */
+static Uint16
+SDL_SYS_ToButton(Uint16 button)
+{
+    Uint16 ff_button;
+
+    ff_button = 0;
+
+    /*
+     * Not sure what the proper syntax is because this actually isn't implemented
+     * in the current kernel from what I've seen (2.6.26).
+     */
+    if (button != 0) {
+        ff_button = BTN_GAMEPAD + button - 1;
+    }
+
+    return ff_button;
+}
+
+
+/*
+ * Returns the ff_effect usable direction from a SDL_HapticDirection.
+ */
+static Uint16
+SDL_SYS_ToDirection(SDL_HapticDirection * dir)
+{
+    Uint32 tmp;
+    float f;                    /* Ideally we'd use fixed point math instead of floats... */
+
+    switch (dir->type) {
+    case SDL_HAPTIC_POLAR:
+        /* Linux directions are inverted. */
+        tmp = (((18000 + dir->dir[0]) % 36000) * 0xFFFF) / 36000;
+        return (Uint16) tmp;
+
+    case SDL_HAPTIC_CARTESIAN:
+        /* We must invert "x" and "y" to go clockwise. */
+        f = atan2(dir->dir[0], dir->dir[1]);
+        tmp = (int) (f * 18000. / M_PI) % 36000;
+        tmp = (tmp * 0xFFFF) / 36000;
+        return (Uint16) tmp;
+
+    case SDL_HAPTIC_SPHERICAL:
+        tmp = (36000 - dir->dir[0]) + 27000;    /* Convert to polars */
+        tmp = (((18000 + tmp) % 36000) * 0xFFFF) / 36000;
+        return (Uint16) tmp;
+
+    default:
+        SDL_SetError("Haptic: Unsupported direction type.");
+        return (Uint16) - 1;
+    }
+
+    return 0;
+}
+
+
+#define  CLAMP(x)    (((x) > 32767) ? 32767 : x)
+/*
+ * Initializes the linux effect struct from a haptic_effect.
+ * Values above 32767 (for unsigned) are unspecified so we must clamp.
+ */
+static int
+SDL_SYS_ToFFEffect(struct ff_effect *dest, SDL_HapticEffect * src)
+{
+    Uint32 tmp;
+    SDL_HapticConstant *constant;
+    SDL_HapticPeriodic *periodic;
+    SDL_HapticCondition *condition;
+    SDL_HapticRamp *ramp;
+
+    /* Clear up */
+    SDL_memset(dest, 0, sizeof(struct ff_effect));
+
+    switch (src->type) {
+    case SDL_HAPTIC_CONSTANT:
+        constant = &src->constant;
+
+        /* Header */
+        dest->type = FF_CONSTANT;
+        dest->direction = SDL_SYS_ToDirection(&constant->direction);
+        if (dest->direction == (Uint16) - 1)
+            return -1;
+
+        /* Replay */
+        dest->replay.length = (constant->length == SDL_HAPTIC_INFINITY) ?
+            0 : CLAMP(constant->length);
+        dest->replay.delay = CLAMP(constant->delay);
+
+        /* Trigger */
+        dest->trigger.button = SDL_SYS_ToButton(constant->button);
+        dest->trigger.interval = CLAMP(constant->interval);
+
+        /* Constant */
+        dest->u.constant.level = constant->level;
+
+        /* Envelope */
+        dest->u.constant.envelope.attack_length =
+            CLAMP(constant->attack_length);
+        dest->u.constant.envelope.attack_level =
+            CLAMP(constant->attack_level);
+        dest->u.constant.envelope.fade_length = CLAMP(constant->fade_length);
+        dest->u.constant.envelope.fade_level = CLAMP(constant->fade_level);
+
+        break;
+
+    case SDL_HAPTIC_SINE:
+    case SDL_HAPTIC_SQUARE:
+    case SDL_HAPTIC_TRIANGLE:
+    case SDL_HAPTIC_SAWTOOTHUP:
+    case SDL_HAPTIC_SAWTOOTHDOWN:
+        periodic = &src->periodic;
+
+        /* Header */
+        dest->type = FF_PERIODIC;
+        dest->direction = SDL_SYS_ToDirection(&periodic->direction);
+        if (dest->direction == (Uint16) - 1)
+            return -1;
+
+        /* Replay */
+        dest->replay.length = (periodic->length == SDL_HAPTIC_INFINITY) ?
+            0 : CLAMP(periodic->length);
+        dest->replay.delay = CLAMP(periodic->delay);
+
+        /* Trigger */
+        dest->trigger.button = SDL_SYS_ToButton(periodic->button);
+        dest->trigger.interval = CLAMP(periodic->interval);
+
+        /* Periodic */
+        if (periodic->type == SDL_HAPTIC_SINE)
+            dest->u.periodic.waveform = FF_SINE;
+        else if (periodic->type == SDL_HAPTIC_SQUARE)
+            dest->u.periodic.waveform = FF_SQUARE;
+        else if (periodic->type == SDL_HAPTIC_TRIANGLE)
+            dest->u.periodic.waveform = FF_TRIANGLE;
+        else if (periodic->type == SDL_HAPTIC_SAWTOOTHUP)
+            dest->u.periodic.waveform = FF_SAW_UP;
+        else if (periodic->type == SDL_HAPTIC_SAWTOOTHDOWN)
+            dest->u.periodic.waveform = FF_SAW_DOWN;
+        dest->u.periodic.period = CLAMP(periodic->period);
+        dest->u.periodic.magnitude = periodic->magnitude;
+        dest->u.periodic.offset = periodic->offset;
+        /* Phase is calculated based of offset from period and then clamped. */
+        tmp = ((periodic->phase % 36000) * dest->u.periodic.period) / 36000;
+        dest->u.periodic.phase = CLAMP(tmp);
+
+        /* Envelope */
+        dest->u.periodic.envelope.attack_length =
+            CLAMP(periodic->attack_length);
+        dest->u.periodic.envelope.attack_level =
+            CLAMP(periodic->attack_level);
+        dest->u.periodic.envelope.fade_length = CLAMP(periodic->fade_length);
+        dest->u.periodic.envelope.fade_level = CLAMP(periodic->fade_level);
+
+        break;
+
+    case SDL_HAPTIC_SPRING:
+    case SDL_HAPTIC_DAMPER:
+    case SDL_HAPTIC_INERTIA:
+    case SDL_HAPTIC_FRICTION:
+        condition = &src->condition;
+
+        /* Header */
+        if (condition->type == SDL_HAPTIC_SPRING)
+            dest->type = FF_SPRING;
+        else if (condition->type == SDL_HAPTIC_DAMPER)
+            dest->type = FF_DAMPER;
+        else if (condition->type == SDL_HAPTIC_INERTIA)
+            dest->type = FF_INERTIA;
+        else if (condition->type == SDL_HAPTIC_FRICTION)
+            dest->type = FF_FRICTION;
+        dest->direction = 0;    /* Handled by the condition-specifics. */
+
+        /* Replay */
+        dest->replay.length = (condition->length == SDL_HAPTIC_INFINITY) ?
+            0 : CLAMP(condition->length);
+        dest->replay.delay = CLAMP(condition->delay);
+
+        /* Trigger */
+        dest->trigger.button = SDL_SYS_ToButton(condition->button);
+        dest->trigger.interval = CLAMP(condition->interval);
+
+        /* Condition */
+        /* X axis */
+        dest->u.condition[0].right_saturation =
+            CLAMP(condition->right_sat[0]);
+        dest->u.condition[0].left_saturation = CLAMP(condition->left_sat[0]);
+        dest->u.condition[0].right_coeff = condition->right_coeff[0];
+        dest->u.condition[0].left_coeff = condition->left_coeff[0];
+        dest->u.condition[0].deadband = CLAMP(condition->deadband[0]);
+        dest->u.condition[0].center = condition->center[0];
+        /* Y axis */
+        dest->u.condition[1].right_saturation =
+            CLAMP(condition->right_sat[1]);
+        dest->u.condition[1].left_saturation = CLAMP(condition->left_sat[1]);
+        dest->u.condition[1].right_coeff = condition->right_coeff[1];
+        dest->u.condition[1].left_coeff = condition->left_coeff[1];
+        dest->u.condition[1].deadband = CLAMP(condition->deadband[1]);
+        dest->u.condition[1].center = condition->center[1];
+
+        /*
+         * There is no envelope in the linux force feedback api for conditions.
+         */
+
+        break;
+
+    case SDL_HAPTIC_RAMP:
+        ramp = &src->ramp;
+
+        /* Header */
+        dest->type = FF_RAMP;
+        dest->direction = SDL_SYS_ToDirection(&ramp->direction);
+        if (dest->direction == (Uint16) - 1)
+            return -1;
+
+        /* Replay */
+        dest->replay.length = (ramp->length == SDL_HAPTIC_INFINITY) ?
+            0 : CLAMP(ramp->length);
+        dest->replay.delay = CLAMP(ramp->delay);
+
+        /* Trigger */
+        dest->trigger.button = SDL_SYS_ToButton(ramp->button);
+        dest->trigger.interval = CLAMP(ramp->interval);
+
+        /* Ramp */
+        dest->u.ramp.start_level = ramp->start;
+        dest->u.ramp.end_level = ramp->end;
+
+        /* Envelope */
+        dest->u.ramp.envelope.attack_length = CLAMP(ramp->attack_length);
+        dest->u.ramp.envelope.attack_level = CLAMP(ramp->attack_level);
+        dest->u.ramp.envelope.fade_length = CLAMP(ramp->fade_length);
+        dest->u.ramp.envelope.fade_level = CLAMP(ramp->fade_level);
+
+        break;
+
+
+    default:
+        SDL_SetError("Haptic: Unknown effect type.");
+        return -1;
+    }
+
+    return 0;
+}
+
+
+/*
+ * Creates a new haptic effect.
+ */
+int
+SDL_SYS_HapticNewEffect(SDL_Haptic * haptic, struct haptic_effect *effect,
+                        SDL_HapticEffect * base)
+{
+    struct ff_effect *linux_effect;
+
+    /* Allocate the hardware effect */
+    effect->hweffect = (struct haptic_hweffect *)
+        SDL_malloc(sizeof(struct haptic_hweffect));
+    if (effect->hweffect == NULL) {
+        SDL_OutOfMemory();
+        return -1;
+    }
+
+    /* Prepare the ff_effect */
+    linux_effect = &effect->hweffect->effect;
+    if (SDL_SYS_ToFFEffect(linux_effect, base) != 0) {
+        goto new_effect_err;
+    }
+    linux_effect->id = -1;      /* Have the kernel give it an id */
+
+    /* Upload the effect */
+    if (ioctl(haptic->hwdata->fd, EVIOCSFF, linux_effect) < 0) {
+        SDL_SetError("Haptic: Error uploading effect to the device: %s",
+                     strerror(errno));
+        goto new_effect_err;
+    }
+
+    return 0;
+
+  new_effect_err:
+    free(effect->hweffect);
+    effect->hweffect = NULL;
+    return -1;
+}
+
+
+/*
+ * Updates an effect.
+ *
+ * Note: Dynamically updating the direction can in some cases force
+ * the effect to restart and run once.
+ */
+int
+SDL_SYS_HapticUpdateEffect(SDL_Haptic * haptic,
+                           struct haptic_effect *effect,
+                           SDL_HapticEffect * data)
+{
+    struct ff_effect linux_effect;
+
+    /* Create the new effect */
+    if (SDL_SYS_ToFFEffect(&linux_effect, data) != 0) {
+        return -1;
+    }
+    linux_effect.id = effect->hweffect->effect.id;
+
+    /* See if it can be uploaded. */
+    if (ioctl(haptic->hwdata->fd, EVIOCSFF, &linux_effect) < 0) {
+        SDL_SetError("Haptic: Error updating the effect: %s",
+                     strerror(errno));
+        return -1;
+    }
+
+    /* Copy the new effect into memory. */
+    SDL_memcpy(&effect->hweffect->effect, &linux_effect,
+               sizeof(struct ff_effect));
+
+    return effect->hweffect->effect.id;
+}
+
+
+/*
+ * Runs an effect.
+ */
+int
+SDL_SYS_HapticRunEffect(SDL_Haptic * haptic, struct haptic_effect *effect,
+                        Uint32 iterations)
+{
+    struct input_event run;
+
+    /* Prepare to run the effect */
+    run.type = EV_FF;
+    run.code = effect->hweffect->effect.id;
+    /* We don't actually have infinity here, so we just do INT_MAX which is pretty damn close. */
+    run.value = (iterations > INT_MAX) ? INT_MAX : iterations;
+
+    if (write(haptic->hwdata->fd, (const void *) &run, sizeof(run)) < 0) {
+        SDL_SetError("Haptic: Unable to run the effect: %s", strerror(errno));
+        return -1;
+    }
+
+    return 0;
+}
+
+
+/*
+ * Stops an effect.
+ */
+int
+SDL_SYS_HapticStopEffect(SDL_Haptic * haptic, struct haptic_effect *effect)
+{
+    struct input_event stop;
+
+    stop.type = EV_FF;
+    stop.code = effect->hweffect->effect.id;
+    stop.value = 0;
+
+    if (write(haptic->hwdata->fd, (const void *) &stop, sizeof(stop)) < 0) {
+        SDL_SetError("Haptic: Unable to stop the effect: %s",
+                     strerror(errno));
+        return -1;
+    }
+
+    return 0;
+}
+
+
+/*
+ * Frees the effect.
+ */
+void
+SDL_SYS_HapticDestroyEffect(SDL_Haptic * haptic, struct haptic_effect *effect)
+{
+    if (ioctl(haptic->hwdata->fd, EVIOCRMFF, effect->hweffect->effect.id) < 0) {
+        SDL_SetError("Haptic: Error removing the effect from the device: %s",
+                     strerror(errno));
+    }
+    SDL_free(effect->hweffect);
+    effect->hweffect = NULL;
+}
+
+
+/*
+ * Gets the status of a haptic effect.
+ */
+int
+SDL_SYS_HapticGetEffectStatus(SDL_Haptic * haptic,
+                              struct haptic_effect *effect)
+{
+#if 0                           /* Not supported atm. */
+    struct input_event ie;
+
+    ie.type = EV_FF;
+    ie.type = EV_FF_STATUS;
+    ie.code = effect->hweffect->effect.id;
+
+    if (write(haptic->hwdata->fd, &ie, sizeof(ie)) < 0) {
+        SDL_SetError("Haptic: Error getting device status.");
+        return -1;
+    }
+
+    return 0;
+#endif
+
+    return -1;
+}
+
+
+/*
+ * Sets the gain.
+ */
+int
+SDL_SYS_HapticSetGain(SDL_Haptic * haptic, int gain)
+{
+    struct input_event ie;
+
+    ie.type = EV_FF;
+    ie.code = FF_GAIN;
+    ie.value = (0xFFFFUL * gain) / 100;
+
+    if (write(haptic->hwdata->fd, &ie, sizeof(ie)) < 0) {
+        SDL_SetError("Haptic: Error setting gain: %s", strerror(errno));
+        return -1;
+    }
+
+    return 0;
+}
+
+
+/*
+ * Sets the autocentering.
+ */
+int
+SDL_SYS_HapticSetAutocenter(SDL_Haptic * haptic, int autocenter)
+{
+    struct input_event ie;
+
+    ie.type = EV_FF;
+    ie.code = FF_AUTOCENTER;
+    ie.value = (0xFFFFUL * autocenter) / 100;
+
+    if (write(haptic->hwdata->fd, &ie, sizeof(ie)) < 0) {
+        SDL_SetError("Haptic: Error setting autocenter: %s", strerror(errno));
+        return -1;
+    }
+
+    return 0;
+}
+
+
+/*
+ * Pausing is not supported atm by linux.
+ */
+int
+SDL_SYS_HapticPause(SDL_Haptic * haptic)
+{
+    return -1;
+}
+
+
+/*
+ * Unpausing is not supported atm by linux.
+ */
+int
+SDL_SYS_HapticUnpause(SDL_Haptic * haptic)
+{
+    return -1;
+}
+
+
+/*
+ * Stops all the currently playing effects.
+ */
+int
+SDL_SYS_HapticStopAll(SDL_Haptic * haptic)
+{
+    int i, ret;
+
+    /* Linux does not support this natively so we have to loop. */
+    for (i = 0; i < haptic->neffects; i++) {
+        if (haptic->effects[i].hweffect != NULL) {
+            ret = SDL_SYS_HapticStopEffect(haptic, &haptic->effects[i]);
+            if (ret < 0) {
+                SDL_SetError
+                    ("Haptic: Error while trying to stop all playing effects.");
+                return -1;
+            }
+        }
+    }
+    return 0;
+}
+
+
+#endif /* SDL_HAPTIC_LINUX */

Externals/SDL/src/haptic/nds/SDL_syshaptic.c

@@ -0,0 +1,330 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 2008 Edgar Simo
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifdef SDL_HAPTIC_NDS
+
+#include "SDL_haptic.h"
+#include "../SDL_syshaptic.h"
+#include "SDL_joystick.h"
+#include <nds/arm9/rumble.h>
+#include <nds/memory.h>
+
+#define MAX_HAPTICS  1
+/* right now only the ezf3in1 (and maybe official rumble pak) are supported
+   and there can only be one of those in at a time (in GBA slot.) */
+
+SDL_Haptic *nds_haptic = NULL;
+
+typedef struct
+{
+    enum
+    { NONE, OFFICIAL, EZF3IN1 } type;
+    int pos;
+} NDS_HapticData;
+
+
+
+void
+NDS_EZF_OpenNorWrite() 
+{
+    
+GBA_BUS[0x0FF0000] = 0xD200;
+    
+GBA_BUS[0x0000000] = 0x1500;
+    
+GBA_BUS[0x0010000] = 0xD200;
+    
+GBA_BUS[0x0020000] = 0x1500;
+    
+GBA_BUS[0x0E20000] = 0x1500;
+    
+GBA_BUS[0x0FE0000] = 0x1500;
+
+} 
+
+
+void
+
+NDS_EZF_CloseNorWrite() 
+{
+    
+GBA_BUS[0x0FF0000] = 0xD200;
+    
+GBA_BUS[0x0000000] = 0x1500;
+    
+GBA_BUS[0x0010000] = 0xD200;
+    
+GBA_BUS[0x0020000] = 0x1500;
+    
+GBA_BUS[0x0E20000] = 0xD200;
+    
+GBA_BUS[0x0FE0000] = 0x1500;
+
+}
+
+void
+NDS_EZF_ChipReset()
+{
+    
+GBA_BUS[0x0000] = 0x00F0;
+    
+GBA_BUS[0x1000] = 0x00F0;
+} 
+uint32 NDS_EZF_IsPresent() 
+{
+    
+vuint16 id1, id2;
+
+    NDS_EZF_OpenNorWrite();
+
+    GBA_BUS[0x0555] = 0x00AA;
+    GBA_BUS[0x02AA] = 0x0055;
+    GBA_BUS[0x0555] = 0x0090;
+    GBA_BUS[0x1555] = 0x00AA;
+    GBA_BUS[0x12AA] = 0x0055;
+    GBA_BUS[0x1555] = 0x0090;
+    
+id1 = GBA_BUS[0x0001];
+    
+id2 = GBA_BUS[0x1001];
+    
+if ((id1 != 0x227E) || (id2 != 0x227E)) {
+        NDS_EZF_CloseNorWrite();
+        
+return 0;
+    }
+    
+
+id1 = GBA_BUS[0x000E];
+    
+id2 = GBA_BUS[0x100E];
+
+    NDS_EZF_CloseNorWrite();
+    
+if (id1 == 0x2218 && id2 == 0x2218) {
+        
+return 1;
+    }
+    
+return 0;
+
+}
+
+void
+NDS_EZF_SetShake(u8 pos) 
+{
+    u16 data = ((pos % 3) | 0x00F0);
+    
+GBA_BUS[0x0FF0000] = 0xD200;
+    
+GBA_BUS[0x0000000] = 0x1500;
+    
+GBA_BUS[0x0010000] = 0xD200;
+    
+GBA_BUS[0x0020000] = 0x1500;
+    
+GBA_BUS[0x0F10000] = data;
+    
+GBA_BUS[0x0FE0000] = 0x1500;
+
+    GBA_BUS[0] = 0x0000;        /* write any value for vibration. */
+    GBA_BUS[0] = 0x0002;
+
+}
+
+static int
+SDL_SYS_LogicError(void)
+{
+    SDL_SetError("Logic error: No haptic devices available.");
+    return 0;
+}
+
+
+int
+SDL_SYS_HapticInit(void)
+{
+    int ret = 0;
+    if (isRumbleInserted()) {
+        /* official rumble pak is present. */
+        ret = 1;
+        printf("debug: haptic present: nintendo\n");
+    } else if (NDS_EZF_IsPresent()) {
+        /* ezflash 3-in-1 pak is present. */
+        ret = 1;
+        printf("debug: haptic present: ezf3in1\n");
+        NDS_EZF_ChipReset();
+    } else {
+        printf("debug: no haptic found\n");
+    }
+
+    return ret;
+}
+
+
+const char *
+SDL_SYS_HapticName(int index)
+{
+    if (nds_haptic) {
+        switch (nds_haptic->hwdata->type) {
+        case OFFICIAL:
+            return "Nintendo DS Rumble Pak";
+        case EZF3IN1:
+            return "EZFlash 3-in-1 Rumble";
+        default:
+            return NULL;
+        }
+    }
+    return NULL;
+}
+
+
+int
+SDL_SYS_HapticOpen(SDL_Haptic * haptic)
+{
+    if (!haptic) {
+        return -1;
+    }
+
+    haptic->hwdata = SDL_malloc(sizeof(NDS_HapticData));
+    if (!haptic->hwdata) {
+        SDL_OutOfMemory();
+        return -1;
+    }
+    nds_haptic = haptic;
+
+    haptic->supported = SDL_HAPTIC_CONSTANT;
+
+    /* determine what is here, if anything */
+    haptic->hwdata->type = NONE;
+    if (isRumbleInserted()) {
+        /* official rumble pak is present. */
+        haptic->hwdata->type = OFFICIAL;
+    } else if (NDS_EZF_IsPresent()) {
+        /* ezflash 3-in-1 pak is present. */
+        haptic->hwdata->type = EZF3IN1;
+        NDS_EZF_ChipReset();
+    } else {
+        /* no haptic present */
+        SDL_SYS_LogicError();
+        return -1;
+    }
+
+    return 0;
+}
+
+
+int
+SDL_SYS_HapticMouse(void)
+{
+    return -1;
+}
+
+
+int
+SDL_SYS_JoystickIsHaptic(SDL_Joystick * joystick)
+{
+    return 0;
+}
+
+
+int
+SDL_SYS_HapticOpenFromJoystick(SDL_Haptic * haptic, SDL_Joystick * joystick)
+{
+    /*SDL_SYS_LogicError(); */
+    return -1;
+}
+
+
+int
+SDL_SYS_JoystickSameHaptic(SDL_Haptic * haptic, SDL_Joystick * joystick)
+{
+    return 0;
+}
+
+
+void
+SDL_SYS_HapticClose(SDL_Haptic * haptic)
+{
+    return;
+}
+
+
+void
+SDL_SYS_HapticQuit(void)
+{
+    return;
+}
+
+
+int
+SDL_SYS_HapticNewEffect(SDL_Haptic * haptic,
+                        struct haptic_effect *effect, SDL_HapticEffect * base)
+{
+    SDL_SYS_LogicError();
+    return -1;
+}
+
+
+int
+SDL_SYS_HapticUpdateEffect(SDL_Haptic * haptic,
+                           struct haptic_effect *effect,
+                           SDL_HapticEffect * data)
+{
+    SDL_SYS_LogicError();
+    return -1;
+}
+
+
+int
+SDL_SYS_HapticRunEffect(SDL_Haptic * haptic, struct haptic_effect *effect,
+                        Uint32 iterations)
+{
+    SDL_SYS_LogicError();
+    return -1;
+}
+
+
+int
+SDL_SYS_HapticStopEffect(SDL_Haptic * haptic, struct haptic_effect *effect)
+{
+    SDL_SYS_LogicError();
+    return -1;
+}
+
+
+void
+SDL_SYS_HapticDestroyEffect(SDL_Haptic * haptic, struct haptic_effect *effect)
+{
+    SDL_SYS_LogicError();
+    return;
+}
+
+
+int
+SDL_SYS_HapticGetEffectStatus(SDL_Haptic * haptic,
+                              struct haptic_effect *effect)
+{
+    SDL_SYS_LogicError();
+    return -1;
+}
+