Remove Router code and test

The router is mostly unuseable in its current state and is unneeded, for the
purposes of this project. A new one should be made from scratch if needed.

9 files changed, 0 insertions, 6014 deletions

diff --git a/Router/OpenAL32.cpp b/Router/OpenAL32.cpp
deleted file mode 100644
index 8c84148b..00000000
--- a/Router/OpenAL32.cpp
+++ /dev/null
@@ -1,135 +0,0 @@
-/**
- * OpenAL cross platform audio library
- * Copyright (C) 1999-2000 by authors.
- * 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 Software Foundation, Inc., 59 Temple Place - Suite 330,
- *  Boston, MA  02111-1307, USA.
- * Or go to http://www.gnu.org/copyleft/lgpl.html
- */
-
-
-
-
-#include <windows.h>
-#include "OpenAL32.h"
-
-
-void CleanDeviceEnumeration();
-void CleanDeviceList(ALDEVICE *pDeviceList);
-
-//*****************************************************************************
-// DllMain
-//*****************************************************************************
-//
-BOOL APIENTRY DllMain(HANDLE module, DWORD reason, LPVOID reserved)
-{
-    BOOL result = TRUE;
-
-    // Perform actions based on the reason for calling.
-    switch(reason)
-    {
-        case DLL_PROCESS_ATTACH:
-            // Create the context list lock so I can safely add/remove contexts.
-            result = alListCreate(&alContextList);
-            break;
-
-        case DLL_THREAD_ATTACH:
-            // Do thread-specific initialization.
-            break;
-
-        case DLL_THREAD_DETACH:
-            // Do thread-specific cleanup.
-            break;
-
-        case DLL_PROCESS_DETACH:
-            // Perform any necessary cleanup.
-			CleanDeviceEnumeration();
-            alListFree(alContextList);
-            alContextList = 0;
-            break;
-    }
-
-    return TRUE;
-}
-
-
-void CleanDeviceEnumeration()
-{
-	if (pszDefaultDeviceSpecifier)
-	{
-		free(pszDefaultDeviceSpecifier);
-		pszDefaultDeviceSpecifier = NULL;
-	}
-
-	if (pszDeviceSpecifierList)
-	{
-		free(pszDeviceSpecifierList);
-		pszDeviceSpecifierList = NULL;
-	}
-
-	if (pszDefaultCaptureDeviceSpecifier)
-	{
-		free(pszDefaultCaptureDeviceSpecifier);
-		pszDefaultCaptureDeviceSpecifier = NULL;
-	}
-
-	if (pszCaptureDeviceSpecifierList)
-	{
-		free(pszCaptureDeviceSpecifierList);
-		pszCaptureDeviceSpecifierList = NULL;
-	}
-
-	if (pszDefaultAllDevicesSpecifier)
-	{
-		free(pszDefaultAllDevicesSpecifier);
-		pszDefaultAllDevicesSpecifier = NULL;
-	}
-
-	if (pszAllDevicesSpecifierList)
-	{
-		free(pszAllDevicesSpecifierList);
-		pszAllDevicesSpecifierList = NULL;
-	}
-
-	CleanDeviceList(g_pDeviceList);
-	g_pDeviceList = NULL;
-
-	CleanDeviceList(g_pCaptureDeviceList);
-	g_pCaptureDeviceList = NULL;
-
-	CleanDeviceList(g_pAllDevicesList);
-	g_pAllDevicesList = NULL;
-}
-
-void CleanDeviceList(ALDEVICE *pDeviceList)
-{
-	ALDEVICE *pDevice, *pNextDevice;
-
-	pDevice = pDeviceList;
-	
-	while (pDevice)
-	{
-		pNextDevice = pDevice->pNextDevice;
-
-		if (pDevice->pszHostDLLFilename)
-			free(pDevice->pszHostDLLFilename);
-
-		if (pDevice->pszDeviceName)
-			free(pDevice->pszDeviceName);
-
-		free(pDevice);
-
-		pDevice = pNextDevice;
-	}
-}
\ No newline at end of file
diff --git a/Router/OpenAL32.h b/Router/OpenAL32.h
deleted file mode 100644
index a291a5a8..00000000
--- a/Router/OpenAL32.h
+++ /dev/null
@@ -1,341 +0,0 @@
-/**
- * OpenAL cross platform audio library
- * Copyright (C) 1999-2000 by authors.
- * 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 Software Foundation, Inc., 59 Temple Place - Suite 330,
- *  Boston, MA  02111-1307, USA.
- * Or go to http://www.gnu.org/copyleft/lgpl.html
- */
-
-
-
-
-#ifndef _OPENAL32_H_
-#define _OPENAL32_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define AL_BUILD_LIBRARY
-
-#include "al\al.h"
-
-// ALAPI
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_ENABLE)(ALenum capability);
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_DISABLE)(ALenum capability);
-typedef ALAPI ALboolean      (ALAPIENTRY *ALAPI_IS_ENABLED)(ALenum capability);
-
-typedef ALAPI const ALchar*  (ALAPIENTRY *ALAPI_GET_STRING)(ALenum param);
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_GET_BOOLEANV)(ALenum param, ALboolean* data);
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_GET_INTEGERV)(ALenum param, ALint* data);
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_GET_FLOATV)(ALenum param, ALfloat* data);
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_GET_DOUBLEV)(ALenum param, ALdouble* data);
-typedef ALAPI ALboolean      (ALAPIENTRY *ALAPI_GET_BOOLEAN)(ALenum param);
-typedef ALAPI ALint          (ALAPIENTRY *ALAPI_GET_INTEGER)(ALenum param);
-typedef ALAPI ALfloat        (ALAPIENTRY *ALAPI_GET_FLOAT)(ALenum param);
-typedef ALAPI ALdouble       (ALAPIENTRY *ALAPI_GET_DOUBLE)(ALenum param);
-
-typedef ALAPI ALenum         (ALAPIENTRY *ALAPI_GET_ERROR)(ALvoid);
-
-typedef ALAPI ALboolean      (ALAPIENTRY *ALAPI_IS_EXTENSION_PRESENT)(const ALchar* ename);
-typedef ALAPI ALvoid*        (ALAPIENTRY *ALAPI_GET_PROC_ADDRESS)(const ALchar* fname);
-typedef ALAPI ALenum         (ALAPIENTRY *ALAPI_GET_ENUM_VALUE)(const ALchar* ename);
-
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_LISTENERF)(ALenum param, ALfloat value);
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_LISTENER3F)(ALenum param, ALfloat v1, ALfloat v2, ALfloat v3);
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_LISTENERFV)(ALenum param, const ALfloat* values);
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_LISTENERI)(ALenum param, ALint value);
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_LISTENER3I)( ALenum param, ALint value1, ALint value2, ALint value3 );
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_LISTENERIV)( ALenum param, const ALint* values );
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_GET_LISTENERF)(ALenum param, ALfloat* value);
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_GET_LISTENER3F)(ALenum param, ALfloat* v1, ALfloat* v2, ALfloat* v3);
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_GET_LISTENERFV)(ALenum param, ALfloat* values);
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_GET_LISTENERI)(ALenum param, ALint* value);
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_GET_LISTENER3I)( ALenum param, ALint *value1, ALint *value2, ALint *value3 );
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_GET_LISTENERIV)( ALenum param, ALint* values );
-
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_GEN_SOURCES)(ALsizei n, ALuint* sourceNames);
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_DELETE_SOURCES)(ALsizei n, const ALuint* sourceNames);
-typedef ALAPI ALboolean      (ALAPIENTRY *ALAPI_IS_SOURCE)(ALuint id);
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_SOURCEF)(ALuint sourceName, ALenum param, ALfloat value);
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_SOURCE3F)(ALuint sourceName, ALenum param, ALfloat v1, ALfloat v2, ALfloat v3);
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_SOURCEFV)(ALuint sourceName, ALenum param, const ALfloat* values);
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_SOURCEI)(ALuint sourceName, ALenum param, ALint value);
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_SOURCE3I)( ALuint sid, ALenum param, ALint value1, ALint value2, ALint value3 );
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_SOURCEIV)( ALuint sid, ALenum param, const ALint* values );
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_GET_SOURCEF)(ALuint sourceName, ALenum param, ALfloat* value);
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_GET_SOURCE3F)(ALuint sourceName, ALenum param, ALfloat* v1, ALfloat* v2, ALfloat* v3);
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_GET_SOURCEFV)(ALuint sourceName, ALenum param, const ALfloat* values);
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_GET_SOURCEI)(ALuint sourceName, ALenum param, ALint* value);
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_GET_SOURCE3I)( ALuint sid, ALenum param, ALint* value1, ALint* value2, ALint* value3);
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_GET_SOURCEIV)( ALuint sid, ALenum param, ALint* values );
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_SOURCE_PLAYV)(ALsizei n, const ALuint* sources);
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_SOURCE_STOPV)(ALsizei n, const ALuint* sources);
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_SOURCE_REWINDV)(ALsizei n, const ALuint* sources);
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_SOURCE_PAUSEV)(ALsizei n, const ALuint* sources);
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_SOURCE_PLAY)(ALuint sourceName);
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_SOURCE_STOP)(ALuint sourceName);
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_SOURCE_REWIND)(ALuint sourceName);
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_SOURCE_PAUSE)(ALuint sourceName);
-
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_SOURCE_QUEUE_BUFFERS)(ALuint sourceName, ALsizei n, const ALuint* bufferNames);
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_SOURCE_UNQUEUE_BUFFERS)(ALuint sourceName, ALsizei n, ALuint* bufferNames);
-
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_GEN_BUFFERS)(ALsizei n, ALuint* bufferNames);
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_DELETE_BUFFERS)(ALsizei n, const ALuint* bufferNames);
-typedef ALAPI ALboolean      (ALAPIENTRY *ALAPI_IS_BUFFER)(ALuint bufferName);
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_BUFFER_DATA)(ALuint bufferName, ALenum format, const ALvoid* data, ALsizei size, ALuint freq);
-
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_BUFFERF)( ALuint bid, ALenum param, ALfloat value);
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_BUFFER3F)( ALuint bid, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3 );
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_BUFFERFV)( ALuint bid, ALenum param, const ALfloat* values );
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_BUFFERI)( ALuint bid, ALenum param, ALint value);
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_BUFFER3I)( ALuint bid, ALenum param, ALint value1, ALint value2, ALint value3 );
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_BUFFERIV)( ALuint bid, ALenum param, const ALint* values );
-
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_GET_BUFFERF)( ALuint bid, ALenum param, ALfloat* value );
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_GET_BUFFER3F)( ALuint bid, ALenum param, ALfloat* value1, ALfloat* value2, ALfloat* value3);
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_GET_BUFFERFV)( ALuint bid, ALenum param, ALfloat* values );
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_GET_BUFFERI)( ALuint bid, ALenum param, ALint* value );
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_GET_BUFFER3I)( ALuint bid, ALenum param, ALint* value1, ALint* value2, ALint* value3);
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_GET_BUFFERIV)( ALuint bid, ALenum param, ALint* values );
-
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_DOPPLER_FACTOR)(ALfloat value);
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_DOPPLER_VELOCITY)(ALfloat value);
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_SPEED_OF_SOUND)(ALfloat value);
-typedef ALAPI ALvoid         (ALAPIENTRY *ALAPI_DISTANCE_MODEL)(ALenum value);
-
-typedef struct ALAPI_FXN_TABLE_STRUCT
-{
-    ALAPI_ENABLE                 alEnable;
-    ALAPI_DISABLE                alDisable;
-    ALAPI_IS_ENABLED             alIsEnabled;
-
-	ALAPI_GET_STRING             alGetString;
-	ALAPI_GET_BOOLEANV           alGetBooleanv;
-    ALAPI_GET_INTEGERV           alGetIntegerv;
-    ALAPI_GET_FLOATV             alGetFloatv;
-    ALAPI_GET_DOUBLEV            alGetDoublev;
-    ALAPI_GET_BOOLEAN            alGetBoolean;
-    ALAPI_GET_INTEGER            alGetInteger;
-    ALAPI_GET_FLOAT              alGetFloat;
-    ALAPI_GET_DOUBLE             alGetDouble;    
-
-    ALAPI_GET_ERROR              alGetError;
-
-    ALAPI_IS_EXTENSION_PRESENT   alIsExtensionPresent;
-    ALAPI_GET_PROC_ADDRESS       alGetProcAddress;
-    ALAPI_GET_ENUM_VALUE         alGetEnumValue;
-
-	ALAPI_LISTENERF              alListenerf;
-    ALAPI_LISTENER3F             alListener3f;
-    ALAPI_LISTENERFV             alListenerfv;
-    ALAPI_LISTENERI              alListeneri;
-	ALAPI_LISTENER3I			 alListener3i;
-	ALAPI_LISTENERIV			 alListeneriv;
-    
-	ALAPI_GET_LISTENERF          alGetListenerf;
-    ALAPI_GET_LISTENER3F         alGetListener3f;
-    ALAPI_GET_LISTENERFV         alGetListenerfv;
-    ALAPI_GET_LISTENERI          alGetListeneri;
-	ALAPI_GET_LISTENER3I		 alGetListener3i;
-	ALAPI_GET_LISTENERIV		 alGetListeneriv;
-
-    ALAPI_GEN_SOURCES            alGenSources;
-    ALAPI_DELETE_SOURCES         alDeleteSources;
-    ALAPI_IS_SOURCE              alIsSource;
-    ALAPI_SOURCEF                alSourcef;
-    ALAPI_SOURCE3F               alSource3f;
-    ALAPI_SOURCEFV               alSourcefv;
-	ALAPI_SOURCEI                alSourcei;
-	ALAPI_SOURCE3I				 alSource3i;
-	ALAPI_SOURCEIV				 alSourceiv;
-    ALAPI_GET_SOURCEF            alGetSourcef;
-    ALAPI_GET_SOURCE3F           alGetSource3f;
-    ALAPI_GET_SOURCEFV           alGetSourcefv;
-	ALAPI_GET_SOURCEI            alGetSourcei;
-	ALAPI_GET_SOURCE3I			 alGetSource3i;
-	ALAPI_GET_SOURCEIV			 alGetSourceiv;
-    ALAPI_SOURCE_PLAYV           alSourcePlayv;
-    ALAPI_SOURCE_STOPV           alSourceStopv;
-    ALAPI_SOURCE_REWINDV         alSourceRewindv;
-	ALAPI_SOURCE_PAUSEV          alSourcePausev;
-    ALAPI_SOURCE_PLAY            alSourcePlay;
-    ALAPI_SOURCE_STOP            alSourceStop;
-    ALAPI_SOURCE_REWIND          alSourceRewind;
-	ALAPI_SOURCE_PAUSE           alSourcePause;
-
-	ALAPI_SOURCE_QUEUE_BUFFERS   alSourceQueueBuffers;
-    ALAPI_SOURCE_UNQUEUE_BUFFERS alSourceUnqueueBuffers;
-
-    ALAPI_GEN_BUFFERS            alGenBuffers;
-    ALAPI_DELETE_BUFFERS         alDeleteBuffers;
-    ALAPI_IS_BUFFER              alIsBuffer;
-    ALAPI_BUFFER_DATA            alBufferData;
-	ALAPI_BUFFERF				 alBufferf;
-	ALAPI_BUFFER3F				 alBuffer3f;
-	ALAPI_BUFFERFV				 alBufferfv;
-	ALAPI_BUFFERI				 alBufferi;
-	ALAPI_BUFFER3I				 alBuffer3i;
-	ALAPI_BUFFERIV				 alBufferiv;
-    ALAPI_GET_BUFFERF            alGetBufferf;
-    ALAPI_GET_BUFFER3F			 alGetBuffer3f;
-	ALAPI_GET_BUFFERFV			 alGetBufferfv;
-	ALAPI_GET_BUFFERI            alGetBufferi;
-    ALAPI_GET_BUFFER3I			 alGetBuffer3i;
-	ALAPI_GET_BUFFERIV			 alGetBufferiv;
-
-    ALAPI_DOPPLER_FACTOR         alDopplerFactor;
-    ALAPI_DOPPLER_VELOCITY       alDopplerVelocity;
-	ALAPI_SPEED_OF_SOUND         alSpeedOfSound;
-	ALAPI_DISTANCE_MODEL         alDistanceModel;
-
-} ALAPI_FXN_TABLE;
-
-#include "al\alc.h"
-
-// ALCAPI
-typedef struct ALCdevice_struct ALCdevice;
-typedef struct ALCcontext_struct ALCcontext;
-
-typedef ALCAPI ALCcontext* (ALCAPIENTRY *ALCAPI_CREATE_CONTEXT)(ALCdevice* device, const ALint* attrList);
-typedef ALCAPI ALboolean   (ALCAPIENTRY *ALCAPI_MAKE_CONTEXT_CURRENT)(ALCcontext* context);
-typedef ALCAPI ALvoid      (ALCAPIENTRY *ALCAPI_PROCESS_CONTEXT)(ALCcontext* context);
-typedef ALCAPI ALCvoid     (ALCAPIENTRY *ALCAPI_SUSPEND_CONTEXT)(ALCcontext* context);
-typedef ALCAPI ALvoid      (ALCAPIENTRY *ALCAPI_DESTROY_CONTEXT)(ALCcontext* context);
-typedef ALCAPI ALCcontext* (ALCAPIENTRY *ALCAPI_GET_CURRENT_CONTEXT)(ALvoid);
-typedef ALCAPI ALCdevice*  (ALCAPIENTRY *ALCAPI_GET_CONTEXTS_DEVICE)(ALCcontext* context);
-
-typedef ALCAPI ALCdevice*  (ALCAPIENTRY *ALCAPI_OPEN_DEVICE)(const ALCchar* deviceName);
-typedef ALCAPI ALCboolean  (ALCAPIENTRY *ALCAPI_CLOSE_DEVICE)(ALCdevice* device);
-
-typedef ALCAPI ALenum      (ALCAPIENTRY *ALCAPI_GET_ERROR)(ALCdevice* device);
-
-typedef ALCAPI ALboolean   (ALCAPIENTRY *ALCAPI_IS_EXTENSION_PRESENT)(ALCdevice* device, const ALCchar* eName);
-typedef ALCAPI ALvoid*     (ALCAPIENTRY *ALCAPI_GET_PROC_ADDRESS)(ALCdevice* device, const ALCchar* fName);
-typedef ALCAPI ALenum      (ALCAPIENTRY *ALCAPI_GET_ENUM_VALUE)(ALCdevice* device, const ALCchar* eName);
-
-typedef ALCAPI const ALCchar*  (ALCAPIENTRY *ALCAPI_GET_STRING)(ALCdevice* device, ALenum param);
-typedef ALCAPI ALvoid          (ALCAPIENTRY *ALCAPI_GET_INTEGERV)(ALCdevice* device, ALenum param, ALsizei size, ALint* data);
-
-typedef ALCAPI ALCdevice * (ALCAPIENTRY *ALCAPI_CAPTURE_OPEN_DEVICE)( const ALCchar *devicename, ALCuint frequency, ALCenum format, ALCsizei buffersize );
-typedef ALCAPI ALCboolean  (ALCAPIENTRY *ALCAPI_CAPTURE_CLOSE_DEVICE)( ALCdevice *device );
-typedef ALCAPI void        (ALCAPIENTRY *ALCAPI_CAPTURE_START)( ALCdevice *device );
-typedef ALCAPI void        (ALCAPIENTRY *ALCAPI_CAPTURE_STOP)( ALCdevice *device );
-typedef ALCAPI void        (ALCAPIENTRY *ALCAPI_CAPTURE_SAMPLES)( ALCdevice *device, ALCvoid *buffer, ALCsizei samples );
-
-typedef struct ALCAPI_FXN_TABLE_STRUCT
-{
-	ALCAPI_CREATE_CONTEXT       alcCreateContext;
-    ALCAPI_MAKE_CONTEXT_CURRENT alcMakeContextCurrent;
-    ALCAPI_PROCESS_CONTEXT      alcProcessContext;
-	ALCAPI_SUSPEND_CONTEXT      alcSuspendContext;
-    ALCAPI_DESTROY_CONTEXT      alcDestroyContext;
-	ALCAPI_GET_CURRENT_CONTEXT  alcGetCurrentContext;
-    ALCAPI_GET_CONTEXTS_DEVICE  alcGetContextsDevice;
-
-	ALCAPI_OPEN_DEVICE          alcOpenDevice;
-    ALCAPI_CLOSE_DEVICE         alcCloseDevice;
-
-	ALCAPI_GET_ERROR            alcGetError;
-
-    ALCAPI_IS_EXTENSION_PRESENT alcIsExtensionPresent;
-    ALCAPI_GET_PROC_ADDRESS     alcGetProcAddress;
-    ALCAPI_GET_ENUM_VALUE       alcGetEnumValue;
-
-    ALCAPI_GET_STRING           alcGetString;
-    ALCAPI_GET_INTEGERV         alcGetIntegerv;
-
-	ALCAPI_CAPTURE_OPEN_DEVICE  alcCaptureOpenDevice;
-	ALCAPI_CAPTURE_CLOSE_DEVICE alcCaptureCloseDevice;
-	ALCAPI_CAPTURE_START        alcCaptureStart;
-	ALCAPI_CAPTURE_STOP         alcCaptureStop;
-	ALCAPI_CAPTURE_SAMPLES      alcCaptureSamples;
-
-} ALCAPI_FXN_TABLE;
-
-#include "windows.h"
-#include "alList.h"
-
-
-//*****************************************************************************
-// Additional Defines
-//*****************************************************************************
-
-typedef struct ALCdevice_struct
-{
-    //
-    // These variables must always be initialized.
-    //
-    ALenum                      LastError;
-    ALint                       InUse;
-
-    //
-    // Support for 3rd party OpenAL implementations.
-    //
-    HINSTANCE                   Dll;
-    ALCAPI_FXN_TABLE            AlcApi;
-
-	// Capture Device
-	ALCdevice*					CaptureDevice;
-
-    struct ALCdevice_struct*     DllDevice;
-
-} ALCdevice;
-
-typedef struct ALCcontext_struct
-{
-    //
-    // These variables are always initialized.
-    //
-    ALlistEntry                 ListEntry;
-    ALboolean                   Suspended;
-    ALenum                      LastError;
-    ALCdevice*                   Device;
-    ALAPI_FXN_TABLE             AlApi;
-    CRITICAL_SECTION            Lock;
-    struct ALCcontext_struct*    DllContext;
-
-} ALCcontext;
-
-
-extern ALlist* alContextList;
-extern ALCcontext* alCurrentContext;
-
-// Device Enumeration structures, strings and variables
-typedef struct _ALDEVICE
-{
-	ALchar				*pszDeviceName;
-	TCHAR				*pszHostDLLFilename;
-	struct _ALDEVICE	*pNextDevice;
-} ALDEVICE;
-
-extern ALchar *pszDefaultDeviceSpecifier;
-extern ALchar *pszDeviceSpecifierList;
-extern ALchar *pszDefaultCaptureDeviceSpecifier;
-extern ALchar *pszCaptureDeviceSpecifierList;
-extern ALchar *pszDefaultAllDevicesSpecifier;
-extern ALchar *pszAllDevicesSpecifierList;
-
-extern ALDEVICE *g_pDeviceList;
-extern ALDEVICE *g_pCaptureDeviceList;
-extern ALDEVICE *g_pAllDevicesList;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
-
diff --git a/Router/OpenAL32.rc b/Router/OpenAL32.rc
deleted file mode 100644
index 5ddbb5b9..00000000
--- a/Router/OpenAL32.rc
+++ /dev/null
@@ -1,101 +0,0 @@
-// Microsoft Visual C++ generated resource script.
-//
-#include "resource.h"
-
-#define APSTUDIO_READONLY_SYMBOLS
-/////////////////////////////////////////////////////////////////////////////
-//
-// Generated from the TEXTINCLUDE 2 resource.
-//
-#include "afxres.h"
-
-/////////////////////////////////////////////////////////////////////////////
-#undef APSTUDIO_READONLY_SYMBOLS
-
-/////////////////////////////////////////////////////////////////////////////
-// English (U.S.) resources
-
-#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
-#ifdef _WIN32
-LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
-#pragma code_page(1252)
-#endif //_WIN32
-
-/////////////////////////////////////////////////////////////////////////////
-//
-// Version
-//
-
-VS_VERSION_INFO VERSIONINFO
- FILEVERSION 6,14,357,23
- PRODUCTVERSION 6,14,357,23
- FILEFLAGSMASK 0x3fL
-#ifdef _DEBUG
- FILEFLAGS 0x1L
-#else
- FILEFLAGS 0x0L
-#endif
- FILEOS 0x40004L
- FILETYPE 0x2L
- FILESUBTYPE 0x0L
-BEGIN
-    BLOCK "StringFileInfo"
-    BEGIN
-        BLOCK "040904b0"
-        BEGIN
-            VALUE "CompanyName", "Portions (C) Creative Labs Inc. and NVIDIA Corp."
-            VALUE "FileDescription", "Standard OpenAL(TM) Implementation"
-            VALUE "FileVersion", "6.14.0357.23"
-            VALUE "LegalCopyright", "Copyright (C) 2000-2006"
-            VALUE "OriginalFilename", "OpenAL32.dll"
-            VALUE "ProductName", "Standard OpenAL(TM) Library"
-            VALUE "ProductVersion", "6.14.0357.23"
-        END
-    END
-    BLOCK "VarFileInfo"
-    BEGIN
-        VALUE "Translation", 0x409, 1200
-    END
-END
-
-
-#ifdef APSTUDIO_INVOKED
-/////////////////////////////////////////////////////////////////////////////
-//
-// TEXTINCLUDE
-//
-
-1 TEXTINCLUDE 
-BEGIN
-    "resource.h\0"
-END
-
-2 TEXTINCLUDE 
-BEGIN
-    "#include ""afxres.h""\r\n"
-    "\0"
-END
-
-3 TEXTINCLUDE 
-BEGIN
-    "\r\n"
-    "\0"
-END
-
-#endif    // APSTUDIO_INVOKED
-
-#endif    // English (U.S.) resources
-/////////////////////////////////////////////////////////////////////////////
-
-
-
-#ifndef APSTUDIO_INVOKED
-/////////////////////////////////////////////////////////////////////////////
-//
-// Generated from the TEXTINCLUDE 3 resource.
-//
-
-
-/////////////////////////////////////////////////////////////////////////////
-#endif    // not APSTUDIO_INVOKED
-
diff --git a/Router/al.cpp b/Router/al.cpp
deleted file mode 100644
index 81e11461..00000000
--- a/Router/al.cpp
+++ /dev/null
@@ -1,981 +0,0 @@
-/**
- * OpenAL cross platform audio library
- * Copyright (C) 1999-2003 by authors.
- * 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 Software Foundation, Inc., 59 Temple Place - Suite 330,
- *  Boston, MA  02111-1307, USA.
- * Or go to http://www.gnu.org/copyleft/lgpl.html
- */
-
-
-
-
-#include <al\alc.h>
-#include "OpenAL32.h"
-
-typedef struct ALfunction_struct
-{
-	ALchar		*funcName;
-	ALvoid		*address;
-} ALfunction;
-
-static ALfunction  function[]=   {	
-	{ "alEnable",                   (ALvoid *) alEnable                  },
-	{ "alDisable",                  (ALvoid *) alDisable                 },
-	{ "alIsEnabled",                (ALvoid *) alIsEnabled               },
-	{ "alGetString",                (ALvoid *) alGetString               },
-	{ "alGetBooleanv",              (ALvoid *) alGetBooleanv             },
-	{ "alGetIntegerv",              (ALvoid *) alGetIntegerv             },
-	{ "alGetFloatv",                (ALvoid *) alGetFloatv               },
-	{ "alGetDoublev",               (ALvoid *) alGetDoublev              },
-	{ "alGetBoolean",               (ALvoid *) alGetBoolean              },
-	{ "alGetInteger",               (ALvoid *) alGetInteger              },
-	{ "alGetFloat",                 (ALvoid *) alGetFloat                },
-	{ "alGetDouble",                (ALvoid *) alGetDouble               },
-	{ "alGetError",                 (ALvoid *) alGetError                },
-	{ "alIsExtensionPresent",       (ALvoid *) alIsExtensionPresent      },
-	{ "alGetProcAddress",           (ALvoid *) alGetProcAddress          },
-	{ "alGetEnumValue",             (ALvoid *) alGetEnumValue            },
-	{ "alListenerf",                (ALvoid *) alListenerf               },
-	{ "alListener3f",               (ALvoid *) alListener3f              },
-	{ "alListenerfv",               (ALvoid *) alListenerfv              },
-	{ "alListeneri",                (ALvoid *) alListeneri               },
-	{ "alListener3i",               (ALvoid *) alListener3i              },
-	{ "alListeneriv",               (ALvoid *) alListeneriv              },
-	{ "alGetListenerf",             (ALvoid *) alGetListenerf            },
-	{ "alGetListener3f",            (ALvoid *) alGetListener3f           },
-	{ "alGetListenerfv",            (ALvoid *) alGetListenerfv           },
-	{ "alGetListeneri",             (ALvoid *) alGetListeneri            },
-	{ "alGetListener3i",            (ALvoid *) alGetListener3i           },
-	{ "alGetListeneriv",            (ALvoid *) alGetListeneriv           },
-	{ "alGenSources",               (ALvoid *) alGenSources              },
-	{ "alDeleteSources",            (ALvoid *) alDeleteSources           },
-	{ "alIsSource",                 (ALvoid *) alIsSource                },
-	{ "alSourcef",                  (ALvoid *) alSourcef                 },
-	{ "alSource3f",                 (ALvoid *) alSource3f                },
-	{ "alSourcefv",                 (ALvoid *) alSourcefv                },
-	{ "alSourcei",                  (ALvoid *) alSourcei                 },
-	{ "alSource3i",                 (ALvoid *) alSource3i                },
-	{ "alSourceiv",                 (ALvoid *) alSourceiv                },
-	{ "alGetSourcef",               (ALvoid *) alGetSourcef              },
-	{ "alGetSource3f",              (ALvoid *) alGetSource3f             },
-	{ "alGetSourcefv",              (ALvoid *) alGetSourcefv             },
-	{ "alGetSourcei",               (ALvoid *) alGetSourcei              },
-	{ "alGetSource3i",              (ALvoid *) alGetSource3i             },
-	{ "alGetSourceiv",              (ALvoid *) alGetSourceiv             },
-	{ "alSourcePlayv",              (ALvoid *) alSourcePlayv             },
-	{ "alSourceStopv",              (ALvoid *) alSourceStopv             },
-	{ "alSourceRewindv",            (ALvoid *) alSourceRewindv           },
-	{ "alSourcePausev",             (ALvoid *) alSourcePausev            },
-	{ "alSourcePlay",               (ALvoid *) alSourcePlay              },
-	{ "alSourceStop",               (ALvoid *) alSourceStop              },
-	{ "alSourceRewind",             (ALvoid *) alSourceRewind            },
-	{ "alSourcePause",              (ALvoid *) alSourcePause             },
-	{ "alSourceQueueBuffers",       (ALvoid *) alSourceQueueBuffers      },
-	{ "alSourceUnqueueBuffers",     (ALvoid *) alSourceUnqueueBuffers    },
-	{ "alGenBuffers",               (ALvoid *) alGenBuffers              },
-	{ "alDeleteBuffers",            (ALvoid *) alDeleteBuffers           },
-	{ "alIsBuffer",                 (ALvoid *) alIsBuffer                },
-	{ "alBufferData",               (ALvoid *) alBufferData              },
-	{ "alBufferf",                  (ALvoid *) alBufferf                 },
-	{ "alBuffer3f",                 (ALvoid *) alBuffer3f                },
-	{ "alBufferfv",                 (ALvoid *) alBufferfv                },
-	{ "alBufferi",                  (ALvoid *) alBufferi                 },
-	{ "alBuffer3i",                 (ALvoid *) alBuffer3i                },
-	{ "alBufferiv",                 (ALvoid *) alBufferiv                },
-	{ "alGetBufferf",               (ALvoid *) alGetBufferf              },
-	{ "alGetBuffer3f",              (ALvoid *) alGetBuffer3f             },
-	{ "alGetBufferfv",              (ALvoid *) alGetBufferfv             },
-	{ "alGetBufferi",               (ALvoid *) alGetBufferi              },
-	{ "alGetBuffer3i",              (ALvoid *) alGetBuffer3i             },
-	{ "alGetBufferiv",              (ALvoid *) alGetBufferiv             },
-	{ "alDopplerFactor",            (ALvoid *) alDopplerFactor           },
-	{ "alDopplerVelocity",          (ALvoid *) alDopplerVelocity         },
-	{ "alSpeedOfSound",             (ALvoid *) alSpeedOfSound            },
-	{ "alDistanceModel",            (ALvoid *) alDistanceModel           },
-	{ NULL,							(ALvoid *) NULL                      } };
-
-
-//*****************************************************************************
-//*****************************************************************************
-//
-// Defines
-//
-//*****************************************************************************
-//*****************************************************************************
-
-
-#ifdef __MINGW32__
-// fix for Mingw32.
-#define AL_VOID_FXN(fxn)                                                    \
-    ALCcontext* context;                                                     \
-                                                                            \
-    alListAcquireLock(alContextList);                                       \
-    if(!alCurrentContext)                                                   \
-    {                                                                       \
-        alListReleaseLock(alContextList);                                   \
-        return;                                                             \
-    }                                                                       \
-                                                                            \
-    context = alCurrentContext;                                             \
-    EnterCriticalSection(&context->Lock);                                   \
-    alListReleaseLock(alContextList);                                       \
-                                                                            \
-    context->AlApi.fxn;                                                   \
-    LeaveCriticalSection(&context->Lock);                                   \
-    return
-#define AL_RESULT_FXN(fxn, resultType, resultDefVal)                        \
-    resultType result = resultDefVal;                                       \
-    ALCcontext* context;                                                     \
-                                                                            \
-    alListAcquireLock(alContextList);                                       \
-    if(!alCurrentContext)                                                   \
-    {                                                                       \
-        alListReleaseLock(alContextList);                                   \
-        return result;                                                      \
-    }                                                                       \
-                                                                            \
-    context = alCurrentContext;                                             \
-    EnterCriticalSection(&context->Lock);                                   \
-    alListReleaseLock(alContextList);                                       \
-                                                                            \
-    result = context->AlApi.fxn;                                          \
-    LeaveCriticalSection(&context->Lock);                                   \
-    return result	
-
-#else
-#define AL_RESULT_FXN(fxn, resultType, resultDefVal)                        \
-    resultType result = resultDefVal;                                       \
-    ALCcontext* context;                                                     \
-                                                                            \
-    alListAcquireLock(alContextList);                                       \
-    if(!alCurrentContext)                                                   \
-    {                                                                       \
-        alListReleaseLock(alContextList);                                   \
-        return result;                                                      \
-    }                                                                       \
-                                                                            \
-    context = alCurrentContext;                                             \
-    EnterCriticalSection(&context->Lock);                                   \
-    alListReleaseLock(alContextList);                                       \
-                                                                            \
-    result = context->AlApi.##fxn;                                          \
-    LeaveCriticalSection(&context->Lock);                                   \
-    return result
-
-#define AL_VOID_FXN(fxn)                                                    \
-    ALCcontext* context;                                                     \
-                                                                            \
-    alListAcquireLock(alContextList);                                       \
-    if(!alCurrentContext)                                                   \
-    {                                                                       \
-        alListReleaseLock(alContextList);                                   \
-        return;                                                             \
-    }                                                                       \
-                                                                            \
-    context = alCurrentContext;                                             \
-    EnterCriticalSection(&context->Lock);                                   \
-    alListReleaseLock(alContextList);                                       \
-                                                                            \
-    context->AlApi.##fxn;                                                   \
-    LeaveCriticalSection(&context->Lock);                                   \
-    return
-#endif
-
-
-//*****************************************************************************
-//*****************************************************************************
-//
-// AL API Buffer Entry Points
-//
-//*****************************************************************************
-//*****************************************************************************
-
-//*****************************************************************************
-// alGenBuffers
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alGenBuffers(ALsizei n, ALuint* bufferNames)
-{
-    AL_VOID_FXN(alGenBuffers(n, bufferNames));
-}
-
-
-//*****************************************************************************
-// alDeleteBuffers
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alDeleteBuffers(ALsizei n, const ALuint* bufferNames)
-{
-    AL_VOID_FXN(alDeleteBuffers(n, bufferNames));
-}
-
-
-//*****************************************************************************
-// alIsBuffer
-//*****************************************************************************
-//
-ALAPI ALboolean ALAPIENTRY alIsBuffer(ALuint bufferName)
-{
-    AL_RESULT_FXN(alIsBuffer(bufferName), ALboolean, AL_FALSE);
-}
-
-//*****************************************************************************
-// alBuffer3f
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alBuffer3f(ALuint bufferName, ALenum param, ALfloat v1, ALfloat v2, ALfloat v3)
-{
-    AL_VOID_FXN(alBuffer3f(bufferName, param, v1, v2, v3));
-}
-
-//*****************************************************************************
-// alBuffer3i
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alBuffer3i(ALuint bufferName, ALenum param, ALint v1, ALint v2, ALint v3)
-{
-    AL_VOID_FXN(alBuffer3i(bufferName, param, v1, v2, v3));
-}
-
-
-//*****************************************************************************
-// alBufferData
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alBufferData(ALuint bufferName, ALenum format, const ALvoid* data, ALsizei size, ALsizei freq)
-{
-    AL_VOID_FXN(alBufferData(bufferName, format, data, size, freq));
-}
-
-
-//*****************************************************************************
-// alBufferf
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alBufferf(ALuint bufferName, ALenum param, ALfloat value)
-{
-    AL_VOID_FXN(alBufferf(bufferName, param, value));
-}
-
-
-//*****************************************************************************
-// alBufferfv
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alBufferfv(ALuint bufferName, ALenum param, const ALfloat* values)
-{
-    AL_VOID_FXN(alBufferfv(bufferName, param, values));
-}
-
-
-//*****************************************************************************
-// alBufferi
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alBufferi(ALuint bufferName, ALenum param, ALint value)
-{
-    AL_VOID_FXN(alBufferi(bufferName, param, value));
-}
-
-
-//*****************************************************************************
-// alBufferiv
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alBufferiv(ALuint bufferName, ALenum param, const ALint* values)
-{
-    AL_VOID_FXN(alBufferiv(bufferName, param, values));
-}
-
-//*****************************************************************************
-// alGetBuffer3f
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alGetBuffer3f(ALuint bufferName, ALenum param, ALfloat *v1, ALfloat *v2, ALfloat *v3)
-{
-    AL_VOID_FXN(alGetBuffer3f(bufferName, param, v1, v2, v3));
-}
-
-//*****************************************************************************
-// alGetBuffer3i
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alGetBuffer3i(ALuint bufferName, ALenum param, ALint *v1, ALint *v2, ALint *v3)
-{
-    AL_VOID_FXN(alGetBuffer3i(bufferName, param, v1, v2, v3));
-}
-
-//*****************************************************************************
-// alGetBufferf
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alGetBufferf(ALuint bufferName, ALenum param, ALfloat* value)
-{
-    AL_VOID_FXN(alGetBufferf(bufferName, param, value));
-}
-
-//*****************************************************************************
-// alGetBufferfv
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alGetBufferfv(ALuint bufferName, ALenum param, ALfloat* values)
-{
-    AL_VOID_FXN(alGetBufferfv(bufferName, param, values));
-}
-
-
-//*****************************************************************************
-// alGetBufferi
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alGetBufferi(ALuint bufferName, ALenum param, ALint* value)
-{
-    AL_VOID_FXN(alGetBufferi(bufferName, param, value));
-}
-
-//*****************************************************************************
-// alGetBufferiv
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alGetBufferiv(ALuint bufferName, ALenum param, ALint* values)
-{
-    AL_VOID_FXN(alGetBufferiv(bufferName, param, values));
-}
-
-
-//*****************************************************************************
-//*****************************************************************************
-//
-// AL API Generic Entry Points
-//
-//*****************************************************************************
-//*****************************************************************************
-
-//*****************************************************************************
-// alEnable
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alEnable(ALenum capability)
-{
-    AL_VOID_FXN(alEnable(capability));
-}
-
-
-//*****************************************************************************
-// alDisable
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alDisable(ALenum capability)
-{
-    AL_VOID_FXN(alDisable(capability));
-}
-
-
-//*****************************************************************************
-// alDopplerFactor
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alDopplerFactor(ALfloat value)
-{
-    AL_VOID_FXN(alDopplerFactor(value));
-}
-
-
-//*****************************************************************************
-// alDopplerVelocity
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alDopplerVelocity(ALfloat value)
-{
-    AL_VOID_FXN(alDopplerVelocity(value));
-}
-
-
-//*****************************************************************************
-// alSpeedOfSound
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alSpeedOfSound(ALfloat value)
-{
-    ALCcontext* context;
-
-    alListAcquireLock(alContextList);
-    if(!alCurrentContext)
-    {
-        alListReleaseLock(alContextList);
-        return;
-    }
-
-    context = alCurrentContext;
-    EnterCriticalSection(&context->Lock);
-    alListReleaseLock(alContextList);
-
-	if (context->AlApi.alSpeedOfSound) { // protect against talking to a 1.0 lib
-		context->AlApi.alSpeedOfSound(value);
-	}
-    LeaveCriticalSection(&context->Lock);
-    return;
-}
-
-
-//*****************************************************************************
-// alDistanceModel
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alDistanceModel(ALenum value)
-{
-    AL_VOID_FXN(alDistanceModel(value));
-}
-
-
-//*****************************************************************************
-// alGetBoolean
-//*****************************************************************************
-//
-ALAPI ALboolean ALAPIENTRY alGetBoolean(ALenum param)
-{
-    AL_RESULT_FXN(alGetBoolean(param), ALboolean, AL_FALSE);
-}
-
-
-//*****************************************************************************
-// alGetBooleanv
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alGetBooleanv(ALenum param, ALboolean* data)
-{
-    AL_VOID_FXN(alGetBooleanv(param, data));
-}
-
-
-//*****************************************************************************
-// alGetDouble
-//*****************************************************************************
-//
-ALAPI ALdouble ALAPIENTRY alGetDouble(ALenum param)
-{
-    AL_RESULT_FXN(alGetDouble(param), ALdouble, 0.0);
-}
-
-
-//*****************************************************************************
-// alGetDoublev
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alGetDoublev(ALenum param, ALdouble* data)
-{
-    AL_VOID_FXN(alGetDoublev(param, data));
-}
-
-//*****************************************************************************
-// alGetFloat
-//*****************************************************************************
-//
-ALAPI ALfloat ALAPIENTRY alGetFloat(ALenum param)
-{
-    AL_RESULT_FXN(alGetFloat(param), ALfloat, 0.0f);
-}
-
-
-//*****************************************************************************
-// alGetFloatv
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alGetFloatv(ALenum param, ALfloat* data)
-{
-    AL_VOID_FXN(alGetFloatv(param, data));
-}
-
-
-//*****************************************************************************
-// alGetInteger
-//*****************************************************************************
-//
-ALAPI ALint ALAPIENTRY alGetInteger(ALenum param)
-{
-    AL_RESULT_FXN(alGetInteger(param), ALint, 0);
-}
-
-
-//*****************************************************************************
-// alGetIntegerv
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alGetIntegerv(ALenum param, ALint* data)
-{
-    AL_VOID_FXN(alGetIntegerv(param, data));
-}
-
-
-//*****************************************************************************
-// alGetEnumValue
-//*****************************************************************************
-//
-ALAPI ALenum ALAPIENTRY alGetEnumValue(const ALCchar* ename)
-{
-    AL_RESULT_FXN(alGetEnumValue(ename), ALenum, AL_INVALID_ENUM);
-}
-
-
-//*****************************************************************************
-// alGetError
-//*****************************************************************************
-//
-ALAPI ALenum ALAPIENTRY alGetError(ALvoid)
-{
-    AL_RESULT_FXN(alGetError(), ALenum, AL_NO_ERROR);
-}
-
-
-//*****************************************************************************
-// alGetProcAddress
-//*****************************************************************************
-//
-ALAPI ALvoid* ALAPIENTRY alGetProcAddress(const ALCchar* fname)
-{
-	// return router's address if available
-	ALsizei i=0;
-	ALvoid *pAddress;
-
-	while ((function[i].funcName)&&(strcmp((char *)function[i].funcName,(char *)fname)))
-		i++;
-	pAddress = function[i].address;
-
-	if (pAddress != NULL) {
-		return pAddress;
-	}
-
-	// router doesn't have this entry point, so go to the device...
-	AL_RESULT_FXN(alGetProcAddress(fname), ALvoid*, 0);
-
-	return pAddress;
-}
-
-
-//*****************************************************************************
-// alGetString
-//*****************************************************************************
-//
-ALAPI const ALCchar* ALAPIENTRY alGetString(ALenum param)
-{
-    AL_RESULT_FXN(alGetString(param), const ALCchar*, 0);
-}
-
-
-//*****************************************************************************
-// alIsExtensionPresent
-//*****************************************************************************
-//
-ALAPI ALboolean ALAPIENTRY alIsExtensionPresent(const ALCchar* ename)
-{
-    AL_RESULT_FXN(alIsExtensionPresent(ename), ALboolean, AL_FALSE);
-}
-
-
-//*****************************************************************************
-// alIsEnabled
-//*****************************************************************************
-//
-ALAPI ALboolean ALAPIENTRY alIsEnabled(ALenum capability)
-{
-    AL_RESULT_FXN(alIsEnabled(capability), ALboolean, AL_FALSE);
-}
-
-
-
-//*****************************************************************************
-//*****************************************************************************
-//
-// AL API Listener Entry Points
-//
-//*****************************************************************************
-//*****************************************************************************
-
-//*****************************************************************************
-// alListenerf
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alListenerf(ALenum param, ALfloat value)
-{
-    AL_VOID_FXN(alListenerf(param, value));
-}
-
-
-//*****************************************************************************
-// alListener3f
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alListener3f(ALenum param, ALfloat v1, ALfloat v2, ALfloat v3)
-{
-    AL_VOID_FXN(alListener3f(param, v1, v2, v3));
-}
-
-
-//*****************************************************************************
-// alListener3i
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alListener3i(ALenum param, ALint v1, ALint v2, ALint v3)
-{
-    AL_VOID_FXN(alListener3i(param, v1, v2, v3));
-}
-
-
-//*****************************************************************************
-// alListenerfv
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alListenerfv(ALenum param, const ALfloat* values)
-{
-    AL_VOID_FXN(alListenerfv(param, values));
-}
-
-
-//*****************************************************************************
-// alListeneri
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alListeneri(ALenum param, ALint value)
-{
-    AL_VOID_FXN(alListeneri(param, value));
-}
-
-
-//*****************************************************************************
-// alListeneriv
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alListeneriv(ALenum param, const ALint *values)
-{
-    AL_VOID_FXN(alListeneriv(param, values));
-}
-
-
-//*****************************************************************************
-// alGetListenerf
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alGetListenerf(ALenum param, ALfloat* value)
-{
-    AL_VOID_FXN(alGetListenerf(param, value));
-}
-
-
-//*****************************************************************************
-// alGetListener3f
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alGetListener3f(ALenum param, ALfloat* v1, ALfloat* v2, ALfloat* v3)
-{
-    AL_VOID_FXN(alGetListener3f(param, v1, v2, v3));
-}
-
-
-//*****************************************************************************
-// alGetListener3i
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alGetListener3i(ALenum param, ALint* v1, ALint* v2, ALint* v3)
-{
-    AL_VOID_FXN(alGetListener3i(param, v1, v2, v3));
-}
-
-
-//*****************************************************************************
-// alGetListenerfv
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alGetListenerfv(ALenum param, ALfloat* values)
-{
-    AL_VOID_FXN(alGetListenerfv(param, values));
-}
-
-
-//*****************************************************************************
-// alGetListeneri
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alGetListeneri(ALenum param, ALint* value)
-{
-    AL_VOID_FXN(alGetListeneri(param, value));
-}
-
-
-//*****************************************************************************
-// alGetListeneriv
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alGetListeneriv(ALenum param, ALint* values)
-{
-    AL_VOID_FXN(alGetListeneriv(param, values));
-}
-
-
-//*****************************************************************************
-//*****************************************************************************
-//
-// AL API Source Entry Points
-//
-//*****************************************************************************
-//*****************************************************************************
-
-
-//*****************************************************************************
-// alGenSources
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alGenSources(ALsizei n, ALuint* sourceNames)
-{
-    AL_VOID_FXN(alGenSources(n, sourceNames));
-}
-
-
-//*****************************************************************************
-// alDeleteSources
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alDeleteSources(ALsizei n, const ALuint* sourceNames)
-{
-    AL_VOID_FXN(alDeleteSources(n, sourceNames));
-}
-
-
-//*****************************************************************************
-// alIsSource
-//*****************************************************************************
-//
-ALAPI ALboolean ALAPIENTRY alIsSource(ALuint sourceName)
-{
-    AL_RESULT_FXN(alIsSource(sourceName), ALboolean, AL_FALSE);
-}
-
-
-//*****************************************************************************
-// alSourcef
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alSourcef(ALuint sourceName, ALenum param, ALfloat value)
-{
-    AL_VOID_FXN(alSourcef(sourceName, param, value));
-}
-
-
-//*****************************************************************************
-// alSourcefv
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alSourcefv(ALuint sourceName, ALenum param, const ALfloat* values)
-{
-    AL_VOID_FXN(alSourcefv(sourceName, param, values));
-}
-
-
-//*****************************************************************************
-// alSource3f
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alSource3f(ALuint sourceName, ALenum param, ALfloat v1, ALfloat v2, ALfloat v3)
-{
-    AL_VOID_FXN(alSource3f(sourceName, param, v1, v2, v3));
-}
-
-
-//*****************************************************************************
-// alSource3i
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alSource3i(ALuint sourceName, ALenum param, ALint v1, ALint v2, ALint v3)
-{
-    AL_VOID_FXN(alSource3i(sourceName, param, v1, v2, v3));
-}
-
-
-//*****************************************************************************
-// alSourcei
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alSourcei(ALuint sourceName, ALenum param, ALint value)
-{
-    AL_VOID_FXN(alSourcei(sourceName, param, value));
-}
-
-//*****************************************************************************
-// alSourceiv
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alSourceiv(ALuint sourceName, ALenum param, const ALint* values)
-{
-    AL_VOID_FXN(alSourceiv(sourceName, param, values));
-}
-
-
-//*****************************************************************************
-// alGetSourcef
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alGetSourcef(ALuint sourceName, ALenum param, ALfloat* value)
-{
-    AL_VOID_FXN(alGetSourcef(sourceName, param, value));
-}
-
-//*****************************************************************************
-// alGetSource3f
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alGetSource3f(ALuint sourceName, ALenum param, ALfloat* v1, ALfloat* v2, ALfloat* v3)
-{
-    AL_VOID_FXN(alGetSource3f(sourceName, param, v1, v2, v3));
-}
-
-
-//*****************************************************************************
-// alGetSource3i
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alGetSource3i(ALuint sourceName, ALenum param, ALint* v1, ALint* v2, ALint* v3)
-{
-    AL_VOID_FXN(alGetSource3i(sourceName, param, v1, v2, v3));
-}
-
-
-//*****************************************************************************
-// alGetSourcefv
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alGetSourcefv(ALuint sourceName, ALenum param, ALfloat* values)
-{
-    AL_VOID_FXN(alGetSourcefv(sourceName, param, values));
-}
-
-
-//*****************************************************************************
-// alGetSourcei
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alGetSourcei(ALuint sourceName, ALenum param, ALint* value)
-{
-    AL_VOID_FXN(alGetSourcei(sourceName, param, value));
-}
-
-
-//*****************************************************************************
-// alGetSourceiv
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alGetSourceiv(ALuint sourceName, ALenum param, ALint* values)
-{
-    AL_VOID_FXN(alGetSourceiv(sourceName, param, values));
-}
-
-
-//*****************************************************************************
-// alSourcePlay
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alSourcePlay(ALuint sourceName)
-{
-    AL_VOID_FXN(alSourcePlay(sourceName));
-}
-
-
-//*****************************************************************************
-// alSourcePlayv
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alSourcePlayv(ALsizei n, const ALuint* sourceNames)
-{
-    AL_VOID_FXN(alSourcePlayv(n, sourceNames));
-}
-
-
-//*****************************************************************************
-// alSourcePause
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alSourcePause(ALuint sourceName)
-{
-    AL_VOID_FXN(alSourcePause(sourceName));
-}
-
-
-//*****************************************************************************
-// alSourcePausev
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alSourcePausev(ALsizei n, const ALuint* sourceNames)
-{
-    AL_VOID_FXN(alSourcePausev(n, sourceNames));
-}
-
-
-//*****************************************************************************
-// alSourceStop
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alSourceStop(ALuint sourceName)
-{
-    AL_VOID_FXN(alSourceStop(sourceName));
-}
-
-
-//*****************************************************************************
-// alSourceStopv
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alSourceStopv(ALsizei n, const ALuint* sourceNames)
-{
-    AL_VOID_FXN(alSourceStopv(n, sourceNames));
-}
-
-
-//*****************************************************************************
-// alSourceRewind
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alSourceRewind(ALuint sourceName)
-{
-    AL_VOID_FXN(alSourceRewind(sourceName));
-}
-
-
-//*****************************************************************************
-// alSourceRewindv
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alSourceRewindv(ALsizei n, const ALuint* sourceNames)
-{
-    AL_VOID_FXN(alSourceRewindv(n, sourceNames));
-}
-
-
-//*****************************************************************************
-// alSourceQueueBuffers
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alSourceQueueBuffers(ALuint sourceName, ALsizei n, const ALuint* buffers)
-{
-    AL_VOID_FXN(alSourceQueueBuffers(sourceName, n, buffers));
-}
-
-
-//*****************************************************************************
-// alSourceUnqueueBuffers
-//*****************************************************************************
-//
-ALAPI ALvoid ALAPIENTRY alSourceUnqueueBuffers(ALuint sourceName, ALsizei n, ALuint* buffers)
-{
-    AL_VOID_FXN(alSourceUnqueueBuffers(sourceName, n, buffers));
-}
-
diff --git a/Router/alList.cpp b/Router/alList.cpp
deleted file mode 100644
index 2c884c56..00000000
--- a/Router/alList.cpp
+++ /dev/null
@@ -1,1029 +0,0 @@
-/**
- * OpenAL cross platform audio library
- * Copyright (C) 1999-2003 by authors.
- * 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 Software Foundation, Inc., 59 Temple Place - Suite 330,
- *  Boston, MA  02111-1307, USA.
- * Or go to http://www.gnu.org/copyleft/lgpl.html
- */
-
-
-
-
-#include "alList.h"
-#include <windows.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-
-//****************************************************************************
-//****************************************************************************
-//
-// Defines
-//
-//****************************************************************************
-//****************************************************************************
-
-//
-// Some occasionally useful debugging stuff.
-//
-#if(DBG)
-    #ifndef ASSERT
-    static ALint alListDebugAssertsEnabled = 1;
-    #define ASSERT(exp)                                                     \
-        {                                                                   \
-            if(!(exp) && alListDebugAssertsEnabled)                         \
-            {                                                               \
-                char tempStr[256];                                          \
-                OutputDebugString("\n");                                    \
-                sprintf(tempStr, "Assert failed in file %s, line %d!\n",    \
-                        __FILE__, __LINE__);                                \
-                OutputDebugString(tempStr);                                 \
-                OutputDebugString("\n");                                    \
-                if(alListDebugAssertsEnabled)                               \
-                {                                                           \
-                    DebugBreak();                                           \
-                }                                                           \
-            }                                                               \
-        }
-
-    #endif
-#else
-    #ifndef ASSERT
-    #define ASSERT(exp)
-    #endif
-#endif
-
-
-
-//****************************************************************************
-//****************************************************************************
-//
-// List Functions
-//
-//****************************************************************************
-//****************************************************************************
-
-//*****************************************************************************
-// alListAddEntry
-//*****************************************************************************
-// Adds an entry to the tail of the list.  Each entry must be unique.
-//
-ALvoid alListAddEntry
-(
-    IN  ALlist* pList,
-    IN  ALlistEntry* pEntry
-)
-{
-#if(DBG)
-    ALlistEntry* pCurrent = 0;
-#endif
-
-    ASSERT(pList);
-    ASSERT(pEntry);
-    ASSERT(pList->Locked);
-    ASSERT(!pEntry->Next);
-    ASSERT(!pEntry->Previous);
-
-    //
-    // Verify the entry doesn't already exist.
-    //
-#if(DBG)
-    pCurrent = pList->Head;
-    while(pCurrent)
-    {
-        if(pCurrent == pEntry)
-        {
-            break;
-        }
-
-        pCurrent = pCurrent->Next;
-    }
-
-    if(pCurrent)
-    {
-        // Duplicate entries are not supported.
-        ASSERT(0);
-        return;
-    }
-#endif
-
-
-    //
-    // Add the item to the tail of the list.
-    //
-    if(pList->Tail)
-    {
-        pList->Tail->Next = pEntry;
-    }
-
-    pEntry->Previous = pList->Tail;
-    pList->Tail = pEntry;
-
-    //
-    // Check if this is the first entry.
-    //
-    if(!pList->Head)
-    {
-        pList->Head = pEntry;
-        pList->Current = pEntry;
-    }
-
-    pList->NumberOfEntries++;
-}
-
-
-//*****************************************************************************
-// alListAddEntryToHead
-//*****************************************************************************
-// Adds an entry to the head of the list.  Each entry must be unique.
-//
-ALvoid alListAddEntryToHead
-(
-    IN  ALlist* pList,
-    IN  ALlistEntry* pEntry
-)
-{
-#if(DBG)
-    ALlistEntry* pCurrent = 0;
-#endif
-    ASSERT(pList);
-    ASSERT(pEntry);
-    ASSERT(pList->Locked);
-    ASSERT(!pEntry->Next);
-    ASSERT(!pEntry->Previous);
-
-    //
-    // Verify the entry doesn't already exist.
-    //
-#if(DBG)
-    pCurrent = pList->Head;
-    while(pCurrent)
-    {
-        if(pCurrent == pEntry)
-        {
-            break;
-        }
-
-        pCurrent = pCurrent->Next;
-    }
-
-    if(pCurrent)
-    {
-        // Duplicate entries are not supported.
-        ASSERT(0);
-        return;
-    }
-#endif
-
-
-    //
-    // Add the item to the head of the list.
-    //
-    if(pList->Head)
-    {
-        pList->Head->Previous = pEntry;
-    }
-
-    pEntry->Next = pList->Head;
-    pList->Head = pEntry;
-
-    //
-    // Check if this is the first entry.
-    //
-    if(!pList->Tail)
-    {
-        pList->Tail = pEntry;
-        pList->Current = pEntry;
-    }
-
-    pList->NumberOfEntries++;
-}
-
-
-//*****************************************************************************
-// alListAcquireLock
-//*****************************************************************************
-// This is called to aquire the list lock for operations that span multiple
-// list calls like iterating over the list.
-//
-ALvoid alListAcquireLock
-(
-    IN  ALlist* pList
-)
-{
-    ASSERT(pList);
-
-    EnterCriticalSection(&pList->Lock);
-#if(DBG)
-    pList->Locked++;
-#endif
-
-    //
-    // Check that only one person has the lock.
-    //
-    ASSERT(pList->Locked == 1);
-}
-
-
-//*****************************************************************************
-// alListCreate
-//*****************************************************************************
-// Creates and initializes a list.
-//
-ALboolean alListCreate
-(
-    OUT ALlist** ppList
-)
-{
-    ALlist* pList = 0;
-
-    ASSERT(ppList);
-
-    //
-    // Allocate and initialize the list context.
-    //
-    *ppList = 0;
-    pList = (ALlist*)malloc(sizeof(ALlist));
-    if(!pList)
-    {
-        // Failed to allocate the list!
-        ASSERT(0);
-        return FALSE;
-    }
-
-    memset(pList, 0, sizeof(ALlist));
-    InitializeCriticalSection(&pList->Lock);
-    pList->NumberOfEntries = 0;
-    *ppList = pList;
-    return TRUE;
-}
-
-
-//*****************************************************************************
-// alListFree
-//*****************************************************************************
-// Destroys the list.
-//
-ALvoid alListFree
-(
-    IN  ALlist* pList
-)
-{
-    ASSERT(pList);
-    ASSERT(!pList->Head);
-
-    //
-    // Free the resources allocated during the creation.
-    //
-    if(pList)
-    {
-        DeleteCriticalSection(&pList->Lock);
-        free(pList);
-    }
-
-    return;
-}
-
-
-//*****************************************************************************
-// alListGetData
-//*****************************************************************************
-// Returns the data from the list entry.
-//
-ALvoid* alListGetData
-(
-    IN  ALlistEntry* pEntry
-)
-{
-    ASSERT(pEntry);
-
-    return pEntry->Data;
-}
-
-
-//*****************************************************************************
-// alListGetEntryAt
-//*****************************************************************************
-// Returns the entry in the list at the specified index of the list.
-//
-ALlistEntry* alListGetEntryAt
-(
-    IN  ALlist* pList,
-    IN  ALint Index
-)
-{
-    ALlistEntry* pEntry = 0;
-    ALint i;
-
-    ASSERT(pList);
-    ASSERT(pList->Locked);
-    ASSERT(Index < pList->NumberOfEntries);
-
-    pEntry = pList->Head;
-    for(i = 0; i < Index && pEntry; i++)
-    {
-        pEntry = pEntry->Next;
-    }
-
-    return pEntry;
-}
-
-
-//*****************************************************************************
-// alListGetEntryCount
-//*****************************************************************************
-// Returns the number of items stored in the list.
-//
-ALint alListGetEntryCount
-(
-    IN  ALlist* pList
-)
-{
-    ASSERT(pList->Locked);
-    return pList->NumberOfEntries;
-}
-
-
-//*****************************************************************************
-// alListGetHead
-//*****************************************************************************
-// Returns the first entry in the list.
-//
-ALlistEntry* alListGetHead
-(
-    IN  ALlist* pList
-)
-{
-    ASSERT(pList);
-    ASSERT(pList->Locked);
-
-    return pList->Head;
-}
-
-
-//*****************************************************************************
-// alListGetNext
-//*****************************************************************************
-// Returns the entry after to the entry pointed to by the iterator.  If
-// the iterator is at the last entry (or has finished iterating over the
-// list), the returned entry will be 0.
-//
-ALlistEntry* alListGetNext
-(
-    IN  ALlist* pList
-)
-{
-    ASSERT(pList);
-    ASSERT(pList->Locked);
-
-    if(!pList->Current)
-    {
-        return 0;
-    }
-
-    return pList->Current->Next;
-}
-
-
-//*****************************************************************************
-// alListGetPrevious
-//*****************************************************************************
-// Returns the entry previous to the entry pointed to by the iterator.  If
-// the iterator is at the first entry, the returned entry will be 0.
-//
-ALlistEntry* alListGetPrevious
-(
-    IN  ALlist* pList
-)
-{
-    ASSERT(pList);
-    ASSERT(pList->Locked);
-
-    if(!pList->Current)
-    {
-        return 0;
-    }
-
-    return pList->Current->Previous;
-}
-
-
-//*****************************************************************************
-// alListGetTail
-//*****************************************************************************
-// Returns the last entry in the list.
-//
-ALlistEntry* alListGetTail
-(
-    IN  ALlist* pList
-)
-{
-    ASSERT(pList);
-    ASSERT(pList->Locked);
-
-    return pList->Tail;
-}
-
-
-//*****************************************************************************
-// alListInitializeEntry
-//*****************************************************************************
-// Initializes a preallocated list entry.
-//
-ALvoid alListInitializeEntry
-(
-    ALlistEntry* pEntry,
-    ALvoid* pData
-)
-{
-    ASSERT(pEntry);
-
-    pEntry->Data = pData;
-    pEntry->Next = 0;
-    pEntry->Previous = 0;
-}
-
-
-//*****************************************************************************
-// alListIsEmpty
-//*****************************************************************************
-// Returns the TRUE if the list is empty.
-//
-ALboolean alListIsEmpty
-(
-    IN  ALlist* pList
-)
-{
-    ASSERT(pList);
-    ASSERT(pList->Locked);
-
-    return (pList->Head == 0);
-}
-
-
-//*****************************************************************************
-// alListIteratorGet
-//*****************************************************************************
-// Returns the entry pointed to by the iterator.
-//
-ALlistEntry* alListIteratorGet
-(
-    IN  ALlist* pList
-)
-{
-    ASSERT(pList);
-    ASSERT(pList->Locked);
-
-    return pList->Current;
-}
-
-
-//*****************************************************************************
-// alListIteratorFindData
-//*****************************************************************************
-// Searches the list for the matching item and return the pointer to the
-// entry.  If the match is not found, the return will be 0.
-//
-ALlistEntry* alListIteratorFindData
-(
-    IN  ALlist* pList,
-    IN  ALvoid* pData
-)
-{
-    ALlistEntry* pCurrent = 0;
-
-    ASSERT(pList);
-    ASSERT(pList->Locked);
-
-    //
-    // Find the item.
-    //
-    pCurrent = pList->Head;
-    while(pCurrent)
-    {
-        if(pCurrent->Data == pData)
-        {
-            break;
-        }
-
-        pCurrent = pCurrent->Next;
-    }
-
-    pList->Current = pCurrent;
-    return pCurrent;
-}
-
-
-//*****************************************************************************
-// alListIteratorNext
-//*****************************************************************************
-// This is called to advance the list iterator to the next entry in the list
-// and return that entry.
-//
-ALlistEntry* alListIteratorNext
-(
-    IN  ALlist* pList
-)
-{
-    ASSERT(pList);
-    ASSERT(pList->Locked);
-
-    if(!pList->Current)
-    {
-        return 0;
-    }
-
-    pList->Current = pList->Current->Next;
-    return pList->Current;
-}
-
-
-//*****************************************************************************
-// alListIteratorPrevious
-//*****************************************************************************
-// This is called to advance the list iterator to the previous entry in the
-// list and return that entry.
-//
-ALlistEntry* alListIteratorPrevious
-(
-    IN  ALlist* pList
-)
-{
-    ASSERT(pList);
-    ASSERT(pList->Locked);
-
-    if(!pList->Current)
-    {
-        return 0;
-    }
-
-    pList->Current = pList->Current->Previous;
-    return pList->Current;
-}
-
-
-//*****************************************************************************
-// alListIteratorRemove
-//*****************************************************************************
-// Removes the current item from the list and returns it.  The iterator will
-// equal the next item in the list.
-//
-ALlistEntry* alListIteratorRemove
-(
-    IN  ALlist* pList
-)
-{
-    ALlistEntry* pEntry = 0;
-
-    ASSERT(pList);
-    ASSERT(pList->Locked);
-
-    //
-    // Make sure we aren't at the end of the list.
-    //
-    if(!pList->Current)
-    {
-        return 0;
-    }
-
-    //
-    // Remove the item from the list.
-    //
-    pEntry = pList->Current;
-
-    //
-    // Fix up the next item in the list.
-    //
-    if(pEntry->Next)
-    {
-        pEntry->Next->Previous = pEntry->Previous;
-    }
-
-    //
-    // Fix up the previous item in the list.
-    //
-    if(pEntry->Previous)
-    {
-        pEntry->Previous->Next = pEntry->Next;
-    }
-
-    //
-    // Fix up the current pointer.
-    //
-    pList->Current = pEntry->Next;
-
-    //
-    // Check the head pointer.
-    //
-    if(pList->Head == pEntry)
-    {
-        pList->Head = pEntry->Next;
-    }
-
-    //
-    // Check the tail pointer.
-    //
-    if(pList->Tail == pEntry)
-    {
-        pList->Tail = pEntry->Previous;
-    }
-
-    //
-    // Set the entry pointers.
-    //
-    pEntry->Next = 0;
-    pEntry->Previous = 0;
-    pList->NumberOfEntries--;
-    ASSERT(0 <= pList->NumberOfEntries);
-    return pEntry;
-}
-
-
-//*****************************************************************************
-// alListIteratorReset
-//*****************************************************************************
-// Returns the list iterator to the head of the list.
-//
-ALlistEntry* alListIteratorReset
-(
-    IN  ALlist* pList
-)
-{
-    ASSERT(pList);
-    ASSERT(pList->Locked);
-
-    pList->Current = pList->Head;
-    return pList->Current;
-}
-
-
-//*****************************************************************************
-// alListIteratorSet
-//*****************************************************************************
-// Sets the current entry pointer to the entry passed in.  If the entry is not
-// found, the current entry will be 0.
-//
-ALlistEntry* alListIteratorSet
-(
-    IN  ALlist* pList,
-    IN  ALlistEntry* pEntry
-)
-{
-    ALlistEntry* pCurrent = 0;
-
-    ASSERT(pList);
-    ASSERT(pList->Locked);
-
-    pCurrent = pList->Head;
-    while(pCurrent)
-    {
-        if(pCurrent == pEntry)
-        {
-            break;
-        }
-
-        pCurrent = pCurrent->Next;
-    }
-
-    pList->Current = pCurrent;
-    return pList->Current;
-}
-
-
-//*****************************************************************************
-// alListMatchEntry
-//*****************************************************************************
-// Matches the entry to an item in the list and returns the data in that
-// entry.  If the match is not found, the return will be 0.
-//
-ALvoid* alListMatchEntry
-(
-    IN  ALlist* pList,
-    IN  ALlistEntry* pEntry
-)
-{
-    ALlistEntry* pCurrent = 0;
-
-    ASSERT(pList);
-    ASSERT(pList->Locked);
-
-    //
-    // Find the item.
-    //
-    pCurrent = pList->Head;
-    while(pCurrent)
-    {
-        if(pCurrent == pEntry)
-        {
-            break;
-        }
-
-        pCurrent = pCurrent->Next;
-    }
-
-    if(!pCurrent)
-    {
-        return 0;
-    }
-
-    return pCurrent->Data;
-}
-
-
-//*****************************************************************************
-// alListMatchData
-//*****************************************************************************
-// Searches the list for the first matching item and returns the pointer to
-// the entry.  If the match is not found, the return will be 0.
-//
-ALlistEntry* alListMatchData
-(
-    IN  ALlist* pList,
-    IN  ALvoid* pData
-)
-{
-    ALlistEntry* pCurrent = 0;
-
-    ASSERT(pList);
-    ASSERT(pList->Locked);
-
-    //
-    // Find the item.
-    //
-    pCurrent = pList->Head;
-    while(pCurrent)
-    {
-        if(pCurrent->Data == pData)
-        {
-            break;
-        }
-
-        pCurrent = pCurrent->Next;
-    }
-
-    return pCurrent;
-}
-
-
-//*****************************************************************************
-// alListReleaseLock
-//*****************************************************************************
-// This is called to release the list lock.
-//
-ALvoid alListReleaseLock
-(
-    IN  ALlist* pList
-)
-{
-    ASSERT(pList);
-    ASSERT(pList->Locked);
-
-#if(DBG)
-    pList->Locked--;
-    ASSERT(pList->Locked == 0);
-#endif
-
-    LeaveCriticalSection(&pList->Lock);
-}
-
-
-//*****************************************************************************
-// alListRemoveEntry
-//*****************************************************************************
-// Removes the item from the list and returns the data from the item.  If
-// this is the current item, the current item will equal the next item in the
-// list.
-//
-ALvoid* alListRemoveEntry
-(
-    IN  ALlist* pList,
-    IN  ALlistEntry* pEntry
-)
-{
-    ALlistEntry* pCurrent = 0;
-
-    ASSERT(pList);
-    ASSERT(pList->Locked);
-    ASSERT(pEntry);
-
-    //
-    // Release the item from the list.
-    //
-    pCurrent = pList->Head;
-    while(pCurrent)
-    {
-        if(pCurrent == pEntry)
-        {
-            break;
-        }
-
-        pCurrent = pCurrent->Next;
-    }
-
-    if(!pCurrent)
-    {
-        return 0;
-    }
-
-    //
-    // Fix up the next item in the list.
-    //
-    if(pEntry->Next)
-    {
-        pEntry->Next->Previous = pEntry->Previous;
-    }
-
-    //
-    // Fix up the previous item in the list.
-    //
-    if(pEntry->Previous)
-    {
-        pEntry->Previous->Next = pEntry->Next;
-    }
-
-    //
-    // Fix up the current pointer.
-    //
-    if(pCurrent == pList->Current)
-    {
-        pList->Current = pEntry->Next;
-    }
-
-    //
-    // Check the head pointer.
-    //
-    if(pList->Head == pEntry)
-    {
-        pList->Head = pEntry->Next;
-    }
-
-    //
-    // Check the tail pointer.
-    //
-    if(pList->Tail == pEntry)
-    {
-        pList->Tail = pEntry->Previous;
-    }
-
-    //
-    // Set the entry pointers.
-    //
-    pEntry->Next = 0;
-    pEntry->Previous = 0;
-    pList->NumberOfEntries--;
-    ASSERT(0 <= pList->NumberOfEntries);
-    return pEntry->Data;
-}
-
-
-//*****************************************************************************
-// alListRemoveHead
-//*****************************************************************************
-// Removes the list entry at the head of the list.  If this is the current
-// item, the current item will equal the next item in the list.
-//
-ALlistEntry* alListRemoveHead
-(
-    IN  ALlist* pList
-)
-{
-    ALlistEntry* pCurrent = 0;
-
-    ASSERT(pList);
-    ASSERT(pList->Locked);
-
-    //
-    // Release the item from the list.
-    //
-    pCurrent = pList->Head;
-    if(!pCurrent)
-    {
-        return 0;
-    }
-
-    //
-    // Fix up the next item in the list.
-    //
-    if(pCurrent->Next)
-    {
-        pCurrent->Next->Previous = 0;
-    }
-
-    //
-    // Fix up the previous item in the list.
-    //
-    ASSERT(!pCurrent->Previous)
-
-    //
-    // Fix up the current pointer.
-    //
-    if(pCurrent == pList->Current)
-    {
-        pList->Current = pCurrent->Next;
-    }
-
-    //
-    // Check the head pointer.
-    //
-    pList->Head = pCurrent->Next;
-
-    //
-    // Check the tail pointer.
-    //
-    if(pList->Tail == pCurrent)
-    {
-        pList->Tail = 0;
-    }
-
-    //
-    // Set the entry pointers.
-    //
-    pCurrent->Next = 0;
-    pCurrent->Previous = 0;
-    pList->NumberOfEntries--;
-    ASSERT(0 <= pList->NumberOfEntries);
-    return pCurrent;
-}
-
-
-//*****************************************************************************
-// alListRemoveTail
-//*****************************************************************************
-// Removes the list entry at the tail of the list.  If this is the current
-// item, the current item will be null.
-//
-ALlistEntry* alListRemoveTail
-(
-    IN  ALlist* pList
-)
-{
-    ALlistEntry* pCurrent = 0;
-
-    ASSERT(pList);
-    ASSERT(pList->Locked);
-
-    //
-    // Release the item from the list.
-    //
-    pCurrent = pList->Tail;
-    if(!pCurrent)
-    {
-        return 0;
-    }
-
-    //
-    // Fix up the next item in the list.
-    //
-    ASSERT(!pCurrent->Next)
-
-    //
-    // Fix up the previous item in the list.
-    //
-    if(pCurrent->Previous)
-    {
-        pCurrent->Previous->Next = 0;
-    }
-
-    //
-    // Fix up the current pointer.
-    //
-    if(pCurrent == pList->Current)
-    {
-        pList->Current = 0;
-    }
-
-    //
-    // Check the head pointer.
-    //
-    if(pList->Head == pCurrent)
-    {
-        pList->Head = 0;
-    }
-
-    //
-    // Check the tail pointer.
-    //
-    pList->Tail = pCurrent->Previous;
-
-    //
-    // Set the entry pointers.
-    //
-    pCurrent->Next = 0;
-    pCurrent->Previous = 0;
-    pList->NumberOfEntries--;
-    ASSERT(0 <= pList->NumberOfEntries);
-    return pCurrent;
-}
-
diff --git a/Router/alList.h b/Router/alList.h
deleted file mode 100644
index 71dc43c5..00000000
--- a/Router/alList.h
+++ /dev/null
@@ -1,433 +0,0 @@
-/**
- * OpenAL cross platform audio library
- * Copyright (C) 1999-2003 by authors.
- * 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 Software Foundation, Inc., 59 Temple Place - Suite 330,
- *  Boston, MA  02111-1307, USA.
- * Or go to http://www.gnu.org/copyleft/lgpl.html
- */
-
-
-
-
-#ifndef _AL_LIST_H_
-#define _AL_LIST_H_
-
-#include <al/al.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <windows.h>
-
-
-
-//*****************************************************************************
-//*****************************************************************************
-//
-// Defines
-//
-//*****************************************************************************
-//*****************************************************************************
-
-//
-// Some useful things to track parameters.
-//
-#ifndef IN
-#define IN
-#endif
-
-#ifndef OPTIONAL
-#define OPTIONAL
-#endif
-
-#ifndef OUT
-#define OUT
-#endif
-
-//
-// The list entry.  This should not be modified outside the list routines.
-//
-typedef struct ALlistEntry_Struct
-{
-    //
-    // The previous list entry.
-    //
-    struct ALlistEntry_Struct* Previous;
-
-    //
-    // The next list entry.
-    //
-    struct ALlistEntry_Struct* Next;
-
-    //
-    // The data for the current entry.
-    //
-    ALvoid* Data;
-
-} ALlistEntry;
-
-
-//
-// This is the context to pass to all the list calls.  It must be initialized
-// before any list calls are made.
-//
-typedef struct //ALlist_Struct
-{
-    //
-    // This is the pointer to the first item in the list.
-    //
-    ALlistEntry* Head;
-
-    //
-    // This is the pointer to the last item in the list.
-    //
-    ALlistEntry* Tail;
-
-    //
-    // This is the list iterator.
-    //
-    ALlistEntry* Current;
-
-    //
-    // This is the list lock to prevent simultaneous addition and removal
-    // of entries.
-    //
-    CRITICAL_SECTION Lock;
-
-    //
-    // This maintains a count of the number of entries in the list.
-    //
-    ALint NumberOfEntries;
-
-    //
-    // This is set if the list is locked.  For debug use only.
-    //
-#if(DBG)
-    ALint Locked;
-#endif
-
-} ALlist;
-
-
-
-//*****************************************************************************
-//*****************************************************************************
-//
-// List Functions
-//
-//*****************************************************************************
-//*****************************************************************************
-
-//*****************************************************************************
-// alListAddEntry
-//*****************************************************************************
-// Adds an entry to the tail of the list.  Each entry must be unique.
-//
-ALvoid alListAddEntry
-(
-    IN  ALlist* pList,
-    IN  ALlistEntry* pEntry
-);
-
-//*****************************************************************************
-// alListAddEntryToHead
-//*****************************************************************************
-// Adds an entry to the head of the list.  Each entry must be unique.
-//
-ALvoid alListAddEntryToHead
-(
-    IN  ALlist* pList,
-    IN  ALlistEntry* pEntry
-);
-
-//*****************************************************************************
-// alListAcquireLock
-//*****************************************************************************
-// This is called to acquire the list lock for operations that span multiple
-// list calls like iterating over the list.
-//
-ALvoid alListAcquireLock
-(
-    IN  ALlist* pList
-);
-
-//*****************************************************************************
-// alListCreate
-//*****************************************************************************
-// Creates and initializes a list.
-//
-ALboolean alListCreate
-(
-    OUT ALlist** ppList
-);
-
-//*****************************************************************************
-// alListFree
-//*****************************************************************************
-// Destroys the list.  Dynamically allocated entries are not freed.
-//
-ALvoid alListFree
-(
-    IN  ALlist* pList
-);
-
-//*****************************************************************************
-// alListGetData
-//*****************************************************************************
-// Returns the data from the list entry.
-//
-ALvoid* alListGetData
-(
-    IN  ALlistEntry* pEntry
-);
-
-//*****************************************************************************
-// alListGetEntryAt
-//*****************************************************************************
-// Returns the entry in the list at the specified index of the list.
-//
-ALlistEntry* alListGetEntryAt
-(
-    IN  ALlist* pList,
-    IN  ALint Index
-);
-
-//*****************************************************************************
-// alListGetEntryCount
-//*****************************************************************************
-// Returns the number of items stored in the list.
-//
-ALint alListGetEntryCount
-(
-    IN  ALlist* pList
-);
-
-//*****************************************************************************
-// alListGetHead
-//*****************************************************************************
-// Returns the first entry in the list.
-//
-ALlistEntry* alListGetHead
-(
-    IN  ALlist* pList
-);
-
-//*****************************************************************************
-// alListGetNext
-//*****************************************************************************
-// Returns the entry after to the entry pointed to by the iterator.  If
-// the iterator is at the last entry (or has finished iterating over the
-// list), the returned entry will be 0.
-//
-ALlistEntry* alListGetNext
-(
-    IN  ALlist* pList
-);
-
-//*****************************************************************************
-// alListGetPrevious
-//*****************************************************************************
-// Returns the entry previous to the entry pointed to by the iterator.  If
-// the iterator is at the first entry, the returned entry will be 0.
-//
-ALlistEntry* alListGetPrevious
-(
-    IN  ALlist* pList
-);
-
-//*****************************************************************************
-// alListGetTail
-//*****************************************************************************
-// Returns the last entry in the list.
-//
-ALlistEntry* alListGetTail
-(
-    IN  ALlist* pList
-);
-
-//*****************************************************************************
-// alListInitializeEntry
-//*****************************************************************************
-// Initializes a preallocated list entry.
-//
-ALvoid alListInitializeEntry
-(
-    IN  ALlistEntry* pListEntry,
-    IN  ALvoid* pData
-);
-
-//*****************************************************************************
-// alListIsEmpty
-//*****************************************************************************
-// Returns the TRUE if the list is empty.
-//
-ALboolean alListIsEmpty
-(
-    IN  ALlist* pList
-);
-
-//*****************************************************************************
-// alListIteratorGet
-//*****************************************************************************
-// Returns the entry pointed to by the iterator.
-//
-ALlistEntry* alListIteratorGet
-(
-    IN  ALlist* pList
-);
-
-//*****************************************************************************
-// alListIteratorFindData
-//*****************************************************************************
-// Searches the list for the matching item and return the pointer to the
-// entry.  If the match is not found, the return will be 0.
-//
-ALlistEntry* alListIteratorFindData
-(
-    IN  ALlist* pList,
-    IN  ALvoid* pData
-);
-
-//*****************************************************************************
-// alListIteratorNext
-//*****************************************************************************
-// This is called to advance the list iterator to the next entry in the list
-// and return that entry.
-//
-ALlistEntry* alListIteratorNext
-(
-    IN  ALlist* pList
-);
-
-//*****************************************************************************
-// alListIteratorPrevious
-//*****************************************************************************
-// This is called to advance the list iterator to the previous entry in the
-// list and return that entry.
-//
-ALlistEntry* alListIteratorPrevious
-(
-    IN  ALlist* pList
-);
-
-//*****************************************************************************
-// alListIteratorReset
-//*****************************************************************************
-// Returns the list iterator to the head of the list and returns the head
-// entry.
-//
-ALlistEntry* alListIteratorReset
-(
-    IN  ALlist* pList
-);
-
-//*****************************************************************************
-// alListIteratorRemove
-//*****************************************************************************
-// Removes the current item from the list and returns it.  The iterator will
-// equal the next item in the list.
-//
-ALlistEntry* alListIteratorRemove
-(
-    IN  ALlist* pList
-);
-
-//*****************************************************************************
-// alListIteratorSet
-//*****************************************************************************
-// Sets the current entry pointer to the entry passed in.  If the entry is not
-// found, the current entry will be 0.
-//
-ALlistEntry* alListIteratorSet
-(
-    IN  ALlist* pList,
-    IN  ALlistEntry* pEntry
-);
-
-//*****************************************************************************
-// alListMatchEntry
-//*****************************************************************************
-// Matches the entry to an item in the list and returns the data in that
-// entry.  If the match is not found, the return will be 0.
-//
-ALvoid* alListMatchEntry
-(
-    IN  ALlist* pList,
-    IN  ALlistEntry* pEntry
-);
-
-//*****************************************************************************
-// alListMatchData
-//*****************************************************************************
-// Searches the list for the matching item and return the pointer to the
-// entry.  If the match is not found, the return will be 0.
-//
-ALlistEntry* alListMatchData
-(
-    IN  ALlist* pList,
-    IN  ALvoid* pData
-);
-
-//*****************************************************************************
-// alListReleaseLock
-//*****************************************************************************
-// This is called to release the list lock.
-//
-ALvoid alListReleaseLock
-(
-    IN  ALlist* pList
-);
-
-//*****************************************************************************
-// alListRemoveEntry
-//*****************************************************************************
-// Removes the item from the list and returns the data from the item.  If
-// this is the current item, the current item will equal the next item in the
-// list.
-//
-ALvoid* alListRemoveEntry
-(
-    IN  ALlist* pList,
-    IN  ALlistEntry* pEntry
-);
-
-//*****************************************************************************
-// alListRemoveHead
-//*****************************************************************************
-// Removes the list entry at the head of the list.  If this is the current
-// item, the current item will equal the next item in the list.
-//
-ALlistEntry* alListRemoveHead
-(
-    IN  ALlist* pList
-);
-
-//*****************************************************************************
-// alListRemoveTail
-//*****************************************************************************
-// Removes the list entry at the tail of the list.  If this is the current
-// item, the current item will be null.
-//
-ALlistEntry* alListRemoveTail
-(
-    IN  ALlist* pList
-);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/Router/alc.cpp b/Router/alc.cpp
deleted file mode 100644
index c4abff8c..00000000
--- a/Router/alc.cpp
+++ /dev/null
@@ -1,2332 +0,0 @@
-/**
- * OpenAL cross platform audio library
- * Copyright (C) 1999-2000 by authors.
- * 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 Software Foundation, Inc., 59 Temple Place - Suite 330,
- *  Boston, MA  02111-1307, USA.
- * Or go to http://www.gnu.org/copyleft/lgpl.html
- */
-
-#ifndef __MINGW32__
-#define _CRT_SECURE_NO_DEPRECATE // get rid of sprintf security warnings on VS2005
-#endif
-
-#include <stdlib.h>
-#include <memory.h>
-#define AL_BUILD_LIBRARY
-#include <al/alc.h>
-#include <stdio.h>
-#include <tchar.h>
-#include <assert.h>
-
-#include <stddef.h>
-#include <windows.h>
-#if defined(_MSC_VER)
-#include <crtdbg.h>
-#else
-#define _malloc_dbg(s,x,f,l)     malloc(s)
-#define _realloc_dbg(p,s,x,f,l)  realloc(p,s)
-#endif
-#include <objbase.h>
-#ifndef __MINGW32__
-#include <atlconv.h>
-#else
-#define T2A(x) x
-#endif
-#include <mmsystem.h>
-
-#include "OpenAL32.h"
-
-
-//*****************************************************************************
-//*****************************************************************************
-//
-// Defines
-//
-//*****************************************************************************
-//*****************************************************************************
-
-typedef struct ALCextension_struct
-{
-
-    const char*		ename;
-
-} ALCextension;
-
-typedef struct
-{
-    const char*		ename;
-    ALenum			value;
-
-} ALCRouterEnum;
-
-typedef struct ALCfunction_struct
-{
-
-    const char*		fname;
-    ALvoid*			address;
-
-} ALCfunction;
-
-
-
-//*****************************************************************************
-//*****************************************************************************
-//
-// Global Vars
-//
-//*****************************************************************************
-//*****************************************************************************
-
-ALlist* alContextList = 0;
-ALCcontext* alCurrentContext = 0;
-
-ALCdevice* g_CaptureDevice = NULL;
-
-//*****************************************************************************
-//*****************************************************************************
-//
-// Local Vars
-//
-//*****************************************************************************
-//*****************************************************************************
-
-//
-// The values of the enums supported by OpenAL.
-//
-static ALCRouterEnum alcEnums[] =
-{
-    // Types
-    {"ALC_INVALID",                     ALC_INVALID},
-	{"ALC_FALSE",                       ALC_FALSE},
-	{"ALC_TRUE",                        ALC_TRUE},
-
-    // ALC Properties
-    {"ALC_MAJOR_VERSION",               ALC_MAJOR_VERSION},
-    {"ALC_MINOR_VERSION",               ALC_MINOR_VERSION},
-    {"ALC_ATTRIBUTES_SIZE",             ALC_ATTRIBUTES_SIZE},
-    {"ALC_ALL_ATTRIBUTES",              ALC_ALL_ATTRIBUTES},
-    {"ALC_DEFAULT_DEVICE_SPECIFIER",    ALC_DEFAULT_DEVICE_SPECIFIER},
-    {"ALC_DEVICE_SPECIFIER",            ALC_DEVICE_SPECIFIER},
-    {"ALC_EXTENSIONS",                  ALC_EXTENSIONS},
-    {"ALC_FREQUENCY",                   ALC_FREQUENCY},
-    {"ALC_REFRESH",                     ALC_REFRESH},
-    {"ALC_SYNC",                        ALC_SYNC},
-	{"ALC_MONO_SOURCES",                ALC_MONO_SOURCES},
-	{"ALC_STEREO_SOURCES",              ALC_STEREO_SOURCES},
-	{"ALC_CAPTURE_DEVICE_SPECIFIER",    ALC_CAPTURE_DEVICE_SPECIFIER},
-	{"ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER", ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER},
-	{"ALC_CAPTURE_SAMPLES",             ALC_CAPTURE_SAMPLES},
-
-	// New Enumeration extension
-	{"ALC_DEFAULT_ALL_DEVICES_SPECIFIER",	ALC_DEFAULT_ALL_DEVICES_SPECIFIER},
-	{"ALC_ALL_DEVICES_SPECIFIER",			ALC_ALL_DEVICES_SPECIFIER},
-
-    // ALC Error Message
-    {"ALC_NO_ERROR",                    ALC_NO_ERROR},
-    {"ALC_INVALID_DEVICE",              ALC_INVALID_DEVICE},
-    {"ALC_INVALID_CONTEXT",             ALC_INVALID_CONTEXT},
-    {"ALC_INVALID_ENUM",                ALC_INVALID_ENUM},
-    {"ALC_INVALID_VALUE",               ALC_INVALID_VALUE},
-    {"ALC_OUT_OF_MEMORY",               ALC_OUT_OF_MEMORY},
-
-    // Default
-    {0,                                 (ALenum)0}
-};
-
-//
-// Our function pointers.
-//
-static ALCfunction alcFunctions[] =
-{
-    {"alcCreateContext",                (ALvoid*)alcCreateContext},
-	{"alcMakeContextCurrent",           (ALvoid*)alcMakeContextCurrent},
-	{"alcProcessContext",               (ALvoid*)alcProcessContext},
-	{"alcSuspendContext",               (ALvoid*)alcSuspendContext},
-    {"alcDestroyContext",               (ALvoid*)alcDestroyContext},
-	{"alcGetCurrentContext",            (ALvoid*)alcGetCurrentContext},
-    {"alcGetContextsDevice",            (ALvoid*)alcGetContextsDevice},
-    {"alcOpenDevice",                   (ALvoid*)alcOpenDevice},
-	{"alcCloseDevice",                  (ALvoid*)alcCloseDevice},
-	{"alcGetError",                     (ALvoid*)alcGetError},
-	{"alcIsExtensionPresent",           (ALvoid*)alcIsExtensionPresent},
-	{"alcGetProcAddress",               (ALvoid*)alcGetProcAddress},
-	{"alcGetEnumValue",                 (ALvoid*)alcGetEnumValue},
-    {"alcGetString",                    (ALvoid*)alcGetString},
-    {"alcGetIntegerv",                  (ALvoid*)alcGetIntegerv},
-	{"alcCaptureOpenDevice",            (ALvoid*)alcCaptureOpenDevice},
-	{"alcCaptureCloseDevice",           (ALvoid*)alcCaptureCloseDevice},
-	{"alcCaptureStart",                 (ALvoid*)alcCaptureStart},
-	{"alcCaptureStop",                  (ALvoid*)alcCaptureStop},
-	{"alcCaptureSamples",               (ALvoid*)alcCaptureSamples},
-	{0,                                 (ALvoid*)0}
-};
-
-//
-// Our extensions.
-//
-static ALCextension alcExtensions[] =
-{
-    "ALC_ENUMERATION_EXT",
-	"ALC_ENUMERATE_ALL_EXT",
-	"ALC_EXT_CAPTURE",
-	0
-};
-
-
-// Error strings
-static ALenum  LastError = ALC_NO_ERROR;
-static const ALCchar alcNoError[] = "No Error";
-static const ALCchar alcErrInvalidDevice[] = "Invalid Device";
-static const ALCchar alcErrInvalidContext[] = "Invalid Context";
-static const ALCchar alcErrInvalidEnum[] = "Invalid Enum";
-static const ALCchar alcErrInvalidValue[] = "Invalid Value";
-
-static ALint alcMajorVersion = 1;
-static ALint alcMinorVersion = 1;
-
-// Enumeration stuff
-ALDEVICE *g_pDeviceList = NULL;				// ALC_ENUMERATION_EXT Device List
-ALDEVICE *g_pCaptureDeviceList = NULL;		// ALC_ENUMERATION_EXT Capture Device List
-ALDEVICE *g_pAllDevicesList = NULL;			// ALC_ENUMERATE_ALL_EXT Device List
-
-ALchar *pszDefaultDeviceSpecifier = NULL;
-ALchar *pszDeviceSpecifierList = NULL;
-ALchar *pszDefaultCaptureDeviceSpecifier = NULL;
-ALchar *pszCaptureDeviceSpecifierList = NULL;
-ALchar *pszDefaultAllDevicesSpecifier = NULL;
-ALchar *pszAllDevicesSpecifierList = NULL;
-ALchar szEmptyString[] = "";
-
-typedef BOOL (CALLBACK *LPDSENUMCALLBACKA)(LPGUID, LPCSTR, LPCSTR, LPVOID);
-typedef HRESULT (WINAPI *LPDIRECTSOUNDENUMERATEA)(LPDSENUMCALLBACKA pDSEnumCallback, LPVOID pContext);
-typedef HRESULT (WINAPI *LPDIRECTSOUNDCAPTUREENUMERATEA)(LPDSENUMCALLBACKA pDSEnumCallback, LPVOID pContext);
-
-BOOL CALLBACK DSEnumCallback(LPGUID lpGuid, LPCSTR lpcstrDescription, LPCSTR lpcstrModule, LPVOID lpContext);
-bool GetDefaultPlaybackDeviceName(char **pszName);
-bool GetDefaultCaptureDeviceName(char **pszName);
-bool FindDevice(ALDEVICE *pDeviceList, char *szDeviceName, bool bExactMatch, char **ppszDefaultName);
-bool HasDLLAlreadyBeenUsed(ALDEVICE *pDeviceList, TCHAR *szDLLName);
-//bool ValidCaptureDevice(const char *szCaptureDeviceName);
-
-//*****************************************************************************
-//*****************************************************************************
-//
-// Logging Options
-//
-//*****************************************************************************
-//*****************************************************************************
-
-// NOTE : LOG macro below requires a compiler newer than Visual Studio 6
-
-//#define _LOGCALLS
-
-#ifdef _LOGCALLS
- void OutputMessage(const char *szTest,...); 
- #define LOG(x, ...) OutputMessage(x, ##__VA_ARGS__)
- #define LOGFILENAME	"OpenALCalls.txt"
-#endif
-
-//*****************************************************************************
-//*****************************************************************************
-//
-// Local Functions
-//
-//*****************************************************************************
-//*****************************************************************************
-
-//*****************************************************************************
-// GetLoadedModuleDirectory
-//*****************************************************************************
-BOOL GetLoadedModuleDirectory(LPCTSTR moduleName,
-                              LPTSTR  directoryContainingModule,
-                              DWORD   directoryContainingModuleLength) {
-    // Attempts to find the given module in the address space of this
-    // process and return the directory containing the module. A NULL
-    // moduleName means to look up the directory containing the
-    // application rather than any given loaded module. There is no
-    // trailing backslash ('\') on the returned path. If the named
-    // module was found in the address space of this process, returns
-    // TRUE, otherwise returns FALSE. directoryContainingModule may be
-    // mutated regardless.
-    HMODULE module = NULL;
-    TCHAR fileDrive[MAX_PATH + 1];
-    TCHAR fileDir[MAX_PATH + 1];
-    TCHAR fileName[MAX_PATH + 1];
-    TCHAR fileExt[MAX_PATH + 1];
-    DWORD numChars;
-
-    if (moduleName != NULL) {
-        module = GetModuleHandle(moduleName);
-        if (module == NULL)
-            return FALSE;
-    }
-
-    numChars = GetModuleFileName(module,
-                                 directoryContainingModule,
-                                 directoryContainingModuleLength);
-    if (numChars == 0)
-        return FALSE;
-    
-    _splitpath(directoryContainingModule, fileDrive, fileDir, fileName, fileExt);
-    _tcscpy(directoryContainingModule, fileDrive);
-    _tcscat(directoryContainingModule, fileDir);
-    return TRUE;
-}
-
-
-
-
-//*****************************************************************************
-// AddDevice
-//*****************************************************************************
-void AddDevice(const char *pszDeviceName, TCHAR *pszHostDLLFilename, ALDEVICE **ppDeviceList)
-{
-	// Adds pszDeviceName nad pszHostDLLFilename to the given Device List *IF* pszDeviceName has
-	// not already been added.
-	ALDEVICE *pNewDevice, *pTempDevice;
-
-	// Check if unique
-	for (pTempDevice = *ppDeviceList; pTempDevice; pTempDevice = pTempDevice->pNextDevice)
-	{
-		if (strcmp(pTempDevice->pszDeviceName, pszDeviceName) == 0)
-			break;
-	}
-
-	if (pTempDevice)
-		return;
-
-	pNewDevice = (ALDEVICE*)malloc(sizeof(ALDEVICE));
-	if (pNewDevice)
-	{
-		pNewDevice->pszDeviceName = (char*)malloc((strlen(pszDeviceName)+1)*sizeof(char));
-		if (pNewDevice->pszDeviceName)
-			strcpy(pNewDevice->pszDeviceName, pszDeviceName);
-
-		pNewDevice->pszHostDLLFilename = (TCHAR*)malloc((_tcslen(pszHostDLLFilename)+1)*sizeof(TCHAR));
-		if (pNewDevice->pszHostDLLFilename)
-			_tcscpy(pNewDevice->pszHostDLLFilename, pszHostDLLFilename);
-
-		pNewDevice->pNextDevice = NULL;
-
-		if (*ppDeviceList)
-		{
-			pTempDevice = *ppDeviceList;
-			while (pTempDevice->pNextDevice)
-				pTempDevice = pTempDevice->pNextDevice;
-			pTempDevice->pNextDevice = pNewDevice;
-		}
-		else
-		{
-			*ppDeviceList = pNewDevice;
-		}
-	}
-}
-
-
-
-
-//*****************************************************************************
-// BuildDeviceList
-//*****************************************************************************
-ALvoid BuildDeviceList()
-{
-	// This function will scan several directories (details below) looking for
-	// OpenAL DLLs.  Each OpenAL DLL found will be opened and queried for it's
-	// list of playback and capture devices.   All the information is stored
-	// in various lists: -
-	//
-	// g_pDevicesList		:	List of Playback Devices
-	// g_pCaptureDeviceList	:	List of Capture devices
-	// g_pAllDevicesList	:	List of *all* possible Playback devices (ALC_ENUMERATE_ALL_EXT support)
-	//
-	// In addition this function allocates memory for the strings that will
-	// be returned to the application in response to alcGetString queries.
-	//
-	// pszDefaultDeviceSpecifier		:	Default Playback Device
-	// pszDeviceSpecifierList			:	List of Playback Devices
-	// pszDefaultCaptureDeviceSpecifier	:	Default Capture Device
-	// pszCaptureDeviceSpecifierList	:	List of Capture Devices
-	// pszDefaultAllDevicesSpecifier	:	Default *all* Playback Device (ALC_ENUMERATE_ALL_EXT support)
-	// pszAllDevicesSpecifierList		:	List of *all* Playback Devices (ALC_ENUMERATE_ALL_EXT support)
-    WIN32_FIND_DATA findData;
-    HANDLE searchHandle = INVALID_HANDLE_VALUE;
-    TCHAR searchName[MAX_PATH + 1];
-    BOOL found = FALSE;
-    const ALCchar* specifier = 0;
-    ALuint specifierSize = 0;
-	ALCdevice *device;
-	void *context;
-	bool bUsedWrapper = false;
-	ALDEVICE *pDevice = NULL;
-
-	// Only build the list once ...
-	if (((g_pDeviceList == NULL) && (waveOutGetNumDevs())) ||
-		((g_pCaptureDeviceList == NULL) && (waveInGetNumDevs())))
-	{
-		//
-		// Directory[0] is the directory containing OpenAL32.dll
-		// Directory[1] is the current directory.
-		// Directory[2] is the current app directory
-		// Directory[3] is the system directory
-		//
-		TCHAR dir[4][MAX_PATH + 1] = { 0 };
-        int numDirs = 0;
-		int i;
-		HINSTANCE dll = 0;
-		ALCAPI_GET_STRING alcGetStringFxn = 0;
-		ALCAPI_IS_EXTENSION_PRESENT alcIsExtensionPresentFxn = 0;
-		ALCAPI_OPEN_DEVICE alcOpenDeviceFxn = 0;
-		ALCAPI_CREATE_CONTEXT alcCreateContextFxn = 0;
-		ALCAPI_MAKE_CONTEXT_CURRENT alcMakeContextCurrentFxn = 0;
-		ALCAPI_DESTROY_CONTEXT alcDestroyContextFxn = 0;
-		ALCAPI_CLOSE_DEVICE alcCloseDeviceFxn = 0;
-
-		//
-		// Construct our search paths
-		//
-		if (GetLoadedModuleDirectory("OpenAL32.dll", dir[0], MAX_PATH)) {
-            ++numDirs;
-        }
-
-		GetCurrentDirectory(MAX_PATH, dir[1]);
-		_tcscat(dir[1], _T("\\"));
-		++numDirs;
-
-		GetLoadedModuleDirectory(NULL, dir[2], MAX_PATH);
-		++numDirs;
-
-		GetSystemDirectory(dir[3], MAX_PATH);
-		_tcscat(dir[3], _T("\\"));
-		++numDirs;
-
-		//
-		// Begin searching for additional OpenAL implementations.
-		//
-		for(i = 0; i < numDirs; i++)
-		{
-			if ((i == 0) && (strcmp(dir[0], dir[3]) == 0))	// if searching router dir and router dir is sys dir, skip search
-				continue;
-
-			if ((i == 2) && (strcmp(dir[2], dir[1]) == 0))	// if searching app dir and app dir is current dir, skip search
-				continue;
-
-			if ((i == 3) && ((strcmp(dir[3], dir[2]) == 0) || (strcmp(dir[3], dir[1]) == 0)))	// if searching sys dir and sys dir is either current or app directory, skip search
-				continue;
-
-			_tcscpy(searchName, dir[i]);
-			_tcscat(searchName, _T("*oal.dll"));
-			searchHandle = FindFirstFile(searchName, &findData);
-			if(searchHandle != INVALID_HANDLE_VALUE)
-			{
-				while(TRUE)
-				{
-					//
-					// if this is an OpenAL32.dll, skip it -- it's probably a router and shouldn't be enumerated regardless
-					//
-					_tcscpy(searchName, dir[i]);
-					_tcscat(searchName, findData.cFileName);
-					TCHAR cmpName[MAX_PATH];
-					_tcscpy(cmpName, searchName);
-					_tcsupr(cmpName);
-					if (_tcsstr(cmpName, _T("OPENAL32.DLL")) == 0)
-					{
-						boolean skipSearch = false;
-
-						// don't search the same DLL twice
-						TCHAR *szDLLName = _tcsrchr(searchName, _T('\\'));
-						if (szDLLName)
-							szDLLName++;	// Skip over the '\'
-						else
-							szDLLName = searchName;
-
-						skipSearch = HasDLLAlreadyBeenUsed(g_pDeviceList, szDLLName);
-						if (!skipSearch)
-							skipSearch = HasDLLAlreadyBeenUsed(g_pCaptureDeviceList, szDLLName);
-						if (!skipSearch)
-							skipSearch = HasDLLAlreadyBeenUsed(g_pAllDevicesList, szDLLName);
-
-						if (skipSearch == false) {
-							dll = LoadLibrary(searchName);
-							if(dll)
-							{
-								alcOpenDeviceFxn = (ALCAPI_OPEN_DEVICE)GetProcAddress(dll, "alcOpenDevice");
-								alcCreateContextFxn = (ALCAPI_CREATE_CONTEXT)GetProcAddress(dll, "alcCreateContext");
-								alcMakeContextCurrentFxn = (ALCAPI_MAKE_CONTEXT_CURRENT)GetProcAddress(dll, "alcMakeContextCurrent");
-								alcGetStringFxn = (ALCAPI_GET_STRING)GetProcAddress(dll, "alcGetString");
-								alcDestroyContextFxn = (ALCAPI_DESTROY_CONTEXT)GetProcAddress(dll, "alcDestroyContext");
-								alcCloseDeviceFxn = (ALCAPI_CLOSE_DEVICE)GetProcAddress(dll, "alcCloseDevice");
-								alcIsExtensionPresentFxn = (ALCAPI_IS_EXTENSION_PRESENT)GetProcAddress(dll, "alcIsExtensionPresent");
-
-								if ((alcOpenDeviceFxn != 0) &&
-									(alcCreateContextFxn != 0) &&
-									(alcMakeContextCurrentFxn != 0) &&
-									(alcGetStringFxn != 0) &&
-									(alcDestroyContextFxn != 0) &&
-									(alcCloseDeviceFxn != 0) &&
-									(alcIsExtensionPresentFxn != 0)) {
-
-									bool bAddToAllDevicesList = false;
-
-									if (alcIsExtensionPresentFxn(NULL, "ALC_ENUMERATE_ALL_EXT")) {
-										// this DLL can enumerate *all* devices -- so add complete list of devices
-										specifier = alcGetStringFxn(0, ALC_ALL_DEVICES_SPECIFIER);
-										if ((specifier) && strlen(specifier))
-										{
-											do {
-												AddDevice(specifier, searchName, &g_pAllDevicesList);
-												specifier += strlen((char *)specifier) + 1;
-											} while (strlen((char *)specifier) > 0);
-										}
-									} else {
-										bAddToAllDevicesList = true;
-									}
-
-									if (alcIsExtensionPresentFxn(NULL, "ALC_ENUMERATION_EXT")) {
-										// this DLL can enumerate devices -- so add complete list of devices
-										specifier = alcGetStringFxn(0, ALC_DEVICE_SPECIFIER);
-										if ((specifier) && strlen(specifier))
-										{
-											do {
-												AddDevice(specifier, searchName, &g_pDeviceList);
-												if (bAddToAllDevicesList)
-													AddDevice(specifier, searchName, &g_pAllDevicesList);
-												specifier += strlen((char *)specifier) + 1;
-											} while (strlen((char *)specifier) > 0);
-										}
-									} else {
-										// no enumeration ability, -- so just add default device to the list
-										device = alcOpenDeviceFxn(NULL);
-										if (device != NULL) {
-											context = alcCreateContextFxn(device, NULL);
-											alcMakeContextCurrentFxn((ALCcontext *)context);
-											if (context != NULL) {
-												specifier = alcGetStringFxn(device, ALC_DEVICE_SPECIFIER);
-												if ((specifier) && strlen(specifier))
-												{
-													AddDevice(specifier, searchName, &g_pDeviceList);
-													if (bAddToAllDevicesList)
-														AddDevice(specifier, searchName, &g_pAllDevicesList);
-												}
-												alcMakeContextCurrentFxn((ALCcontext *)NULL);
-												alcDestroyContextFxn((ALCcontext *)context);
-												alcCloseDeviceFxn(device);
-											}
-										}
-									}
-
-									// add to capture device list
-									if (_tcsstr(cmpName, _T("CT_OAL.DLL")) == 0) {
-										// Skip native AL component (will contain same Capture List as the wrap_oal component)
-										if (alcIsExtensionPresentFxn(NULL, "ALC_EXT_CAPTURE")) {
-											// this DLL supports capture -- so add complete list of capture devices
-											specifier = alcGetStringFxn(0, ALC_CAPTURE_DEVICE_SPECIFIER);
-											if ((specifier) && strlen(specifier))
-											{
-												do {
-													AddDevice(specifier, searchName, &g_pCaptureDeviceList);
-													specifier += strlen((char *)specifier) + 1;
-												} while (strlen((char *)specifier) > 0);
-											}
-										}
-									}
-								}
-
-								FreeLibrary(dll);
-								dll = 0;
-							}
-						}
-					}
-
-					if(!FindNextFile(searchHandle, &findData))
-					{
-						if(GetLastError() == ERROR_NO_MORE_FILES)
-						{
-							break;
-						}
-					}
-				}
-
-				FindClose(searchHandle);
-				searchHandle = INVALID_HANDLE_VALUE;
-			}
-		}
-
-		// We now have a list of all the Device Names and their associated DLLs.
-		// Put the names in the appropriate strings
-		ALuint uiLength;
-		ALchar *pszTemp;
-		char *pszDefaultName = NULL;
-		bool bFound = false;
-
-		if (g_pDeviceList)
-		{
-			uiLength = 0;
-			for (pDevice = g_pDeviceList; pDevice; pDevice = pDevice->pNextDevice)
-				uiLength += (strlen(pDevice->pszDeviceName) + 1);
-
-			pszDeviceSpecifierList = (ALchar*)malloc((uiLength + 1) * sizeof(ALchar));
-			if (pszTemp = pszDeviceSpecifierList)
-			{
-				memset(pszDeviceSpecifierList, 0, (uiLength + 1) * sizeof(ALchar));
-				for (pDevice = g_pDeviceList; pDevice; pDevice = pDevice->pNextDevice)
-				{
-					strcpy(pszTemp, pDevice->pszDeviceName);
-					pszTemp += (strlen(pDevice->pszDeviceName) + 1);
-				}
-			}
-
-			// Determine what the Default Device should be
-			if (GetDefaultPlaybackDeviceName(&pszDefaultName))
-			{
-				bFound = false;
-
-				// Search for an exact match first
-				bFound = FindDevice(g_pDeviceList, pszDefaultName, true, &pszDefaultDeviceSpecifier);
-
-				// If we haven't found a match ... search for a partial match if name contains 'X-Fi'
-				if ((!bFound) && (strstr(pszDefaultName, "X-Fi")))
-					bFound = FindDevice(g_pDeviceList, "X-Fi", false, &pszDefaultDeviceSpecifier);
-				
-				// If we haven't found a match ... search for a partial match if name contains 'Audigy'
-				if ((!bFound) && (strstr(pszDefaultName, "Audigy")))
-					bFound = FindDevice(g_pDeviceList, "Audigy", false, &pszDefaultDeviceSpecifier);
-
-				// If we haven't found a match ... search for a partial match with 'Generic Hardware'
-				if (!bFound)
-					bFound = FindDevice(g_pDeviceList, "Generic Hardware", false, &pszDefaultDeviceSpecifier);
-
-				// If we haven't found a match ... search for a partial match with 'Generic Software'
-				if (!bFound)
-					bFound = FindDevice(g_pDeviceList, "Generic Software", false, &pszDefaultDeviceSpecifier);
-
-				// If we STILL haven't found a match ... pick the 1st device!
-				if (!bFound)
-				{
-					pszDefaultDeviceSpecifier = (char*)malloc((strlen(g_pDeviceList->pszDeviceName) + 1) * sizeof(char));
-					if (pszDefaultDeviceSpecifier)
-						strcpy(pszDefaultDeviceSpecifier, g_pDeviceList->pszDeviceName);
-				}
-				
-				free(pszDefaultName);
-				pszDefaultName = NULL;
-			}
-		}
-
-		if (g_pCaptureDeviceList)
-		{
-			uiLength = 0;
-			for (pDevice = g_pCaptureDeviceList; pDevice; pDevice = pDevice->pNextDevice)
-				uiLength += (strlen(pDevice->pszDeviceName) + 1);
-
-			pszCaptureDeviceSpecifierList = (ALchar*)malloc((uiLength + 1) * sizeof(ALchar));
-			if (pszTemp = pszCaptureDeviceSpecifierList)
-			{
-				memset(pszCaptureDeviceSpecifierList, 0, (uiLength + 1) * sizeof(ALchar));
-				for (pDevice = g_pCaptureDeviceList; pDevice; pDevice = pDevice->pNextDevice)
-				{
-					strcpy(pszTemp, pDevice->pszDeviceName);
-					pszTemp += (strlen(pDevice->pszDeviceName) + 1);
-				}
-			}
-
-			if (GetDefaultCaptureDeviceName(&pszDefaultName))
-			{
-				bFound = false;
-
-				// Search for an exact match first
-				bFound = FindDevice(g_pCaptureDeviceList, pszDefaultName, true, &pszDefaultCaptureDeviceSpecifier);
-
-				// If we haven't found a match, truncate the default name to 32 characters (MMSYSTEM limitation)
-				if ((!bFound) && (strlen(pszDefaultName) > 31))
-				{
-					pszDefaultName[31] = '\0';
-					bFound = FindDevice(g_pCaptureDeviceList, pszDefaultName, true, &pszDefaultCaptureDeviceSpecifier);
-				}
-
-				// If we haven't found a match ... pick the 1st device!
-				if (!bFound)
-				{
-					pszDefaultCaptureDeviceSpecifier = (char*)malloc((strlen(g_pCaptureDeviceList->pszDeviceName) + 1) * sizeof(char));
-					if (pszDefaultCaptureDeviceSpecifier)
-						strcpy(pszDefaultCaptureDeviceSpecifier, g_pCaptureDeviceList->pszDeviceName);
-				}
-
-				free(pszDefaultName);
-				pszDefaultName = NULL;
-			}
-		}
-
-		if (g_pAllDevicesList)
-		{
-			uiLength = 0;
-			for (pDevice = g_pAllDevicesList; pDevice; pDevice = pDevice->pNextDevice)
-				uiLength += (strlen(pDevice->pszDeviceName) + 1);
-
-			pszAllDevicesSpecifierList = (ALchar*)malloc((uiLength + 1) * sizeof(ALchar));
-			if (pszTemp = pszAllDevicesSpecifierList)
-			{
-				memset(pszAllDevicesSpecifierList, 0, (uiLength + 1) * sizeof(ALchar));
-				for (pDevice = g_pAllDevicesList; pDevice; pDevice = pDevice->pNextDevice)
-				{
-					strcpy(pszTemp, pDevice->pszDeviceName);
-					pszTemp += (strlen(pDevice->pszDeviceName) + 1);
-				}
-			}
-
-			// Determine what the Default Device should be
-			if (GetDefaultPlaybackDeviceName(&pszDefaultName))
-			{
-				bFound = false;
-
-				// If the (regular) default Playback device exists in this list ... use that
-				bFound = FindDevice(g_pAllDevicesList, pszDefaultDeviceSpecifier, true, &pszDefaultAllDevicesSpecifier);
-
-				// If we haven't found a match ... pick a partial match with the Default Device Name
-				if (!bFound)
-					bFound = FindDevice(g_pAllDevicesList, pszDefaultName, false, &pszDefaultAllDevicesSpecifier);
-
-				// If we STILL haven't found a match ... pick the 1st device!
-				if (!bFound)
-				{
-					pszDefaultAllDevicesSpecifier = (char*)malloc((strlen(g_pAllDevicesList->pszDeviceName) + 1) * sizeof(char));
-					if (pszDefaultAllDevicesSpecifier)
-						strcpy(pszDefaultAllDevicesSpecifier, g_pAllDevicesList->pszDeviceName);
-				}
-				
-				free(pszDefaultName);
-				pszDefaultName = NULL;
-			}
-		}
-	}
-
-    return;
-}
-
-
-
-
-//*****************************************************************************
-// HasDLLAlreadyBeenUsed
-//*****************************************************************************
-bool HasDLLAlreadyBeenUsed(ALDEVICE *pDeviceList, TCHAR *szDLLName)
-{
-	// Checks if an OpenAL DLL has already been enumerated
-	ALDEVICE *pDevice = NULL;
-	TCHAR *szHostDLLName;
-	bool bReturn = false;
-
-	for (pDevice = pDeviceList; pDevice; pDevice = pDevice->pNextDevice)
-	{
-		szHostDLLName = _tcsrchr(pDevice->pszHostDLLFilename, _T('\\'));
-		if (szHostDLLName)
-			szHostDLLName++;	// Skip over the '\'
-		else
-			szHostDLLName = pDevice->pszHostDLLFilename;
-
-		if (_tcscmp(szHostDLLName, szDLLName) == 0)
-		{
-			bReturn = true;
-			break;
-		}
-	}
-
-	return bReturn;
-}
-
-
-
-
-//*****************************************************************************
-// ValidCaptureDevice
-//*****************************************************************************
-/*
-bool ValidCaptureDevice(const char *szCaptureDeviceName)
-{
-	// Microsoft changed the behaviour of Input devices on Windows Vista such that *each* input
-	// on each soundcard is reported as a separate device.   Unfortunately, even though you can
-	// enumerate each input there are restrictions on what devices can be opened (e.g. you can only
-	// open the soundcard's default input).   There is no API call to change the default input, so
-	// there is little point enumerating input devices that cannot be used, so we filter them out here.
-	WAVEFORMATEX wfex = { WAVE_FORMAT_PCM, 1, 22050, 44100, 2, 16, 0 };	// 16bit Mono 22050Hz
-	WAVEINCAPS WaveInCaps;
-	HWAVEIN	hWaveIn;
-	bool bValid = false;
-
-	// Find the device ID from the device name
-	long lNumCaptureDevs = waveInGetNumDevs();
-	long lDeviceID = -1;
-	for (long lLoop = 0; lLoop < lNumCaptureDevs; lLoop++)
-	{
-		if (waveInGetDevCaps(lLoop, &WaveInCaps, sizeof(WAVEINCAPS)) == MMSYSERR_NOERROR)
-		{
-			if (!strcmp(szCaptureDeviceName, WaveInCaps.szPname))
-			{
-				lDeviceID = lLoop;
-				break;
-			}
-		}
-	}
-
-	if (lDeviceID != -1)
-	{
-		if (waveInOpen(&hWaveIn, lDeviceID, &wfex, NULL, NULL, WAVE_MAPPED) == MMSYSERR_NOERROR)
-		{
-			waveInClose(hWaveIn);
-			bValid = true;
-		}
-	}
-
-	return bValid;
-}
-*/
-
-
-
-//*****************************************************************************
-// GetDefaultPlaybackDeviceName
-//*****************************************************************************
-bool GetDefaultPlaybackDeviceName(char **pszName)
-{
-	// Try to use DirectSound to get the name of the 'Preferred Audio Device / Endpoint"
-	// If that fails use MMSYSTEM (name will be limited to 32 characters in length)
-	TCHAR szPath[_MAX_PATH];
-	HINSTANCE hDSoundDLL;
-
-	if (!pszName)
-		return false;
-
-	*pszName = NULL;
-
-	// Load dsound.dll from the System Directory and use the DirectSoundEnumerateA function to
-	// get the list of playback devices
-	if (GetSystemDirectory(szPath, _MAX_PATH))
-	{
-		_tcscat(szPath, "\\dsound.dll");
-		hDSoundDLL = LoadLibrary(szPath);
-		if (hDSoundDLL)
-		{
-			LPDIRECTSOUNDENUMERATEA pfnDirectSoundEnumerateA = (LPDIRECTSOUNDENUMERATEA)GetProcAddress(hDSoundDLL, "DirectSoundEnumerateA");
-			if (pfnDirectSoundEnumerateA)
-				pfnDirectSoundEnumerateA(&DSEnumCallback, pszName);
-			FreeLibrary(hDSoundDLL);
-		}
-	}
-
-	// Falling back to MMSYSTEM
-	if (*pszName == NULL)
-	{
-		UINT uDeviceID=0;
-		DWORD dwFlags=1;
-		WAVEOUTCAPS outputInfo;
-
-		#if !defined(_WIN64)
-		#ifdef __GNUC__
-		  __asm__ ("pusha;");
-        #else
-		__asm pusha; // workaround for register destruction caused by these wavOutMessage calls (weird but true)
-		#endif
-		#endif // !defined(_WIN64)
-		waveOutMessage((HWAVEOUT)(UINT_PTR)WAVE_MAPPER,0x2000+0x0015,(LPARAM)&uDeviceID,(WPARAM)&dwFlags);
-		waveOutGetDevCaps(uDeviceID,&outputInfo,sizeof(outputInfo));
-		#if !defined(_WIN64)
-		#ifdef __GNUC__
-		  __asm__ ("popa;");
-        #else
-		__asm popa;
-		#endif
-		#endif // !defined(_WIN64)
-
-		*pszName = (char*)malloc((strlen(outputInfo.szPname) + 1) * sizeof(char));
-		if (*pszName)
-			strcpy(*pszName, outputInfo.szPname);
-	}
-
-	return (*pszName) ? true : false;
-}
-
-
-
-
-//*****************************************************************************
-// GetDefaultCaptureDeviceName
-//*****************************************************************************
-bool GetDefaultCaptureDeviceName(char **pszName)
-{
-	// Try to use DirectSound to get the name of the 'Preferred Audio Device / Endpoint" for recording.
-	// If that fails use MMSYSTEM (name will be limited to 32 characters in length)
-	TCHAR szPath[_MAX_PATH];
-	HINSTANCE hDSoundDLL;
-
-	if (!pszName)
-		return false;
-
-	*pszName = NULL;
-
-	// Load dsound.dll from the System Directory and use the DirectSoundCaptureEnumerateA function to
-	// get the list of capture devices
-	if (GetSystemDirectory(szPath, _MAX_PATH))
-	{
-		_tcscat(szPath, "\\dsound.dll");
-		hDSoundDLL = LoadLibrary(szPath);
-		if (hDSoundDLL)
-		{
-			LPDIRECTSOUNDCAPTUREENUMERATEA pfnDirectSoundCaptureEnumerateA = (LPDIRECTSOUNDCAPTUREENUMERATEA)GetProcAddress(hDSoundDLL, "DirectSoundCaptureEnumerateA");
-			if (pfnDirectSoundCaptureEnumerateA)
-				pfnDirectSoundCaptureEnumerateA(&DSEnumCallback, pszName);
-			FreeLibrary(hDSoundDLL);
-		}
-	}
-
-	// Falling back to MMSYSTEM
-	if (*pszName == NULL)
-	{
-		UINT uDeviceID=0;
-		DWORD dwFlags=1;
-		WAVEINCAPS inputInfo;
-
-		#if !defined(_WIN64)
-		#ifdef __GNUC__
-		  __asm__ ("pusha;");
-        #else
-		__asm pusha; // workaround for register destruction caused by these wavOutMessage calls (weird but true)
-		#endif
-		#endif // !defined(_WIN64)
-		waveInMessage((HWAVEIN)(UINT_PTR)WAVE_MAPPER,0x2000+0x0015,(LPARAM)&uDeviceID,(WPARAM)&dwFlags);
-		waveInGetDevCaps(uDeviceID, &inputInfo, sizeof(inputInfo));
-		#if !defined(_WIN64)
-		#ifdef __GNUC__
-		  __asm__ ("popa;");
-        #else
-		__asm popa;
-		#endif
-		#endif // !defined(_WIN64)
-
-		*pszName = (char*)malloc((strlen(inputInfo.szPname) + 1) * sizeof(char));
-		if (*pszName)
-			strcpy(*pszName, inputInfo.szPname);
-	}
-
-	return (*pszName) ? true : false;
-}
-
-
-
-
-//*****************************************************************************
-// DSEnumCallback
-//*****************************************************************************
-BOOL CALLBACK DSEnumCallback(LPGUID lpGuid, LPCSTR lpcstrDescription, LPCSTR lpcstrModule, LPVOID lpContext)
-{
-	// DirectSound Enumeration callback will be called for each device found.
-	// The first device returned with a non-NULL GUID is the 'preferred device'
-
-	// Skip over the device without a GUID
-	if (lpGuid)
-	{
-		char **pszName = (char**)lpContext;
-		*pszName = (char*)malloc((strlen(lpcstrDescription)+1) * sizeof(char));
-		if (*pszName)
-		{
-			strcpy(*pszName, lpcstrDescription);
-			return FALSE;
-		}
-	}
-
-	return TRUE;
-}
-
-
-
-//*****************************************************************************
-// FindDevice
-//*****************************************************************************
-bool FindDevice(ALDEVICE *pDeviceList, char *szDeviceName, bool bExactMatch, char **ppszDefaultName)
-{
-	// Search through pDeviceList for szDeviceName using an exact match if bExactMatch is true, or using
-	// a sub-string search otherwise.
-	// If found, allocate memory for *ppszDefaultName and copy the device name over
-	ALDEVICE *pDevice = NULL;
-	bool bFound = false;
-
-	if (!pDeviceList || !szDeviceName || !ppszDefaultName)
-		return false;
-
-	for (pDevice = pDeviceList; pDevice; pDevice = pDevice->pNextDevice)
-	{
-		if (bExactMatch)
-			bFound = (strcmp(pDevice->pszDeviceName, szDeviceName) == 0) ? true : false;
-		else
-			bFound = (strstr(pDevice->pszDeviceName, szDeviceName)) ? true : false;
-
-		if (bFound)
-		{
-			*ppszDefaultName = (char*)malloc((strlen(pDevice->pszDeviceName) + 1) * sizeof(char));
-			if (*ppszDefaultName)
-			{
-				strcpy(*ppszDefaultName, pDevice->pszDeviceName);
-				break;
-			}
-		}
-	}
-
-	return *ppszDefaultName ? true : false;
-}
-
-
-
-
-//*****************************************************************************
-// LoadDevicesDLL
-//*****************************************************************************
-HINSTANCE LoadDevicesDLL(ALDEVICE *pDeviceList, const ALchar *szDeviceName)
-{
-	// Search pDeviceList for szDeviceName, and when found load the OpenAL DLL
-	// that contains that Device name.
-	HINSTANCE hDLL = NULL;
-	ALDEVICE *pDevice;
-
-	for (pDevice = pDeviceList; pDevice; pDevice = pDevice->pNextDevice)
-	{
-		if (strcmp(pDevice->pszDeviceName, szDeviceName) == 0)
-		{
-			hDLL = LoadLibrary(pDevice->pszHostDLLFilename);
-			break;
-		}
-	}
-
-	return hDLL;
-}
-
-
-
-
-//*****************************************************************************
-// FillOutAlcFunctions
-//*****************************************************************************
-ALboolean FillOutAlcFunctions(ALCdevice* device)
-{
-    ALboolean alcFxns = FALSE;
-    ALCAPI_FXN_TABLE* alcApi = &device->AlcApi;
-
-	memset(alcApi, 0, sizeof(ALCAPI_FXN_TABLE));
-
-    //
-    // Get the OpenAL 1.0 Entry points.
-    //
-	alcApi->alcCreateContext      = (ALCAPI_CREATE_CONTEXT)GetProcAddress(device->Dll, "alcCreateContext");
-    alcApi->alcMakeContextCurrent = (ALCAPI_MAKE_CONTEXT_CURRENT)GetProcAddress(device->Dll, "alcMakeContextCurrent");
-    alcApi->alcProcessContext     = (ALCAPI_PROCESS_CONTEXT)GetProcAddress(device->Dll, "alcProcessContext");
-	alcApi->alcSuspendContext     = (ALCAPI_SUSPEND_CONTEXT)GetProcAddress(device->Dll, "alcSuspendContext");
-    alcApi->alcDestroyContext     = (ALCAPI_DESTROY_CONTEXT)GetProcAddress(device->Dll, "alcDestroyContext");
-	alcApi->alcGetCurrentContext  = (ALCAPI_GET_CURRENT_CONTEXT)GetProcAddress(device->Dll, "alcGetCurrentContext");
-    alcApi->alcGetContextsDevice  = (ALCAPI_GET_CONTEXTS_DEVICE)GetProcAddress(device->Dll, "alcGetContextsDevice");
-
-	alcApi->alcOpenDevice         = (ALCAPI_OPEN_DEVICE)GetProcAddress(device->Dll, "alcOpenDevice");
-    alcApi->alcCloseDevice        = (ALCAPI_CLOSE_DEVICE)GetProcAddress(device->Dll, "alcCloseDevice");
-
-	alcApi->alcGetError           = (ALCAPI_GET_ERROR)GetProcAddress(device->Dll, "alcGetError");
-
-	alcApi->alcIsExtensionPresent = (ALCAPI_IS_EXTENSION_PRESENT)GetProcAddress(device->Dll, "alcIsExtensionPresent");
-    alcApi->alcGetProcAddress     = (ALCAPI_GET_PROC_ADDRESS)GetProcAddress(device->Dll, "alcGetProcAddress");
-	alcApi->alcGetEnumValue       = (ALCAPI_GET_ENUM_VALUE)GetProcAddress(device->Dll, "alcGetEnumValue");
-
-    alcApi->alcGetString          = (ALCAPI_GET_STRING)GetProcAddress(device->Dll, "alcGetString");
-    alcApi->alcGetIntegerv        = (ALCAPI_GET_INTEGERV)GetProcAddress(device->Dll, "alcGetIntegerv");
-
-	//
-	// Get the OpenAL 1.1 Entry points.
-	//
-    alcApi->alcCaptureOpenDevice = (ALCAPI_CAPTURE_OPEN_DEVICE)GetProcAddress(device->Dll, "alcCaptureOpenDevice");
-    alcApi->alcCaptureCloseDevice = (ALCAPI_CAPTURE_CLOSE_DEVICE)GetProcAddress(device->Dll, "alcCaptureCloseDevice");
-    alcApi->alcCaptureStart = (ALCAPI_CAPTURE_START)GetProcAddress(device->Dll, "alcCaptureStart");
-    alcApi->alcCaptureStop = (ALCAPI_CAPTURE_STOP)GetProcAddress(device->Dll, "alcCaptureStop");
-    alcApi->alcCaptureSamples = (ALCAPI_CAPTURE_SAMPLES)GetProcAddress(device->Dll, "alcCaptureSamples");
-
-	// handle legacy issue with old Creative DLLs which may not have alcGetProcAddress, alcIsExtensionPresent, alcGetEnumValue
-	if (alcApi->alcGetProcAddress == NULL) {
-		alcApi->alcGetProcAddress = (ALCAPI_GET_PROC_ADDRESS)alcGetProcAddress;
-	}
-	if (alcApi->alcIsExtensionPresent == NULL) {
-		alcApi->alcIsExtensionPresent = (ALCAPI_IS_EXTENSION_PRESENT)alcIsExtensionPresent;
-	}
-	if (alcApi->alcGetEnumValue == NULL) {
-		alcApi->alcGetEnumValue = (ALCAPI_GET_ENUM_VALUE)alcGetEnumValue;
-	}
-
-
-    alcFxns = (alcApi->alcCreateContext      &&
-               alcApi->alcMakeContextCurrent &&
-               alcApi->alcProcessContext     &&
-			   alcApi->alcSuspendContext     &&
-               alcApi->alcDestroyContext     &&
-			   alcApi->alcGetCurrentContext  &&
-               alcApi->alcGetContextsDevice  &&
-			   alcApi->alcOpenDevice         &&
-               alcApi->alcCloseDevice        &&
-			   alcApi->alcGetError           &&
-			   alcApi->alcIsExtensionPresent &&
-               alcApi->alcGetProcAddress     &&
-			   alcApi->alcGetEnumValue       &&
-			   alcApi->alcGetString          &&
-               alcApi->alcGetIntegerv);
-
-    return alcFxns;
-}
-
-
-
-
-//*****************************************************************************
-// FillOutAlFunctions
-//*****************************************************************************
-ALboolean FillOutAlFunctions(ALCcontext* context)
-{
-    ALboolean  alFxns = FALSE;
-    ALAPI_FXN_TABLE*   alApi = &context->AlApi;
-
-	memset(alApi, 0, sizeof(ALAPI_FXN_TABLE));
-
-    //
-    // Get the OpenAL 1.0 & 1.1 Entry points.
-    //
-    alApi->alEnable               = (ALAPI_ENABLE)GetProcAddress(context->Device->Dll, "alEnable");
-    alApi->alDisable              = (ALAPI_DISABLE)GetProcAddress(context->Device->Dll, "alDisable");
-    alApi->alIsEnabled            = (ALAPI_IS_ENABLED)GetProcAddress(context->Device->Dll, "alIsEnabled");
-
-	alApi->alGetString            = (ALAPI_GET_STRING)GetProcAddress(context->Device->Dll, "alGetString");
-	alApi->alGetBooleanv          = (ALAPI_GET_BOOLEANV)GetProcAddress(context->Device->Dll, "alGetBooleanv");
-    alApi->alGetIntegerv          = (ALAPI_GET_INTEGERV)GetProcAddress(context->Device->Dll, "alGetIntegerv");
-    alApi->alGetFloatv            = (ALAPI_GET_FLOATV)GetProcAddress(context->Device->Dll, "alGetFloatv");
-    alApi->alGetDoublev           = (ALAPI_GET_DOUBLEV)GetProcAddress(context->Device->Dll, "alGetDoublev");
-    alApi->alGetBoolean           = (ALAPI_GET_BOOLEAN)GetProcAddress(context->Device->Dll, "alGetBoolean");
-    alApi->alGetInteger           = (ALAPI_GET_INTEGER)GetProcAddress(context->Device->Dll, "alGetInteger");
-    alApi->alGetFloat             = (ALAPI_GET_FLOAT)GetProcAddress(context->Device->Dll, "alGetFloat");
-    alApi->alGetDouble            = (ALAPI_GET_DOUBLE)GetProcAddress(context->Device->Dll, "alGetDouble");
-	alApi->alGetError             = (ALAPI_GET_ERROR)GetProcAddress(context->Device->Dll, "alGetError");
-    alApi->alIsExtensionPresent   = (ALAPI_IS_EXTENSION_PRESENT)GetProcAddress(context->Device->Dll, "alIsExtensionPresent");
-	alApi->alGetProcAddress       = (ALAPI_GET_PROC_ADDRESS)GetProcAddress(context->Device->Dll, "alGetProcAddress");
-    alApi->alGetEnumValue         = (ALAPI_GET_ENUM_VALUE)GetProcAddress(context->Device->Dll, "alGetEnumValue");
-
-	alApi->alListenerf            = (ALAPI_LISTENERF)GetProcAddress(context->Device->Dll, "alListenerf");
-	alApi->alListener3f           = (ALAPI_LISTENER3F)GetProcAddress(context->Device->Dll, "alListener3f");
-	alApi->alListenerfv           = (ALAPI_LISTENERFV)GetProcAddress(context->Device->Dll, "alListenerfv");
-    alApi->alListeneri            = (ALAPI_LISTENERI)GetProcAddress(context->Device->Dll, "alListeneri");
-	alApi->alListener3i           = (ALAPI_LISTENER3I)GetProcAddress(context->Device->Dll, "alListener3i");
-	alApi->alListeneriv           = (ALAPI_LISTENERIV)GetProcAddress(context->Device->Dll, "alListeneriv");
-    alApi->alGetListenerf         = (ALAPI_GET_LISTENERF)GetProcAddress(context->Device->Dll, "alGetListenerf");
-	alApi->alGetListener3f        = (ALAPI_GET_LISTENER3F)GetProcAddress(context->Device->Dll, "alGetListener3f");
-	alApi->alGetListenerfv        = (ALAPI_GET_LISTENERFV)GetProcAddress(context->Device->Dll, "alGetListenerfv");
-	alApi->alGetListeneri         = (ALAPI_GET_LISTENERI)GetProcAddress(context->Device->Dll, "alGetListeneri");
-	alApi->alGetListener3i        = (ALAPI_GET_LISTENER3I)GetProcAddress(context->Device->Dll, "alGetListener3i");
-	alApi->alGetListeneriv        = (ALAPI_GET_LISTENERIV)GetProcAddress(context->Device->Dll, "alGetListeneriv");
-
-    alApi->alGenSources           = (ALAPI_GEN_SOURCES)GetProcAddress(context->Device->Dll, "alGenSources");
-    alApi->alDeleteSources        = (ALAPI_DELETE_SOURCES)GetProcAddress(context->Device->Dll, "alDeleteSources");
-    alApi->alIsSource             = (ALAPI_IS_SOURCE)GetProcAddress(context->Device->Dll, "alIsSource");
-	alApi->alSourcef              = (ALAPI_SOURCEF)GetProcAddress(context->Device->Dll, "alSourcef");
-    alApi->alSource3f             = (ALAPI_SOURCE3F)GetProcAddress(context->Device->Dll, "alSource3f");
-    alApi->alSourcefv             = (ALAPI_SOURCEFV)GetProcAddress(context->Device->Dll, "alSourcefv");
-    alApi->alSourcei              = (ALAPI_SOURCEI)GetProcAddress(context->Device->Dll, "alSourcei");
-    alApi->alSource3i             = (ALAPI_SOURCE3I)GetProcAddress(context->Device->Dll, "alSource3i");
-    alApi->alSourceiv             = (ALAPI_SOURCEIV)GetProcAddress(context->Device->Dll, "alSourceiv");
-    alApi->alGetSourcef           = (ALAPI_GET_SOURCEF)GetProcAddress(context->Device->Dll, "alGetSourcef");
-    alApi->alGetSource3f          = (ALAPI_GET_SOURCE3F)GetProcAddress(context->Device->Dll, "alGetSource3f");
-    alApi->alGetSourcefv          = (ALAPI_GET_SOURCEFV)GetProcAddress(context->Device->Dll, "alGetSourcefv");
-	alApi->alGetSourcei           = (ALAPI_GET_SOURCEI)GetProcAddress(context->Device->Dll, "alGetSourcei");
-    alApi->alGetSource3i          = (ALAPI_GET_SOURCE3I)GetProcAddress(context->Device->Dll, "alGetSource3i");
-    alApi->alGetSourceiv          = (ALAPI_GET_SOURCEIV)GetProcAddress(context->Device->Dll, "alGetSourceiv");
-    alApi->alSourcePlayv          = (ALAPI_SOURCE_PLAYV)GetProcAddress(context->Device->Dll, "alSourcePlayv");
-    alApi->alSourceStopv          = (ALAPI_SOURCE_STOPV)GetProcAddress(context->Device->Dll, "alSourceStopv");
-    alApi->alSourceRewindv        = (ALAPI_SOURCE_REWINDV)GetProcAddress(context->Device->Dll, "alSourceRewindv");
-	alApi->alSourcePausev         = (ALAPI_SOURCE_PAUSEV)GetProcAddress(context->Device->Dll, "alSourcePausev");
-    alApi->alSourcePlay           = (ALAPI_SOURCE_PLAY)GetProcAddress(context->Device->Dll, "alSourcePlay");
-    alApi->alSourceStop           = (ALAPI_SOURCE_STOP)GetProcAddress(context->Device->Dll, "alSourceStop");
-    alApi->alSourceRewind         = (ALAPI_SOURCE_STOP)GetProcAddress(context->Device->Dll, "alSourceRewind");
-	alApi->alSourcePause          = (ALAPI_SOURCE_PAUSE)GetProcAddress(context->Device->Dll, "alSourcePause");
-
-	alApi->alSourceQueueBuffers   = (ALAPI_SOURCE_QUEUE_BUFFERS)GetProcAddress(context->Device->Dll, "alSourceQueueBuffers");
-    alApi->alSourceUnqueueBuffers = (ALAPI_SOURCE_UNQUEUE_BUFFERS)GetProcAddress(context->Device->Dll, "alSourceUnqueueBuffers");
-
-    alApi->alGenBuffers           = (ALAPI_GEN_BUFFERS)GetProcAddress(context->Device->Dll, "alGenBuffers");
-    alApi->alDeleteBuffers        = (ALAPI_DELETE_BUFFERS)GetProcAddress(context->Device->Dll, "alDeleteBuffers");
-    alApi->alIsBuffer             = (ALAPI_IS_BUFFER)GetProcAddress(context->Device->Dll, "alIsBuffer");
-    alApi->alBufferData           = (ALAPI_BUFFER_DATA)GetProcAddress(context->Device->Dll, "alBufferData");
-	alApi->alBufferf              = (ALAPI_BUFFERF)GetProcAddress(context->Device->Dll, "alBufferf");
-    alApi->alBuffer3f             = (ALAPI_BUFFER3F)GetProcAddress(context->Device->Dll, "alBuffer3f");
-    alApi->alBufferfv             = (ALAPI_BUFFERFV)GetProcAddress(context->Device->Dll, "alBufferfv");
-    alApi->alBufferi              = (ALAPI_BUFFERI)GetProcAddress(context->Device->Dll, "alBufferi");
-    alApi->alBuffer3i             = (ALAPI_BUFFER3I)GetProcAddress(context->Device->Dll, "alBuffer3i");
-    alApi->alBufferiv             = (ALAPI_BUFFERIV)GetProcAddress(context->Device->Dll, "alBufferiv");
-	alApi->alGetBufferf           = (ALAPI_GET_BUFFERF)GetProcAddress(context->Device->Dll, "alGetBufferf");
-    alApi->alGetBuffer3f          = (ALAPI_GET_BUFFER3F)GetProcAddress(context->Device->Dll, "alGetBuffer3f");
-    alApi->alGetBufferfv          = (ALAPI_GET_BUFFERFV)GetProcAddress(context->Device->Dll, "alGetBufferfv");
-    alApi->alGetBufferi           = (ALAPI_GET_BUFFERI)GetProcAddress(context->Device->Dll, "alGetBufferi");
-    alApi->alGetBuffer3i          = (ALAPI_GET_BUFFER3I)GetProcAddress(context->Device->Dll, "alGetBuffer3i");
-    alApi->alGetBufferiv          = (ALAPI_GET_BUFFERIV)GetProcAddress(context->Device->Dll, "alGetBufferiv");
-
-	alApi->alDopplerFactor        = (ALAPI_DOPPLER_FACTOR)GetProcAddress(context->Device->Dll, "alDopplerFactor");
-    alApi->alDopplerVelocity      = (ALAPI_DOPPLER_VELOCITY)GetProcAddress(context->Device->Dll, "alDopplerVelocity");
-	alApi->alSpeedOfSound         = (ALAPI_SPEED_OF_SOUND)GetProcAddress(context->Device->Dll, "alSpeedOfSound");
-    alApi->alDistanceModel        = (ALAPI_DISTANCE_MODEL)GetProcAddress(context->Device->Dll, "alDistanceModel");
-    
-    alFxns = (alApi->alEnable               &&
-              alApi->alDisable              &&
-              alApi->alIsEnabled            &&
-
-              alApi->alGetString            &&
-              alApi->alGetBooleanv          &&
-              alApi->alGetIntegerv          &&
-              alApi->alGetFloatv            &&
-              alApi->alGetDoublev           &&
-			  alApi->alGetBoolean           &&
-              alApi->alGetInteger           &&
-              alApi->alGetFloat             &&
-              alApi->alGetDouble            &&
-              
-              alApi->alGetError             &&
-
-              alApi->alIsExtensionPresent   &&
-              alApi->alGetProcAddress       &&
-              alApi->alGetEnumValue         &&
-
-			  alApi->alListenerf            &&
-              alApi->alListener3f           &&
-              alApi->alListenerfv           &&
-              alApi->alListeneri            &&
-              alApi->alGetListenerf         &&
-              alApi->alGetListener3f        &&
-              alApi->alGetListenerfv        &&
-			  alApi->alGetListeneri         &&
-              
-              alApi->alGenSources           &&
-              alApi->alDeleteSources        &&
-              alApi->alIsSource             &&
-              alApi->alSourcef              &&
-              alApi->alSource3f             &&
-              alApi->alSourcefv             &&
-			  alApi->alSourcei              &&
-              alApi->alGetSourcef           &&
-              alApi->alGetSource3f          &&
-              alApi->alGetSourcefv          &&
-              alApi->alGetSourcei           &&
-              alApi->alSourcePlayv          &&
-              alApi->alSourceStopv          &&
-              alApi->alSourceRewindv        &&
-			  alApi->alSourcePausev         &&
-              alApi->alSourcePlay           &&
-              alApi->alSourceStop           &&
-              alApi->alSourceRewind         &&
-			  alApi->alSourcePause          &&
-
-			  alApi->alSourceQueueBuffers   &&
-              alApi->alSourceUnqueueBuffers &&              
-
-              alApi->alGenBuffers           &&
-              alApi->alDeleteBuffers        &&
-              alApi->alIsBuffer             &&
-              alApi->alBufferData           &&
-              alApi->alGetBufferf           &&
-			  alApi->alGetBufferi           &&
-
-			  alApi->alDopplerFactor        &&
-              alApi->alDopplerVelocity      &&
-              alApi->alDistanceModel);
-
-    return alFxns;
-}
-
-
-
-
-//*****************************************************************************
-//*****************************************************************************
-//
-// ALC API Entry Points
-//
-//*****************************************************************************ALC_
-//*****************************************************************************
-
-//*****************************************************************************
-// alcCloseDevice
-//*****************************************************************************
-//
-ALCAPI ALCboolean ALCAPIENTRY alcCloseDevice(ALCdevice* device)
-{
-#ifdef _LOGCALLS
-	LOG("alcCloseDevice device %p\n", device);
-#endif
-    if(!device)
-    {
-        return ALC_FALSE;
-    }
-
-	if (device == g_CaptureDevice)
-		return g_CaptureDevice->AlcApi.alcCloseDevice(g_CaptureDevice->CaptureDevice);
-
-    //
-    // Check if its linked to a context.
-    //
-    if(device->InUse)
-    {
-        ALCcontext* context = 0;
-        ALlistEntry* entry = 0;
-
-        //
-        // Not all of the contexts using the device have been destroyed.
-        //
-        assert(0);
-
-        //
-        // Loop through the context list and free and contexts linked to the device.
-        // Go back to the beginning each time in case some one changed the context
-        // list iterator.
-        //
-        alListAcquireLock(alContextList);
-        entry = alListIteratorReset(alContextList);
-        while(entry)
-        {
-            context = (ALCcontext*)alListGetData(entry);
-            if(context->Device == device)
-            {
-                alListReleaseLock(alContextList);
-                alcDestroyContext((ALCcontext *)context);
-                alListAcquireLock(alContextList);
-                entry = alListIteratorReset(alContextList);
-            }
-
-            else
-            {
-                entry = alListIteratorNext(alContextList);
-            }
-        }
-
-        alListReleaseLock(alContextList);
-        assert(!device->InUse);
-    }
-
-    device->AlcApi.alcCloseDevice(device->DllDevice);
-    FreeLibrary(device->Dll);
-    free(device);
-
-	return ALC_TRUE;
-}
-
-
-
-
-//*****************************************************************************
-// alcCreateContext
-//*****************************************************************************
-ALCAPI ALCcontext* ALCAPIENTRY alcCreateContext(ALCdevice* device, const ALint* attrList)
-{
-#ifdef _LOGCALLS
-	LOG("alcCreateContext device %p ", device);
-	if (attrList)
-	{
-		unsigned long ulIndex = 0;
-		while ((ulIndex < 16) && (attrList[ulIndex]))
-		{
-			switch(attrList[ulIndex])
-			{
-			case ALC_FREQUENCY:
-				LOG("ALC_FREQUENCY %d ", attrList[ulIndex + 1]);
-				break;
-
-			case ALC_REFRESH:
-				LOG("ALC_REFRESH %d ", attrList[ulIndex + 1]);
-				break;
-
-			case ALC_SYNC:
-				LOG("ALC_SYNC %d ", attrList[ulIndex + 1]);
-				break;
-
-			case ALC_MONO_SOURCES:
-				LOG("ALC_MONO_SOURCES %d ", attrList[ulIndex + 1]);
-				break;
-
-			case ALC_STEREO_SOURCES:
-				LOG("ALC_STEREO_SOURCES %d ", attrList[ulIndex + 1]);
-				break;
-
-			case 0x20003/*ALC_MAX_AUXILIARY_SENDS*/:
-				LOG("ALC_MAX_AUXILIARY_SENDS %d", attrList[ulIndex + 1]);
-				break;
-			}
-			ulIndex += 2;
-		}
-	}
-	LOG("\n");
-#endif
-
-	ALCcontext* context = 0;
-
-    if(!device)
-    {
-        LastError = ALC_INVALID_DEVICE;
-        return 0;
-    }
-
-	if (device == g_CaptureDevice)
-		return g_CaptureDevice->AlcApi.alcCreateContext(g_CaptureDevice->CaptureDevice, attrList);
-
-    //
-    // Allocate the context.
-    //
-    context = (ALCcontext*)malloc(sizeof(ALCcontext));
-    if(!context)
-    {
-        return 0;
-    }
-
-    memset(context, 0, sizeof(ALCcontext));
-    context->Device = device;
-    context->Suspended = FALSE;
-    context->LastError = ALC_NO_ERROR;
-    InitializeCriticalSection(&context->Lock);
-
-    //
-    // We don't fill out the AL functions in case they are context specific.
-    //
-
-    context->DllContext = device->AlcApi.alcCreateContext(device->DllDevice, attrList);
-    if(!context->DllContext)
-    {
-        DeleteCriticalSection(&context->Lock);
-        free(context);
-        context = 0;
-        return 0;
-    }
-
-    device->InUse++;
-
-    //
-    // Add it to the context list.
-    //
-    alListInitializeEntry(&context->ListEntry, context);
-    alListAcquireLock(alContextList);
-    alListAddEntry(alContextList, &context->ListEntry);
-    alListReleaseLock(alContextList);
-    return context;
-}
-
-
-
-
-//*****************************************************************************
-// alcDestroyContext
-//*****************************************************************************
-ALCAPI ALvoid ALCAPIENTRY alcDestroyContext(ALCcontext* context)
-{
-#ifdef _LOGCALLS
-	LOG("alcDestroyContext context %p\n", context);
-#endif
-    ALCcontext* listData = 0;
-
-    if(!context)
-    {
-        return;
-    }
-
-    //
-    // Remove the entry from the context list.
-    //
-    alListAcquireLock(alContextList);
-    listData = (ALCcontext*)alListRemoveEntry(alContextList, &context->ListEntry);
-    if(!listData)
-    {
-        alListReleaseLock(alContextList);
-        return;
-    }
-
-    if(context == alCurrentContext)
-    {
-        alCurrentContext = 0;
-    }
-
-    EnterCriticalSection(&context->Lock);
-    alListReleaseLock(alContextList);
-
-    context->Device->InUse--;
-
-    // Clean up the context.
-    if(context->DllContext)
-    {
-        context->Device->AlcApi.alcDestroyContext(context->DllContext);
-    }
-
-    LeaveCriticalSection(&context->Lock);
-    DeleteCriticalSection(&context->Lock);
-    free(context);
-}
-
-
-
-
-//*****************************************************************************
-// alcGetContextsDevice
-//*****************************************************************************
-ALCAPI ALCdevice* ALCAPIENTRY alcGetContextsDevice(ALCcontext* context)
-{
-#ifdef _LOGCALLS
-	LOG("alcGetContextsDevice context %p\n", context);
-#endif
-    ALCdevice* ALCdevice = 0;
-
-    alListAcquireLock(alContextList);
-    if(alListMatchData(alContextList, context))
-    {
-        ALCdevice = context->Device;
-    }
-
-    alListReleaseLock(alContextList);
-
-    return ALCdevice;
-}
-
-
-
-
-//*****************************************************************************
-// alcGetCurrentContext
-//*****************************************************************************
-ALCAPI ALCcontext* ALCAPIENTRY alcGetCurrentContext(ALvoid)
-{
-#ifdef _LOGCALLS
-	LOG("alcGetCurrentContext\n");
-#endif
-    return (ALCcontext *)alCurrentContext;
-}
-
-
-
-
-//*****************************************************************************
-// alcGetEnumValue
-//*****************************************************************************
-ALCAPI ALenum ALCAPIENTRY alcGetEnumValue(ALCdevice* device, const ALCchar* ename)
-{
-#ifdef _LOGCALLS
-	LOG("alcGetEnumValue device %p enum name '%s'\n", device, ename ? ename : "<NULL>");
-#endif
-    //
-    // Always return the router version of the ALC enum if it exists.
-    //
-    ALsizei i = 0;
-    while(alcEnums[i].ename && strcmp((char*)alcEnums[i].ename, (char*)ename))
-    {
-        i++;
-    }
-
-    if(alcEnums[i].ename)
-    {
-        return alcEnums[i].value;
-    }
-
-    if(device)
-    {
-		if (device == g_CaptureDevice)
-			return g_CaptureDevice->AlcApi.alcGetEnumValue(g_CaptureDevice->CaptureDevice, ename);
-
-        return device->AlcApi.alcGetEnumValue(device->DllDevice, ename);
-    }
-
-    LastError = ALC_INVALID_ENUM;
-    return 0;
-}
-
-
-
-
-//*****************************************************************************
-// alcGetError
-//*****************************************************************************
-ALCAPI ALenum ALCAPIENTRY alcGetError(ALCdevice* device)
-{
-#ifdef _LOGCALLS
-	LOG("alcGetError device %p\n", device);
-#endif
-    ALenum errorCode = ALC_NO_ERROR;
-
-    // Try to get a valid device.
-    if(!device)
-    {
-		if (g_CaptureDevice == device)
-			return 
-        errorCode = LastError;
-        LastError = ALC_NO_ERROR;
-        return errorCode;
-    }
-
-    //
-    // Check if its a 3rd party device.
-    //
-	if (device == g_CaptureDevice)
-		errorCode = g_CaptureDevice->AlcApi.alcGetError(g_CaptureDevice->CaptureDevice);
-	else
-		errorCode = device->AlcApi.alcGetError(device->DllDevice);
-
-    return errorCode;
-}
-
-
-
-
-//*****************************************************************************
-// alcGetIntegerv
-//*****************************************************************************
-ALCAPI ALvoid ALCAPIENTRY alcGetIntegerv(ALCdevice* device, ALenum param, ALsizei size, ALint* data)
-{
-#ifdef _LOGCALLS
-	LOG("alcGetIntegerv device %p enum ", device);
-	switch (param)
-	{
-	case ALC_ATTRIBUTES_SIZE:
-		LOG("ALC_ATTRIBUTES_SIZE\n");
-		break;
-	case ALC_ALL_ATTRIBUTES:
-		LOG("ALC_ALL_ATTRIBUTES\n");
-		break;
-	case ALC_MAJOR_VERSION:
-		LOG("ALC_MAJOR_VERSION\n");
-		break;
-	case ALC_MINOR_VERSION:
-		LOG("ALC_MINOR_VERSION\n");
-		break;
-	case ALC_CAPTURE_SAMPLES:
-		LOG("ALC_CAPTURE_SAMPLES\n");
-		break;
-	case ALC_FREQUENCY:
-		LOG("ALC_FREQUENCY\n");
-		break;
-	case ALC_REFRESH:
-		LOG("ALC_REFRESH\n");
-		break;
-	case ALC_SYNC:
-		LOG("ALC_SYNC\n");
-		break;
-	case ALC_MONO_SOURCES:
-		LOG("ALC_MONO_SOURCES\n");
-		break;
-	case ALC_STEREO_SOURCES:
-		LOG("ALC_STEREO_SOURCES\n");
-		break;
-	case 0x20003: // ALC_MAX_AUXILIARY_SENDS
-		LOG("ALC_MAX_AUXILIARY_SENDS\n");
-		break;
-	case 0x20001: // ALC_EFX_MAJOR_VERSION
-		LOG("ALC_EFX_MAJOR_VERSION\n");
-		break;
-	case 0x20002: // ALC_EFX_MINOR_VERSION
-		LOG("ALC_EFX_MINOR_VERSION\n");
-		break;
-	default:
-		LOG("<Unknown>\n");
-		break;
-	}
-#endif
-
-	if(device)
-    {
-		if (device == g_CaptureDevice)
-		{
-			g_CaptureDevice->AlcApi.alcGetIntegerv(g_CaptureDevice->CaptureDevice, param, size, data);
-			return;
-		}
-
-        device->AlcApi.alcGetIntegerv(device->DllDevice, param, size, data);
-        return;
-    }
-
-    switch(param)
-    {
-        case ALC_MAJOR_VERSION:
-        {
-            if((size < sizeof(ALint)) || (data == 0))
-            {
-                LastError = ALC_INVALID;
-                return;
-            }
-
-            *data = alcMajorVersion;
-        }
-        break;
-
-        case ALC_MINOR_VERSION:
-        {
-            if((size < sizeof(ALint)) || (data == 0))
-            {
-                LastError = ALC_INVALID;
-                return;
-            }
-
-            *data = alcMinorVersion;
-        }
-        break;
-
-        default:
-        {
-            device->LastError = ALC_INVALID_ENUM;
-        }
-        break;
-    }
-}
-
-
-
-
-//*****************************************************************************
-// alcGetProcAddress
-//*****************************************************************************
-ALCAPI ALvoid* ALCAPIENTRY alcGetProcAddress(ALCdevice* device, const ALCchar* fname)
-{
-#ifdef _LOGCALLS
-	LOG("alcGetProcAddress device %p function name '%s'\n", device, fname ? fname : "<NULL>");
-#endif
-
-    //
-    // Always return the router version of the ALC function if it exists.
-    //
-    ALsizei i = 0;
-    while(alcFunctions[i].fname && strcmp((char*)alcFunctions[i].fname, (char*)fname))
-    {
-        i++;
-    }
-
-    if(alcFunctions[i].fname)
-    {
-        return alcFunctions[i].address;
-    }
-
-    if(device)
-    {
-		if (device == g_CaptureDevice)
-			return g_CaptureDevice->AlcApi.alcGetProcAddress(g_CaptureDevice->CaptureDevice, fname);
-
-        return device->AlcApi.alcGetProcAddress(device->DllDevice, fname);
-    }
-
-    LastError = ALC_INVALID_ENUM;
-    return 0;
-}
-
-
-
-
-//*****************************************************************************
-// alcIsExtensionPresent
-//*****************************************************************************
-ALCAPI ALboolean ALCAPIENTRY alcIsExtensionPresent(ALCdevice* device, const ALCchar* ename)
-{
-#ifdef _LOGCALLS
-	LOG("alcIsExtensionPresent device %p extension name '%s'\n", device, ename ? ename : "<NULL>");
-#endif
-    //
-    // Check if its a router supported extension first as its a good idea to have
-    // ALC calls go through the router if possible.
-    //
-    ALsizei i = 0;
-    while(alcExtensions[i].ename && _stricmp((char*)alcExtensions[i].ename, (char*)ename))
-    {
-        i++;
-    }
-
-    if(alcExtensions[i].ename)
-    {
-        return ALC_TRUE;
-    }
-
-    //
-    // Check the device passed in to see if the extension is supported.
-    //
-    if(device)
-    {
-		if (device == g_CaptureDevice)
-			return g_CaptureDevice->AlcApi.alcIsExtensionPresent(g_CaptureDevice->CaptureDevice, ename);
-
-        return device->AlcApi.alcIsExtensionPresent(device->DllDevice, ename);
-    }
-
-    LastError = ALC_INVALID_ENUM;
-    return ALC_FALSE;
-}
-
-
-
-
-//*****************************************************************************
-// alcMakeContextCurrent
-//*****************************************************************************
-ALCAPI ALboolean ALCAPIENTRY alcMakeContextCurrent(ALCcontext* context)
-{
-#ifdef _LOGCALLS
-	LOG("alcMakeContextCurrent context %p\n", context);
-#endif
-    ALboolean contextSwitched = AL_TRUE;
-
-    //
-    // Context must be a valid context or 0
-    //
-    alListAcquireLock(alContextList);
-    if(!alListMatchData(alContextList, context) && context != 0)
-    {
-        alListReleaseLock(alContextList);
-        return ALC_FALSE;
-    }
-
-    //
-    // Try the new context.
-    //
-    if(context)
-    {
-        contextSwitched = context->Device->AlcApi.alcMakeContextCurrent(context->DllContext);
-
-        //
-        // If this is the first time the context has been made the current context, fill in the context
-        // function pointers.
-        //
-        if(contextSwitched && !context->AlApi.alGetProcAddress)
-        {
-            //
-            // Don't fill out the functions here in case they are context specific pointers in the device.
-            //
-            if(!FillOutAlFunctions(context))
-            {
-                LastError = ALC_INVALID_CONTEXT;
-                contextSwitched = AL_FALSE;
-
-                //
-                // Something went wrong, restore the old context.
-                //
-                if(alCurrentContext)
-                {
-                    alCurrentContext->Device->AlcApi.alcMakeContextCurrent(alCurrentContext->DllContext);
-                }
-
-                else
-                {
-                    alCurrentContext->Device->AlcApi.alcMakeContextCurrent(0);
-                }
-            }
-        }
-	} else {
-		if ((alCurrentContext) && (alCurrentContext->Device) && (alCurrentContext->Device->AlcApi.alcMakeContextCurrent)) {
-			contextSwitched = alCurrentContext->Device->AlcApi.alcMakeContextCurrent(0);
-		}
-    }
-
-    //
-    // Set the context states if the switch was successful.
-    //
-    if(contextSwitched)
-    {
-        alCurrentContext = context;
-    }
-
-    alListReleaseLock(alContextList);
-    return contextSwitched;
-}
-
-
-
-
-//*****************************************************************************
-// alcOpenDevice
-//*****************************************************************************
-ALCAPI ALCdevice* ALCAPIENTRY alcOpenDevice(const ALCchar* deviceName)
-{
-#ifdef _LOGCALLS
-	LOG("alcOpenDevice device name '%s'\n", deviceName ? deviceName : "<NULL>");
-#endif
-    HINSTANCE dll = 0;
-    ALCdevice* device = 0;
-	const ALchar *pszDeviceName = NULL;
-
-	BuildDeviceList();
-
-	if (g_pDeviceList)
-	{
-		if ((!deviceName) || (strlen(deviceName)==0) || (strcmp(deviceName, "DirectSound3D")==0))
-			pszDeviceName = pszDefaultDeviceSpecifier;
-		else
-			pszDeviceName = deviceName;
-
-		// Search for device in Playback Device List
-		dll = LoadDevicesDLL(g_pDeviceList, pszDeviceName);
-
-		if (!dll)
-		{
-			// If NOT found, and the requested name is one of these ...
-			//		"Generic Hardware"	(no longer available on Windows Vista)
-			//		"DirectSound"		(legacy name for OpenAL Software mixer device)
-			//		"MMSYSTEM"			(legacy name for OpenAL Software mixer using MMSYSTEM instead of DirectSound)
-			// try to open the "Generic Software" device instead
-			if ((strcmp(pszDeviceName, "Generic Hardware") == 0) ||
-				(strcmp(pszDeviceName, "DirectSound") == 0) ||
-				(strcmp(pszDeviceName, "MMSYSTEM") == 0))
-			{
-				dll = LoadDevicesDLL(g_pDeviceList, "Generic Software");
-			}
-		}
-
-		if (!dll)
-			dll = LoadDevicesDLL(g_pAllDevicesList, pszDeviceName);
-
-		if (dll)
-		{
-			device = (ALCdevice*)malloc(sizeof(ALCdevice));
-			if (device)
-			{
-				memset(device, 0, sizeof(ALCdevice));
-				device->LastError = ALC_NO_ERROR;
-				device->InUse = 0;
-				device->Dll = dll;
-				if (FillOutAlcFunctions(device))
-					device->DllDevice = device->AlcApi.alcOpenDevice(pszDeviceName);
-
-				if (!device->DllDevice)
-				{
-					FreeLibrary(dll);
-				    free(device);
-				    device = 0;
-				}
-			}
-		}
-	}
-
-	if (!device)
-		LastError = ALC_INVALID_DEVICE;
-
-	return device;
-}
-
-
-
-
-//*****************************************************************************
-// alcProcessContext
-//*****************************************************************************
-ALCAPI ALvoid ALCAPIENTRY alcProcessContext(ALCcontext* context)
-{
-#ifdef _LOGCALLS
-	LOG("alcProcessContext context %p\n", context);
-#endif
-    alListAcquireLock(alContextList);
-    if(!context && !alCurrentContext)
-    {
-        alListReleaseLock(alContextList);
-        return;
-    }
-
-    if(!context)
-    {
-        context = alCurrentContext;
-    }
-
-    EnterCriticalSection(&context->Lock);
-    alListReleaseLock(alContextList);
-
-    if(context->DllContext)
-    {
-        context->Device->AlcApi.alcProcessContext(context->DllContext);
-    }
-
-    context->Suspended = FALSE;
-
-    LeaveCriticalSection(&context->Lock);
-    return;
-}
-
-
-
-
-//*****************************************************************************
-// alcSuspendContext
-//*****************************************************************************
-ALCAPI ALCvoid ALCAPIENTRY alcSuspendContext(ALCcontext* context)
-{
-#ifdef _LOGCALLS
-	LOG("alcSuspendContext context %p\n", context);
-#endif
-    alListAcquireLock(alContextList);
-    if(!context && !alCurrentContext)
-    {
-        alListReleaseLock(alContextList);
-        return;
-    }
-
-    if(!context)
-    {
-        context = (ALCcontext *)alCurrentContext;
-    }
-
-    EnterCriticalSection(&context->Lock);
-    alListReleaseLock(alContextList);
-
-    context->Suspended = TRUE;
-
-    if(context->DllContext)
-    {
-        context->Device->AlcApi.alcSuspendContext(context->DllContext);
-    }
-
-    LeaveCriticalSection(&context->Lock);
-    return;
-}
-
-
-
-
-//*****************************************************************************
-// alcGetString
-//*****************************************************************************
-ALCAPI const ALCchar* ALCAPIENTRY alcGetString(ALCdevice* device, ALenum param)
-{
-#ifdef _LOGCALLS
-	LOG("alcGetString device %p enum ", device);
-	switch (param)
-	{
-	case ALC_NO_ERROR:
-		LOG("ALC_NO_ERROR\n");
-		break;
-    case ALC_INVALID_ENUM:
-	    LOG("ALC_INVALID_ENUM\n");
-		break;
-    case ALC_INVALID_VALUE:
-		LOG("ALC_INVALID_VALUE\n");
-	    break;
-    case ALC_INVALID_DEVICE:
-		LOG("ALC_INVALID_DEVICE\n");
-	    break;
-    case ALC_INVALID_CONTEXT:
-		LOG("ALC_INVALID_CONTEXT\n");
-	    break;
-    case ALC_DEFAULT_DEVICE_SPECIFIER:
-		LOG("ALC_DEFAULT_DEVICE_SPECIFIER\n");
-		break;
-    case ALC_DEVICE_SPECIFIER:
-		LOG("ALC_DEVICE_SPECIFIER\n");
-		break;
-	case ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER:
-		LOG("ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER\n");
-		break;
-	case ALC_CAPTURE_DEVICE_SPECIFIER:
-		LOG("ALC_CAPTURE_DEVICE_SPECIFIER\n");
-		break;
-	case ALC_ALL_DEVICES_SPECIFIER:
-		LOG("ALC_ALL_DEVICES_SPECIFIER\n");
-		break;
-	case ALC_DEFAULT_ALL_DEVICES_SPECIFIER:
-		LOG("ALC_DEFAULT_ALL_DEVICES_SPECIFIER\n");
-		break;
-	case ALC_EXTENSIONS:
-		LOG("ALC_EXTENSIONS\n");
-		break;
-	default:
-		LOG("<Unknown>\n");
-		break;
-	}
-#endif
-
-    const ALCchar* value = 0;
-
-	if ((param != ALC_DEFAULT_DEVICE_SPECIFIER) && (param != ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER)) {
-		if(device)
-		{
-			if (device == g_CaptureDevice)
-				return g_CaptureDevice->AlcApi.alcGetString(g_CaptureDevice->CaptureDevice, param);
-
-			return device->AlcApi.alcGetString(device->DllDevice, param);
-		}
-	}
-
-    switch(param)
-    {
-        case ALC_NO_ERROR:
-        {
-            value = alcNoError;
-        }
-        break;
-
-        case ALC_INVALID_ENUM:
-        {
-            value = alcErrInvalidEnum;
-        }
-        break;
-
-        case ALC_INVALID_VALUE:
-        {
-            value = alcErrInvalidValue;
-        }
-        break;
-
-        case ALC_INVALID_DEVICE:
-        {
-            value = alcErrInvalidDevice;
-        }
-        break;
-
-        case ALC_INVALID_CONTEXT:
-        {
-            value = alcErrInvalidContext;
-        }
-        break;
-
-        case ALC_DEFAULT_DEVICE_SPECIFIER:
-			BuildDeviceList();
-			if (pszDefaultDeviceSpecifier)
-				value = pszDefaultDeviceSpecifier;
-			else
-				value = szEmptyString;
-			break;
-
-        case ALC_DEVICE_SPECIFIER:
-			BuildDeviceList();
-			if (pszDeviceSpecifierList)
-				value = pszDeviceSpecifierList;
-			else
-				value = szEmptyString;
-			break;
-
-		case ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER:
-			BuildDeviceList();
-			if (pszDefaultCaptureDeviceSpecifier)
-				value = pszDefaultCaptureDeviceSpecifier;
-			else
-				value = szEmptyString;
-			break;
-
-		case ALC_CAPTURE_DEVICE_SPECIFIER:
-			BuildDeviceList();
-			if (pszCaptureDeviceSpecifierList)
-				value = pszCaptureDeviceSpecifierList;
-			else
-				value = szEmptyString;
-			break;
-
-		case ALC_ALL_DEVICES_SPECIFIER:
-			BuildDeviceList();
-			if (pszAllDevicesSpecifierList)
-				value = pszAllDevicesSpecifierList;
-			else
-				value = szEmptyString;
-			break;
-
-		case ALC_DEFAULT_ALL_DEVICES_SPECIFIER:
-			BuildDeviceList();
-			if (pszDefaultAllDevicesSpecifier)
-				value = pszDefaultAllDevicesSpecifier;
-			else
-				value = szEmptyString;
-			break;
-
-        default:
-            LastError = ALC_INVALID_ENUM;
-            break;
-    }
-
-    return value;
-}
-
-
-
-
-//*****************************************************************************
-// alcCaptureOpenDevice
-//*****************************************************************************
-ALCAPI ALCdevice * ALCAPIENTRY alcCaptureOpenDevice(const ALCchar *deviceName, ALCuint frequency, ALCenum format, ALCsizei buffersize)
-{
-#ifdef _LOGCALLS
-	LOG("alcCaptureOpenDevice device name '%s' frequency %d format %d buffersize %d\n", deviceName ? deviceName : "<NULL>", frequency, format, buffersize);
-#endif
-	const ALchar *pszDeviceName = NULL;
-
-	BuildDeviceList();
-
-	if (!g_pCaptureDeviceList)
-		return NULL;
-
-	if (!g_CaptureDevice) {
-		g_CaptureDevice = (ALCdevice*)malloc(sizeof(ALCdevice));
-
-		if (g_CaptureDevice)
-		{
-			// clear
-			memset(g_CaptureDevice, 0, sizeof(ALCdevice));
-
-			// make sure we have a device name
-			if ((!deviceName) || (strlen(deviceName) == 0))
-				pszDeviceName = pszDefaultCaptureDeviceSpecifier;
-			else
-				pszDeviceName = deviceName;
-
-			g_CaptureDevice->Dll = LoadDevicesDLL(g_pCaptureDeviceList, pszDeviceName);
-
-			if (g_CaptureDevice->Dll) {
-				if(FillOutAlcFunctions(g_CaptureDevice)) {
-					if (g_CaptureDevice->AlcApi.alcCaptureOpenDevice) {
-						g_CaptureDevice->CaptureDevice = g_CaptureDevice->AlcApi.alcCaptureOpenDevice(pszDeviceName, frequency, format, buffersize);
-						g_CaptureDevice->LastError = ALC_NO_ERROR;
-						g_CaptureDevice->InUse = 0;
-					} else {
-						g_CaptureDevice->LastError = ALC_INVALID_DEVICE;
-					}
-				}
-			}
-		}
-	} else {
-		// already open
-		g_CaptureDevice->LastError = ALC_INVALID_VALUE;
-	}
-
-	if (g_CaptureDevice != NULL) {
-		if (g_CaptureDevice->CaptureDevice) {
-			return g_CaptureDevice;
-		} else {
-			free(g_CaptureDevice);
-			g_CaptureDevice = NULL;
-			return NULL;
-		}
-	} else {
-		return NULL;
-	}
-}
-
-
-
-
-//*****************************************************************************
-// alcCaptureCloseDevice
-//*****************************************************************************
-ALCAPI ALCboolean ALCAPIENTRY alcCaptureCloseDevice(ALCdevice *device)
-{
-#ifdef _LOGCALLS
-	LOG("alcCaptureCloseDevice device %p\n", device);
-#endif
-	ALCboolean bReturn = ALC_FALSE;
-
-	if (device == g_CaptureDevice)
-	{
-		if (g_CaptureDevice != NULL) {
-			if (g_CaptureDevice->AlcApi.alcCaptureCloseDevice) {
-				bReturn = g_CaptureDevice->AlcApi.alcCaptureCloseDevice(g_CaptureDevice->CaptureDevice);
-				delete g_CaptureDevice;
-				g_CaptureDevice = NULL;
-			} else {
-				g_CaptureDevice->LastError = ALC_INVALID_DEVICE;
-			}
-		}
-	}
-
-    return bReturn;
-}
-
-
-
-
-//*****************************************************************************
-// alcCaptureStart
-//*****************************************************************************
-ALCAPI ALCvoid ALCAPIENTRY alcCaptureStart(ALCdevice *device)
-{
-#ifdef _LOGCALLS
-	LOG("alcCaptureStart device %p\n", device);
-#endif
-	if (device == g_CaptureDevice)
-	{
-		if (g_CaptureDevice != NULL) {
-			if (g_CaptureDevice->AlcApi.alcCaptureStart) {
-				g_CaptureDevice->AlcApi.alcCaptureStart(g_CaptureDevice->CaptureDevice);
-			} else {
-				g_CaptureDevice->LastError = ALC_INVALID_DEVICE;
-			}
-		}
-	}
-
-    return;
-}
-
-
-
-
-//*****************************************************************************
-// alcCaptureStop
-//*****************************************************************************
-ALCAPI ALCvoid ALCAPIENTRY alcCaptureStop(ALCdevice *device)
-{
-#ifdef _LOGCALLS
-	LOG("alcCaptureStop device %p\n", device);
-#endif
-	if (device == g_CaptureDevice)
-	{
-		if (g_CaptureDevice != NULL) {
-			if (g_CaptureDevice->AlcApi.alcCaptureStop) {
-				g_CaptureDevice->AlcApi.alcCaptureStop(g_CaptureDevice->CaptureDevice);
-			} else {
-				g_CaptureDevice->LastError = ALC_INVALID_DEVICE;
-			}
-		}
-	}
-
-    return;
-}
-
-
-
-
-//*****************************************************************************
-// alcCaptureSamples
-//*****************************************************************************
-ALCAPI ALCvoid ALCAPIENTRY alcCaptureSamples(ALCdevice *device, ALCvoid *buffer, ALCsizei samples)
-{
-#ifdef _LOGCALLS
-	LOG("alcCaptureSamples device %p buffer %p samples %d\n", device, buffer, samples);
-#endif
-	if (device == g_CaptureDevice)
-	{
-		if (g_CaptureDevice != NULL) {
-			if (g_CaptureDevice->AlcApi.alcCaptureSamples) {
-				g_CaptureDevice->AlcApi.alcCaptureSamples(g_CaptureDevice->CaptureDevice, buffer, samples);
-			} else {
-				g_CaptureDevice->LastError = ALC_INVALID_DEVICE;
-			}
-		}
-	}
-
-    return;
-}
-
-#ifdef _LOGCALLS
-void OutputMessage(const char *szDebug,...)
-{
-	static FILE *pFile = NULL;
-	SYSTEMTIME sysTime;
-	va_list args;
-
-	va_start(args, szDebug);
-
-	if (!pFile)
-	{
-		pFile = fopen(LOGFILENAME, "w");
-		GetLocalTime(&sysTime);
-		fprintf(pFile, "OpenAL Router\n\nLog Time : %d/%d/%d at %d:%s%d:%s%d\n\n", sysTime.wDay, sysTime.wMonth, sysTime.wYear,
-			sysTime.wHour, (sysTime.wMinute < 10) ? "0" : "", sysTime.wMinute, (sysTime.wSecond < 10) ? "0" : "", sysTime.wSecond);
-	}
-
-	vfprintf(pFile, szDebug, args);
-	fflush(pFile);
-
-	va_end(args);
-}
-#endif
\ No newline at end of file
diff --git a/Router/resource.h b/Router/resource.h
deleted file mode 100644
index bdff6160..00000000
--- a/Router/resource.h
+++ /dev/null
@@ -1,15 +0,0 @@
-//{{NO_DEPENDENCIES}}
-// Microsoft Developer Studio generated include file.
-// Used by openal32.rc
-//
-
-// Next default values for new objects
-// 
-#ifdef APSTUDIO_INVOKED
-#ifndef APSTUDIO_READONLY_SYMBOLS
-#define _APS_NEXT_RESOURCE_VALUE        101
-#define _APS_NEXT_COMMAND_VALUE         40001
-#define _APS_NEXT_CONTROL_VALUE         1000
-#define _APS_NEXT_SYMED_VALUE           101
-#endif
-#endif
diff --git a/RouterTest/main.cpp b/RouterTest/main.cpp
deleted file mode 100644
index 961c3ecb..00000000
--- a/RouterTest/main.cpp
+++ /dev/null
@@ -1,647 +0,0 @@
-#include <al.h>

-#include <alc.h>

-#include <stdio.h>

-#include <conio.h>

-#include <string.h>

-#include <windows.h>

-#include <mmsystem.h>

-

-int main(int argc, char* argv[])

-{

-	const ALchar *szNames = NULL;

-	long lErrorCount = 0;

-

-	///////////////////////////////////////////////////////////////////

-	// TEST : Enumerate the playback devices

-	//

-	printf("--------------------------------------\n");

-	printf("TESTING ALC_ENUMERATION_EXT EXTENSION\n\n");

-	if (alcIsExtensionPresent(NULL, "ALC_ENUMERATION_EXT") == AL_TRUE)

-	{

-		printf("ALC_ENUMERATION_EXT Device List:-\n\n");

-

-		szNames = alcGetString(NULL, ALC_DEVICE_SPECIFIER);

-		if (strlen(szNames) == 0)

-			printf("NO DEVICES FOUND\n");

-		else

-		{

-			while (szNames && *szNames)

-			{

-				printf("%s ", szNames);

-				// Try opening each device

-				ALCdevice *pDevice = alcOpenDevice(szNames);

-				if (pDevice)

-				{

-					printf("- Opened Successfully\n");

-					alcCloseDevice(pDevice);

-				}

-				else

-				{

-					printf("- FAILED to open\n");

-					lErrorCount++;

-				}

-				szNames += (strlen(szNames) + 1);

-			}

-		}

-	}

-	else

-	{

-		printf("!!!ERROR!!! : ALC_ENUMERATION_EXT NOT FOUND!\n");

-		lErrorCount++;

-	}

-	printf("--------------------------------------\n\n");

-	///////////////////////////////////////////////////////////////////

-

-

-	///////////////////////////////////////////////////////////////////

-	// TEST : Get Default Playback Device

-	//

-	printf("--------------------------------------\n");

-	printf("TESTING GET DEFAULT PLAYBACK DEVICE\n\n");

-	szNames = alcGetString(NULL, ALC_DEFAULT_DEVICE_SPECIFIER);

-	if (szNames && strlen(szNames))

-	{

-		printf("\nDEFAULT DEVICE is %s\n", szNames);

-	}

-	else

-	{

-		if (waveOutGetNumDevs())

-		{

-			printf("\n!!!ERROR!!! DEFAULT DEVICE NOT FOUND!\n");

-			lErrorCount++;

-		}

-		else

-		{

-			printf("\nDEFAULT DEVICE NOT FOUND!\n");

-		}

-	}

-	printf("--------------------------------------\n\n");

-	///////////////////////////////////////////////////////////////////

-

-

-	///////////////////////////////////////////////////////////////////

-	// TEST : Enumerate all the capture devices

-	//

-	printf("--------------------------------------\n");

-	printf("TESTING CAPTURE ENUMERATION EXTENSION\n\n");

-	if (alcIsExtensionPresent(NULL, "ALC_ENUMERATION_EXT") == AL_TRUE)

-	{

-		printf("ALC_ENUMERATION_EXT Capture Device List:-\n\n");

-

-		szNames = alcGetString(NULL, ALC_CAPTURE_DEVICE_SPECIFIER);

-		if (strlen(szNames) == 0)

-			printf("NO DEVICES FOUND\n");

-		else

-		{

-			while (szNames && *szNames)

-			{

-				printf("%s ", szNames);

-				// Try opening each device

-				ALCdevice *pDevice = alcCaptureOpenDevice(szNames, 11025, AL_FORMAT_STEREO16, 8192);

-				if (pDevice)

-				{

-					printf("- Opened Successfully\n");

-					alcCaptureCloseDevice(pDevice);

-				}

-				else

-				{

-					printf("- FAILED to open\n");

-					lErrorCount++;

-				}

-				szNames += (strlen(szNames) + 1);

-			}

-		}

-	}

-	else

-	{

-		printf("!!!ERROR!!! : ALC_ENUMERATION_EXT NOT FOUND!\n");

-		lErrorCount++;

-	}

-	printf("--------------------------------------\n\n");

-	///////////////////////////////////////////////////////////////////

-

-

-	///////////////////////////////////////////////////////////////////

-	// TEST : Get Default Capture Device

-	//

-	printf("--------------------------------------\n");

-	printf("TESTING DEFAULT CAPTURE DEVICE\n\n");

-	szNames = alcGetString(NULL, ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER);

-	if (szNames && strlen(szNames))

-	{

-		printf("\nDEFAULT CAPTURE DEVICE IS %s\n", szNames);

-	}

-	else

-	{

-		if (waveInGetNumDevs())

-		{

-			printf("\n!!!ERROR!!! DEFAULT CAPTURE DEVICE NOT FOUND!\n");

-			lErrorCount++;

-		}

-		else

-		{

-			printf("\nDEFAULT CAPTURE DEVICE NOT FOUND!\n");

-		}

-	}

-	printf("--------------------------------------\n\n");

-	///////////////////////////////////////////////////////////////////

-

-

-	///////////////////////////////////////////////////////////////////

-	// TEST : Enumerate *all* the playback devices

-	//

-	printf("--------------------------------------\n");

-	printf("TESTING PLAYBACK ENUMERATE ALL EXTENSION\n\n");

-	if (alcIsExtensionPresent(NULL, "ALC_ENUMERATE_ALL_EXT") == AL_TRUE)

-	{

-		printf("ALC_ENUMERATE_ALL_EXT DEVICE LIST:-\n\n");

-

-		szNames = alcGetString(NULL, ALC_ALL_DEVICES_SPECIFIER);

-		if (strlen(szNames) == 0)

-			printf("NO DEVICES FOUND\n");

-		else

-		{

-			while (szNames && *szNames)

-			{

-				printf("%s ", szNames);

-

-				// Try opening each device

-				ALCdevice *pDevice = alcOpenDevice(szNames);

-				if (pDevice)

-				{

-					printf("- Opened Successfully\n");

-					alcCloseDevice(pDevice);

-				}

-				else

-				{

-					printf("- FAILED to open\n");

-					lErrorCount++;

-				}

-

-				szNames += (strlen(szNames) + 1);

-			}

-		}

-	}

-	else

-	{

-		printf("!!!ERROR!!! : ALC_ENUMERATE_ALL_EXT NOT FOUND!\n");

-		lErrorCount++;

-	}

-	printf("--------------------------------------\n\n");

-	///////////////////////////////////////////////////////////////////

-

-

-	///////////////////////////////////////////////////////////////////

-	// TEST : Get Default *All* Playback Device

-	//

-	printf("--------------------------------------\n");

-	printf("TESTING DEFAULT ALL PLAYBACK DEVICE\n\n");

-	szNames = alcGetString(NULL, ALC_DEFAULT_ALL_DEVICES_SPECIFIER);

-	if (szNames && strlen(szNames))

-	{

-		printf("\nDEFAULT ALL DEVICES IS %s\n", szNames);

-	}

-	else

-	{

-		if (waveOutGetNumDevs())

-		{

-			printf("\n!!!ERROR!!! DEFAULT ALL DEVICE NOT FOUND!\n");

-			lErrorCount++;

-		}

-		else

-		{

-			printf("\nDEFAULT ALL DEVICES NOT FOUND!\n");

-		}

-	}

-	printf("--------------------------------------\n\n");

-	///////////////////////////////////////////////////////////////////

-

-

-	///////////////////////////////////////////////////////////////////

-	// TEST : Open 'Generic Hardware' device

-	//

-	printf("--------------------------------------\n");

-	printf("TESTING 'Generic Hardware' DEVICE\n\n");

-	ALCdevice *pDevice = alcOpenDevice("Generic Hardware");

-	if (pDevice)

-	{

-		printf("OPENED 'Generic Hardware' DEVICE ... GOT %s\n", alcGetString(pDevice, ALC_DEVICE_SPECIFIER));

-		alcCloseDevice(pDevice);

-	}

-	else

-	{

-		if (waveOutGetNumDevs())

-		{

-			printf("!!!ERROR!!! : FAILED TO OPEN 'Generic Hardware' DEVICE\n");

-			lErrorCount++;

-		}

-		else

-		{

-			printf("FAILED TO OPEN 'Generic Hardware' DEVICE\n");

-		}

-	}

-	printf("--------------------------------------\n\n");

-	///////////////////////////////////////////////////////////////////

-

-

-	///////////////////////////////////////////////////////////////////

-	// TEST : Open 'Generic Software' device

-	//

-	printf("--------------------------------------\n");

-	printf("TESTING 'Generic Software' DEVICE\n\n");

-	pDevice = alcOpenDevice("Generic Software");

-	if (pDevice)

-	{

-		printf("OPENED 'Generic Software' DEVICE ... GOT %s\n", alcGetString(pDevice, ALC_DEVICE_SPECIFIER));

-		alcCloseDevice(pDevice);

-	}

-	else

-	{

-		if (waveOutGetNumDevs())

-		{

-			printf("!!!ERROR!!! : FAILED TO OPEN 'Generic Software' DEVICE\n");

-			lErrorCount++;

-		}

-		else

-		{

-			printf("FAILED TO OPEN 'Generic Software' DEVICE\n");

-		}

-	}

-	printf("--------------------------------------\n\n");

-	///////////////////////////////////////////////////////////////////

-

-	///////////////////////////////////////////////////////////////////

-	// TEST : Open legacy 'DirectSound3D' device

-	//

-	printf("--------------------------------------\n");

-	printf("TESTING LEGACY 'DirectSound3D' DEVICE\n\n");

-	pDevice = alcOpenDevice("DirectSound3D");

-	if (pDevice)

-	{

-		printf("OPENED 'DirectSound3D' DEVICE ... GOT %s\n", alcGetString(pDevice, ALC_DEVICE_SPECIFIER));

-		alcCloseDevice(pDevice);

-	}

-	else

-	{

-		if (waveOutGetNumDevs())

-		{

-			printf("!!!ERROR!!! : FAILED TO OPEN 'DirectSound3D' DEVICE\n");

-			lErrorCount++;

-		}

-		else

-		{

-			printf("FAILED TO OPEN 'DirectSound3D' DEVICE\n");

-		}

-	}

-	printf("--------------------------------------\n\n");

-	///////////////////////////////////////////////////////////////////

-

-

-	///////////////////////////////////////////////////////////////////

-	// TEST : Open legacy 'DirectSound' device

-	//

-	printf("--------------------------------------\n");

-	printf("TESTING LEGACY 'DirectSound' DEVICE\n\n");

-	pDevice = alcOpenDevice("DirectSound");

-	if (pDevice)

-	{

-		printf("OPENED 'DirectSound' DEVICE ... GOT %s\n", alcGetString(pDevice, ALC_DEVICE_SPECIFIER));

-		alcCloseDevice(pDevice);

-	}

-	else

-	{

-		if (waveOutGetNumDevs())

-		{

-			printf("!!!ERROR!!! : FAILED TO OPEN 'DirectSound' DEVICE\n");

-			lErrorCount++;

-		}

-		else

-		{

-			printf("FAILED TO OPEN 'DirectSound' DEVICE\n");

-		}

-	}

-	printf("--------------------------------------\n\n");

-	///////////////////////////////////////////////////////////////////

-

-

-	///////////////////////////////////////////////////////////////////

-	// TEST : Open legacy 'MMSYSTEM' device

-	//

-	printf("--------------------------------------\n");

-	printf("TESTING LEGACY 'MMSYSTEM' DEVICE\n\n");

-	pDevice = alcOpenDevice("MMSYSTEM");

-	if (pDevice)

-	{

-		printf("OPENED 'MMSYSTEM' DEVICE ... GOT %s\n", alcGetString(pDevice, ALC_DEVICE_SPECIFIER));

-		alcCloseDevice(pDevice);

-	}

-	else

-	{

-		if (waveOutGetNumDevs())

-		{

-			printf("!!!ERROR!!! : FAILED TO OPEN 'MMSYSTEM' DEVICE\n");

-			lErrorCount++;

-		}

-		else

-		{

-			printf("FAILED TO OPEN 'MMSYSTEM' DEVICE\n");

-		}

-	}

-	printf("--------------------------------------\n\n");

-	///////////////////////////////////////////////////////////////////

-

-

-	///////////////////////////////////////////////////////////////////

-	// TEST : Open NULL device

-	//

-	printf("--------------------------------------\n");

-	printf("TESTING NULL DEVICE\n\n");

-	pDevice = alcOpenDevice(NULL);

-	if (pDevice)

-	{

-		printf("OPENED NULL DEVICE ... GOT %s\n", alcGetString(pDevice, ALC_DEVICE_SPECIFIER));

-		alcCloseDevice(pDevice);

-	}

-	else

-	{

-		if (waveOutGetNumDevs())

-		{

-			printf("!!!ERROR!!! : FAILED TO OPEN NULL DEVICE\n");

-			lErrorCount++;

-		}

-		else

-		{

-			printf("FAILED TO OPEN NULL DEVICE\n");

-		}

-	}

-	printf("--------------------------------------\n\n");

-	///////////////////////////////////////////////////////////////////

-

-

-	///////////////////////////////////////////////////////////////////

-	// TEST : Open "" device

-	//

-	printf("--------------------------------------\n");

-	printf("TESTING EMPTY DEVICE\n\n");

-	pDevice = alcOpenDevice("");

-	if (pDevice)

-	{

-		printf("OPENED \"\" DEVICE ... GOT %s\n", alcGetString(pDevice, ALC_DEVICE_SPECIFIER));

-		alcCloseDevice(pDevice);

-	}

-	else

-	{

-		if (waveOutGetNumDevs())

-		{

-			printf("!!!ERROR!!! : FAILED TO OPEN EMPTY DEVICE\n");

-			lErrorCount++;

-		}

-		else

-		{

-			printf("FAILED TO OPEN EMPTY DEVICE\n");

-		}

-	}

-	printf("--------------------------------------\n\n");

-	///////////////////////////////////////////////////////////////////

-

-

-	///////////////////////////////////////////////////////////////////

-	// TEST : Open "A Random Name" device

-	//

-	printf("--------------------------------------\n");

-	printf("TESTING 'A Random Name' DEVICE\n\n");

-	pDevice = alcOpenDevice("A Random Name");

-	if (pDevice)

-	{

-		printf("!!!ERROR!!! : OPENED 'A Random Name' DEVICE ... GOT %s\n", alcGetString(pDevice, ALC_DEVICE_SPECIFIER));

-		lErrorCount++;

-		alcCloseDevice(pDevice);

-	}

-	else

-	{

-		printf("FAILED TO OPEN 'A Random Name' DEVICE\n");

-	}

-	printf("--------------------------------------\n\n");

-	///////////////////////////////////////////////////////////////////

-

-

-	///////////////////////////////////////////////////////////////////

-	// TEST : Open NULL Capture device

-	//

-	printf("--------------------------------------\n");

-	printf("TESTING NULL CAPTURE DEVICE\n\n");

-	pDevice = alcCaptureOpenDevice(NULL, 22500, AL_FORMAT_MONO16, 4096);

-	if (pDevice)

-	{

-		printf("OPENED NULL CAPTURE DEVICE ... GOT %s\n", alcGetString(pDevice, ALC_CAPTURE_DEVICE_SPECIFIER));

-		alcCaptureCloseDevice(pDevice);

-	}

-	else

-	{

-		if (waveInGetNumDevs())

-		{

-			printf("!!!ERROR!!! : FAILED TO OPEN NULL CAPTURE DEVICE\n");

-			lErrorCount++;

-		}

-		else

-		{

-			printf("FAILED TO OPEN NULL CAPTURE DEVICE\n");

-		}

-	}

-	printf("--------------------------------------\n\n");

-	///////////////////////////////////////////////////////////////////

-

-

-	///////////////////////////////////////////////////////////////////

-	// TEST : Open "" capture device

-	//

-	printf("--------------------------------------\n");

-	printf("TESTING EMPTY CAPTURE DEVICE\n\n");

-	pDevice = alcCaptureOpenDevice("", 22500, AL_FORMAT_MONO16, 4096);

-	if (pDevice)

-	{

-		printf("OPENED \"\" CAPTURE DEVICE ... GOT %s\n", alcGetString(pDevice, ALC_CAPTURE_DEVICE_SPECIFIER));

-		alcCaptureCloseDevice(pDevice);

-	}

-	else

-	{

-		if (waveInGetNumDevs())

-		{

-			printf("!!!ERROR!!! : FAILED TO OPEN EMPTY CAPTURE DEVICE\n");

-			lErrorCount++;

-		}

-		else

-		{

-			printf("FAILED TO OPEN EMPTY CAPTURE DEVICE\n");

-		}

-	}

-	printf("--------------------------------------\n\n");

-	///////////////////////////////////////////////////////////////////

-

-

-	///////////////////////////////////////////////////////////////////

-	// TEST : Open "A Random Name" capture device

-	//

-	printf("--------------------------------------\n");

-	printf("TESTING 'A Random Name' CAPTURE DEVICE\n\n");

-	pDevice = alcCaptureOpenDevice("A Random Name", 22500, AL_FORMAT_MONO16, 4096);

-	if (pDevice)

-	{

-		printf("!!!ERROR!!! : OPENED 'A Random Name' CAPTURE DEVICE ... GOT %s\n", alcGetString(pDevice, ALC_CAPTURE_DEVICE_SPECIFIER));

-		lErrorCount++;

-		alcCaptureCloseDevice(pDevice);

-	}

-	else

-	{

-		printf("FAILED TO OPEN 'A Random Name' CAPTURE DEVICE\n");

-	}

-	printf("--------------------------------------\n\n");

-	///////////////////////////////////////////////////////////////////

-

-	printf("\nFOUND %d ERRORS\n", lErrorCount);

-

-	printf("\nPress a key to quit\n");

-	char ch = _getch();

-

-	return 0;

-}

-

-

-/*

-ALboolean InitOpenAL(ALCdevice **ppDevice, ALCcontext **ppContext)

-{

-	ALchar		szDeviceNames[10][1024];

-	ALchar		*szNames;

-	ALint		lNumDevices;

-	ALint		lLoop;

-	ALint		lLength;

-	ALbyte		ch;

-	ALboolean	bInit;

-

-	bInit = AL_FALSE;

-	memset(szDeviceNames, 0, sizeof(ALchar) * 10 * 1024);

-	lNumDevices = 0;

-

-	

-

-	if (!szNames)

-	{

-		szNames = (char *)alcGetString(NULL, ALC_DEFAULT_DEVICE_SPECIFIER);

-		if (szNames && *szNames && (strlen(szNames) < 1024))

-			strcpy(szDeviceNames[lNumDevices++], szNames);

-	}

-

-	for (lLoop = 0; lLoop < lNumDevices; lLoop++)

-		printf("Press %d for '%s' Device\n", lLoop+1, szDeviceNames[lLoop]);

-	printf("Press Q to quit\n");

-

-	do

-	{

-		ch = _getch();

-		if (ch == 'q' || ch == 'Q')

-			exit(0);

-		else if ((ch >= '1') && (ch < ('1' + lNumDevices)))

-			break;

-	} while (1);

-

-	*ppDevice = alcOpenDevice(szDeviceNames[ch - '1']);

-	if (*ppDevice)

-	{

-		*ppContext = alcCreateContext(*ppDevice,NULL);

-		if (*ppContext)

-		{

-			alcGetError(*ppDevice);

-			alcMakeContextCurrent(*ppContext);

-			if (alcGetError(*ppDevice) == ALC_NO_ERROR)

-				bInit = AL_TRUE;

-		}

-		else

-		{

-			alcCloseDevice(*ppDevice);

-		}

-	}

-

-	return bInit;

-}

-

-

-ALboolean InitOpenALEx(ALCdevice **ppDevice, ALCcontext **ppContext)

-{

-	ALchar			szDeviceNames[32][1024];

-	const ALchar	*szNames;

-	const ALchar	*szDefaultName = NULL;

-	const ALchar	*szDefaultAllName = NULL;

-	ALint			lNumDevices = 0;

-	ALint			lLoop;

-	ALint			lLength;

-	ALbyte			ch;

-	ALboolean		bInit;

-

-	bInit = AL_FALSE;

-	memset(szDeviceNames, 0, sizeof(ALchar) * 32 * 1024);

-

-	// Get legacy enumeration list and Default Device

-	if (alcIsExtensionPresent(NULL, "ALC_ENUMERATION_EXT") == AL_TRUE)

-	{

-		szNames = alcGetString(NULL, ALC_DEVICE_SPECIFIER);

-

-		while (szNames && *szNames)

-		{

-			if ((lLength = strlen(szNames)) < 1024)

-				strcpy(szDeviceNames[lNumDevices++], szNames);

-			szNames += lLength + 1;

-		}

-

-		szDefaultName = alcGetString(NULL, ALC_DEFAULT_DEVICE_SPECIFIER);

-	}

-

-	// Get new uber enumeration list and Default Device

-	if (alcIsExtensionPresent(NULL, "ALC_ENUMERATE_ALL_EXT") == AL_TRUE)

-	{

-		szNames = alcGetString(NULL, alcGetEnumValue(NULL, "ALC_ALL_DEVICES_SPECIFIER"));

-

-		while (szNames && *szNames)

-		{

-			if ((lLength = strlen(szNames)) < 1024)

-				strcpy(szDeviceNames[lNumDevices++], szNames);

-			szNames += lLength + 1;

-		}

-

-		szDefaultAllName = alcGetString(NULL, alcGetEnumValue(NULL, "ALC_DEFAULT_ALL_DEVICES_SPECIFIER"));

-	}

-

-

-	for (lLoop = 0; lLoop < lNumDevices; lLoop++)

-		printf("Press %d for '%s' Device %s\n", lLoop+1, szDeviceNames[lLoop],

-		(strcmp(szDeviceNames[lLoop], szDefaultName?szDefaultName:"") == 0) ? "*" : (strcmp(szDeviceNames[lLoop], szDefaultAllName?szDefaultAllName:"") == 0) ? "**" : "");

-	printf("Press Q to quit\n");

-

-	do

-	{

-		ch = _getch();

-		if (ch == 'q' || ch == 'Q')

-			exit(0);

-		else if ((ch >= '1') && (ch < ('1' + lNumDevices)))

-			break;

-	} while (1);

-

-	*ppDevice = alcOpenDevice(szDeviceNames[ch - '1']);

-	if (*ppDevice)

-	{

-		*ppContext = alcCreateContext(*ppDevice,NULL);

-		if (*ppContext)

-		{

-			alcGetError(*ppDevice);

-			alcMakeContextCurrent(*ppContext);

-			if (alcGetError(*ppDevice) == ALC_NO_ERROR)

-				bInit = AL_TRUE;

-		}

-		else

-		{

-			alcCloseDevice(*ppDevice);

-		}

-	}

-

-	return bInit;

-}

-*/
\ No newline at end of file