19 files changed, 9692 insertions, 406 deletions

diff --git a/eax/eax-util.cpp b/eax/eax-util.cpp
new file mode 100644
index 00000000..44425957
--- /dev/null
+++ b/eax/eax-util.cpp
@@ -0,0 +1,706 @@
+/***********************************************************************************************\
+*																								*
+*  EAX-UTIL.CPP -	utilities for EAX 3.0														*
+*					Function declaration for EAX Morphing										*
+*					String names of the all the presets defined in eax-util.h					*
+*					Arrays grouping together all the EAX presets in a scenario					*
+*																								*
+************************************************************************************************/
+
+#include "eax-util.h"
+#include <math.h>
+
+// Function prototypes used by EAX3ListenerInterpolate
+void Clamp(EAXVECTOR *eaxVector);
+bool CheckEAX3LP(LPEAXLISTENERPROPERTIES lpEAX3LP);
+
+
+/***********************************************************************************************\
+*
+* Definition of the EAXMorph function - EAX3ListenerInterpolate
+*
+\***********************************************************************************************/
+
+/*
+	EAX3ListenerInterpolate
+	lpStart			- Initial EAX 3 Listener parameters
+	lpFinish		- Final EAX 3 Listener parameters
+	flRatio			- Ratio Destination : Source (0.0 == Source, 1.0 == Destination)
+	lpResult		- Interpolated EAX 3 Listener parameters
+	bCheckValues	- Check EAX 3.0 parameters are in range, default = false (no checking)
+*/
+bool EAX3ListenerInterpolate(LPEAXLISTENERPROPERTIES lpStart, LPEAXLISTENERPROPERTIES lpFinish,
+						float flRatio, LPEAXLISTENERPROPERTIES lpResult, bool bCheckValues)
+{
+	EAXVECTOR StartVector, FinalVector;
+
+	float flInvRatio;
+
+	if (bCheckValues)
+	{
+		if (!CheckEAX3LP(lpStart))
+			return false;
+
+		if (!CheckEAX3LP(lpFinish))
+			return false;
+	}
+
+	if (flRatio >= 1.0f)
+	{
+		memcpy(lpResult, lpFinish, sizeof(EAXLISTENERPROPERTIES));
+		return true;
+	}
+	else if (flRatio <= 0.0f)
+	{
+		memcpy(lpResult, lpStart, sizeof(EAXLISTENERPROPERTIES));
+		return true;
+	}
+
+	flInvRatio = (1.0f - flRatio);
+
+	// Environment
+	lpResult->ulEnvironment = 26;	// (UNDEFINED environment)
+
+	// Environment Size
+	if (lpStart->flEnvironmentSize == lpFinish->flEnvironmentSize)
+		lpResult->flEnvironmentSize = lpStart->flEnvironmentSize;
+	else
+		lpResult->flEnvironmentSize = (float)exp( (log(lpStart->flEnvironmentSize) * flInvRatio) + (log(lpFinish->flEnvironmentSize) * flRatio) );
+	
+	// Environment Diffusion
+	if (lpStart->flEnvironmentDiffusion == lpFinish->flEnvironmentDiffusion)
+		lpResult->flEnvironmentDiffusion = lpStart->flEnvironmentDiffusion;
+	else
+		lpResult->flEnvironmentDiffusion = (lpStart->flEnvironmentDiffusion * flInvRatio) + (lpFinish->flEnvironmentDiffusion * flRatio);
+	
+	// Room
+	if (lpStart->lRoom == lpFinish->lRoom)
+		lpResult->lRoom = lpStart->lRoom;
+	else
+		lpResult->lRoom = (int)( ((float)lpStart->lRoom * flInvRatio) + ((float)lpFinish->lRoom * flRatio) );
+	
+	// Room HF
+	if (lpStart->lRoomHF == lpFinish->lRoomHF)
+		lpResult->lRoomHF = lpStart->lRoomHF;
+	else
+		lpResult->lRoomHF = (int)( ((float)lpStart->lRoomHF * flInvRatio) + ((float)lpFinish->lRoomHF * flRatio) );
+	
+	// Room LF
+	if (lpStart->lRoomLF == lpFinish->lRoomLF)
+		lpResult->lRoomLF = lpStart->lRoomLF;
+	else
+		lpResult->lRoomLF = (int)( ((float)lpStart->lRoomLF * flInvRatio) + ((float)lpFinish->lRoomLF * flRatio) );
+	
+	// Decay Time
+	if (lpStart->flDecayTime == lpFinish->flDecayTime)
+		lpResult->flDecayTime = lpStart->flDecayTime;
+	else
+		lpResult->flDecayTime = (float)exp( (log(lpStart->flDecayTime) * flInvRatio) + (log(lpFinish->flDecayTime) * flRatio) );
+	
+	// Decay HF Ratio
+	if (lpStart->flDecayHFRatio == lpFinish->flDecayHFRatio)
+		lpResult->flDecayHFRatio = lpStart->flDecayHFRatio;
+	else
+		lpResult->flDecayHFRatio = (float)exp( (log(lpStart->flDecayHFRatio) * flInvRatio) + (log(lpFinish->flDecayHFRatio) * flRatio) );
+	
+	// Decay LF Ratio
+	if (lpStart->flDecayLFRatio == lpFinish->flDecayLFRatio)
+		lpResult->flDecayLFRatio = lpStart->flDecayLFRatio;
+	else
+		lpResult->flDecayLFRatio = (float)exp( (log(lpStart->flDecayLFRatio) * flInvRatio) + (log(lpFinish->flDecayLFRatio) * flRatio) );
+	
+	// Reflections
+	if (lpStart->lReflections == lpFinish->lReflections)
+		lpResult->lReflections = lpStart->lReflections;
+	else
+		lpResult->lReflections = (int)( ((float)lpStart->lReflections * flInvRatio) + ((float)lpFinish->lReflections * flRatio) );
+	
+	// Reflections Delay
+	if (lpStart->flReflectionsDelay == lpFinish->flReflectionsDelay)
+		lpResult->flReflectionsDelay = lpStart->flReflectionsDelay;
+	else
+		lpResult->flReflectionsDelay = (float)exp( (log(lpStart->flReflectionsDelay+0.0001) * flInvRatio) + (log(lpFinish->flReflectionsDelay+0.0001) * flRatio) );
+
+	// Reflections Pan
+
+	// To interpolate the vector correctly we need to ensure that both the initial and final vectors vectors are clamped to a length of 1.0f
+	StartVector = lpStart->vReflectionsPan;
+	FinalVector = lpFinish->vReflectionsPan;
+
+	Clamp(&StartVector);
+	Clamp(&FinalVector);
+
+	if (lpStart->vReflectionsPan.x == lpFinish->vReflectionsPan.x)
+		lpResult->vReflectionsPan.x = lpStart->vReflectionsPan.x;
+	else
+		lpResult->vReflectionsPan.x = FinalVector.x + (flInvRatio * (StartVector.x - FinalVector.x));
+	
+	if (lpStart->vReflectionsPan.y == lpFinish->vReflectionsPan.y)
+		lpResult->vReflectionsPan.y = lpStart->vReflectionsPan.y;
+	else
+		lpResult->vReflectionsPan.y = FinalVector.y + (flInvRatio * (StartVector.y - FinalVector.y));
+	
+	if (lpStart->vReflectionsPan.z == lpFinish->vReflectionsPan.z)
+		lpResult->vReflectionsPan.z = lpStart->vReflectionsPan.z;
+	else
+		lpResult->vReflectionsPan.z = FinalVector.z + (flInvRatio * (StartVector.z - FinalVector.z));
+	
+	// Reverb
+	if (lpStart->lReverb == lpFinish->lReverb)
+		lpResult->lReverb = lpStart->lReverb;
+	else
+		lpResult->lReverb = (int)( ((float)lpStart->lReverb * flInvRatio) + ((float)lpFinish->lReverb * flRatio) );
+	
+	// Reverb Delay
+	if (lpStart->flReverbDelay == lpFinish->flReverbDelay)
+		lpResult->flReverbDelay = lpStart->flReverbDelay;
+	else
+		lpResult->flReverbDelay = (float)exp( (log(lpStart->flReverbDelay+0.0001) * flInvRatio) + (log(lpFinish->flReverbDelay+0.0001) * flRatio) );
+	
+	// Reverb Pan
+
+	// To interpolate the vector correctly we need to ensure that both the initial and final vectors are clamped to a length of 1.0f	
+	StartVector = lpStart->vReverbPan;
+	FinalVector = lpFinish->vReverbPan;
+
+	Clamp(&StartVector);
+	Clamp(&FinalVector);
+
+	if (lpStart->vReverbPan.x == lpFinish->vReverbPan.x)
+		lpResult->vReverbPan.x = lpStart->vReverbPan.x;
+	else
+		lpResult->vReverbPan.x = FinalVector.x + (flInvRatio * (StartVector.x - FinalVector.x));
+	
+	if (lpStart->vReverbPan.y == lpFinish->vReverbPan.y)
+		lpResult->vReverbPan.y = lpStart->vReverbPan.y;
+	else
+		lpResult->vReverbPan.y = FinalVector.y + (flInvRatio * (StartVector.y - FinalVector.y));
+	
+	if (lpStart->vReverbPan.z == lpFinish->vReverbPan.z)
+		lpResult->vReverbPan.z = lpStart->vReverbPan.z;
+	else
+		lpResult->vReverbPan.z = FinalVector.z + (flInvRatio * (StartVector.z - FinalVector.z));
+	
+	// Echo Time
+	if (lpStart->flEchoTime == lpFinish->flEchoTime)
+		lpResult->flEchoTime = lpStart->flEchoTime;
+	else
+		lpResult->flEchoTime = (float)exp( (log(lpStart->flEchoTime) * flInvRatio) + (log(lpFinish->flEchoTime) * flRatio) );
+	
+	// Echo Depth
+	if (lpStart->flEchoDepth == lpFinish->flEchoDepth)
+		lpResult->flEchoDepth = lpStart->flEchoDepth;
+	else
+		lpResult->flEchoDepth = (lpStart->flEchoDepth * flInvRatio) + (lpFinish->flEchoDepth * flRatio);
+
+	// Modulation Time
+	if (lpStart->flModulationTime == lpFinish->flModulationTime)
+		lpResult->flModulationTime = lpStart->flModulationTime;
+	else
+		lpResult->flModulationTime = (float)exp( (log(lpStart->flModulationTime) * flInvRatio) + (log(lpFinish->flModulationTime) * flRatio) );
+	
+	// Modulation Depth
+	if (lpStart->flModulationDepth == lpFinish->flModulationDepth)
+		lpResult->flModulationDepth = lpStart->flModulationDepth;
+	else
+		lpResult->flModulationDepth = (lpStart->flModulationDepth * flInvRatio) + (lpFinish->flModulationDepth * flRatio);
+	
+	// Air Absorption HF
+	if (lpStart->flAirAbsorptionHF == lpFinish->flAirAbsorptionHF)
+		lpResult->flAirAbsorptionHF = lpStart->flAirAbsorptionHF;
+	else
+		lpResult->flAirAbsorptionHF = (lpStart->flAirAbsorptionHF * flInvRatio) + (lpFinish->flAirAbsorptionHF * flRatio);
+	
+	// HF Reference
+	if (lpStart->flHFReference == lpFinish->flHFReference)
+		lpResult->flHFReference = lpStart->flHFReference;
+	else
+		lpResult->flHFReference = (float)exp( (log(lpStart->flHFReference) * flInvRatio) + (log(lpFinish->flHFReference) * flRatio) );
+	
+	// LF Reference
+	if (lpStart->flLFReference == lpFinish->flLFReference)
+		lpResult->flLFReference = lpStart->flLFReference;
+	else
+		lpResult->flLFReference = (float)exp( (log(lpStart->flLFReference) * flInvRatio) + (log(lpFinish->flLFReference) * flRatio) );
+	
+	// Room Rolloff Factor
+	if (lpStart->flRoomRolloffFactor == lpFinish->flRoomRolloffFactor)
+		lpResult->flRoomRolloffFactor = lpStart->flRoomRolloffFactor;
+	else
+		lpResult->flRoomRolloffFactor = (lpStart->flRoomRolloffFactor * flInvRatio) + (lpFinish->flRoomRolloffFactor * flRatio);
+	
+	// Flags
+	lpResult->ulFlags = (lpStart->ulFlags & lpFinish->ulFlags);
+
+	// Clamp Delays
+	if (lpResult->flReflectionsDelay > EAXLISTENER_MAXREFLECTIONSDELAY)
+		lpResult->flReflectionsDelay = EAXLISTENER_MAXREFLECTIONSDELAY;
+
+	if (lpResult->flReverbDelay > EAXLISTENER_MAXREVERBDELAY)
+		lpResult->flReverbDelay = EAXLISTENER_MAXREVERBDELAY;
+
+	return true;
+}
+
+
+/*
+	CheckEAX3LP
+	Checks that the parameters in the EAX 3 Listener Properties structure are in-range
+*/
+bool CheckEAX3LP(LPEAXLISTENERPROPERTIES lpEAX3LP)
+{
+	if ( (lpEAX3LP->lRoom < EAXLISTENER_MINROOM) || (lpEAX3LP->lRoom > EAXLISTENER_MAXROOM) )
+		return false;
+
+	if ( (lpEAX3LP->lRoomHF < EAXLISTENER_MINROOMHF) || (lpEAX3LP->lRoomHF > EAXLISTENER_MAXROOMHF) )
+		return false;
+
+	if ( (lpEAX3LP->lRoomLF < EAXLISTENER_MINROOMLF) || (lpEAX3LP->lRoomLF > EAXLISTENER_MAXROOMLF) )
+		return false;
+
+	if ( (lpEAX3LP->ulEnvironment < EAXLISTENER_MINENVIRONMENT) || (lpEAX3LP->ulEnvironment > EAXLISTENER_MAXENVIRONMENT) )
+		return false;
+
+	if ( (lpEAX3LP->flEnvironmentSize < EAXLISTENER_MINENVIRONMENTSIZE) || (lpEAX3LP->flEnvironmentSize > EAXLISTENER_MAXENVIRONMENTSIZE) )
+		return false;
+
+	if ( (lpEAX3LP->flEnvironmentDiffusion < EAXLISTENER_MINENVIRONMENTDIFFUSION) || (lpEAX3LP->flEnvironmentDiffusion > EAXLISTENER_MAXENVIRONMENTDIFFUSION) )
+		return false;
+
+	if ( (lpEAX3LP->flDecayTime < EAXLISTENER_MINDECAYTIME) || (lpEAX3LP->flDecayTime > EAXLISTENER_MAXDECAYTIME) )
+		return false;
+
+	if ( (lpEAX3LP->flDecayHFRatio < EAXLISTENER_MINDECAYHFRATIO) || (lpEAX3LP->flDecayHFRatio > EAXLISTENER_MAXDECAYHFRATIO) )
+		return false;
+
+	if ( (lpEAX3LP->flDecayLFRatio < EAXLISTENER_MINDECAYLFRATIO) || (lpEAX3LP->flDecayLFRatio > EAXLISTENER_MAXDECAYLFRATIO) )
+		return false;
+
+	if ( (lpEAX3LP->lReflections < EAXLISTENER_MINREFLECTIONS) || (lpEAX3LP->lReflections > EAXLISTENER_MAXREFLECTIONS) )
+		return false;
+
+	if ( (lpEAX3LP->flReflectionsDelay < EAXLISTENER_MINREFLECTIONSDELAY) || (lpEAX3LP->flReflectionsDelay > EAXLISTENER_MAXREFLECTIONSDELAY) )
+		return false;
+
+	if ( (lpEAX3LP->lReverb < EAXLISTENER_MINREVERB) || (lpEAX3LP->lReverb > EAXLISTENER_MAXREVERB) )
+		return false;
+
+	if ( (lpEAX3LP->flReverbDelay < EAXLISTENER_MINREVERBDELAY) || (lpEAX3LP->flReverbDelay > EAXLISTENER_MAXREVERBDELAY) )
+		return false;
+
+	if ( (lpEAX3LP->flEchoTime < EAXLISTENER_MINECHOTIME) || (lpEAX3LP->flEchoTime > EAXLISTENER_MAXECHOTIME) )
+		return false;
+
+	if ( (lpEAX3LP->flEchoDepth < EAXLISTENER_MINECHODEPTH) || (lpEAX3LP->flEchoDepth > EAXLISTENER_MAXECHODEPTH) )
+		return false;
+
+	if ( (lpEAX3LP->flModulationTime < EAXLISTENER_MINMODULATIONTIME) || (lpEAX3LP->flModulationTime > EAXLISTENER_MAXMODULATIONTIME) )
+		return false;
+
+	if ( (lpEAX3LP->flModulationDepth < EAXLISTENER_MINMODULATIONDEPTH) || (lpEAX3LP->flModulationDepth > EAXLISTENER_MAXMODULATIONDEPTH) )
+		return false;
+
+	if ( (lpEAX3LP->flAirAbsorptionHF < EAXLISTENER_MINAIRABSORPTIONHF) || (lpEAX3LP->flAirAbsorptionHF > EAXLISTENER_MAXAIRABSORPTIONHF) )
+		return false;
+
+	if ( (lpEAX3LP->flHFReference < EAXLISTENER_MINHFREFERENCE) || (lpEAX3LP->flHFReference > EAXLISTENER_MAXHFREFERENCE) )
+		return false;
+
+	if ( (lpEAX3LP->flLFReference < EAXLISTENER_MINLFREFERENCE) || (lpEAX3LP->flLFReference > EAXLISTENER_MAXLFREFERENCE) )
+		return false;
+
+	if ( (lpEAX3LP->flRoomRolloffFactor < EAXLISTENER_MINROOMROLLOFFFACTOR) || (lpEAX3LP->flRoomRolloffFactor > EAXLISTENER_MAXROOMROLLOFFFACTOR) )
+		return false;
+
+	if (lpEAX3LP->ulFlags & EAXLISTENERFLAGS_RESERVED)
+		return false;
+
+	return true;
+}
+
+/*
+	Clamp
+	Clamps the length of the vector to 1.0f
+*/
+void Clamp(EAXVECTOR *eaxVector)
+{
+	float flMagnitude;
+	float flInvMagnitude;
+
+	flMagnitude = (float)sqrt((eaxVector->x*eaxVector->x) + (eaxVector->y*eaxVector->y) + (eaxVector->z*eaxVector->z));
+
+	if (flMagnitude <= 1.0f)
+		return;
+
+	flInvMagnitude = 1.0f / flMagnitude;
+
+	eaxVector->x *= flInvMagnitude;
+	eaxVector->y *= flInvMagnitude;
+	eaxVector->z *= flInvMagnitude;
+}
+
+
+/***********************************************************************************************\
+*
+* To assist those developers wishing to add EAX effects to their level editors, each of the 
+
+* List of string names of the various EAX 3.0 presets defined in eax-util.h
+* Arrays to group together presets of the same scenario
+*
+\***********************************************************************************************/
+
+
+//////////////////////////////////////////////////////
+// Array of scenario names							//
+//////////////////////////////////////////////////////
+
+char* EAX30_SCENARIO_NAMES[] =				
+{	
+	"Castle", 
+	"Factory", 
+	"IcePalace", 
+	"SpaceStation", 
+	"WoodenShip",
+	"Sports",
+	"Prefab",
+	"Domes and Pipes",
+	"Outdoors",
+	"Mood",
+	"Driving",
+	"City",
+	"Miscellaneous",
+	"Original"
+};
+
+//////////////////////////////////////////////////////
+// Array of standardised location names				//
+//////////////////////////////////////////////////////
+
+char* EAX30_LOCATION_NAMES[] =				
+{	
+	"Hall", 
+	"Large Room", 
+	"Medium Room", 
+	"Small Room", 
+	"Cupboard", 
+	"Alcove", 
+	"Long Passage", 
+	"Short Passage", 
+	"Courtyard"
+};
+
+//////////////////////////////////////////////////////
+// Standardised Location effects can be accessed	//
+// from a matrix									//
+//////////////////////////////////////////////////////
+
+EAXLISTENERPROPERTIES EAX30_STANDARD_PRESETS[EAX30_NUM_STANDARD_SCENARIOS][EAX30_NUM_LOCATIONS]=
+{
+	{EAX30_PRESET_CASTLE_HALL,		EAX30_PRESET_CASTLE_LARGEROOM,		EAX30_PRESET_CASTLE_MEDIUMROOM,			EAX30_PRESET_CASTLE_SMALLROOM,		EAX30_PRESET_CASTLE_CUPBOARD,		EAX30_PRESET_CASTLE_ALCOVE,			EAX30_PRESET_CASTLE_LONGPASSAGE,		EAX30_PRESET_CASTLE_SHORTPASSAGE,		EAX30_PRESET_CASTLE_COURTYARD},
+	{EAX30_PRESET_FACTORY_HALL,		EAX30_PRESET_FACTORY_LARGEROOM,		EAX30_PRESET_FACTORY_MEDIUMROOM,		EAX30_PRESET_FACTORY_SMALLROOM,		EAX30_PRESET_FACTORY_CUPBOARD,		EAX30_PRESET_FACTORY_ALCOVE,		EAX30_PRESET_FACTORY_LONGPASSAGE,		EAX30_PRESET_FACTORY_SHORTPASSAGE,		EAX30_PRESET_FACTORY_COURTYARD},
+	{EAX30_PRESET_ICEPALACE_HALL,	EAX30_PRESET_ICEPALACE_LARGEROOM,	EAX30_PRESET_ICEPALACE_MEDIUMROOM,		EAX30_PRESET_ICEPALACE_SMALLROOM,	EAX30_PRESET_ICEPALACE_CUPBOARD,	EAX30_PRESET_ICEPALACE_ALCOVE,		EAX30_PRESET_ICEPALACE_LONGPASSAGE,		EAX30_PRESET_ICEPALACE_SHORTPASSAGE,	EAX30_PRESET_ICEPALACE_COURTYARD},
+	{EAX30_PRESET_SPACESTATION_HALL,EAX30_PRESET_SPACESTATION_LARGEROOM,EAX30_PRESET_SPACESTATION_MEDIUMROOM,	EAX30_PRESET_SPACESTATION_SMALLROOM,EAX30_PRESET_SPACESTATION_CUPBOARD,	EAX30_PRESET_SPACESTATION_ALCOVE,	EAX30_PRESET_SPACESTATION_LONGPASSAGE,	EAX30_PRESET_SPACESTATION_SHORTPASSAGE, EAX30_PRESET_SPACESTATION_HALL},
+	{EAX30_PRESET_WOODEN_HALL,		EAX30_PRESET_WOODEN_LARGEROOM,		EAX30_PRESET_WOODEN_MEDIUMROOM,			EAX30_PRESET_WOODEN_SMALLROOM,		EAX30_PRESET_WOODEN_CUPBOARD,		EAX30_PRESET_WOODEN_ALCOVE,			EAX30_PRESET_WOODEN_LONGPASSAGE,		EAX30_PRESET_WOODEN_SHORTPASSAGE,		EAX30_PRESET_WOODEN_COURTYARD},
+};
+
+
+/********************************************************************************************************/
+
+//////////////////////////////////////////////////////
+// Array of original environment names				//
+//////////////////////////////////////////////////////
+
+char* EAX30_ORIGINAL_PRESET_NAMES[] =
+{
+	"Generic",
+	"Padded Cell",
+	"Room",
+	"Bathroom",
+	"Living Room",
+	"Stone Room",
+	"Auditorium",
+	"Concert Hall",
+	"Cave",
+	"Arena",
+	"Hangar",
+	"Carpetted Hallway",
+	"Hallway",
+	"Stone Corridor",
+	"Alley",
+	"Forest",
+	"City",
+	"Mountains",
+	"Quarry",
+	"Plain",
+	"Parking Lot",
+	"Sewer Pipe",
+	"Underwater",
+	"Drugged",
+	"Dizzy",
+	"Psychotic"
+};
+
+//////////////////////////////////////////////////////
+// Sports effects matrix							//
+//////////////////////////////////////////////////////
+
+EAXLISTENERPROPERTIES		EAX30_ORIGINAL_PRESETS[] =
+{
+	EAX30_PRESET_GENERIC,
+	EAX30_PRESET_PADDEDCELL,
+	EAX30_PRESET_ROOM,
+	EAX30_PRESET_BATHROOM,
+	EAX30_PRESET_LIVINGROOM,
+	EAX30_PRESET_STONEROOM,
+	EAX30_PRESET_AUDITORIUM,
+	EAX30_PRESET_CONCERTHALL,
+	EAX30_PRESET_CAVE,
+	EAX30_PRESET_ARENA,
+	EAX30_PRESET_HANGAR,
+	EAX30_PRESET_CARPETTEDHALLWAY,
+	EAX30_PRESET_HALLWAY,
+	EAX30_PRESET_STONECORRIDOR,
+	EAX30_PRESET_ALLEY,
+	EAX30_PRESET_FOREST,
+	EAX30_PRESET_CITY,
+	EAX30_PRESET_MOUNTAINS,
+	EAX30_PRESET_QUARRY,
+	EAX30_PRESET_PLAIN,
+	EAX30_PRESET_PARKINGLOT,
+	EAX30_PRESET_SEWERPIPE,
+	EAX30_PRESET_UNDERWATER,
+	EAX30_PRESET_DRUGGED,
+	EAX30_PRESET_DIZZY,
+	EAX30_PRESET_PSYCHOTIC
+};
+
+/********************************************************************************************************/
+
+//////////////////////////////////////////////////////
+// Array of sport environment names					//
+//////////////////////////////////////////////////////
+
+char* EAX30_SPORTS_PRESET_NAMES[] =
+{
+	"Empty Stadium",
+	"Full Stadium", 
+	"Stadium Tannoy",
+	"Squash Court",
+	"Small Swimming Pool", 
+	"Large Swimming Pool",
+	"Gymnasium"
+};
+
+//////////////////////////////////////////////////////
+// Sports effects matrix							//
+//////////////////////////////////////////////////////
+
+EAXLISTENERPROPERTIES		EAX30_SPORTS_PRESETS[] =
+{
+	EAX30_PRESET_SPORT_EMPTYSTADIUM,
+	EAX30_PRESET_SPORT_FULLSTADIUM,
+	EAX30_PRESET_SPORT_STADIUMTANNOY,
+	EAX30_PRESET_SPORT_SQUASHCOURT,
+	EAX30_PRESET_SPORT_SMALLSWIMMINGPOOL,
+	EAX30_PRESET_SPORT_LARGESWIMMINGPOOL,
+	EAX30_PRESET_SPORT_GYMNASIUM
+};
+
+/********************************************************************************************************/
+
+//////////////////////////////////////////////////////
+// Array of prefab environment names				//
+//////////////////////////////////////////////////////
+
+char* EAX30_PREFAB_PRESET_NAMES[] =
+{
+	"Workshop",
+	"School Room",
+	"Practise Room",
+	"Outhouse",
+	"Caravan"
+};
+
+//////////////////////////////////////////////////////
+// Prefab effects matrix							//
+//////////////////////////////////////////////////////
+
+EAXLISTENERPROPERTIES EAX30_PREFAB_PRESETS[] =
+{
+	EAX30_PRESET_PREFAB_WORKSHOP,
+	EAX30_PRESET_PREFAB_SCHOOLROOM,
+	EAX30_PRESET_PREFAB_PRACTISEROOM,
+	EAX30_PRESET_PREFAB_OUTHOUSE,
+	EAX30_PRESET_PREFAB_CARAVAN
+};
+
+/********************************************************************************************************/
+
+//////////////////////////////////////////////////////
+// Array of Domes & Pipes environment names			//
+//////////////////////////////////////////////////////
+
+char* EAX30_DOMESNPIPES_PRESET_NAMES[] =
+{
+	"Domed Tomb",
+	"Saint Paul's Dome",
+	"Small Pipe",
+	"Long Thin Pipe", 
+	"Large Pipe",
+	"Resonant Pipe"
+};
+
+//////////////////////////////////////////////////////
+// Domes & Pipes effects matrix						//
+//////////////////////////////////////////////////////
+
+EAXLISTENERPROPERTIES EAX30_DOMESNPIPES_PRESETS[] =
+{
+	EAX30_PRESET_DOME_TOMB,
+	EAX30_PRESET_DOME_SAINTPAULS,
+	EAX30_PRESET_PIPE_SMALL,
+	EAX30_PRESET_PIPE_LONGTHIN,
+	EAX30_PRESET_PIPE_LARGE,
+	EAX30_PRESET_PIPE_RESONANT
+};
+
+/********************************************************************************************************/
+
+//////////////////////////////////////////////////////
+// Array of Outdoors environment names				//
+//////////////////////////////////////////////////////
+
+char* EAX30_OUTDOORS_PRESET_NAMES[] =
+{
+	"Backyard", 
+	"Rolling Plains",
+	"Deep Canyon",
+	"Creek",
+	"Valley"
+};
+
+//////////////////////////////////////////////////////
+// Outdoors effects matrix							//
+//////////////////////////////////////////////////////
+
+EAXLISTENERPROPERTIES EAX30_OUTDOORS_PRESETS[] =
+{
+	EAX30_PRESET_OUTDOORS_BACKYARD,
+	EAX30_PRESET_OUTDOORS_ROLLINGPLAINS,
+	EAX30_PRESET_OUTDOORS_DEEPCANYON,
+	EAX30_PRESET_OUTDOORS_CREEK,
+	EAX30_PRESET_OUTDOORS_VALLEY
+};
+
+/********************************************************************************************************/
+
+//////////////////////////////////////////////////////
+// Array of Mood environment names					//
+//////////////////////////////////////////////////////
+
+char* EAX30_MOOD_PRESET_NAMES[] =
+{
+	"Heaven",
+	"Hell",
+	"Memory"
+};
+
+//////////////////////////////////////////////////////
+// Mood effects matrix								//
+//////////////////////////////////////////////////////
+
+EAXLISTENERPROPERTIES EAX30_MOOD_PRESETS[] =
+{
+	EAX30_PRESET_MOOD_HEAVEN,
+	EAX30_PRESET_MOOD_HELL,
+	EAX30_PRESET_MOOD_MEMORY
+};
+
+/********************************************************************************************************/
+
+//////////////////////////////////////////////////////
+// Array of driving environment names				//
+//////////////////////////////////////////////////////
+
+char* EAX30_DRIVING_PRESET_NAMES[] =
+{
+	"Race Commentator",
+	"Pit Garage",
+	"In-car (Stripped out racer)",
+	"In-car (Sportscar)",
+	"In-car (Luxury)",
+	"Full Grandstand",
+	"Empty Grandstand",
+	"Tunnel"
+};
+
+//////////////////////////////////////////////////////
+// Driving effects matrix							//
+//////////////////////////////////////////////////////
+
+EAXLISTENERPROPERTIES EAX30_DRIVING_PRESETS[] =
+{
+	EAX30_PRESET_DRIVING_COMMENTATOR,
+	EAX30_PRESET_DRIVING_PITGARAGE,
+	EAX30_PRESET_DRIVING_INCAR_RACER,
+	EAX30_PRESET_DRIVING_INCAR_SPORTS,
+	EAX30_PRESET_DRIVING_INCAR_LUXURY,
+	EAX30_PRESET_DRIVING_FULLGRANDSTAND,
+	EAX30_PRESET_DRIVING_EMPTYGRANDSTAND,
+	EAX30_PRESET_DRIVING_TUNNEL
+};
+
+/********************************************************************************************************/
+
+//////////////////////////////////////////////////////
+// Array of City environment names					//
+//////////////////////////////////////////////////////
+
+char* EAX30_CITY_PRESET_NAMES[] =
+{
+	"City Streets",
+	"Subway",
+	"Museum",
+	"Library",
+	"Underpass",
+	"Abandoned City"
+};
+
+//////////////////////////////////////////////////////
+// City effects matrix								//
+//////////////////////////////////////////////////////
+
+EAXLISTENERPROPERTIES EAX30_CITY_PRESETS[] =
+{
+	EAX30_PRESET_CITY_STREETS,
+	EAX30_PRESET_CITY_SUBWAY,
+	EAX30_PRESET_CITY_MUSEUM,
+	EAX30_PRESET_CITY_LIBRARY,
+	EAX30_PRESET_CITY_UNDERPASS,
+	EAX30_PRESET_CITY_ABANDONED
+};
+
+/********************************************************************************************************/
+
+//////////////////////////////////////////////////////
+// Array of Misc environment names					//
+//////////////////////////////////////////////////////
+
+char* EAX30_MISC_PRESET_NAMES[] =
+{
+	"Dusty Box Room",
+	"Chapel",
+	"Small Water Room"
+};
+
+//////////////////////////////////////////////////////
+// Misc effects matrix								//
+//////////////////////////////////////////////////////
+
+EAXLISTENERPROPERTIES EAX30_MISC_PRESETS[] =
+{
+	EAX30_PRESET_DUSTYROOM,
+	EAX30_PRESET_CHAPEL,
+	EAX30_PRESET_SMALLWATERROOM
+};
+
diff --git a/eax/eax-util.h b/eax/eax-util.h
new file mode 100644
index 00000000..204582aa
--- /dev/null
+++ b/eax/eax-util.h
@@ -0,0 +1,765 @@
+/*******************************************************************\
+*																	*
+*  EAX-UTIL.H - utilities for Environmental Audio Extensions v. 3.0	*
+*				Definitions of the Original 26 EAX Presets			*
+*				Definitions for some new EAX Presets				*
+*				Definitions of some Material Presets				*
+*				Function declaration for EAX Morphing				*
+*																	*
+\*******************************************************************/
+
+#ifndef EAXUTIL_INCLUDED
+#define EAXUTIL_INCLUDED
+
+#include <eax.h>
+
+/***********************************************************************************************
+* Function	:	EAX3ListenerInterpolate
+* Params	:	lpStart			- Initial EAX 3 Listener parameters
+*			:	lpFinish		- Final EAX 3 Listener parameters
+*			:	flRatio			- Ratio Destination : Source (0.0 == Source, 1.0 == Destination)
+*			:	lpResult		- Interpolated EAX 3 Listener parameters
+*			:	bCheckValues	- Check EAX 3.0 parameters are in range,
+								- default == false (no checking)
+************************************************************************************************/
+bool EAX3ListenerInterpolate(EAXLISTENERPROPERTIES *lpStartEAX3LP, EAXLISTENERPROPERTIES *lpFinishEAX3LP,
+			float flRatio, EAXLISTENERPROPERTIES *lpResultEAX3LP, bool bCheckValues = false);
+
+
+/***********************************************************************************************\
+*
+* Legacy environment presets for use with DSPROPERTY_EAXLISTENER_ALLPARAMETERS.
+* Each array conforms to the DSPROPSETID_EAX30_ListenerProperties structure defined in EAX.H.
+*
+************************************************************************************************/
+
+//	Env		Size	Diffus	Room	RoomHF	RoomLF	DecTm	DcHF	DcLF	Refl	RefDel	Ref Pan				Revb	RevDel		Rev Pan				EchTm	EchDp	ModTm	ModDp	AirAbs	HFRef		LFRef	RRlOff	FLAGS
+#define EAX30_PRESET_GENERIC \
+	{0,		7.5f,	1.000f,	-1000,	-100,	0,		1.49f,	0.83f,	1.00f,	-2602,	0.007f,	0.00f,0.00f,0.00f,	200,	0.011f,		0.00f,0.00f,0.00f,	0.250f,	0.000f,	0.250f,	0.000f,	-5.0f,	5000.0f,	250.0f,	0.00f,	0x3f }
+#define EAX30_PRESET_PADDEDCELL \
+	{1,		1.4f,	1.000f,	-1000,	-6000,	0,		0.17f,	0.10f,	1.00f,	-1204,	0.001f, 0.00f,0.00f,0.00f,  207,	0.002f,		0.00f,0.00f,0.00f,	0.250f, 0.000f, 0.250f, 0.000f,	-5.0f,	5000.0f,	250.0f,	0.00f,	0x3f }
+#define EAX30_PRESET_ROOM \
+	{2,		1.9f,	1.000f,	-1000,	-454,	0,		0.40f,	0.83f,	1.00f,  -1646,	0.002f, 0.00f,0.00f,0.00f,	53,		0.003f,		0.00f,0.00f,0.00f,	0.250f, 0.000f, 0.250f, 0.000f,	-5.0f,  5000.0f,	250.0f,	0.00f,	0x3f }
+#define EAX30_PRESET_BATHROOM \
+	{3,		1.4f,	1.000f,	-1000,  -1200,	0,		1.49f,	0.54f,	1.00f,  -370,	0.007f, 0.00f,0.00f,0.00f,	1030,	0.011f,		0.00f,0.00f,0.00f,	0.250f, 0.000f, 0.250f, 0.000f,	-5.0f,  5000.0f,	250.0f,	0.00f,	0x3f }
+#define EAX30_PRESET_LIVINGROOM \
+	{4,		2.5f,	1.000f,	-1000,  -6000,	0,		0.50f,	0.10f,	1.00f,  -1376,	0.003f, 0.00f,0.00f,0.00f,	-1104,	0.004f,		0.00f,0.00f,0.00f,	0.250f, 0.000f, 0.250f, 0.000f,	-5.0f,  5000.0f,	250.0f,	0.00f,	0x3f }
+#define EAX30_PRESET_STONEROOM \
+	{5,		11.6f,	1.000f,  -1000, -300,	0,		2.31f,	0.64f,	1.00f,	-711,	0.012f, 0.00f,0.00f,0.00f,	83,		0.017f,		0.00f,0.00f,0.00f,	0.250f, 0.000f, 0.250f, 0.000f,	-5.0f,  5000.0f,	250.0f,	0.00f,	0x3f }
+#define EAX30_PRESET_AUDITORIUM \
+	{6,		21.6f,	1.000f,  -1000,	-476,	0,		4.32f,	0.59f,	1.00f,	-789,	0.020f, 0.00f,0.00f,0.00f,	-289,	0.030f,		0.00f,0.00f,0.00f,	0.250f, 0.000f, 0.250f, 0.000f,	-5.0f,  5000.0f,	250.0f,	0.00f,	0x3f }
+#define EAX30_PRESET_CONCERTHALL \
+	{7,		19.6f,	1.000f,  -1000,	-500,	0,		3.92f,	0.70f,	1.00f,  -1230,	0.020f, 0.00f,0.00f,0.00f,  -02,	0.029f,		0.00f,0.00f,0.00f,	0.250f, 0.000f, 0.250f, 0.000f, -5.0f,  5000.0f,	250.0f, 0.00f,	0x3f }
+#define EAX30_PRESET_CAVE \
+	{8,		14.6f,	1.000f,  -1000,	0,		0,		2.91f,	1.30f,	1.00f,  -602,	0.015f, 0.00f,0.00f,0.00f,	-302,	0.022f,		0.00f,0.00f,0.00f,	0.250f, 0.000f, 0.250f, 0.000f, -5.0f,  5000.0f,	250.0f,	0.00f,	0x1f }
+#define EAX30_PRESET_ARENA \
+	{9,		36.2f,	1.000f,  -1000,	-698,	0,		7.24f,	0.33f,	1.00f,  -1166,	0.020f, 0.00f,0.00f,0.00f,  16,		0.030f,		0.00f,0.00f,0.00f,	0.250f, 0.000f, 0.250f, 0.000f, -5.0f,  5000.0f,	250.0f,	0.00f,	0x3f }
+#define EAX30_PRESET_HANGAR \
+	{10,	50.3f,	1.000f,  -1000,	-1000,	0,		10.05f, 0.23f,	1.00f,  -602,	0.020f, 0.00f,0.00f,0.00f,  198,	0.030f,		0.00f,0.00f,0.00f,	0.250f, 0.000f, 0.250f, 0.000f, -5.0f,  5000.0f,	250.0f, 0.00f,	0x3f }
+#define EAX30_PRESET_CARPETTEDHALLWAY \
+	{11,	1.9f,	1.000f,	-1000,	-4000,	0,		0.30f,	0.10f,	1.00f,  -1831,	0.002f, 0.00f,0.00f,0.00f,	-1630,	0.030f,		0.00f,0.00f,0.00f,	0.250f, 0.000f, 0.250f, 0.000f, -5.0f,  5000.0f,	250.0f, 0.00f,	0x3f }
+#define EAX30_PRESET_HALLWAY \
+	{12,	1.8f,	1.000f,	-1000,	-300,	0,		1.49f,	0.59f,	1.00f,  -1219,	0.007f, 0.00f,0.00f,0.00f,  441,	0.011f,		0.00f,0.00f,0.00f,	0.250f, 0.000f, 0.250f, 0.000f, -5.0f,  5000.0f,	250.0f, 0.00f,	0x3f }
+#define EAX30_PRESET_STONECORRIDOR \
+	{13,	13.5f,	1.000f,	-1000,	-237,	0,		2.70f,	0.79f,	1.00f,  -1214,	0.013f, 0.00f,0.00f,0.00f,  395,	0.020f,		0.00f,0.00f,0.00f,	0.250f, 0.000f, 0.250f, 0.000f, -5.0f,  5000.0f,	250.0f, 0.00f,	0x3f }
+#define EAX30_PRESET_ALLEY \
+	{14,	7.5f,	0.300f,	-1000,	-270,	0,		1.49f,	0.86f,	1.00f,  -1204,	0.007f, 0.00f,0.00f,0.00f,  -4,		0.011f,		0.00f,0.00f,0.00f,	0.125f, 0.950f, 0.250f, 0.000f, -5.0f,  5000.0f,	250.0f, 0.00f,	0x3f }
+#define EAX30_PRESET_FOREST \
+	{15,	38.0f,	0.300f,	-1000,	-3300,	0,		1.49f,	0.54f,	1.00f,  -2560,	0.162f, 0.00f,0.00f,0.00f,	-229,	0.088f,		0.00f,0.00f,0.00f,	0.125f, 1.000f, 0.250f, 0.000f, -5.0f,  5000.0f,	250.0f, 0.00f,	0x3f }
+#define EAX30_PRESET_CITY \
+	{16,	7.5f,	0.500f,	-1000,	-800,	0,		1.49f,	0.67f,	1.00f,  -2273,	0.007f, 0.00f,0.00f,0.00f,	-1691,	0.011f,		0.00f,0.00f,0.00f,	0.250f, 0.000f, 0.250f, 0.000f, -5.0f,  5000.0f,	250.0f, 0.00f,	0x3f }
+#define EAX30_PRESET_MOUNTAINS \
+	{17,	100.0f, 0.270f,	-1000,	-2500,	0,		1.49f,	0.21f,	1.00f,  -2780,	0.300f, 0.00f,0.00f,0.00f,	-1434,	0.100f,		0.00f,0.00f,0.00f,	0.250f, 1.000f, 0.250f, 0.000f, -5.0f,  5000.0f,	250.0f, 0.00f,	0x1f }
+#define EAX30_PRESET_QUARRY \
+	{18,	17.5f,	1.000f,	-1000,	-1000,	0,		1.49f,	0.83f,	1.00f,	-10000, 0.061f, 0.00f,0.00f,0.00f,  500,	0.025f,		0.00f,0.00f,0.00f,	0.125f, 0.700f, 0.250f, 0.000f, -5.0f,  5000.0f,	250.0f, 0.00f,	0x3f }
+#define EAX30_PRESET_PLAIN \
+	{19,	42.5f,	0.210f,	-1000,	-2000,	0,		1.49f,	0.50f,	1.00f,  -2466,	0.179f, 0.00f,0.00f,0.00f,	-1926,	0.100f,		0.00f,0.00f,0.00f,	0.250f, 1.000f, 0.250f, 0.000f, -5.0f,  5000.0f,	250.0f, 0.00f,	0x3f }
+#define EAX30_PRESET_PARKINGLOT \
+	{20,	8.3f,	1.000f,	-1000,	0,		0,		1.65f,	1.50f,	1.00f,  -1363,	0.008f, 0.00f,0.00f,0.00f,	-1153,	0.012f,		0.00f,0.00f,0.00f,	0.250f, 0.000f, 0.250f, 0.000f, -5.0f,  5000.0f,	250.0f, 0.00f,	0x1f }
+#define EAX30_PRESET_SEWERPIPE \
+	{21,	1.7f,	0.800f,	-1000,	-1000,	0,		2.81f,	0.14f,	1.00f,	429,	0.014f, 0.00f,0.00f,0.00f,	1023,	0.021f,		0.00f,0.00f,0.00f,	0.250f, 0.000f, 0.250f, 0.000f, -5.0f,  5000.0f,	250.0f, 0.00f,	0x3f }
+#define EAX30_PRESET_UNDERWATER \
+	{22,	1.8f,	1.000f,	-1000,  -4000,	0,		1.49f,	0.10f,	1.00f,  -449,	0.007f, 0.00f,0.00f,0.00f,	1700,	0.011f,		0.00f,0.00f,0.00f,	0.250f, 0.000f, 1.180f, 0.348f, -5.0f,  5000.0f,	250.0f, 0.00f,	0x3f }
+#define EAX30_PRESET_DRUGGED \
+	{23,	1.9f,	0.500f,	-1000,	0,		0,		8.39f,	1.39f,	1.00f,  -115,	0.002f, 0.00f,0.00f,0.00f,  985,	0.030f,		0.00f,0.00f,0.00f,	0.250f, 0.000f, 0.250f, 1.000f, -5.0f,  5000.0f,	250.0f, 0.00f,	0x1f }
+#define EAX30_PRESET_DIZZY \
+	{24,	1.8f,	0.600f,	-1000,	-400,	0,		17.23f, 0.56f,	1.00f,  -1713,	0.020f, 0.00f,0.00f,0.00f,	-613,	0.030f,		0.00f,0.00f,0.00f,	0.250f, 1.000f, 0.810f, 0.310f, -5.0f,  5000.0f,	250.0f, 0.00f,	0x1f }
+#define EAX30_PRESET_PSYCHOTIC \
+	{25,	1.0f,	0.500f,	-1000,	-151,	0,		7.56f,	0.91f,	1.00f,  -626,	0.020f, 0.00f,0.00f,0.00f,  774,	0.030f,		0.00f,0.00f,0.00f,	0.250f, 0.000f, 4.000f, 1.000f, -5.0f,  5000.0f,	250.0f, 0.00f,	0x1f }
+
+
+/***********************************************************************************************\
+*
+* New environment presets for use with DSPROPERTY_EAXLISTENER_ALLPARAMETERS.
+* Each array conforms to the DSPROPSETID_EAX30_ListenerProperties structure defined in EAX.H.
+*
+************************************************************************************************/
+
+// STANDARDISED-LOCATION SCENARIOS
+
+// CASTLE PRESETS
+
+//	Env		Size	Diffus	Room	RoomHF	RoomLF	DecTm	DcHF	DcLF	Refl	RefDel	Ref Pan				Revb	RevDel		Rev Pan				EchTm	EchDp	ModTm	ModDp	AirAbs	HFRef		LFRef	RRlOff	FLAGS
+#define EAX30_PRESET_CASTLE_SMALLROOM \
+	{ 26,   8.3f,	0.890f,	-1100,	-800,	-2000,	1.22f,	0.83f,	0.31f,	-100,	0.022f,	0.00f,0.00f,0.00f,	0,		0.011f,		0.00f,0.00f,0.00f,	0.138f,	0.080f,	0.250f,	0.000f,	-5.0f,	5168.6f,	139.5f,  0.00f, 0x20 }
+#define EAX30_PRESET_CASTLE_SHORTPASSAGE \
+	{ 26,   8.3f,	0.890f, -1000,  -1000,  -2000,  2.32f,	0.83f,	0.31f,	-100,	0.007f, 0.00f,0.00f,0.00f,  -500,	0.023f,		0.00f,0.00f,0.00f,	0.138f, 0.080f, 0.250f, 0.000f, -5.0f,  5168.6f,	139.5f,  0.00f, 0x20 }
+#define EAX30_PRESET_CASTLE_MEDIUMROOM \
+	{ 26,   8.3f,	0.930f, -1000,  -1100,  -2000,  2.04f,	0.83f,	0.46f,  -300,	0.022f, 0.00f,0.00f,0.00f,	-200,	0.011f,		0.00f,0.00f,0.00f,	0.155f, 0.030f, 0.250f, 0.000f, -5.0f,  5168.6f,	139.5f,  0.00f, 0x20 }
+#define EAX30_PRESET_CASTLE_LONGPASSAGE \
+	{ 26,   8.3f,	0.890f, -1000,  -800,	-2000,  3.42f,	0.83f,	0.31f,  -200,	0.007f, 0.00f,0.00f,0.00f,	-600,	0.023f,		0.00f,0.00f,0.00f,	0.138f, 0.080f, 0.250f, 0.000f, -5.0f,  5168.6f,	139.5f,  0.00f, 0x20 }
+#define EAX30_PRESET_CASTLE_LARGEROOM \
+	{ 26,   8.3f,	0.820f, -1000,  -1100,  -1800,  2.53f,	0.83f,	0.50f,  -900,	0.034f, 0.00f,0.00f,0.00f,	-400,	0.016f,		0.00f,0.00f,0.00f,	0.185f, 0.070f, 0.250f, 0.000f, -5.0f,  5168.6f,	139.5f,  0.00f, 0x20 }
+#define EAX30_PRESET_CASTLE_HALL \
+	{ 26,   8.3f,	0.810f, -1000,  -1100,  -1500,  3.14f,	0.79f,	0.62f,  -1300,	0.056f, 0.00f,0.00f,0.00f,	-500,	0.024f,		0.00f,0.00f,0.00f,	0.250f, 0.000f, 0.250f, 0.000f, -5.0f,  5168.6f,	139.5f,  0.00f, 0x20 }
+#define EAX30_PRESET_CASTLE_CUPBOARD \
+	{ 26,   8.3f,	0.890f, -1000,  -1100,  -2000,  0.67f,	0.87f,	0.31f,  300,	0.010f,	0.00f,0.00f,0.00f,	300,	0.007f,		0.00f,0.00f,0.00f,	0.138f, 0.080f, 0.250f, 0.000f, -5.0f,  5168.6f,	139.5f,  0.00f, 0x20 }
+#define EAX30_PRESET_CASTLE_COURTYARD \
+	{ 26,   8.3f,	0.420f, -1100,  -700,   -900,	2.13f,	0.61f,	0.23f,  -2300,	0.112f, 0.00f,0.00f,0.00f,	-1500,	0.036f,		0.00f,0.00f,0.00f,	0.250f, 0.370f, 0.250f, 0.000f, -0.0f,  5000.0f,	250.0f,  0.00f, 0x1f }
+#define EAX30_PRESET_CASTLE_ALCOVE \
+	{ 26,   8.3f,	0.890f,	-1000,  -600,	-2000,  1.64f,	0.87f,	0.31f,  -100,	0.007f, 0.00f,0.00f,0.00f,	-500,	0.034f,		0.00f,0.00f,0.00f,	0.138f, 0.080f, 0.250f, 0.000f, -5.0f,	5168.6f,	139.5f,  0.00f, 0x20 }
+
+
+// FACTORY PRESETS
+
+//	Env		Size	Diffus	Room	RoomHF	RoomLF	DecTm	DcHF	DcLF	Refl	RefDel	Ref Pan				Revb	RevDel		Rev Pan				EchTm	EchDp	ModTm	ModDp	AirAbs	HFRef		LFRef	RRlOff	FLAGS
+#define EAX30_PRESET_FACTORY_ALCOVE \
+	{ 26,   1.8f,	0.590f,  -1200, -200,   -600,	3.14f,	0.65f,	1.31f,  300,	0.010f, 0.00f,0.00f,0.00f,	-1200,	0.038f,		0.00f,0.00f,0.00f,	0.114f, 0.100f, 0.250f, 0.000f, -0.0f,  3762.6f,	362.5f,  0.00f, 0x20 }
+#define EAX30_PRESET_FACTORY_SHORTPASSAGE \
+	{ 26,   1.8f,	0.640f,  -1200, -200,   -600,	2.53f,	0.65f,	1.31f,  0,		0.010f, 0.00f,0.00f,0.00f,	-600,	0.038f,		0.00f,0.00f,0.00f,	0.135f, 0.230f, 0.250f, 0.000f, -0.0f,  3762.6f,	362.5f,  0.00f, 0x20 }
+#define EAX30_PRESET_FACTORY_MEDIUMROOM \
+	{ 26,   1.9f,	0.820f,  -1200, -200,   -600,	2.76f,	0.65f,	1.31f,  -1100,	0.022f, 0.00f,0.00f,0.00f,	-400,	0.023f,		0.00f,0.00f,0.00f,	0.174f, 0.070f, 0.250f, 0.000f, -0.0f,  3762.6f,	362.5f,  0.00f, 0x20 }
+#define EAX30_PRESET_FACTORY_LONGPASSAGE \
+	{ 26,   1.8f,	0.640f,  -1200, -200,   -600,	4.06f,	0.65f,	1.31f,  0,		0.020f, 0.00f,0.00f,0.00f,	-900,	0.037f,		0.00f,0.00f,0.00f,	0.135f, 0.230f, 0.250f, 0.000f, -0.0f,  3762.6f,	362.5f,  0.00f, 0x20 }
+#define EAX30_PRESET_FACTORY_LARGEROOM \
+	{ 26,   1.9f,	0.750f,  -1200, -300,   -400,	4.24f,	0.51f,	1.31f,  -1500,	0.039f, 0.00f,0.00f,0.00f,	-600,	0.023f,		0.00f,0.00f,0.00f,	0.231f, 0.070f, 0.250f, 0.000f, -0.0f,  3762.6f,	362.5f,  0.00f, 0x20 }
+#define EAX30_PRESET_FACTORY_HALL \
+	{ 26,   1.9f,	0.750f,  -1000, -300,   -400,	7.43f,	0.51f,	1.31f,  -2400,	0.073f, 0.00f,0.00f,0.00f,	-500,	0.027f,		0.00f,0.00f,0.00f,	0.250f, 0.070f, 0.250f, 0.000f, -0.0f,  3762.6f,	362.5f,  0.00f, 0x20 }
+#define EAX30_PRESET_FACTORY_CUPBOARD \
+	{ 26,   1.7f,	0.630f,  -1200, -200,   -600,	0.49f,	0.65f,	1.31f,  200,	0.010f, 0.00f,0.00f,0.00f,	200,	0.032f,		0.00f,0.00f,0.00f,	0.107f, 0.070f, 0.250f, 0.000f, -0.0f,  3762.6f,	362.5f,  0.00f, 0x20 }
+#define EAX30_PRESET_FACTORY_COURTYARD \
+	{ 26,   1.7f,	0.570f,  -1000, -1000,  -400,	2.32f,	0.29f,	0.56f,  -2400,	0.090f, 0.00f,0.00f,0.00f,	-2000,	0.039f,		0.00f,0.00f,0.00f,	0.250f, 0.290f, 0.250f, 0.000f, -0.0f,  3762.6f,	362.5f,  0.00f, 0x20 }
+#define EAX30_PRESET_FACTORY_SMALLROOM \
+	{ 26,   1.8f,	0.820f,  -1200,	-200,   -600,	1.72f,	0.65f,	1.31f,  -300,	0.010f, 0.00f,0.00f,0.00f,	-200,	0.024f,		0.00f,0.00f,0.00f,	0.119f, 0.070f, 0.250f, 0.000f, -0.0f,	3762.6f,	362.5f,  0.00f, 0x20 }
+
+// ICE PALACE PRESETS
+
+//	Env		Size	Diffus	Room	RoomHF	RoomLF	DecTm	DcHF	DcLF	Refl	RefDel	Ref Pan				Revb	RevDel		Rev Pan				EchTm	EchDp	ModTm	ModDp	AirAbs	HFRef		LFRef	RRlOff	FLAGS
+#define EAX30_PRESET_ICEPALACE_ALCOVE \
+	{ 26,   2.7f,	0.840f, -1000,  -500,	-1100,  2.76f,	1.46f,	0.28f,  100,	0.010f, 0.00f,0.00f,0.00f,	-1200,	0.030f,		0.00f,0.00f,0.00f,	0.161f, 0.090f, 0.250f, 0.000f,	-0.0f,	12428.5f,	99.6f,  0.00f,	0x20 }
+#define EAX30_PRESET_ICEPALACE_SHORTPASSAGE \
+	{ 26,   2.7f,	0.750f, -1000,  -500,	-1100,  1.79f,	1.46f,	0.28f,  -600,	0.010f, 0.00f,0.00f,0.00f,	-700,	0.019f,		0.00f,0.00f,0.00f,	0.177f, 0.090f, 0.250f, 0.000f, -0.0f,	12428.5f,	99.6f,  0.00f,	0x20 }
+#define EAX30_PRESET_ICEPALACE_MEDIUMROOM \
+	{ 26,   2.7f,	0.870f, -1000,  -500,   -700,	2.22f,	1.53f,	0.32f,  -800,	0.039f, 0.00f,0.00f,0.00f,	-1200,	0.027f,		0.00f,0.00f,0.00f,	0.186f, 0.120f, 0.250f, 0.000f, -0.0f,	12428.5f,	99.6f,  0.00f,	0x20 }
+#define EAX30_PRESET_ICEPALACE_LONGPASSAGE \
+	{ 26,   2.7f,	0.770f, -1000,  -500,   -800,	3.01f,	1.46f,	0.28f,  -200,	0.012f, 0.00f,0.00f,0.00f,	-800,	0.025f,		0.00f,0.00f,0.00f,	0.186f, 0.040f, 0.250f, 0.000f, -0.0f,	12428.5f,	99.6f,  0.00f,	0x20 }
+#define EAX30_PRESET_ICEPALACE_LARGEROOM \
+	{ 26,   2.9f,	0.810f, -1000,  -500,   -700,	3.14f,	1.53f,	0.32f,  -1200,	0.039f, 0.00f,0.00f,0.00f,	-1300,	0.027f,		0.00f,0.00f,0.00f,	0.214f, 0.110f, 0.250f, 0.000f, -0.0f,	12428.5f,	99.6f,  0.00f,	0x20 }
+#define EAX30_PRESET_ICEPALACE_HALL \
+	{ 26,   2.9f,	0.760f, -1000,  -700,   -500,	5.49f,	1.53f,	0.38f,  -1900,	0.054f, 0.00f,0.00f,0.00f,	-1400,	0.052f,		0.00f,0.00f,0.00f,	0.226f, 0.110f, 0.250f, 0.000f, -0.0f,	12428.5f,	99.6f,  0.00f,	0x20 }
+#define EAX30_PRESET_ICEPALACE_CUPBOARD \
+	{ 26,   2.7f,	0.830f, -1000,  -600,	-1300,  0.76f,	1.53f,	0.26f,  100,	0.012f, 0.00f,0.00f,0.00f,	100,	0.016f,		0.00f,0.00f,0.00f,	0.143f, 0.080f, 0.250f, 0.000f, -0.0f,	12428.5f,	99.6f,  0.00f,	0x20 }
+#define EAX30_PRESET_ICEPALACE_COURTYARD \
+	{ 26,   2.9f,	0.590f, -1000,  -1100,  -1000,  2.04f,	1.20f,	0.38f,  -2000,	0.073f, 0.00f,0.00f,0.00f,	-2200,	0.043f,		0.00f,0.00f,0.00f,	0.235f, 0.480f, 0.250f, 0.000f, -0.0f,	12428.5f,	99.6f,  0.00f,	0x20 }
+#define EAX30_PRESET_ICEPALACE_SMALLROOM \
+	{ 26,   2.7f,	0.840f, -1000,  -500,	-1100,  1.51f,	1.53f,	0.27f,	-100,	0.010f, 0.00f,0.00f,0.00f,	-900,	0.011f,		0.00f,0.00f,0.00f,	0.164f, 0.140f, 0.250f, 0.000f, -0.0f,	12428.5f,	99.6f,  0.00f,	0x20 }
+
+// SPACE STATION PRESETS
+
+//	Env		Size	Diffus	Room	RoomHF	RoomLF	DecTm	DcHF	DcLF	Refl	RefDel	Ref Pan				Revb	RevDel		Rev Pan				EchTm	EchDp	ModTm	ModDp	AirAbs	HFRef		LFRef	RRlOff	FLAGS
+#define EAX30_PRESET_SPACESTATION_ALCOVE \
+	{ 26,   1.5f,	0.780f, -1100,  -300,   -100,	1.16f,	0.81f,	0.55f,  300,	0.007f, 0.00f,0.00f,0.00f,	-500,	0.018f,		0.00f,0.00f,0.00f,	0.192f, 0.210f, 0.250f, 0.000f,	-5.0f,  3316.1f,	458.2f,  0.00f, 0x20 }
+#define EAX30_PRESET_SPACESTATION_MEDIUMROOM \
+	{ 26,   1.5f,	0.750f, -1000,  -400,   -100,	3.01f,	0.50f,	0.55f,  -1000,	0.034f, 0.00f,0.00f,0.00f,	-700,	0.035f,		0.00f,0.00f,0.00f,	0.209f, 0.310f, 0.250f, 0.000f,	-5.0f,  3316.1f,	458.2f,  0.00f, 0x20 }
+#define EAX30_PRESET_SPACESTATION_SHORTPASSAGE \
+	{ 26,   1.5f,	0.870f, -1000,  -400,   -100,	3.57f,	0.50f,	0.55f,  0,		0.012f, 0.00f,0.00f,0.00f,	-600,	0.016f,		0.00f,0.00f,0.00f,	0.172f, 0.200f, 0.250f, 0.000f, -5.0f,  3316.1f,	458.2f,  0.00f, 0x20 }
+#define EAX30_PRESET_SPACESTATION_LONGPASSAGE \
+	{ 26,   1.9f,	0.820f, -1000,  -400,   -100,	4.62f,	0.62f,	0.55f,  0,		0.012f, 0.00f,0.00f,0.00f,	-800,	0.031f,		0.00f,0.00f,0.00f,	0.250f, 0.230f, 0.250f, 0.000f, -5.0f,  3316.1f,	458.2f,  0.00f, 0x20 }
+#define EAX30_PRESET_SPACESTATION_LARGEROOM \
+	{ 26,   1.8f,	0.810f, -1000,  -400,   -100,	3.89f,	0.38f,	0.61f,  -1200,	0.056f, 0.00f,0.00f,0.00f,	-800,	0.035f,		0.00f,0.00f,0.00f,	0.233f, 0.280f, 0.250f, 0.000f, -5.0f,  3316.1f,	458.2f,  0.00f, 0x20 }
+#define EAX30_PRESET_SPACESTATION_HALL \
+	{ 26,   1.9f,	0.870f, -1000,  -400,   -100,	7.11f,	0.38f,	0.61f,  -1500,	0.100f, 0.00f,0.00f,0.00f,	-1000,	0.047f,		0.00f,0.00f,0.00f,	0.250f, 0.250f, 0.250f, 0.000f, -5.0f,  3316.1f,	458.2f,  0.00f, 0x20 }
+#define EAX30_PRESET_SPACESTATION_CUPBOARD \
+	{ 26,   1.4f,	0.560f, -1000,  -300,   -100,	0.79f,	0.81f,	0.55f,  200,	0.007f, 0.00f,0.00f,0.00f,	400,	0.018f,		0.00f,0.00f,0.00f,	0.181f, 0.310f, 0.250f, 0.000f, -5.0f,  3316.1f,	458.2f,  0.00f, 0x20 }
+#define EAX30_PRESET_SPACESTATION_SMALLROOM \
+	{ 26,   1.5f,	0.700f, -1000,  -300,   -100,	1.72f,	0.82f,	0.55f,	-400,	0.007f, 0.00f,0.00f,0.00f,	-500,	0.013f,		0.00f,0.00f,0.00f,	0.188f, 0.260f, 0.250f, 0.000f, -5.0f,  3316.1f,	458.2f,  0.00f, 0x20 }
+
+// WOODEN GALLEON PRESETS
+
+//	Env		Size	Diffus	Room	RoomHF	RoomLF	DecTm	DcHF	DcLF	Refl	RefDel	Ref Pan				Revb	RevDel		Rev Pan				EchTm	EchDp	ModTm	ModDp	AirAbs	HFRef		LFRef	RRlOff	FLAGS
+#define EAX30_PRESET_WOODEN_ALCOVE \
+	{ 26,   7.5f,	1.000f, -1100,  -1800,  -1000,  1.22f,	0.62f,	0.91f,	-100,	0.012f, 0.00f,0.00f,0.00f,	-600,	0.024f,		0.00f,0.00f,0.00f,	0.250f, 0.000f, 0.250f, 0.000f, -5.0f,  4705.0f,	99.6f,  0.00f,	0x3f }
+#define EAX30_PRESET_WOODEN_SHORTPASSAGE \
+	{ 26,   7.5f,	1.000f, -1100,  -1800,  -1000,  1.45f,	0.50f,	0.87f,	-300,	0.012f, 0.00f,0.00f,0.00f,	-700,	0.024f,		0.00f,0.00f,0.00f,	0.250f, 0.000f, 0.250f, 0.000f, -5.0f,  4705.0f,	99.6f,  0.00f,	0x3f }
+#define EAX30_PRESET_WOODEN_MEDIUMROOM \
+	{ 26,   7.5f,	1.000f, -1200,  -2000,  -1100,  1.07f,	0.42f,	0.82f,	-300,	0.039f, 0.00f,0.00f,0.00f,	-400,	0.029f,		0.00f,0.00f,0.00f,	0.250f, 0.000f, 0.250f, 0.000f, -5.0f,  4705.0f,	99.6f,  0.00f,	0x3f }
+#define EAX30_PRESET_WOODEN_LONGPASSAGE \
+	{ 26,   7.5f,	1.000f, -1100,  -2000,  -1000,  1.79f,	0.40f,	0.79f,	-200,	0.020f, 0.00f,0.00f,0.00f,	-1000,	0.036f,		0.00f,0.00f,0.00f,	0.250f, 0.000f, 0.250f, 0.000f, -5.0f,  4705.0f,	99.6f,  0.00f,	0x3f }
+#define EAX30_PRESET_WOODEN_LARGEROOM \
+	{ 26,   7.5f,	1.000f, -1200,  -2100,  -1100,  1.45f,	0.33f,	0.82f,	-300,	0.056f, 0.00f,0.00f,0.00f,	-500,	0.049f,		0.00f,0.00f,0.00f,	0.250f, 0.000f, 0.250f, 0.000f, -5.0f,  4705.0f,	99.6f,  0.00f,	0x3f }
+#define EAX30_PRESET_WOODEN_HALL \
+	{ 26,   7.5f,	1.000f, -1200,  -2200,  -1100,  1.95f,	0.30f,	0.82f,	-300,	0.068f, 0.00f,0.00f,0.00f,	-500,	0.063f,		0.00f,0.00f,0.00f,	0.250f, 0.000f, 0.250f, 0.000f, -5.0f,  4705.0f,	99.6f,  0.00f,	0x3f }
+#define EAX30_PRESET_WOODEN_CUPBOARD \
+	{ 26,   7.5f,	1.000f, -1000,  -1700,  -1000,  0.56f,	0.46f,	0.91f,	-100,	0.012f, 0.00f,0.00f,0.00f,	-100,	0.028f,		0.00f,0.00f,0.00f,	0.250f, 0.000f, 0.250f, 0.000f, -5.0f,  4705.0f,	99.6f,  0.00f,	0x3f }
+#define EAX30_PRESET_WOODEN_SMALLROOM \
+	{ 26,   7.5f,	1.000f, -1200,  -1900,  -1000,  0.79f,	0.32f,	0.87f,	-200,	0.032f, 0.00f,0.00f,0.00f,	-300,	0.029f,		0.00f,0.00f,0.00f,	0.250f, 0.000f, 0.250f, 0.000f, -5.0f,  4705.0f,	99.6f,  0.00f,	0x3f }
+#define EAX30_PRESET_WOODEN_COURTYARD \
+	{ 26,   7.5f,	0.650f, -1700,  -2200,  -1000,  1.79f,	0.35f,	0.79f,	-700,	0.063f, 0.00f,0.00f,0.00f,	-2300,	0.032f,		0.00f,0.00f,0.00f,	0.250f, 0.000f, 0.250f, 0.000f, -5.0f,  4705.0f,	99.6f,  0.00f,	0x3f }
+
+
+// OTHER SCENARIOS
+
+// SPORTS PRESETS
+
+//	Env		Size	Diffus	Room	RoomHF	RoomLF	DecTm	DcHF	DcLF	Refl	RefDel	Ref Pan				Revb	RevDel		Rev Pan				EchTm	EchDp	ModTm	ModDp	AirAbs	HFRef		LFRef	RRlOff	FLAGS
+#define EAX30_PRESET_SPORT_EMPTYSTADIUM \
+	{ 26,   7.2f,	1.000f, -1300,  -700,   -200,	6.26f,	0.51f,	1.10f,  -2400,	0.183f, 0.00f,0.00f,0.00f,	-1100,	0.038f,		0.00f,0.00f,0.00f,	0.250f, 0.000f, 0.250f, 0.000f, -5.0f,  5000.0f,	250.0f,  0.00f, 0x20 }
+#define EAX30_PRESET_SPORT_SQUASHCOURT \
+	{ 26,   7.5f,	0.750f, -1100,  -1000,  -200,	2.22f,	0.91f,	1.16f,  -700,	0.007f, 0.00f,0.00f,0.00f,	-300,	0.011f,		0.00f,0.00f,0.00f,	0.126f, 0.190f, 0.250f, 0.000f, -0.0f,  7176.9f,	211.2f,  0.00f, 0x20 }
+#define EAX30_PRESET_SPORT_SMALLSWIMMINGPOOL \
+	{ 26,  36.2f,	0.700f, -1400,  -200,   -100,	2.76f,	1.25f,	1.14f,  -400,	0.020f, 0.00f,0.00f,0.00f,	-300,	0.030f,		0.00f,0.00f,0.00f,	0.179f, 0.150f, 0.895f, 0.190f, -5.0f,  5000.0f,	250.0f,  0.00f, 0x0 }
+#define EAX30_PRESET_SPORT_LARGESWIMMINGPOOL\
+	{ 26,  36.2f,	0.820f, -1200,  -200,   0,		5.49f,	1.31f,	1.14f,  -700,	0.039f, 0.00f,0.00f,0.00f,	-800,	0.049f,		0.00f,0.00f,0.00f,	0.222f, 0.550f, 1.159f, 0.210f, -5.0f,  5000.0f,	250.0f,  0.00f, 0x0 }
+#define EAX30_PRESET_SPORT_GYMNASIUM \
+	{ 26,   7.5f,	0.810f, -1200,  -700,   -100,	3.14f,	1.06f,	1.35f,  -800,	0.029f, 0.00f,0.00f,0.00f,	-700,	0.045f,		0.00f,0.00f,0.00f,	0.146f, 0.140f, 0.250f, 0.000f, -0.0f,  7176.9f,	211.2f,  0.00f, 0x20 }
+#define EAX30_PRESET_SPORT_FULLSTADIUM \
+	{ 26,   7.2f,	1.000f, -1300,  -2300,  -200,	5.25f,	0.17f,	0.80f,  -2000,	0.188f, 0.00f,0.00f,0.00f,	-1300,	0.038f,		0.00f,0.00f,0.00f,	0.250f, 0.000f, 0.250f, 0.000f, -5.0f,  5000.0f,	250.0f,  0.00f, 0x20 }
+#define EAX30_PRESET_SPORT_STADIUMTANNOY \
+	{ 26,   3.0f,	0.780f, -900,   -500,   -600,	2.53f,	0.88f,	0.68f,  -1100,	0.230f, 0.00f,0.00f,0.00f,	-600,	0.063f,		0.00f,0.00f,0.00f,	0.250f, 0.200f, 0.250f, 0.000f, -0.0f,  5000.0f,	250.0f,  0.00f, 0x20 }
+
+// PREFAB PRESETS
+
+//	Env		Size	Diffus	Room	RoomHF	RoomLF	DecTm	DcHF	DcLF	Refl	RefDel	Ref Pan				Revb	RevDel		Rev Pan				EchTm	EchDp	ModTm	ModDp	AirAbs	HFRef		LFRef	RRlOff	FLAGS
+#define EAX30_PRESET_PREFAB_WORKSHOP \
+	{ 26,   1.9f,	1.000f, -1000,  -1700,  -800,	0.76f,	1.00f,	1.00f,	0,		0.012f, 0.00f,0.00f,0.00f,	-200,	0.012f,		0.00f,0.00f,0.00f,	0.250f, 0.000f, 0.250f, 0.000f, -5.0f,  5000.0f,	250.0f,  0.00f, 0x0 }
+#define EAX30_PRESET_PREFAB_SCHOOLROOM \
+	{ 26,   1.86f,	0.690f, -1100,  -400,   -600,	0.98f,	0.45f,	0.18f,  300,	0.017f, 0.00f,0.00f,0.00f,  0,		0.015f,		0.00f,0.00f,0.00f,	0.095f, 0.140f, 0.250f, 0.000f, -0.0f,  7176.9f,	211.2f,  0.00f, 0x20 }
+#define EAX30_PRESET_PREFAB_PRACTISEROOM \
+	{ 26,   1.86f,	0.870f, -1000,  -800,   -600,	1.12f,	0.56f,	0.18f,  200,	0.010f, 0.00f,0.00f,0.00f,	-200,	0.011f,		0.00f,0.00f,0.00f,	0.095f, 0.140f, 0.250f, 0.000f, -0.0f,  7176.9f,	211.2f,  0.00f, 0x20 }
+#define EAX30_PRESET_PREFAB_OUTHOUSE \
+	{ 26,  80.3f,	0.820f, -1100,  -1900,  -1600,  1.38f,	0.38f,	0.35f,	-100,	0.024f, 0.00f,0.00f,-0.00f,	-800,	0.044f,		0.00f,0.00f,0.00f,	0.121f, 0.170f, 0.250f, 0.000f, -0.0f,  2854.4f,	107.5f,  0.00f, 0x0 }
+#define EAX30_PRESET_PREFAB_CARAVAN \
+	{ 26,   8.3f,	1.000f, -1000,  -2100,  -1800,  0.43f,	1.50f,	1.00f,  0,		0.012f, 0.00f,0.00f,0.00f,	400,	0.012f,		0.00f,0.00f,0.00f,	0.250f, 0.000f, 0.250f, 0.000f, -5.0f,  5000.0f,	250.0f,  0.00f, 0x1f }
+			// for US developers, a caravan is the same as a trailer =o)
+
+
+// DOME AND PIPE PRESETS
+
+//	Env		Size	Diffus	Room	RoomHF	RoomLF	DecTm	DcHF	DcLF	Refl	RefDel	Ref Pan				Revb	RevDel		Rev Pan				EchTm	EchDp	ModTm	ModDp	AirAbs	HFRef		LFRef	RRlOff	FLAGS
+#define EAX30_PRESET_DOME_TOMB \
+	{ 26,  51.8f,	0.790f, -1000,  -900,	-1300,  4.18f,	0.21f,	0.10f,  -825,	0.030f, 0.00f,0.00f,0.00f,	-125,	0.022f,		0.00f,0.00f,0.00f,	0.177f, 0.190f, 0.250f, 0.000f,	-5.0f,  2854.4f,	20.0f,  0.00f,	0x0 }
+#define EAX30_PRESET_PIPE_SMALL \
+	{ 26,  50.3f,	1.000f, -1000,  -900,	-1300,  5.04f,	0.10f,	0.10f,  -600,	0.032f, 0.00f,0.00f,0.00f,	400,	0.015f,		0.00f,0.00f,0.00f,	0.250f, 0.000f, 0.250f, 0.000f, -5.0f,  2854.4f,	20.0f,  0.00f,	0x3f }
+#define EAX30_PRESET_DOME_SAINTPAULS \
+	{ 26,  50.3f,	0.870f, -1000,  -900,	-1300,  10.48f,	0.19f,	0.10f,  -1500,	0.090f, 0.00f,0.00f,0.00f,	-500,	0.042f,		0.00f,0.00f,0.00f,	0.250f, 0.120f, 0.250f, 0.000f, -5.0f,  2854.4f,	20.0f,  0.00f,	0x3f }
+#define EAX30_PRESET_PIPE_LONGTHIN \
+	{ 26,   1.6f,	0.910f, -1200,  -700,	-1100,  9.21f,	0.18f,	0.10f,  -300,	0.010f, 0.00f,0.00f,0.00f,	-1000,	0.022f,		0.00f,0.00f,0.00f,	0.250f, 0.000f, 0.250f, 0.000f, -5.0f,  2854.4f,	20.0f,  0.00f,	0x0 }
+#define EAX30_PRESET_PIPE_LARGE \
+	{ 26,  50.3f,	1.000f, -1000,  -900,	-1300,  8.45f,	0.10f,	0.10f,  -800,	0.046f, 0.00f,0.00f,0.00f,  0,		0.032f,		0.00f,0.00f,0.00f,	0.250f, 0.000f, 0.250f, 0.000f, -5.0f,  2854.4f,	20.0f,  0.00f,	0x3f }
+#define EAX30_PRESET_PIPE_RESONANT \
+	{ 26,   1.3f,	0.910f, -1200,  -700,	-1100,  6.81f,	0.18f,	0.10f,  -300,	0.010f, 0.00f,0.00f,0.00f,	-700,	0.022f,		0.00f,0.00f,0.00f,	0.250f, 0.000f, 0.250f, 0.000f, -5.0f,  2854.4f,	20.0f,  0.00f,	0x0 }
+
+// OUTDOORS PRESETS
+
+//	Env		Size	Diffus	Room	RoomHF	RoomLF	DecTm	DcHF	DcLF	Refl	RefDel	Ref Pan				Revb	RevDel		Rev Pan				EchTm	EchDp	ModTm	ModDp	AirAbs	HFRef		LFRef	RRlOff	FLAGS
+#define EAX30_PRESET_OUTDOORS_BACKYARD \
+	{ 26,  80.3f,	0.450f,	-1100,  -1200,  -600,	1.12f,	0.34f,	0.46f,  -1100,	0.049f, 0.00f,0.00f,-0.00f,	-1300,	0.023f,		0.00f,0.00f,0.00f,	0.218f, 0.340f, 0.250f, 0.000f,	-5.0f,  4399.1f,	242.9f,  0.00f, 0x0 }
+#define EAX30_PRESET_OUTDOORS_ROLLINGPLAINS \
+	{ 26,  80.3f,	0.000f,	-1100,  -3900,  -400,	2.13f,	0.21f,	0.46f,  -2000,	0.300f, 0.00f,0.00f,-0.00f,	-1500,	0.019f,		0.00f,0.00f,0.00f,	0.250f, 1.000f, 0.250f, 0.000f, -5.0f,  4399.1f,	242.9f,  0.00f, 0x0 }
+#define EAX30_PRESET_OUTDOORS_DEEPCANYON \
+	{ 26,  80.3f,	0.740f,	-1100,  -1500,  -400,	3.89f,	0.21f,	0.46f,  -2000,	0.193f, 0.00f,0.00f,-0.00f,	-1100,	0.019f,		0.00f,0.00f,0.00f,	0.250f, 1.000f, 0.250f, 0.000f, -5.0f,  4399.1f,	242.9f,  0.00f, 0x0 }
+#define EAX30_PRESET_OUTDOORS_CREEK \
+	{ 26,  80.3f,	0.350f,	-1100,  -1500,  -600,	2.13f,	0.21f,	0.46f,  -1700,	0.115f, 0.00f,0.00f,-0.00f,	-1100,	0.031f,		0.00f,0.00f,0.00f,	0.218f, 0.340f, 0.250f, 0.000f, -5.0f,  4399.1f,	242.9f,  0.00f, 0x0 }
+#define EAX30_PRESET_OUTDOORS_VALLEY \
+	{ 26,  80.3f,	0.280f,	-1100,  -3100,	-1600,  2.88f,	0.26f,	0.35f,  -3200,	0.163f, 0.00f,0.00f,-0.00f,	-1000,	0.100f,		0.00f,0.00f,0.00f,	0.250f, 0.340f, 0.250f, 0.000f, -0.0f,  2854.4f,	107.5f,  0.00f, 0x0 }
+
+
+// MOOD PRESETS
+
+//	Env		Size	Diffus	Room	RoomHF	RoomLF	DecTm	DcHF	DcLF	Refl	RefDel	Ref Pan				Revb	RevDel		Rev Pan				EchTm	EchDp	ModTm	ModDp	AirAbs	HFRef		LFRef	RRlOff	FLAGS
+#define EAX30_PRESET_MOOD_HEAVEN \
+	{ 26,  19.6f,	0.940f,  -1000, -200,   -700,	5.04f,	1.12f,	0.56f,  -1230,	0.020f, 0.00f,0.00f,0.00f,	-200,	0.029f,		0.00f,0.00f,0.00f,	0.250f, 0.080f, 2.742f, 0.050f, -2.0f,  5000.0f,	250.0f,  0.00f, 0x3f }
+#define EAX30_PRESET_MOOD_HELL \
+	{ 26, 100.0f,	0.570f,  -1000, -900,   -700,	3.57f,	0.49f,	2.00f,	-10000, 0.020f, 0.00f,0.00f,0.00f,	100,	0.030f,		0.00f,0.00f,0.00f,	0.110f, 0.040f, 2.109f, 0.520f, -5.0f,  5000.0f,	139.5f,  0.00f, 0x40 }
+#define EAX30_PRESET_MOOD_MEMORY \
+	{ 26,   8.0f,	0.850f,  -1000, -400,   -900,	4.06f,	0.82f,	0.56f,  -2800,	0.000f, 0.00f,0.00f,0.00f,	-500,	0.000f,		0.00f,0.00f,0.00f,	0.250f, 0.000f, 0.474f, 0.450f, -2.0f,  5000.0f,	250.0f,  0.00f, 0x0 }
+
+// DRIVING SIMULATION PRESETS
+
+//	Env		Size	Diffus	Room	RoomHF	RoomLF	DecTm	DcHF	DcLF	Refl	RefDel	Ref Pan				Revb	RevDel		Rev Pan				EchTm	EchDp	ModTm	ModDp	AirAbs	HFRef		LFRef	RRlOff	FLAGS
+#define EAX30_PRESET_DRIVING_COMMENTATOR \
+	{ 26,   3.0f,	0.000f, -900,   -500,   -600,	2.42f,	0.88f,	0.68f,  -1400,	0.093f, 0.00f,0.00f,0.00f,	-1200,	0.017f,		0.00f,0.00f,0.00f,	0.250f, 1.000f, 0.250f, 0.000f, -0.0f,  5000.0f,	250.0f,  0.00f, 0x20 }
+#define EAX30_PRESET_DRIVING_PITGARAGE \
+	{ 26,   1.9f,	0.590f, -1400,  -300,   -500,	1.72f,	0.93f,	0.87f,  -500,	0.000f, 0.00f,0.00f,0.00f,	0,		0.016f,		0.00f,0.00f,0.00f,	0.250f, 0.110f, 0.250f, 0.000f, -5.0f,  5000.0f,	250.0f,  0.00f, 0x0 }
+#define EAX30_PRESET_DRIVING_INCAR_RACER \
+	{ 26,   1.1f,	0.800f, -700,   0,		-200,	0.17f,	2.00f,	0.41f,  500,	0.007f, 0.00f,0.00f,0.00f,	-500,	0.015f,		0.00f,0.00f,0.00f,	0.250f, 0.000f, 0.250f, 0.000f, -0.0f,	10268.2f,	251.0f,  0.00f, 0x20 }
+#define EAX30_PRESET_DRIVING_INCAR_SPORTS \
+	{ 26,   1.1f,	0.800f, -900,	-400,   0,		0.17f,	0.75f,	0.41f,  0,		0.010f, 0.00f,0.00f,0.00f,	-600,	0.000f,		0.00f,0.00f,0.00f,	0.250f, 0.000f, 0.250f, 0.000f, -0.0f,	10268.2f,	251.0f,  0.00f, 0x20 }
+#define EAX30_PRESET_DRIVING_INCAR_LUXURY \
+	{ 26,   1.6f,	1.000f, -800,	-2000,  -600,	0.13f,	0.41f,	0.46f,  -200,	0.010f, 0.00f,0.00f,0.00f,	300,	0.010f,		0.00f,0.00f,0.00f,	0.250f, 0.000f, 0.250f, 0.000f, -0.0f,	10268.2f,	251.0f,  0.00f, 0x20 }
+#define EAX30_PRESET_DRIVING_FULLGRANDSTAND \
+	{ 26,   8.3f,	1.000f, -1100,  -1100,  -400,	3.01f,	1.37f,	1.28f,  -900,	0.090f, 0.00f,0.00f,0.00f,	-1700,	0.049f,		0.00f,0.00f,0.00f,	0.250f, 0.000f, 0.250f, 0.000f, -5.0f,	10420.2f,	250.0f,  0.00f, 0x1f }
+#define EAX30_PRESET_DRIVING_EMPTYGRANDSTAND \
+	{ 26,   8.3f,	1.000f, -700,   0,		-200,	4.62f,	1.75f,	1.40f,  -1363,	0.090f, 0.00f,0.00f,0.00f,	-1900,	0.049f,		0.00f,0.00f,0.00f,	0.250f, 0.000f, 0.250f, 0.000f, -5.0f,	10420.2f,	250.0f,  0.00f, 0x1f }
+#define EAX30_PRESET_DRIVING_TUNNEL \
+	{ 26,   3.1f,	0.810f, -900,   -800,	-100,	3.42f,	0.94f,	1.31f,  -300,	0.051f, 0.00f,0.00f,0.00f,  -500,	0.047f,		0.00f,0.00f,0.00f,	0.214f, 0.050f, 0.250f, 0.000f, -0.0f,  5000.0f,	155.3f,  0.00f, 0x20 }
+
+// CITY PRESETS
+
+//	Env		Size	Diffus	Room	RoomHF	RoomLF	DecTm	DcHF	DcLF	Refl	RefDel	Ref Pan				Revb	RevDel		Rev Pan				EchTm	EchDp	ModTm	ModDp	AirAbs	HFRef		LFRef	RRlOff	FLAGS
+#define EAX30_PRESET_CITY_STREETS \
+	{ 26,   3.0f,	0.780f, -1100,  -300,   -100,	1.79f,	1.12f,	0.91f,  -1700,	0.046f, 0.00f,0.00f,0.00f,	-2800,	0.028f,		0.00f,0.00f,0.00f,	0.250f, 0.200f, 0.250f, 0.000f, -0.0f,  5000.0f,	250.0f,  0.00f, 0x20 }
+#define EAX30_PRESET_CITY_SUBWAY \
+	{ 26,   3.0f,	0.740f, -1100,  -300,   -100,	3.01f,	1.23f,	0.91f,   -700,	0.046f, 0.00f,0.00f,0.00f,	-1000,	0.028f,		0.00f,0.00f,0.00f,	0.125f, 0.210f, 0.250f, 0.000f, -0.0f,  5000.0f,	250.0f,  0.00f, 0x20 }
+#define EAX30_PRESET_CITY_MUSEUM \
+	{ 26,  80.3f,	0.820f, -1100,  -1500,  -1500,  3.28f,	1.40f,	0.57f,  -1600,	0.039f, 0.00f,0.00f,-0.00f, -600,	0.034f,		0.00f,0.00f,0.00f,	0.130f, 0.170f, 0.250f, 0.000f, -0.0f,  2854.4f,	107.5f,  0.00f, 0x0 }
+#define EAX30_PRESET_CITY_LIBRARY \
+	{ 26,  80.3f,	0.820f, -1100,  -1100,  -2100,  2.76f,	0.89f,	0.41f,  -1100,	0.029f, 0.00f,0.00f,-0.00f, -500,	0.020f,		0.00f,0.00f,0.00f,	0.130f, 0.170f, 0.250f, 0.000f, -0.0f,  2854.4f,	107.5f,  0.00f, 0x0 }
+#define EAX30_PRESET_CITY_UNDERPASS \
+	{ 26,   3.0f,	0.820f, -1500,  -700,   -100,	3.57f,	1.12f,	0.91f,  -1500,	0.059f, 0.00f,0.00f,0.00f,	-1100,	0.037f,		0.00f,0.00f,0.00f,	0.250f, 0.140f, 0.250f, 0.000f, -0.0f,  5000.0f,	250.0f,  0.00f, 0x20 }
+#define EAX30_PRESET_CITY_ABANDONED \
+	{ 26,   3.0f,	0.690f, -1100,  -200,   -100,	3.28f,	1.17f,	0.91f,  -1400,	0.044f, 0.00f,0.00f,0.00f,	-2400,	0.024f,		0.00f,0.00f,0.00f,	0.250f, 0.200f, 0.250f, 0.000f, -0.0f,  5000.0f,	250.0f,  0.00f, 0x20 }
+
+// MISC ROOMS
+
+//	Env		Size	Diffus	Room	RoomHF	RoomLF	DecTm	DcHF	DcLF	Refl	RefDel	Ref Pan				Revb	RevDel		Rev Pan				EchTm	EchDp	ModTm	ModDp	AirAbs	HFRef		LFRef	RRlOff	FLAGS
+#define EAX30_PRESET_DUSTYROOM  \
+	{ 26,   1.8f,	0.560f,	-1100,	-200,	-300,	1.79f,	0.38f,	0.21f,	-600,	0.002f,	0.00f,0.00f,0.00f,	200,	0.006f,		0.00f,0.00f,0.00f,	0.202f, 0.050f, 0.250f, 0.000f, -3.0f,  13046.0f,	163.3f,	0.00f,	0x20 }
+#define EAX30_PRESET_CHAPEL \
+	{ 26,  19.6f,	0.840f,	-1000,  -500,	0,		4.62f,	0.64f,	1.23f,  -700,	0.032f,	0.00f,0.00f,0.00f,	-800,	0.049f,		0.00f,0.00f,0.00f,	0.250f, 0.000f, 0.250f, 0.110f, -5.0f,  5000.0f,	250.0f, 0.00f,	0x3f }
+#define EAX30_PRESET_SMALLWATERROOM \
+	{ 26,  36.2f,	0.700f, -1200,  -698,   0,		1.51f,	1.25f,	1.14f,  -100,	0.020f, 0.00f,0.00f,0.00f,	200,	0.030f,		0.00f,0.00f,0.00f,	0.179f, 0.150f, 0.895f, 0.190f, -5.0f,  5000.0f,	250.0f, 0.00f, 0x0 }
+
+/********************************************************************************************************/
+
+//////////////////////////////////////////////////////
+// Effect Scenarios enumerated						//
+//////////////////////////////////////////////////////
+
+typedef enum
+{
+	EAX30_SCENARIO_CASTLE = 0,
+	EAX30_SCENARIO_FACTORY,
+	EAX30_SCENARIO_ICEPALACE,
+	EAX30_SCENARIO_SPACESTATION,
+	EAX30_SCENARIO_WOODGALLEON,
+	EAX30_SCENARIO_SPORTS,
+	EAX30_SCENARIO_PREFAB,
+	EAX30_SCENARIO_DOMESNPIPES,
+	EAX30_SCENARIO_OUTDOORS,
+	EAX30_SCENARIO_MOOD,
+	EAX30_SCENARIO_DRIVING,
+	EAX30_SCENARIO_CITY,
+	EAX30_SCENARIO_MISC,
+	EAX30_SCENARIO_ORIGINAL
+}
+EAX30_SCENARIO;
+
+//////////////////////////////////////////////////////
+// Number of Effect Scenarios						//
+//////////////////////////////////////////////////////
+
+#define EAX30_NUM_SCENARIOS					14
+
+//////////////////////////////////////////////////////
+// Number of Effect Scenarios with standardised		//
+// locations										//
+//////////////////////////////////////////////////////
+
+#define EAX30_NUM_STANDARD_SCENARIOS		5
+
+//////////////////////////////////////////////////////
+// Array of scenario names							//
+//////////////////////////////////////////////////////
+
+extern char* EAX30_SCENARIO_NAMES[];
+
+//////////////////////////////////////////////////////
+// Standardised Locations enumerated				//
+//////////////////////////////////////////////////////
+
+typedef enum 
+{
+	EAX30_LOCATION_HALL = 0,
+	EAX30_LOCATION_LARGEROOM,
+	EAX30_LOCATION_MEDIUMROOM,
+	EAX30_LOCATION_SMALLROOM,
+	EAX30_LOCATION_CUPBOARD,
+	EAX30_LOCATION_ALCOVE,
+	EAX30_LOCATION_LONGPASSAGE,
+	EAX30_LOCATION_SHORTPASSAGE,
+	EAX30_LOCATION_COURTYARD
+}
+EAX30_LOCATION;
+
+//////////////////////////////////////////////////////
+// Number of Standardised Locations					//
+//////////////////////////////////////////////////////
+
+#define EAX30_NUM_LOCATIONS						9
+
+//////////////////////////////////////////////////////
+// Array of standardised location names				//
+//////////////////////////////////////////////////////
+
+extern char* EAX30_LOCATION_NAMES[];
+
+//////////////////////////////////////////////////////
+// Number of effects in each scenario				//
+//////////////////////////////////////////////////////
+
+#define EAX30_NUM_ORIGINAL_PRESETS		26
+#define EAX30_NUM_CASTLE_PRESETS		EAX30_NUM_LOCATIONS
+#define EAX30_NUM_FACTORY_PRESETS		EAX30_NUM_LOCATIONS
+#define EAX30_NUM_ICEPALACE_PRESETS		EAX30_NUM_LOCATIONS
+#define EAX30_NUM_SPACESTATION_PRESETS	EAX30_NUM_LOCATIONS
+#define EAX30_NUM_WOODGALLEON_PRESETS	EAX30_NUM_LOCATIONS
+#define EAX30_NUM_SPORTS_PRESETS		7
+#define EAX30_NUM_PREFAB_PRESETS		5
+#define EAX30_NUM_DOMESNPIPES_PRESETS	6
+#define EAX30_NUM_OUTDOORS_PRESETS		5
+#define EAX30_NUM_MOOD_PRESETS			3
+#define EAX30_NUM_DRIVING_PRESETS		8
+#define EAX30_NUM_CITY_PRESETS			6
+#define EAX30_NUM_MISC_PRESETS			3
+
+//////////////////////////////////////////////////////
+// Standardised Location effects can be accessed	//
+// from a matrix									//
+//////////////////////////////////////////////////////
+
+extern EAXLISTENERPROPERTIES EAX30_STANDARD_PRESETS[EAX30_NUM_STANDARD_SCENARIOS][EAX30_NUM_LOCATIONS];
+
+/********************************************************************************************************/
+
+//////////////////////////////////////////////////////
+// Original Preset effects enumerated				//
+//////////////////////////////////////////////////////
+
+typedef enum
+{
+	ORIGINAL_GENERIC = 0,
+	ORIGINAL_PADDEDCELL,
+	ORIGINAL_ROOM,
+	ORIGINAL_BATHROOM,
+	ORIGINAL_LIVINGROOM,
+	ORIGINAL_STONEROOM,
+	ORIGINAL_AUDITORIUM,
+	ORIGINAL_CONCERTHALL,
+	ORIGINAL_CAVE,
+	ORIGINAL_ARENA,
+	ORIGINAL_HANGAR,
+	ORIGINAL_CARPETTEDHALLWAY,
+	ORIGINAL_HALLWAY,
+	ORIGINAL_STONECORRIDOR,
+	ORIGINAL_ALLEY,
+	ORIGINAL_FOREST,
+	ORIGINAL_CITY,
+	ORIGINAL_MOUNTAINS,
+	ORIGINAL_QUARRY,
+	ORIGINAL_PLAIN,
+	ORIGINAL_PARKINGLOT,
+	ORIGINAL_SEWERPIPE,
+	ORIGINAL_UNDERWATER,
+	ORIGINAL_DRUGGED,
+	ORIGINAL_DIZZY,
+	ORIGINAL_PSYCHOTIC
+}
+EAX30_ORIGINAL_PRESET_ENUMS;
+
+//////////////////////////////////////////////////////
+// Array of original environment names				//
+//////////////////////////////////////////////////////
+
+extern char* EAX30_ORIGINAL_PRESET_NAMES[];
+
+//////////////////////////////////////////////////////
+// Original effects matrix							//
+//////////////////////////////////////////////////////
+
+extern EAXLISTENERPROPERTIES EAX30_ORIGINAL_PRESETS[];
+
+/********************************************************************************************************/
+
+//////////////////////////////////////////////////////
+// Sports scenario effects enumerated				//
+//////////////////////////////////////////////////////
+
+typedef enum
+{
+	SPORT_EMPTYSTADIUM=0,
+	SPORT_FULLSTADIUM,
+	SPORT_STADIUMTANNOY,
+	SPORT_SQUASHCOURT,
+	SPORT_SMALLSWIMMINGPOOL,
+	SPORT_LARGESWIMMINGPOOL,
+	SPORT_GYMNASIUM
+}
+EAX30_SPORTS_PRESET_ENUMS;
+
+//////////////////////////////////////////////////////
+// Array of sport environment names					//
+//////////////////////////////////////////////////////
+
+extern char* EAX30_SPORTS_PRESET_NAMES[];
+
+//////////////////////////////////////////////////////
+// Sports effects matrix							//
+//////////////////////////////////////////////////////
+
+extern EAXLISTENERPROPERTIES EAX30_SPORTS_PRESETS[];
+
+/********************************************************************************************************/
+
+//////////////////////////////////////////////////////
+// Prefab scenario effects enumerated				//
+//////////////////////////////////////////////////////
+
+typedef enum
+{
+	PREFAB_WORKSHOP,
+	PREFAB_SCHOOLROOM,
+	PREFAB_PRACTISEROOM,
+	PREFAB_OUTHOUSE,
+	PREFAB_CARAVAN
+}
+EAX30_PREFAB_PRESET_ENUMS;
+
+//////////////////////////////////////////////////////
+// Array of prefab environment names				//
+//////////////////////////////////////////////////////
+
+char* EAX30_PREFAB_PRESET_NAMES[];
+
+//////////////////////////////////////////////////////
+// Prefab effects matrix							//
+//////////////////////////////////////////////////////
+
+extern EAXLISTENERPROPERTIES EAX30_PREFAB_PRESETS[];
+
+/********************************************************************************************************/
+
+//////////////////////////////////////////////////////
+// Domes & Pipes effects enumerated					//
+//////////////////////////////////////////////////////
+
+typedef enum
+{
+	DOME_TOMB,
+	DOME_SAINTPAULS,
+	PIPE_SMALL,
+	PIPE_LONGTHIN,
+	PIPE_LARGE,
+	PIPE_RESONANT
+}
+EAX30_DOMESNPIPES_PRESET_ENUMS;
+
+//////////////////////////////////////////////////////
+// Array of Domes & Pipes environment names			//
+//////////////////////////////////////////////////////
+
+extern char* EAX30_DOMESNPIPES_PRESET_NAMES[];
+
+//////////////////////////////////////////////////////
+// Domes & Pipes effects matrix						//
+//////////////////////////////////////////////////////
+
+extern EAXLISTENERPROPERTIES EAX30_DOMESNPIPES_PRESETS[];
+
+/********************************************************************************************************/
+
+//////////////////////////////////////////////////////
+// Outdoors scenario effects enumerated				//
+//////////////////////////////////////////////////////
+
+typedef enum
+{
+	OUTDOORS_BACKYARD,
+	OUTDOORS_ROLLINGPLAINS,
+	OUTDOORS_DEEPCANYON,
+	OUTDOORS_CREEK,
+	OUTDOORS_VALLEY
+}
+EAX30_OUTDOORS_PRESET_ENUMS;
+
+//////////////////////////////////////////////////////
+// Array of Outdoors environment names				//
+//////////////////////////////////////////////////////
+
+extern char* EAX30_OUTDOORS_PRESET_NAMES[];
+
+//////////////////////////////////////////////////////
+// Outdoors effects matrix							//
+//////////////////////////////////////////////////////
+
+extern EAXLISTENERPROPERTIES EAX30_OUTDOORS_PRESETS[];
+
+/********************************************************************************************************/
+
+//////////////////////////////////////////////////////
+// Mood scenario effects enumerated					//
+//////////////////////////////////////////////////////
+
+typedef enum
+{
+	MOOD_HEAVEN,
+	MOOD_HELL,
+	MOOD_MEMORY
+}
+EAX30_MOOD_PRESET_ENUMS;
+
+//////////////////////////////////////////////////////
+// Array of Mood environment names					//
+//////////////////////////////////////////////////////
+
+extern char* EAX30_MOOD_PRESET_NAMES[];
+
+//////////////////////////////////////////////////////
+// Mood effects matrix								//
+//////////////////////////////////////////////////////
+
+extern EAXLISTENERPROPERTIES EAX30_MOOD_PRESETS[];
+
+/********************************************************************************************************/
+
+//////////////////////////////////////////////////////
+// Driving scenario effects enumerated				//
+//////////////////////////////////////////////////////
+
+typedef enum
+{
+	DRIVING_COMMENTATOR,
+	DRIVING_PITGARAGE,
+	DRIVING_INCAR_RACER,
+	DRIVING_INCAR_SPORTS,
+	DRIVING_INCAR_LUXURY,
+	DRIVING_FULLGRANDSTAND,
+	DRIVING_EMPTYGRANDSTAND,
+	DRIVING_TUNNEL
+}
+EAX30_DRIVING_PRESET_ENUMS;
+
+//////////////////////////////////////////////////////
+// Array of driving environment names				//
+//////////////////////////////////////////////////////
+
+extern char* EAX30_DRIVING_PRESET_NAMES[];
+
+//////////////////////////////////////////////////////
+// Driving effects matrix							//
+//////////////////////////////////////////////////////
+
+extern EAXLISTENERPROPERTIES EAX30_DRIVING_PRESETS[];
+
+/********************************************************************************************************/
+
+//////////////////////////////////////////////////////
+// City scenario effects enumerated					//
+//////////////////////////////////////////////////////
+
+typedef enum
+{
+	CITY_STREETS,
+	CITY_SUBWAY,
+	CITY_MUSEUM,
+	CITY_LIBRARY,
+	CITY_UNDERPASS,
+	CITY_ABANDONED
+}
+EAX30_CITY_PRESET_ENUMS;
+
+//////////////////////////////////////////////////////
+// Array of City environment names					//
+//////////////////////////////////////////////////////
+
+extern char* EAX30_CITY_PRESET_NAMES[];
+
+//////////////////////////////////////////////////////
+// City effects matrix								//
+//////////////////////////////////////////////////////
+
+extern EAXLISTENERPROPERTIES EAX30_CITY_PRESETS[];
+
+/********************************************************************************************************/
+
+//////////////////////////////////////////////////////
+// Misc scenario effects enumerated					//
+//////////////////////////////////////////////////////
+
+typedef enum
+{
+	DUSTYROOM,
+	CHAPEL,
+	SMALLWATERROOM
+}
+EAX30_MISC_PRESET_ENUMS;
+
+
+//////////////////////////////////////////////////////
+// Array of Misc environment names					//
+//////////////////////////////////////////////////////
+
+extern char* EAX30_MISC_PRESET_NAMES[];
+
+//////////////////////////////////////////////////////
+// Misc effects matrix								//
+//////////////////////////////////////////////////////
+
+extern EAXLISTENERPROPERTIES EAX30_MISC_PRESETS[];
+
+
+/***********************************************************************************************\
+*
+* Material transmission presets
+*
+* Three values in this order :-
+*
+*	1. Occlusion (or Obstruction)
+*	2. Occlusion LF Ratio (or Obstruction LF Ratio)
+*	3. Occlusion Room Ratio
+*
+************************************************************************************************/
+
+
+// Single window material preset
+#define EAX_MATERIAL_SINGLEWINDOW          (-2800)
+#define EAX_MATERIAL_SINGLEWINDOWLF        0.71f
+#define EAX_MATERIAL_SINGLEWINDOWROOMRATIO 0.43f
+
+// Double window material preset
+#define EAX_MATERIAL_DOUBLEWINDOW          (-5000)
+#define EAX_MATERIAL_DOUBLEWINDOWLF        0.40f
+#define EAX_MATERIAL_DOUBLEWINDOWROOMRATIO 0.24f
+
+// Thin door material preset
+#define EAX_MATERIAL_THINDOOR              (-1800)
+#define EAX_MATERIAL_THINDOORLF            0.66f
+#define EAX_MATERIAL_THINDOORROOMRATIO     0.66f
+
+// Thick door material preset
+#define EAX_MATERIAL_THICKDOOR             (-4400)
+#define EAX_MATERIAL_THICKDOORLF           0.64f
+#define EAX_MATERIAL_THICKDOORROOMRATIO	   0.27f
+
+// Wood wall material preset
+#define EAX_MATERIAL_WOODWALL              (-4000)
+#define EAX_MATERIAL_WOODWALLLF            0.50f
+#define EAX_MATERIAL_WOODWALLROOMRATIO     0.30f
+
+// Brick wall material preset
+#define EAX_MATERIAL_BRICKWALL             (-5000)
+#define EAX_MATERIAL_BRICKWALLLF           0.60f
+#define EAX_MATERIAL_BRICKWALLROOMRATIO    0.24f
+
+// Stone wall material preset
+#define EAX_MATERIAL_STONEWALL             (-6000)
+#define EAX_MATERIAL_STONEWALLLF           0.68f
+#define EAX_MATERIAL_STONEWALLROOMRATIO    0.20f
+
+// Curtain material preset
+#define EAX_MATERIAL_CURTAIN               (-1200)
+#define EAX_MATERIAL_CURTAINLF             0.15f
+#define EAX_MATERIAL_CURTAINROOMRATIO      1.00f
+
+
+#endif // EAXUTIL_INCLUDED
diff --git a/eax/eax.h b/eax/eax.h
new file mode 100644
index 00000000..ecc93c15
--- /dev/null
+++ b/eax/eax.h
@@ -0,0 +1,535 @@
+/*******************************************************************\
+*																	*
+*  EAX.H - Environmental Audio Extensions version 3.0				*
+*          for OpenAL and DirectSound3D								*
+*																	*
+********************************************************************/
+
+#ifndef EAX_H_INCLUDED
+#define EAX_H_INCLUDED
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+#ifndef OPENAL
+	#include <dsound.h>
+
+	/*
+	 * EAX Wrapper Interface (using Direct X 7) {4FF53B81-1CE0-11d3-AAB8-00A0C95949D5}
+	 */
+	DEFINE_GUID(CLSID_EAXDirectSound, 
+    	0x4ff53b81, 
+    	0x1ce0, 
+    	0x11d3,
+    	0xaa, 0xb8, 0x0, 0xa0, 0xc9, 0x59, 0x49, 0xd5);
+    	
+   /*
+	* EAX Wrapper Interface (using Direct X 8) {CA503B60-B176-11d4-A094-D0C0BF3A560C}
+	*/
+	DEFINE_GUID(CLSID_EAXDirectSound8, 
+		0xca503b60,
+		0xb176,
+		0x11d4,
+		0xa0, 0x94, 0xd0, 0xc0, 0xbf, 0x3a, 0x56, 0xc);
+
+	
+
+#ifdef DIRECTSOUND_VERSION		
+#if DIRECTSOUND_VERSION >= 0x0800
+	__declspec(dllimport) HRESULT WINAPI EAXDirectSoundCreate8(GUID*, LPDIRECTSOUND8*, IUnknown FAR *);
+	typedef HRESULT (FAR PASCAL *LPEAXDIRECTSOUNDCREATE8)(GUID*, LPDIRECTSOUND8*, IUnknown FAR*);
+#endif
+#endif
+	
+	__declspec(dllimport) HRESULT WINAPI EAXDirectSoundCreate(GUID*, LPDIRECTSOUND*, IUnknown FAR *);
+	typedef HRESULT (FAR PASCAL *LPEAXDIRECTSOUNDCREATE)(GUID*, LPDIRECTSOUND*, IUnknown FAR*);
+
+	__declspec(dllimport) void CDECL GetCurrentVersion(LPDWORD major, LPDWORD minor);
+    typedef void (CDECL *LPGETCURRENTVERSION)(LPDWORD major, LPDWORD minor);
+
+
+#else // OPENAL
+	#include <al.h>
+	
+	#ifndef GUID_DEFINED
+		#define GUID_DEFINED
+		typedef struct _GUID
+		{
+			unsigned long Data1;
+			unsigned short Data2;
+			unsigned short Data3;
+			unsigned char Data4[8];
+		} GUID;
+	#endif // !GUID_DEFINED
+
+	#ifndef DEFINE_GUID
+		#ifndef INITGUID
+			#define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
+					extern const GUID /*FAR*/ name
+		#else
+			#define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
+					extern const GUID name = { l, w1, w2, { b1, b2,  b3,  b4,  b5,  b6,  b7,  b8 } }
+		#endif // INITGUID
+	#endif // DEFINE_GUID
+	
+
+	/*
+	 * EAX OpenAL Extension
+	 */
+	typedef ALenum (*EAXSet)(const GUID*, ALuint, ALuint, ALvoid*, ALuint);
+	typedef ALenum (*EAXGet)(const GUID*, ALuint, ALuint, ALvoid*, ALuint);
+#endif
+
+#pragma pack(push, 4)
+
+/*
+ * EAX 3.0 listener property set {A8FA6880-B476-11d3-BDB9-00C0F02DDF87}
+ */
+DEFINE_GUID(DSPROPSETID_EAX30_ListenerProperties, 
+	0xa8fa6882, 
+	0xb476, 
+	0x11d3, 
+	0xbd, 0xb9, 0x00, 0xc0, 0xf0, 0x2d, 0xdf, 0x87);
+
+// For compatibility with future EAX versions:
+#define DSPROPSETID_EAX_ListenerProperties DSPROPSETID_EAX30_ListenerProperties
+
+typedef enum
+{
+    DSPROPERTY_EAXLISTENER_NONE,
+    DSPROPERTY_EAXLISTENER_ALLPARAMETERS,
+    DSPROPERTY_EAXLISTENER_ENVIRONMENT,
+    DSPROPERTY_EAXLISTENER_ENVIRONMENTSIZE,
+    DSPROPERTY_EAXLISTENER_ENVIRONMENTDIFFUSION,
+    DSPROPERTY_EAXLISTENER_ROOM,
+    DSPROPERTY_EAXLISTENER_ROOMHF,
+    DSPROPERTY_EAXLISTENER_ROOMLF,
+    DSPROPERTY_EAXLISTENER_DECAYTIME,
+    DSPROPERTY_EAXLISTENER_DECAYHFRATIO,
+    DSPROPERTY_EAXLISTENER_DECAYLFRATIO,
+    DSPROPERTY_EAXLISTENER_REFLECTIONS,
+    DSPROPERTY_EAXLISTENER_REFLECTIONSDELAY,
+    DSPROPERTY_EAXLISTENER_REFLECTIONSPAN,
+    DSPROPERTY_EAXLISTENER_REVERB,
+    DSPROPERTY_EAXLISTENER_REVERBDELAY,
+    DSPROPERTY_EAXLISTENER_REVERBPAN,
+    DSPROPERTY_EAXLISTENER_ECHOTIME,
+    DSPROPERTY_EAXLISTENER_ECHODEPTH,
+    DSPROPERTY_EAXLISTENER_MODULATIONTIME,
+    DSPROPERTY_EAXLISTENER_MODULATIONDEPTH,
+    DSPROPERTY_EAXLISTENER_AIRABSORPTIONHF,
+    DSPROPERTY_EAXLISTENER_HFREFERENCE,
+    DSPROPERTY_EAXLISTENER_LFREFERENCE,
+    DSPROPERTY_EAXLISTENER_ROOMROLLOFFFACTOR,
+    DSPROPERTY_EAXLISTENER_FLAGS
+} DSPROPERTY_EAX_LISTENERPROPERTY;
+
+// OR these flags with property id
+#define DSPROPERTY_EAXLISTENER_IMMEDIATE 0x00000000 // changes take effect immediately
+#define DSPROPERTY_EAXLISTENER_DEFERRED  0x80000000 // changes take effect later
+#define DSPROPERTY_EAXLISTENER_COMMITDEFERREDSETTINGS (DSPROPERTY_EAXLISTENER_NONE | \
+                                                       DSPROPERTY_EAXLISTENER_IMMEDIATE)
+
+typedef struct _EAXVECTOR {
+	float x;
+	float y;
+	float z;
+} EAXVECTOR;
+
+// Use this structure for DSPROPERTY_EAXLISTENER_ALLPARAMETERS
+// - all levels are hundredths of decibels
+// - all times and delays are in seconds
+//
+// NOTE: This structure may change in future EAX versions.
+//       It is recommended to initialize fields by name:
+//              myListener.lRoom = -1000;
+//              myListener.lRoomHF = -100;
+//              ...
+//              myListener.dwFlags = myFlags /* see EAXLISTENERFLAGS below */ ;
+//       instead of:
+//              myListener = { -1000, -100, ... , 0x00000009 };
+//       If you want to save and load presets in binary form, you 
+//       should define your own structure to insure future compatibility.
+//
+typedef struct _EAXLISTENERPROPERTIES
+{
+    unsigned long ulEnvironment;   // sets all listener properties
+    float flEnvironmentSize;       // environment size in meters
+    float flEnvironmentDiffusion;  // environment diffusion
+    long lRoom;                    // room effect level (at mid frequencies)
+    long lRoomHF;                  // relative room effect level at high frequencies
+    long lRoomLF;                  // relative room effect level at low frequencies  
+    float flDecayTime;             // reverberation decay time at mid frequencies
+    float flDecayHFRatio;          // high-frequency to mid-frequency decay time ratio
+    float flDecayLFRatio;          // low-frequency to mid-frequency decay time ratio   
+    long lReflections;             // early reflections level relative to room effect
+    float flReflectionsDelay;      // initial reflection delay time
+    EAXVECTOR vReflectionsPan;     // early reflections panning vector
+    long lReverb;                  // late reverberation level relative to room effect
+    float flReverbDelay;           // late reverberation delay time relative to initial reflection
+    EAXVECTOR vReverbPan;          // late reverberation panning vector
+    float flEchoTime;              // echo time
+    float flEchoDepth;             // echo depth
+    float flModulationTime;        // modulation time
+    float flModulationDepth;       // modulation depth
+    float flAirAbsorptionHF;       // change in level per meter at high frequencies
+    float flHFReference;           // reference high frequency
+    float flLFReference;           // reference low frequency 
+    float flRoomRolloffFactor;     // like DS3D flRolloffFactor but for room effect
+    unsigned long ulFlags;         // modifies the behavior of properties
+} EAXLISTENERPROPERTIES, *LPEAXLISTENERPROPERTIES;
+
+// used by DSPROPERTY_EAXLISTENER_ENVIRONMENT
+enum
+{
+    EAX_ENVIRONMENT_GENERIC,
+    EAX_ENVIRONMENT_PADDEDCELL,
+    EAX_ENVIRONMENT_ROOM,
+    EAX_ENVIRONMENT_BATHROOM,
+    EAX_ENVIRONMENT_LIVINGROOM,
+    EAX_ENVIRONMENT_STONEROOM,
+    EAX_ENVIRONMENT_AUDITORIUM,
+    EAX_ENVIRONMENT_CONCERTHALL,
+    EAX_ENVIRONMENT_CAVE,
+    EAX_ENVIRONMENT_ARENA,
+    EAX_ENVIRONMENT_HANGAR,
+    EAX_ENVIRONMENT_CARPETEDHALLWAY,
+    EAX_ENVIRONMENT_HALLWAY,
+    EAX_ENVIRONMENT_STONECORRIDOR,
+    EAX_ENVIRONMENT_ALLEY,
+    EAX_ENVIRONMENT_FOREST,
+    EAX_ENVIRONMENT_CITY,
+    EAX_ENVIRONMENT_MOUNTAINS,
+    EAX_ENVIRONMENT_QUARRY,
+    EAX_ENVIRONMENT_PLAIN,
+    EAX_ENVIRONMENT_PARKINGLOT,
+    EAX_ENVIRONMENT_SEWERPIPE,
+    EAX_ENVIRONMENT_UNDERWATER,
+    EAX_ENVIRONMENT_DRUGGED,
+    EAX_ENVIRONMENT_DIZZY,
+    EAX_ENVIRONMENT_PSYCHOTIC,
+
+    EAX_ENVIRONMENT_UNDEFINED,
+
+    EAX_ENVIRONMENT_COUNT
+};
+
+// Used by DSPROPERTY_EAXLISTENER_FLAGS
+//
+// Note: The number and order of flags may change in future EAX versions.
+//       It is recommended to use the flag defines as follows:
+//              myFlags = EAXLISTENERFLAGS_DECAYTIMESCALE | EAXLISTENERFLAGS_REVERBSCALE;
+//       instead of:
+//              myFlags = 0x00000009;
+//
+// These flags determine what properties are affected by environment size.
+#define EAXLISTENERFLAGS_DECAYTIMESCALE        0x00000001 // reverberation decay time
+#define EAXLISTENERFLAGS_REFLECTIONSSCALE      0x00000002 // reflection level
+#define EAXLISTENERFLAGS_REFLECTIONSDELAYSCALE 0x00000004 // initial reflection delay time
+#define EAXLISTENERFLAGS_REVERBSCALE           0x00000008 // reflections level
+#define EAXLISTENERFLAGS_REVERBDELAYSCALE      0x00000010 // late reverberation delay time
+#define EAXLISTENERFLAGS_ECHOTIMESCALE         0x00000040 // echo time
+#define EAXLISTENERFLAGS_MODULATIONTIMESCALE   0x00000080 // modulation time
+
+// This flag limits high-frequency decay time according to air absorption.
+#define EAXLISTENERFLAGS_DECAYHFLIMIT          0x00000020
+ 
+#define EAXLISTENERFLAGS_RESERVED              0xFFFFFF00 // reserved future use
+
+// Property ranges and defaults:
+
+#define EAXLISTENER_MINENVIRONMENT                0
+#define EAXLISTENER_MAXENVIRONMENT                (EAX_ENVIRONMENT_COUNT-1)
+#define EAXLISTENER_DEFAULTENVIRONMENT            EAX_ENVIRONMENT_GENERIC
+
+#define EAXLISTENER_MINENVIRONMENTSIZE            1.0f
+#define EAXLISTENER_MAXENVIRONMENTSIZE            100.0f
+#define EAXLISTENER_DEFAULTENVIRONMENTSIZE        7.5f
+
+#define EAXLISTENER_MINENVIRONMENTDIFFUSION       0.0f
+#define EAXLISTENER_MAXENVIRONMENTDIFFUSION       1.0f
+#define EAXLISTENER_DEFAULTENVIRONMENTDIFFUSION   1.0f
+
+#define EAXLISTENER_MINROOM                       (-10000)
+#define EAXLISTENER_MAXROOM                       0
+#define EAXLISTENER_DEFAULTROOM                   (-1000)
+
+#define EAXLISTENER_MINROOMHF                     (-10000)
+#define EAXLISTENER_MAXROOMHF                     0
+#define EAXLISTENER_DEFAULTROOMHF                 (-100)
+
+#define EAXLISTENER_MINROOMLF                     (-10000)
+#define EAXLISTENER_MAXROOMLF                     0
+#define EAXLISTENER_DEFAULTROOMLF                 0
+
+#define EAXLISTENER_MINDECAYTIME                  0.1f
+#define EAXLISTENER_MAXDECAYTIME                  20.0f
+#define EAXLISTENER_DEFAULTDECAYTIME              1.49f
+
+#define EAXLISTENER_MINDECAYHFRATIO               0.1f
+#define EAXLISTENER_MAXDECAYHFRATIO               2.0f
+#define EAXLISTENER_DEFAULTDECAYHFRATIO           0.83f
+
+#define EAXLISTENER_MINDECAYLFRATIO               0.1f
+#define EAXLISTENER_MAXDECAYLFRATIO               2.0f
+#define EAXLISTENER_DEFAULTDECAYLFRATIO           1.00f
+
+#define EAXLISTENER_MINREFLECTIONS                (-10000)
+#define EAXLISTENER_MAXREFLECTIONS                1000
+#define EAXLISTENER_DEFAULTREFLECTIONS            (-2602)
+
+#define EAXLISTENER_MINREFLECTIONSDELAY           0.0f
+#define EAXLISTENER_MAXREFLECTIONSDELAY           0.3f
+#define EAXLISTENER_DEFAULTREFLECTIONSDELAY       0.007f
+
+#define EAXLISTENER_MINREVERB                     (-10000)
+#define EAXLISTENER_MAXREVERB                     2000
+#define EAXLISTENER_DEFAULTREVERB                 200
+
+#define EAXLISTENER_MINREVERBDELAY                0.0f
+#define EAXLISTENER_MAXREVERBDELAY                0.1f
+#define EAXLISTENER_DEFAULTREVERBDELAY            0.011f
+
+#define EAXLISTENER_MINECHOTIME                   0.075f
+#define EAXLISTENER_MAXECHOTIME	                  0.25f
+#define EAXLISTENER_DEFAULTECHOTIME               0.25f
+
+#define EAXLISTENER_MINECHODEPTH                  0.0f
+#define EAXLISTENER_MAXECHODEPTH                  1.0f
+#define EAXLISTENER_DEFAULTECHODEPTH              0.0f
+
+#define EAXLISTENER_MINMODULATIONTIME             0.04f
+#define EAXLISTENER_MAXMODULATIONTIME             4.0f
+#define EAXLISTENER_DEFAULTMODULATIONTIME         0.25f
+
+#define EAXLISTENER_MINMODULATIONDEPTH            0.0f
+#define EAXLISTENER_MAXMODULATIONDEPTH            1.0f
+#define EAXLISTENER_DEFAULTMODULATIONDEPTH        0.0f
+
+#define EAXLISTENER_MINAIRABSORPTIONHF            (-100.0f)
+#define EAXLISTENER_MAXAIRABSORPTIONHF            0.0f
+#define EAXLISTENER_DEFAULTAIRABSORPTIONHF        (-5.0f)
+
+#define EAXLISTENER_MINHFREFERENCE                1000.0f
+#define EAXLISTENER_MAXHFREFERENCE                20000.0f
+#define EAXLISTENER_DEFAULTHFREFERENCE            5000.0f
+
+#define EAXLISTENER_MINLFREFERENCE                20.0f
+#define EAXLISTENER_MAXLFREFERENCE                1000.0f
+#define EAXLISTENER_DEFAULTLFREFERENCE            250.0f
+
+#define EAXLISTENER_MINROOMROLLOFFFACTOR          0.0f
+#define EAXLISTENER_MAXROOMROLLOFFFACTOR          10.0f
+#define EAXLISTENER_DEFAULTROOMROLLOFFFACTOR      0.0f
+
+#define EAXLISTENER_DEFAULTFLAGS                  (EAXLISTENERFLAGS_DECAYTIMESCALE |        \
+                                                   EAXLISTENERFLAGS_REFLECTIONSSCALE |      \
+                                                   EAXLISTENERFLAGS_REFLECTIONSDELAYSCALE | \
+                                                   EAXLISTENERFLAGS_REVERBSCALE |           \
+                                                   EAXLISTENERFLAGS_REVERBDELAYSCALE |      \
+                                                   EAXLISTENERFLAGS_DECAYHFLIMIT)
+
+
+
+/*
+* EAX 3.0 buffer property set {A8FA6881-B476-11d3-BDB9-00C0F02DDF87}
+*/
+DEFINE_GUID(DSPROPSETID_EAX30_BufferProperties, 
+	0xa8fa6881, 
+	0xb476, 
+	0x11d3, 
+	0xbd, 0xb9, 0x0, 0xc0, 0xf0, 0x2d, 0xdf, 0x87);
+
+// For compatibility with future EAX versions:
+#define DSPROPSETID_EAX_BufferProperties DSPROPSETID_EAX30_BufferProperties
+#define DSPROPSETID_EAX_SourceProperties DSPROPSETID_EAX30_BufferProperties
+
+typedef enum
+{
+    DSPROPERTY_EAXBUFFER_NONE,
+    DSPROPERTY_EAXBUFFER_ALLPARAMETERS,
+    DSPROPERTY_EAXBUFFER_OBSTRUCTIONPARAMETERS,
+    DSPROPERTY_EAXBUFFER_OCCLUSIONPARAMETERS,
+    DSPROPERTY_EAXBUFFER_EXCLUSIONPARAMETERS,
+    DSPROPERTY_EAXBUFFER_DIRECT,
+    DSPROPERTY_EAXBUFFER_DIRECTHF,
+    DSPROPERTY_EAXBUFFER_ROOM,
+    DSPROPERTY_EAXBUFFER_ROOMHF,
+    DSPROPERTY_EAXBUFFER_OBSTRUCTION,
+    DSPROPERTY_EAXBUFFER_OBSTRUCTIONLFRATIO,
+    DSPROPERTY_EAXBUFFER_OCCLUSION, 
+    DSPROPERTY_EAXBUFFER_OCCLUSIONLFRATIO,
+    DSPROPERTY_EAXBUFFER_OCCLUSIONROOMRATIO,
+    DSPROPERTY_EAXBUFFER_OCCLUSIONDIRECTRATIO,
+    DSPROPERTY_EAXBUFFER_EXCLUSION, 
+    DSPROPERTY_EAXBUFFER_EXCLUSIONLFRATIO,
+    DSPROPERTY_EAXBUFFER_OUTSIDEVOLUMEHF, 
+    DSPROPERTY_EAXBUFFER_DOPPLERFACTOR, 
+    DSPROPERTY_EAXBUFFER_ROLLOFFFACTOR, 
+    DSPROPERTY_EAXBUFFER_ROOMROLLOFFFACTOR,
+    DSPROPERTY_EAXBUFFER_AIRABSORPTIONFACTOR,
+    DSPROPERTY_EAXBUFFER_FLAGS
+} DSPROPERTY_EAX_BUFFERPROPERTY;    
+
+// OR these flags with property id
+#define DSPROPERTY_EAXBUFFER_IMMEDIATE 0x00000000 // changes take effect immediately
+#define DSPROPERTY_EAXBUFFER_DEFERRED  0x80000000 // changes take effect later
+#define DSPROPERTY_EAXBUFFER_COMMITDEFERREDSETTINGS (DSPROPERTY_EAXBUFFER_NONE | \
+                                                     DSPROPERTY_EAXBUFFER_IMMEDIATE)
+
+// Use this structure for DSPROPERTY_EAXBUFFER_ALLPARAMETERS
+// - all levels are hundredths of decibels
+// - all delays are in seconds
+//
+// NOTE: This structure may change in future EAX versions.
+//       It is recommended to initialize fields by name:
+//              myBuffer.lDirect = 0;
+//              myBuffer.lDirectHF = -200;
+//              ...
+//              myBuffer.dwFlags = myFlags /* see EAXBUFFERFLAGS below */ ;
+//       instead of:
+//              myBuffer = { 0, -200, ... , 0x00000003 };
+//
+typedef struct _EAXBUFFERPROPERTIES
+{
+    long lDirect;                 // direct path level (at low and mid frequencies)
+    long lDirectHF;               // relative direct path level at high frequencies
+    long lRoom;                   // room effect level (at low and mid frequencies)
+    long lRoomHF;                 // relative room effect level at high frequencies
+    long lObstruction;            // main obstruction control (attenuation at high frequencies) 
+    float flObstructionLFRatio;   // obstruction low-frequency level re. main control
+    long lOcclusion;              // main occlusion control (attenuation at high frequencies)
+    float flOcclusionLFRatio;     // occlusion low-frequency level re. main control
+    float flOcclusionRoomRatio;   // relative occlusion control for room effect
+    float flOcclusionDirectRatio; // relative occlusion control for direct path
+    long lExclusion;              // main exlusion control (attenuation at high frequencies)
+    float flExclusionLFRatio;     // exclusion low-frequency level re. main control
+    long lOutsideVolumeHF;        // outside sound cone level at high frequencies
+    float flDopplerFactor;        // like DS3D flDopplerFactor but per source
+    float flRolloffFactor;        // like DS3D flRolloffFactor but per source
+    float flRoomRolloffFactor;    // like DS3D flRolloffFactor but for room effect
+    float flAirAbsorptionFactor;  // multiplies DSPROPERTY_EAXLISTENER_AIRABSORPTIONHF
+    unsigned long ulFlags;        // modifies the behavior of properties
+} EAXBUFFERPROPERTIES, *LPEAXBUFFERPROPERTIES;
+
+// Use this structure for DSPROPERTY_EAXBUFFER_OBSTRUCTION,
+typedef struct _EAXOBSTRUCTIONPROPERTIES
+{
+    long lObstruction;
+    float flObstructionLFRatio;
+} EAXOBSTRUCTIONPROPERTIES, *LPEAXOBSTRUCTIONPROPERTIES;
+
+// Use this structure for DSPROPERTY_EAXBUFFER_OCCLUSION
+typedef struct _EAXOCCLUSIONPROPERTIES
+{
+    long lOcclusion;
+    float flOcclusionLFRatio;
+    float flOcclusionRoomRatio;
+    float flOcclusionDirectRatio;
+} EAXOCCLUSIONPROPERTIES, *LPEAXOCCLUSIONPROPERTIES;
+
+// Use this structure for DSPROPERTY_EAXBUFFER_EXCLUSION
+typedef struct _EAXEXCLUSIONPROPERTIES
+{
+    long lExclusion;
+    float flExclusionLFRatio;
+} EAXEXCLUSIONPROPERTIES, *LPEAXEXCLUSIONPROPERTIES;
+
+// Used by DSPROPERTY_EAXBUFFER_FLAGS
+//    TRUE:    value is computed automatically - property is an offset
+//    FALSE:   value is used directly
+//
+// Note: The number and order of flags may change in future EAX versions.
+//       To insure future compatibility, use flag defines as follows:
+//              myFlags = EAXBUFFERFLAGS_DIRECTHFAUTO | EAXBUFFERFLAGS_ROOMAUTO;
+//       instead of:
+//              myFlags = 0x00000003;
+//
+#define EAXBUFFERFLAGS_DIRECTHFAUTO          0x00000001 // affects DSPROPERTY_EAXBUFFER_DIRECTHF
+#define EAXBUFFERFLAGS_ROOMAUTO              0x00000002 // affects DSPROPERTY_EAXBUFFER_ROOM
+#define EAXBUFFERFLAGS_ROOMHFAUTO            0x00000004 // affects DSPROPERTY_EAXBUFFER_ROOMHF
+
+#define EAXBUFFERFLAGS_RESERVED              0xFFFFFFF8 // reserved future use
+
+// Property ranges and defaults:
+
+#define EAXBUFFER_MINDIRECT                    (-10000)
+#define EAXBUFFER_MAXDIRECT                    1000
+#define EAXBUFFER_DEFAULTDIRECT                0
+
+#define EAXBUFFER_MINDIRECTHF                  (-10000)
+#define EAXBUFFER_MAXDIRECTHF                  0
+#define EAXBUFFER_DEFAULTDIRECTHF              0
+
+#define EAXBUFFER_MINROOM                      (-10000)
+#define EAXBUFFER_MAXROOM                      1000
+#define EAXBUFFER_DEFAULTROOM                  0
+
+#define EAXBUFFER_MINROOMHF                    (-10000)
+#define EAXBUFFER_MAXROOMHF                    0
+#define EAXBUFFER_DEFAULTROOMHF                0
+
+#define EAXBUFFER_MINOBSTRUCTION               (-10000)
+#define EAXBUFFER_MAXOBSTRUCTION               0
+#define EAXBUFFER_DEFAULTOBSTRUCTION           0
+
+#define EAXBUFFER_MINOBSTRUCTIONLFRATIO        0.0f
+#define EAXBUFFER_MAXOBSTRUCTIONLFRATIO        1.0f
+#define EAXBUFFER_DEFAULTOBSTRUCTIONLFRATIO    0.0f
+
+#define EAXBUFFER_MINOCCLUSION                 (-10000)
+#define EAXBUFFER_MAXOCCLUSION                 0
+#define EAXBUFFER_DEFAULTOCCLUSION             0
+
+#define EAXBUFFER_MINOCCLUSIONLFRATIO          0.0f
+#define EAXBUFFER_MAXOCCLUSIONLFRATIO          1.0f
+#define EAXBUFFER_DEFAULTOCCLUSIONLFRATIO      0.25f
+
+#define EAXBUFFER_MINOCCLUSIONROOMRATIO        0.0f
+#define EAXBUFFER_MAXOCCLUSIONROOMRATIO        10.0f
+#define EAXBUFFER_DEFAULTOCCLUSIONROOMRATIO    1.5f
+
+#define EAXBUFFER_MINOCCLUSIONDIRECTRATIO      0.0f
+#define EAXBUFFER_MAXOCCLUSIONDIRECTRATIO      10.0f
+#define EAXBUFFER_DEFAULTOCCLUSIONDIRECTRATIO  1.0f
+
+#define EAXBUFFER_MINEXCLUSION                 (-10000)
+#define EAXBUFFER_MAXEXCLUSION                 0
+#define EAXBUFFER_DEFAULTEXCLUSION             0
+
+#define EAXBUFFER_MINEXCLUSIONLFRATIO          0.0f
+#define EAXBUFFER_MAXEXCLUSIONLFRATIO          1.0f
+#define EAXBUFFER_DEFAULTEXCLUSIONLFRATIO      1.0f
+
+#define EAXBUFFER_MINOUTSIDEVOLUMEHF           (-10000)
+#define EAXBUFFER_MAXOUTSIDEVOLUMEHF           0
+#define EAXBUFFER_DEFAULTOUTSIDEVOLUMEHF       0
+
+#define EAXBUFFER_MINDOPPLERFACTOR             0.0f
+#define EAXBUFFER_MAXDOPPLERFACTOR             10.f
+#define EAXBUFFER_DEFAULTDOPPLERFACTOR         0.0f
+
+#define EAXBUFFER_MINROLLOFFFACTOR             0.0f
+#define EAXBUFFER_MAXROLLOFFFACTOR             10.f
+#define EAXBUFFER_DEFAULTROLLOFFFACTOR         0.0f
+
+#define EAXBUFFER_MINROOMROLLOFFFACTOR         0.0f
+#define EAXBUFFER_MAXROOMROLLOFFFACTOR         10.f
+#define EAXBUFFER_DEFAULTROOMROLLOFFFACTOR     0.0f
+
+#define EAXBUFFER_MINAIRABSORPTIONFACTOR       0.0f
+#define EAXBUFFER_MAXAIRABSORPTIONFACTOR       10.0f
+#define EAXBUFFER_DEFAULTAIRABSORPTIONFACTOR   1.0f
+
+#define EAXBUFFER_DEFAULTFLAGS                 (EAXBUFFERFLAGS_DIRECTHFAUTO |       \
+                                                EAXBUFFERFLAGS_ROOMAUTO |           \
+                                                EAXBUFFERFLAGS_ROOMHFAUTO )
+
+#pragma pack(pop)
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+#endif
diff --git a/milessdk/include/mss.h b/milessdk/include/mss.h
new file mode 100644
index 00000000..fbc91c73
--- /dev/null
+++ b/milessdk/include/mss.h
@@ -0,0 +1,4805 @@
+//############################################################################
+//##                                                                        ##
+//##  Miles Sound System                                                    ##
+//##                                                                        ##
+//##  MSS.H: Miles Sound System main header file                            ##
+//##                                                                        ##
+//##  Version 1.00 of 15-Feb-95: Initial, derived from AIL.H V3.02          ##
+//##          1.01 of 19-Jun-95: Added various functions for V3.03 release  ##
+//##          1.02 of 22-Nov-95: C++ typedef problem fixed, declspecs added ##
+//##          1.03 of 15-Feb-96: Changes for 16 bit callbacks and multiple  ##
+//##                             16 bit DLL loads (JKR)                     ##
+//##          1.04 of  2-Nov-97: Changes made to handle DLS in future       ##
+//##                             versions                                   ##
+//##          1.05 of  1-Jan-98: Massive changes for version 4.0            ##
+//##          1.06 of 17-Sep-98: Massive changes for version 5.0            ##
+//##          1.07 of  2-Feb-99: Changes for new input API                  ##
+//##          1.08 of  8-Feb-99: Changes for new filter helper functions    ##
+//##                                                                        ##
+//##  Author: John Miles                                                    ##
+//##                                                                        ##
+//############################################################################
+//##                                                                        ##
+//##  Contact RAD Game Tools at 425-893-4300 for technical support.         ##
+//##                                                                        ##
+//############################################################################
+
+#ifndef MSS_VERSION
+
+#define MSS_VERSION      "6.1a"
+#define MSS_MAJOR_VERSION 6
+#define MSS_MINOR_VERSION 1
+#define MSS_SUB_VERSION   1
+#define MSS_VERSION_DATE "06-Mar-01"
+
+#define MSS_COPYRIGHT "Copyright (C) 1991-2001, RAD Game Tools, Inc."
+
+#endif
+
+#ifndef MSS_H
+#define MSS_H
+
+// IS_DOS for DOS
+// IS_WINDOWS for Windows or Win32s
+// IS_WIN32 for Win32s
+// IS_WIN16 for Windows
+// IS_32 for 32-bit DOS or Win32s
+// IS_16 for 16-bit Windows
+// IS_LE for little endian (PCs)
+// IS_BE for big endian (Macs)
+// IS_X86 for Intel
+// IS_MAC for Mac
+// IS_PPC for PPC Mac
+// IS_68K for 68K Mac
+
+
+#ifdef IS_DOS
+#undef IS_DOS
+#endif
+
+#ifdef IS_WINDOWS
+#undef IS_WINDOWS
+#endif
+
+#ifdef IS_WIN32
+#undef IS_WIN32
+#endif
+
+#ifdef IS_WIN16
+#undef IS_WIN16
+#endif
+
+#ifdef IS_32
+#undef IS_32
+#endif
+
+#ifdef IS_16
+#undef IS_16
+#endif
+
+#ifdef IS_LE
+#undef IS_LE
+#endif
+
+#ifdef IS_BE
+#undef IS_BE
+#endif
+
+#ifdef IS_X86
+#undef IS_X86
+#endif
+
+#ifdef IS_MAC
+#undef IS_MAC
+#endif
+
+#ifdef IS_PPC
+#undef IS_PPC
+#endif
+
+#ifdef IS_68K
+#undef IS_68K
+#endif
+
+#ifdef __DOS__
+  #define IS_DOS
+  #define IS_32
+  #define IS_LE
+  #define IS_X86
+#else
+  #ifdef _WIN32
+    #define IS_WINDOWS
+    #define IS_WIN32
+    #define IS_32
+    #define IS_LE
+    #define IS_X86
+  #else
+    #ifdef WIN32
+      #define IS_WINDOWS
+      #define IS_WIN32
+      #define IS_32
+      #define IS_LE
+      #define IS_X86
+    #else
+      #ifdef __NT__
+        #define IS_WINDOWS
+        #define IS_WIN32
+        #define IS_32
+        #define IS_LE
+        #define IS_X86
+      #else
+        #ifdef __WIN32__
+          #define IS_WINDOWS
+          #define IS_WIN32
+          #define IS_32
+          #define IS_LE
+          #define IS_X86
+        #else
+          #ifdef _WINDOWS
+            #define IS_WINDOWS
+            #define IS_WIN16
+            #define IS_16
+            #define IS_LE
+            #define IS_X86
+          #else
+            #ifdef _WINDLL
+              #define IS_WINDOWS
+              #define IS_WIN16
+              #define IS_16
+              #define IS_LE
+              #define IS_X86
+            #else
+              #ifdef WINDOWS
+                #define IS_WINDOWS
+                #define IS_WIN16
+                #define IS_16
+                #define IS_LE
+                #define IS_X86
+              #else
+                #ifdef __WINDOWS__
+                  #define IS_WINDOWS
+                  #define IS_WIN16
+                  #define IS_16
+                  #define IS_LE
+                  #define IS_X86
+                #else
+                  #ifdef _Windows
+                    #define IS_WINDOWS
+                    #define IS_WIN16
+                    #define IS_16
+                    #define IS_LE
+                    #define IS_X86
+                  #else
+                    #if defined(macintosh) || defined(__powerc) || defined(powerc) || defined(__POWERPC__) || defined(__MC68K__)
+                      #define IS_MAC
+                      #define IS_32
+                      #define IS_BE
+                      #if defined(__powerc) || defined(powerc) || defined(__POWERPC__)
+                        #define IS_PPC
+                      #else
+                        #if defined(__MC68K__)
+                          #define IS_68K
+                        #endif
+                      #endif
+                    #endif
+                  #endif
+                #endif
+              #endif
+            #endif
+          #endif
+        #endif
+      #endif
+    #endif
+  #endif
+#endif
+
+#if (!defined(IS_LE) && !defined(IS_BE))
+  #error MSS.H did not detect your platform.  Define __DOS__, _WINDOWS, WIN32, or macintosh.
+#endif
+
+
+#if defined(_PUSHPOP_SUPPORTED) || PRAGMA_STRUCT_PACKPUSH
+  #pragma pack(push,1)
+#else
+  #pragma pack(1)
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef IS_DOS
+
+#define AILCALLBACK __pascal
+#define AILEXPORT cdecl
+#define DXDEC extern
+#define DXDEF
+#define AILCALL cdecl
+#define FAR
+#define HIWORD(ptr) (((U32)ptr)>>16)
+#define LOWORD(ptr) ((U16)((U32)ptr))
+
+#define FOURCC U32
+
+#define MAKEFOURCC(ch0, ch1, ch2, ch3)                              \
+              ((U32)(U8)(ch0) | ((U32)(U8)(ch1) << 8) |   \
+              ((U32)(U8)(ch2) << 16) | ((U32)(U8)(ch3) << 24 ))
+
+#define mmioFOURCC(w,x,y,z) MAKEFOURCC(w,x,y,z)
+
+#define AILLIBCALLBACK __pascal
+
+#define MSS_MAIN_DEF
+
+#define MSS_REDIST_DIR_NAME "DOS"
+
+#define MSS_DIR_SEP "\\"
+#define MSS_DIR_UP ".." MSS_DIR_SEP
+#define MSS_DIR_UP_TWO MSS_DIR_UP MSS_DIR_UP
+
+#else
+
+#ifdef IS_WINDOWS
+
+#define AILLIBCALLBACK WINAPI
+
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+
+#ifndef WIN32_EXTRA_LEAN
+#define WIN32_EXTRA_LEAN
+#endif
+
+#ifndef STRICT
+#define STRICT
+#endif
+
+#include <windows.h>
+#include <mmsystem.h>
+
+#define MSS_MAIN_DEF __cdecl
+
+//
+// If compiling MSS DLL, use __declspec(dllexport) for both
+// declarations and definitions
+//
+// If compiling MSS16 library or application, use "extern" in declarations
+// and nothing in definitions
+//
+
+#ifdef IS_WIN32
+
+  #define AILEXPORT WINAPI
+
+  #ifdef BUILD_MSS
+    #define DXDEC __declspec(dllexport)
+    #define DXDEF __declspec(dllexport)
+  #else
+
+    #if 1 /*def __BORLANDC__*/
+      #define DXDEC extern
+	  #define DXDEF
+    #else
+      #define DXDEC __declspec(dllimport)
+    #endif
+
+  #endif
+
+  #define MSSDLLNAME "MSS32.DLL"
+  #define MSS_REDIST_DIR_NAME "WIN32"
+
+  #define MSS_DIR_SEP "\\"
+  #define MSS_DIR_UP ".." MSS_DIR_SEP
+  #define MSS_DIR_UP_TWO MSS_DIR_UP MSS_DIR_UP
+ 
+#else
+
+  #define AILEXPORT __export WINAPI
+
+  #define DXDEC  extern
+  #define DXDEF
+
+  #define MSSDLLNAME "MSS16.DLL"
+  #define MSS_REDIST_DIR_NAME "WIN16"
+  
+  #define MSS_DIR_SEP "\\"
+  #define MSS_DIR_UP ".." MSS_DIR_SEP
+  #define MSS_DIR_UP_TWO MSS_DIR_UP MSS_DIR_UP
+
+#endif
+
+#define AILCALL WINAPI
+#define AILCALLBACK AILEXPORT
+
+typedef LPVOID AILLPDIRECTSOUND;
+typedef LPVOID AILLPDIRECTSOUNDBUFFER;
+
+#else
+
+#ifdef IS_MAC
+
+#include <string.h>
+#include <Files.h>
+#include <Sound.h>
+#include <Resources.h>		// needed for GetResource, ReleaseResource
+
+#define FAR
+
+#define AILLIBCALLBACK //pascal
+#define AILCALL        //pascal
+#define AILEXPORT      //pascal
+#define AILCALLBACK    //pascal
+
+#ifdef BUILD_MSS
+  #define DXDEC __declspec(export)
+  #define DXDEF
+#else
+  #define DXDEC extern
+  #define DXDEF
+#endif
+
+#define MSS_REDIST_DIR_NAME "MAC"
+
+#define MSS_DIR_SEP ":"
+#define MSS_DIR_UP ":" MSS_DIR_SEP
+#define MSS_DIR_UP_TWO MSS_DIR_UP MSS_DIR_SEP
+
+#define HIWORD(ptr) (((U32)ptr)>>16)
+#define LOWORD(ptr) ((U16)((U32)ptr))
+
+#define FOURCC U32
+
+#ifndef MAKEFOURCC
+#define MAKEFOURCC(ch0, ch1, ch2, ch3)                              \
+        (((U32)(U8)(ch0) << 24) | ((U32)(U8)(ch1) << 16) |   \
+              ((U32)(U8)(ch2) <<  8) | ((U32)(U8)(ch3)      ))
+#endif
+
+#define mmioFOURCC(w,x,y,z) MAKEFOURCC(w,x,y,z)
+
+#define MSS_MAIN_DEF
+
+#endif
+
+#endif
+
+#endif
+
+#ifndef NULL
+#define NULL 0
+#endif
+
+//
+// Misc. constant definitions
+//
+
+#define MAX_DRVRS                16       // Max. # of simultaneous drivers
+#define MAX_TIMERS               16       // Max. # of simultaneous timers
+#define MAX_NOTES                32       // Max # of notes "on"
+#define FOR_NEST                 4        // # of nested XMIDI FOR loops
+#define NUM_CHANS                16       // # of possible MIDI channels
+#define MAX_W_VOICES             16       // Max virtual wave synth voice cnt
+#define MAX_W_ENTRIES            512      // 512 wave library entries max.
+#ifdef IS_MAC
+#define MAX_INSTR                150      // Max # of instruments 128 + 32
+#endif
+
+#define MIN_CHAN                 ( 1-1)   // Min channel recognized (0-based)
+#define MAX_CHAN                 (16-1)   // Max channel recognized
+#define MIN_LOCK_CHAN            ( 2-1)   // Min channel available for locking
+#define MAX_LOCK_CHAN            ( 9-1)   // Max channel available for locking
+#define PERCUSS_CHAN             (10-1)   // Percussion channel (no locking)
+
+#define AIL_MAX_FILE_HEADER_SIZE 4096     // AIL_set_named_sample_file() requires at least 4K
+                                          // of data or the entire file image, whichever is less,
+                                          // to determine sample format
+#define DIG_F_16BITS_MASK        1
+#define DIG_F_STEREO_MASK        2
+#define DIG_F_ADPCM_MASK         4
+
+#define DIG_F_MONO_8             0        // PCM data formats
+#define DIG_F_MONO_16            (DIG_F_16BITS_MASK)
+#define DIG_F_STEREO_8           (DIG_F_STEREO_MASK)
+#define DIG_F_STEREO_16          (DIG_F_STEREO_MASK|DIG_F_16BITS_MASK)
+#define DIG_F_ADPCM_MONO_16      (DIG_F_ADPCM_MASK |DIG_F_16BITS_MASK)
+#define DIG_F_ADPCM_STEREO_16    (DIG_F_ADPCM_MASK |DIG_F_16BITS_MASK|DIG_F_STEREO_MASK)
+#define DIG_F_USING_ASI          16
+
+#define DIG_PCM_SIGN             0x0001   // (obsolete)
+#define DIG_PCM_ORDER            0x0002
+
+#define DIG_PCM_POLARITY         0x0004   // PCM flags used by driver hardware
+#define DIG_PCM_SPLIT            0x0008
+#define DIG_BUFFER_SERVICE       0x0010
+#define DIG_DUAL_DMA             0x0020
+#define DIG_RECORDING_SUPPORTED  0x8000
+
+#define WAVE_FORMAT_PCM         1
+#define WAVE_FORMAT_IMA_ADPCM   0x0011
+
+#ifdef IS_DOS
+
+#define AIL3DIG                  0        // .DIG driver
+#define AIL3MDI                  1        // .MDI driver
+
+#define DIG_DETECT_8_BIT_ONLY    0x0001   // Detect 8-bit DMA only
+#define DIG_DETECT_16_BIT_ONLY   0x0002   // Detect 16-bit DMA only
+#define DIG_DETECT_8_AND_16_BITS 0x0003   // Detect both 8- and 16-bit DMA
+
+#define DRV_INIT          0x300     // Functions common to .MDI and .DIG
+#define DRV_GET_INFO      0x301     // drivers
+#define DRV_SERVE         0x302
+#define DRV_PARSE_ENV     0x303
+#define DRV_VERIFY_IO     0x304
+#define DRV_INIT_DEV      0x305
+#define DRV_SHUTDOWN_DEV  0x306
+
+#define DIG_HW_VOLUME     0x400     // .DIG driver functions
+#define DIG_START_P_CMD   0x401
+#define DIG_STOP_P_REQ    0x402
+#define DIG_START_R_CMD   0x403
+#define DIG_STOP_R_REQ    0x404
+#define DIG_VSE           0x405
+
+#define MDI_HW_VOLUME     0x500     // .MDI driver functions
+#define MDI_INIT_INS_MGR  0x501
+#define MDI_MIDI_XMIT     0x502
+#define MDI_INSTALL_T_SET 0x503
+#define MDI_GET_T_STATUS  0x504
+#define MDI_PROT_UNPROT_T 0x505
+#define MDI_VSE           0x506
+
+#else
+
+//
+// Pass to AIL_midiOutOpen for NULL MIDI driver
+//
+
+#define MIDI_NULL_DRIVER ((U32)(S32)-2)
+
+#endif
+
+
+//
+// Non-specific XMIDI/MIDI controllers and event types
+//
+
+#define SYSEX_BYTE        105
+#define PB_RANGE          106
+#define CHAN_MUTE         107
+#define CALLBACK_PFX      108
+#define SEQ_BRANCH        109
+#define CHAN_LOCK         110
+#define CHAN_PROTECT      111
+#define VOICE_PROTECT     112
+#define TIMBRE_PROTECT    113
+#define PATCH_BANK_SEL    114
+#define INDIRECT_C_PFX    115
+#define FOR_LOOP          116
+#define NEXT_LOOP         117
+#define CLEAR_BEAT_BAR    118
+#define CALLBACK_TRIG     119
+#define SEQ_INDEX         120
+
+#define GM_BANK_MSB       0
+#define MODULATION        1
+#define DATA_MSB          6
+#define PART_VOLUME       7
+#define PANPOT            10
+#define EXPRESSION        11
+#define GM_BANK_LSB       32
+#define DATA_LSB          38
+#define SUSTAIN           64
+#define REVERB            91
+#define CHORUS            93
+#define RPN_LSB           100
+#define RPN_MSB           101
+#define RESET_ALL_CTRLS   121
+#define ALL_NOTES_OFF     123
+
+#define EV_NOTE_OFF       0x80
+#define EV_NOTE_ON        0x90
+#define EV_POLY_PRESS     0xa0
+#define EV_CONTROL        0xb0
+#define EV_PROGRAM        0xc0
+#define EV_CHAN_PRESS     0xd0
+#define EV_PITCH          0xe0
+#define EV_SYSEX          0xf0
+#define EV_ESC            0xf7
+#define EV_META           0xff
+
+#define META_EOT          0x2f
+#define META_TEMPO        0x51
+#define META_TIME_SIG     0x58
+
+//
+// SAMPLE.system_data[] usage
+//
+
+#define SSD_EOD_CALLBACK  0  // Application end-of-data callback if not NULL
+#define VOC_BLK_PTR       1  // Pointer to current block
+#define VOC_REP_BLK       2  // Pointer to beginning of repeat loop block
+#define VOC_N_REPS        3  // # of iterations left in repeat loop
+#define VOC_MARKER        4  // Marker to search for, or -1 if all
+#define VOC_MARKER_FOUND  5  // Desired marker found if 1, else 0
+#define SSD_RELEASE       6  // Release sample handle upon termination if >0
+#ifdef IS_WINDOWS
+#define SSD_EOD_CB_WIN32S 7  // Application end-of-data callback is in Win32s
+#else
+#define SSD_TEMP          7  // Temporary storage location for general use
+#endif
+
+//
+// Timer status values
+//
+
+#define AILT_FREE         0         // Timer handle is free for allocation
+#define AILT_STOPPED      1         // Timer is stopped
+#define AILT_RUNNING      2         // Timer is running
+
+//
+// SAMPLE.status flag values
+//
+
+#define SMP_FREE          0x0001    // Sample is available for allocation
+
+#define SMP_DONE          0x0002    // Sample has finished playing, or has
+                                    // never been started
+
+#define SMP_PLAYING       0x0004    // Sample is playing
+
+#define SMP_STOPPED       0x0008    // Sample has been stopped
+
+#define SMP_PLAYINGBUTRELEASED 0x0010 // Sample is playing, but digital handle
+                                      // has been temporarily released
+
+
+
+//
+// SEQUENCE.status flag values
+//
+
+#define SEQ_FREE          0x0001    // Sequence is available for allocation
+
+#define SEQ_DONE          0x0002    // Sequence has finished playing, or has
+                                    // never been started
+
+#define SEQ_PLAYING       0x0004    // Sequence is playing
+
+#define SEQ_STOPPED       0x0008    // Sequence has been stopped
+
+#define SEQ_PLAYINGBUTRELEASED 0x0010 // Sequence is playing, but MIDI handle
+                                      // has been temporarily released
+
+#ifdef IS_DOS
+
+//
+// MIDI driver types
+//
+
+#define MDIDRVRTYPE_GM    0         // General MIDI driver (Roland-compatible)
+#define MDIDRVRTYPE_FM_2  1         // 2-operator FM MIDI driver (OPL2)
+#define MDIDRVRTYPE_FM_4  2         // 4-operator FM MIDI driver (OPL3)
+#define MDIDRVRTYPE_SPKR  3         // Tandy or PC speaker "beep" driver
+
+//
+// .INI installation result codes
+//
+
+#define AIL_INIT_SUCCESS  0         // Driver installed successfully
+#define AIL_NO_INI_FILE   1         // No MDI.INI or DIG.INI file exists
+#define AIL_INIT_FAILURE  2         // Driver could not be initialized
+
+#ifdef __BORLANDC__
+
+ #ifndef REALPTR
+ #define REALPTR(x) ((void *) (U32) ((((U32) (x))>>16<<4) + ((x) & 0xffff) \
+                    - AIL_sel_base(_DS)))
+ #endif
+
+#else
+
+ #ifndef REALPTR
+ #define REALPTR(x) ((void *) (U32) ((((U32) (x))>>16<<4) + ((x) & 0xffff)))
+ #endif
+
+#endif
+
+#else
+
+#ifdef IS_WINDOWS
+
+//
+// AIL_set_direct_buffer_control() command values
+//
+
+#define AILDS_RELINQUISH  0         // App returns control of secondary buffer
+#define AILDS_SEIZE       1         // App takes control of secondary buffer
+#define AILDS_SEIZE_LOOP  2         // App wishes to loop the secondary buffer
+
+#endif
+
+#endif
+
+//
+// General type definitions for portability
+//
+
+#ifndef C8
+#define C8 char
+#endif
+
+#ifndef U8
+#define U8 unsigned char
+#endif
+
+#ifndef S8
+#define S8 signed char
+#endif
+
+#ifndef U16
+#define U16 unsigned short
+#endif
+
+#ifndef S16
+#define S16 signed short
+#endif
+
+#ifndef U32
+#define U32 unsigned long
+#endif
+
+#ifndef S32
+#define S32 signed long
+#endif
+
+#ifndef F32
+#define F32 float
+#endif
+
+#ifndef F64
+#define F64 double
+#endif
+
+
+#ifndef REALFAR
+#define REALFAR unsigned long
+#endif
+
+#ifndef FILE_ERRS
+#define FILE_ERRS
+
+#define AIL_NO_ERROR        0
+#define AIL_IO_ERROR        1
+#define AIL_OUT_OF_MEMORY   2
+#define AIL_FILE_NOT_FOUND  3
+#define AIL_CANT_WRITE_FILE 4
+#define AIL_CANT_READ_FILE  5
+#define AIL_DISK_FULL       6
+
+#endif
+
+#define MIN_VAL 0
+#define NOM_VAL 1
+#define MAX_VAL 2
+
+#ifndef YES
+#define YES 1
+#endif
+
+#ifndef NO
+#define NO  0
+#endif
+
+#ifndef TRUE
+#define TRUE 1
+#endif
+
+#ifndef FALSE
+#define FALSE  0
+#endif
+
+//
+// Preference names and default values
+//
+
+#define DIG_RESAMPLING_TOLERANCE   0
+#define DEFAULT_DRT                131    // Resampling triggered at +/- 0.2%
+
+#define DIG_MIXER_CHANNELS         1
+#define DEFAULT_DMC                64     // 64 allocatable SAMPLE structures
+
+#define DIG_DEFAULT_VOLUME         2
+#define DEFAULT_DDV                127    // Default sample volume = 127 (0-127)
+
+#define MDI_SERVICE_RATE           3
+#define DEFAULT_MSR                120    // XMIDI sequencer timing = 120 Hz
+
+#define MDI_SEQUENCES              4
+#define DEFAULT_MS                 8      // 8 sequence handles/driver
+
+#define MDI_DEFAULT_VOLUME         5
+#define DEFAULT_MDV                127    // Default sequence volume = 127 (0-127)
+
+#define MDI_QUANT_ADVANCE          6
+#define DEFAULT_MQA                1      // Beat/bar count +1 interval
+
+#define MDI_ALLOW_LOOP_BRANCHING   7
+#define DEFAULT_ALB                NO     // Branches cancel XMIDI FOR loops
+
+#define MDI_DEFAULT_BEND_RANGE     8
+#define DEFAULT_MDBR               2      // Default pitch-bend range = 2
+
+#ifdef IS_X86
+
+#define MDI_DOUBLE_NOTE_OFF        9
+#define DEFAULT_MDNO               NO     // For stuck notes on SB daughterboards
+
+#endif
+
+#define DIG_ENABLE_RESAMPLE_FILTER 31     // Enable resampling filter by
+#define DEFAULT_DERF               YES    // default
+
+#define DIG_DECODE_BUFFER_SIZE     32     // 2K decode buffer size by default
+#define DEFAULT_DDBS               2048
+
+#if defined(IS_WINDOWS) || defined(IS_MAC)
+
+#define MDI_SYSEX_BUFFER_SIZE      10
+#define DEFAULT_MSBS               1536   // Default sysex buffer = 1536 bytes
+
+#define DIG_OUTPUT_BUFFER_SIZE     11
+#define DEFAULT_DOBS               49152  // 48K output buffer size
+
+#define AIL_MM_PERIOD              12
+#define DEFAULT_AMP                5      // Default MM timer period = 5 msec.
+
+#endif
+
+#ifdef IS_WINDOWS
+
+#define DIG_DS_FRAGMENT_SIZE       34
+#define DEFAULT_DDFS               8      // Use 8 millisecond buffer fragments with DirectSound if MSS mixer in use
+
+#define DIG_DS_FRAGMENT_CNT        35
+#define DEFAULT_DDFC               96     // Use 96 buffer fragments with DirectSound if MSS mixer in use
+
+#define DIG_DS_MIX_FRAGMENT_CNT    42
+#define DEFAULT_DDMFC              8      // Mix ahead 8 buffer fragments
+
+#define DIG_DS_USE_PRIMARY         36
+#define DEFAULT_DDUP               NO     // Mix into secondary DirectSound buffer by default
+
+#define DIG_DS_DSBCAPS_CTRL3D      37
+#define DEFAULT_DDDC               NO     // Do not use DSBCAPS_CTRL3D by default
+
+#define DIG_DS_CREATION_HANDLER    38
+#define DEFAULT_DDCH               NULL   // Use DirectSoundCreate() by default
+
+#define AIL_TIMERS                 13
+#define DEFAULT_AT                 16     // 16 allocatable HTIMER handles
+
+#define DIG_MAX_CHAIN_ELEMENT_SIZE 14
+#define DEFAULT_MCES               8192   // max of 8192 bytes/waveOut buffer
+
+#define DIG_MIN_CHAIN_ELEMENT_TIME 45
+#define DEFAULT_MCET               100    // 100 milliseconds buffers
+
+#define DIG_USE_WAVEOUT            15
+#define DEFAULT_DUW                NO     // Use DirectSound by default
+
+#define DIG_DS_SECONDARY_SIZE      16
+#define DEFAULT_DDSS               (32*1024L)  // Must be 2^n -- use 32K by default
+
+#define DIG_DS_SAMPLE_CEILING      17
+#define DEFAULT_DDSC               44100  // Allow up to 44 kHz samples
+
+#define AIL_LOCK_PROTECTION        18
+#define DEFAULT_ALP                NO     // Don't suspend foreground thread by default
+
+#define AIL_WIN32S_CALLBACK_SIZE   19
+#define DEFAULT_WCS                4096   // Size of callback data in bytes
+
+#define AIL_MUTEX_PROTECTION       44
+#define DEFAULT_AMPR               YES    // Lock each call into Miles with a mutex
+
+#else
+
+#ifdef IS_DOS
+
+#define DIG_SERVICE_RATE          10
+#define DEFAULT_DSR               200     // DMA buffer-polling rate = 200 Hz
+
+#define DIG_HARDWARE_SAMPLE_RATE  11
+#define DEFAULT_DHSR              NOM_VAL // Use nominal sample rate by default
+
+#define DIG_DMA_RESERVE           12
+#define DEFAULT_DDR               32768   // Reserve 32K real-mode mem for DMA
+
+#define DIG_LATENCY               13
+#define DEFAULT_DL                100     // Half-buffer size in ms = 100
+
+#define DIG_USE_STEREO            14
+#define DEFAULT_DUS               NO      // Use mono output only
+
+#define DIG_USE_16_BITS           15
+#define DEFAULT_DU16              NO      // Use 8-bit output by default
+
+#define DIG_ALLOW_16_BIT_DMA      16
+#define DEFAULT_DA16DMA           YES     // OK to use 16-bit DMA if necessary
+
+#define DIG_SS_LOCK               17
+#define DEFAULT_DSL               NO      // Don't disable IRQs while mixing
+
+#define AIL_SCAN_FOR_HARDWARE     18
+#define DEFAULT_ASH               YES     // Scan for I/O settings if necessary
+
+#define AIL_ALLOW_VDM_EXECUTION   19
+#define DEFAULT_AVE               YES     // Allow Windows "DOS box" execution
+
+#endif
+
+#endif
+
+// ----------------------------------
+// DLS Preference names and default values
+// Unless otherwise specified, values must be established
+// BEFORE calling DLSMSSOpen()!
+// ----------------------------------
+
+#define DLS_TIMEBASE               20
+#define DEFAULT_DTB                120  // 120 intervals/second by default
+
+#define DLS_VOICE_LIMIT            21
+#define DEFAULT_DVL                24   // 24 voices supported
+
+#define DLS_BANK_SELECT_ALIAS      22
+#define DEFAULT_DBSA               NO   // Do not treat controller 114 as bank
+
+#define DLS_STREAM_BOOTSTRAP       23   // Don't submit first stream buffer
+#define DEFAULT_DSB                YES  // until at least 2 available
+
+#define DLS_VOLUME_BOOST           24
+#define DEFAULT_DVB                0    // Boost final volume by 0 dB
+
+#define DLS_ENABLE_FILTERING       25   // Filtering = on by default
+#define DEFAULT_DEF                YES  // (may be changed at any time)
+
+#ifdef IS_X86
+
+#define AIL_ENABLE_MMX_SUPPORT     27   // Enable MMX support if present
+#define DEFAULT_AEMS               YES  // (may be changed at any time)
+
+#endif
+
+#define DLS_GM_PASSTHROUGH         28   // Pass unrecognized traffic on to
+#define DEFAULT_DGP                YES  // default GM driver layer
+                                        // (may be changed at any time)
+
+#define DLS_ADPCM_TO_ASI_THRESHOLD 39   // Size in samples to switch to ASI
+#define DEFAULT_DATAT              32768
+
+//
+// Add'l platform-independent prefs
+//
+
+#define DIG_REVERB_BUFFER_SIZE     40
+#define DEFAULT_DRBS               0    // No reverb support by default
+
+#define DIG_INPUT_LATENCY          41   // Use >= 250-millisecond input buffers if
+#define DEFAULT_DIL                250  // explicit size request cannot be satisfied
+
+#ifdef IS_WINDOWS
+
+#define DIG_USE_WAVEIN             43
+#define DEFAULT_DUWI               YES  // Use waveIn for input by default
+
+#endif
+
+#define N_PREFS 46                      // # of preference types
+
+typedef struct _AILSOUNDINFO {
+  S32 format;
+  void const FAR* data_ptr;
+  U32 data_len;
+  U32 rate;
+  S32 bits;
+  S32 channels;
+  U32 samples;
+  U32 block_size;
+  void const FAR* initial_ptr;
+} AILSOUNDINFO;
+
+
+// for multi-processor machines
+
+#ifdef IS_WIN32
+
+#ifdef BUILD_MSS
+
+  #define MSSLockedIncrement(var) _asm { lock inc [var] }
+  #define MSSLockedDecrement(var) _asm { lock dec [var] }
+
+  static void __MSSLockedIncrementAddr(void * addr)
+  {
+    _asm
+    {
+      mov eax,[addr]
+      lock inc dword ptr [eax]
+    }
+  }
+
+  static void __MSSLockedDecrementAddr(void * addr)
+  {
+    _asm {
+      mov eax,[addr]
+      lock dec dword ptr [eax]
+    }
+  }
+
+  #define MSSLockedIncrementPtr(var) __MSSLockedIncrementAddr(&(var))
+  #define MSSLockedDecrementPtr(var) __MSSLockedDecrementAddr(&(var))
+
+#else
+
+  #define MSSLockedIncrement(var) (++var)
+  #define MSSLockedDecrement(var) (--var)
+
+  #define MSSLockedIncrementPtr(var) (++var)
+  #define MSSLockedDecrementPtr(var) (--var)
+
+#endif
+
+#else
+  #define MSSLockedIncrement(var) (++var)
+  #define MSSLockedDecrement(var) (--var)
+
+  #define MSSLockedIncrementPtr(var) (++var)
+  #define MSSLockedDecrementPtr(var) (--var)
+#endif
+
+#ifndef RIB_H        // RIB.H contents included if RIB.H not already included
+
+// #include "rib.h"
+
+#define RIB_H
+#define ARY_CNT(x) (sizeof((x)) / sizeof((x)[0]))
+
+// ----------------------------------
+// RIB data types
+// ----------------------------------
+
+typedef S32 RIBRESULT;
+
+#define RIB_NOERR                    0   // Success -- no error
+#define RIB_NOT_ALL_AVAILABLE        1   // Some requested functions/attribs not available
+#define RIB_NOT_FOUND                2   // Resource not found
+#define RIB_OUT_OF_MEM               3   // Out of system RAM
+
+//
+// Handle to interface provider
+//
+
+typedef U32 HPROVIDER;
+
+//
+// Handle representing token used to obtain attribute or preference
+// data from RIB provider
+//
+
+typedef U32 HATTRIB;
+
+//
+// Handle representing an enumerated interface entry
+//
+// RIB_enumerate_interface() returns 1 if valid next entry found, else
+// 0 if end of list reached
+//
+
+typedef U32 HINTENUM;
+#define HINTENUM_FIRST 0
+
+//
+// Handle representing an enumerated provider entry
+//
+// RIB_enumerate_providers() returns 1 if valid next entry found, else
+// 0 if end of list reached
+//
+
+typedef U32 HPROENUM;
+#define HPROENUM_FIRST 0
+
+//
+// Data types for RIB attributes and preferences
+//
+
+typedef enum
+{
+   RIB_NONE = 0, // No type
+   RIB_CUSTOM,   // Used for pointers to application-specific structures
+   RIB_DEC,      // Used for 32-bit integer values to be reported in decimal
+   RIB_HEX,      // Used for 32-bit integer values to be reported in hex
+   RIB_FLOAT,    // Used for 32-bit single-precision FP values
+   RIB_PERCENT,  // Used for 32-bit single-precision FP values to be reported as percentages
+   RIB_BOOL,     // Used for Boolean-constrained integer values to be reported as TRUE or FALSE
+   RIB_STRING    // Used for pointers to null-terminated ASCII strings
+}
+RIB_DATA_SUBTYPE;
+
+//
+// RIB_ENTRY_TYPE structure, used to register an interface or request one
+//
+
+typedef enum
+{
+   RIB_FUNCTION = 0,
+   RIB_ATTRIBUTE,     // Attribute: read-only data type used for status/info communication
+   RIB_PREFERENCE     // Preference: read/write data type used to control behavior
+}
+RIB_ENTRY_TYPE;
+
+//
+// RIB_INTERFACE_ENTRY, used to represent a function or data entry in an
+// interface
+//
+
+typedef struct
+{
+   RIB_ENTRY_TYPE   type;        // See list above
+   C8 FAR          *entry_name;  // Name of desired function or attribute
+   U32              token;       // Function pointer or attribute token
+   RIB_DATA_SUBTYPE subtype;     // Data (attrib or preference) subtype
+}
+RIB_INTERFACE_ENTRY;
+
+//
+// Standard RAD Interface Broker provider identification attributes
+//
+
+#define PROVIDER_NAME    (-100)  // RIB_STRING name of decoder
+#define PROVIDER_VERSION (-101)  // RIB_HEX BCD version number
+
+//
+// Standard function to obtain provider attributes (see PROVIDER_ defines
+// above)
+//
+// Each provider of a searchable interface must export this function
+//
+
+typedef U32 (AILCALL FAR *PROVIDER_QUERY_ATTRIBUTE) (HATTRIB index);
+
+//
+// Macros to simplify interface registrations/requests for functions,
+// attributes, and preferences
+//
+
+#define FN(entry_name)        { RIB_FUNCTION, #entry_name, (U32) &(entry_name), RIB_NONE }
+#define REG_FN(entry_name)    { RIB_FUNCTION, #entry_name, (U32) &(entry_name), RIB_NONE }
+
+#define AT(entry_name,ID)             { RIB_ATTRIBUTE, (entry_name), (U32) &(ID), RIB_NONE }
+#define REG_AT(entry_name,ID,subtype) { RIB_ATTRIBUTE, (entry_name), (U32)  (ID), subtype  }
+
+#define PR(entry_name,ID)             { RIB_PREFERENCE, (entry_name), (U32) &(ID), RIB_NONE }
+#define REG_PR(entry_name,ID,subtype) { RIB_PREFERENCE, (entry_name), (U32)  (ID), subtype  }
+
+#define RIB_register(x,y,z)   RIB_register_interface  (HPROVIDER(x), y, ARY_CNT(z), z)
+#define RIB_unregister(x,y,z) RIB_unregister_interface(HPROVIDER(x), y, ARY_CNT(z), z)
+#define RIB_unregister_all(x) RIB_unregister_interface(HPROVIDER(x), NULL, 0, NULL)
+#define RIB_free_libraries()  RIB_free_provider_library(HPROVIDER(NULL));
+#define RIB_request(x,y,z)    RIB_request_interface   (x, y, ARY_CNT(z), z)
+
+// ----------------------------------
+// Standard RIB API prototypes
+// ----------------------------------
+
+DXDEC  HPROVIDER  AILCALL RIB_alloc_provider_handle   (U32            module);
+DXDEC  void       AILCALL RIB_free_provider_handle    (HPROVIDER      provider);
+
+DXDEC  HPROVIDER  AILCALL RIB_load_provider_library   (C8 const FAR *filename);
+DXDEC  void       AILCALL RIB_free_provider_library   (HPROVIDER      provider);
+
+DXDEC  HPROVIDER  AILCALL RIB_provider_library_handle (void);
+
+DXDEC  RIBRESULT  AILCALL RIB_register_interface      (HPROVIDER                      provider,
+                                                       C8 const FAR                   *interface_name,
+                                                       S32                            entry_count,
+                                                       RIB_INTERFACE_ENTRY const FAR *rlist);
+
+DXDEC  RIBRESULT  AILCALL RIB_unregister_interface    (HPROVIDER                      provider,
+                                                       C8 const FAR                  *interface_name,
+                                                       S32                            entry_count,
+                                                       RIB_INTERFACE_ENTRY const FAR *rlist);
+
+DXDEC  RIBRESULT  AILCALL RIB_request_interface       (HPROVIDER                provider,
+                                                       C8 const FAR            *interface_name,
+                                                       S32                      entry_count,
+                                                       RIB_INTERFACE_ENTRY FAR *rlist);
+
+DXDEC  RIBRESULT  AILCALL RIB_request_interface_entry (HPROVIDER                provider,
+                                                       C8 const FAR            *interface_name,
+                                                       RIB_ENTRY_TYPE           entry_type,
+                                                       C8 const FAR            *entry_name,
+                                                       U32 FAR                 *token);
+
+DXDEC  S32        AILCALL RIB_enumerate_interface     (HPROVIDER                provider,
+                                                       C8 FAR             *interface_name,
+                                                       RIB_ENTRY_TYPE           type,
+                                                       HINTENUM FAR            *next,
+                                                       RIB_INTERFACE_ENTRY FAR *dest);
+
+DXDEC  S32        AILCALL RIB_enumerate_providers     (C8 FAR                  *interface_name,
+                                                       HPROENUM FAR            *next,
+                                                       HPROVIDER FAR           *dest);
+
+DXDEC  C8 FAR *   AILCALL RIB_type_string             (U32                      data,
+                                                       RIB_DATA_SUBTYPE         subtype);
+
+DXDEC  HPROVIDER  AILCALL RIB_find_file_provider      (C8 const FAR            *interface_name,
+                                                       C8 const FAR            *attribute_name,
+                                                       C8 const FAR            *file_suffix);
+
+DXDEC  HPROVIDER  AILCALL RIB_find_provider           (C8 const FAR            *interface_name,
+                                                       C8 const FAR            *attribute_name,
+                                                       C8 const FAR            *attribute_value);
+
+DXDEC  HPROVIDER  AILCALL RIB_find_files_provider     (C8 const FAR *interface_name,
+                                                       C8 const FAR *attribute_name_1,
+                                                       C8 const FAR *file_suffix_1,
+                                                       C8 const FAR *attribute_name_2,
+                                                       C8 const FAR *file_suffix_2);
+
+DXDEC  HPROVIDER  AILCALL RIB_find_file_dec_provider  (C8 const FAR *interface_name,
+                                                       C8 const FAR *attribute_name_1,
+                                                       U32 attribute_value_1,
+                                                       C8 const FAR *attribute_name_2,
+                                                       C8 const FAR *file_suffix_2);
+
+DXDEC  S32        AILCALL RIB_load_application_providers
+                                                      (C8 const FAR  *filespec);
+
+DXDEC  void       AILCALL RIB_set_provider_user_data  (HPROVIDER provider,
+                                                       U32       index,
+                                                       S32       value);
+
+DXDEC  S32        AILCALL RIB_provider_user_data      (HPROVIDER provider,
+                                                       U32       index);
+
+DXDEC  void       AILCALL RIB_set_provider_system_data
+                                                      (HPROVIDER provider,
+                                                       U32       index,
+                                                       S32       value);
+
+DXDEC  S32        AILCALL RIB_provider_system_data    (HPROVIDER provider,
+                                                       U32       index);
+
+DXDEC  C8 FAR *  AILCALL  RIB_error                   (void);
+
+#endif
+
+#ifndef MSS_ASI_VERSION // MSSASI.H contents included if MSSASI.H not already included
+
+// #include "mssasi.h"
+
+#define AIL_ASI_VERSION  1
+#define AIL_ASI_REVISION 0
+
+//
+// Handle to stream being managed by ASI codec
+//
+
+typedef S32 HASISTREAM;
+
+//
+// ASI result codes
+//
+
+typedef S32 ASIRESULT;
+
+#define ASI_NOERR                   0   // Success -- no error
+#define ASI_NOT_ENABLED             1   // ASI not enabled
+#define ASI_ALREADY_STARTED         2   // ASI already started
+#define ASI_INVALID_PARAM           3   // Invalid parameters used
+#define ASI_INTERNAL_ERR            4   // Internal error in ASI driver
+#define ASI_OUT_OF_MEM              5   // Out of system RAM
+#define ASI_ERR_NOT_IMPLEMENTED     6   // Feature not implemented
+#define ASI_NOT_FOUND               7   // ASI supported device not found
+#define ASI_NOT_INIT                8   // ASI not initialized
+#define ASI_CLOSE_ERR               9   // ASI not closed correctly
+
+// ----------------------------------
+// Application-provided ASI callbacks
+// ----------------------------------
+
+//
+// AILASIFETCHCB: Called by ASI to obtain data from stream source
+//
+// offset normally will be either 0 at the first call made by the codec
+// or -1 to specify a continuous stream, except when ASI_stream_seek()
+// is called to restart the stream codec at a new stream offset.  In this
+// case, the application must execute the seek operation on the ASI codec's
+// behalf.
+//
+// In response to this callback, the application should read the requested
+// data and copy it to the specified destination buffer, returning the number
+// of bytes copied (which can be less than bytes_requested if the end of
+// the stream is reached).
+//
+
+typedef S32 (AILCALLBACK FAR * AILASIFETCHCB) (U32       user,            // User value passed to ASI_open_stream()
+                                               void FAR *dest,            // Location to which stream data should be copied by app
+                                               S32       bytes_requested, // # of bytes requested by ASI codec
+                                               S32       offset);         // If not -1, application should seek to this point in stream
+
+//############################################################################
+//##                                                                        ##
+//## Interface "ASI codec"                                                  ##
+//##                                                                        ##
+//############################################################################
+
+//
+// Initialize ASI stream codec
+//
+// No other ASI functions may be called outside an ASI_startup() /
+// ASI_shutdown() pair, except for the standard RIB function
+// PROVIDER_query_attribute().  All provider attributes must be accessible
+// without starting up the codec.
+//
+
+typedef ASIRESULT (AILCALL FAR *ASI_STARTUP)(void);
+
+//
+// Shut down ASI codec
+//
+
+typedef ASIRESULT (AILCALL FAR * ASI_SHUTDOWN)(void);
+
+//
+// Return codec error message, or NULL if no errors have occurred since
+// last call
+//
+// The ASI error text state is global to all streams
+//
+
+typedef C8 FAR *  (AILCALL FAR * ASI_ERROR)(void);
+
+//############################################################################
+//##                                                                        ##
+//## Interface "ASI stream"                                                 ##
+//##                                                                        ##
+//############################################################################
+
+//
+// Open a stream, returning handle to stream
+//
+
+typedef HASISTREAM (AILCALL FAR *ASI_STREAM_OPEN) (U32           user,              // User value passed to fetch callback
+                                                   AILASIFETCHCB fetch_CB,          // Source data fetch handler
+                                                   U32           total_size);       // Total size for %-done calculations (0=unknown)
+
+//
+// Translate data in stream, returning # of bytes actually decoded or encoded
+//
+// Any number of bytes may be requested.  Requesting more data than is
+// available in the codec's internal buffer will cause the AILASIFETCHCB
+// handler to be called to fetch more data from the stream.
+//
+
+typedef S32  (AILCALL FAR *ASI_STREAM_PROCESS) (HASISTREAM  stream,              // Handle of stream
+                                                void FAR   *buffer,              // Destination for processed data
+                                                S32         buffer_size);        // # of bytes to return in buffer
+
+//
+// Restart stream decoding process at new offset
+//
+// Relevant for decoders only
+//
+// Seek destination is given as offset in bytes from beginning of stream
+//
+// At next ASI_stream_process() call, decoder will seek to the closest possible
+// point in the stream which occurs at or after the specified position
+//
+// This function has no effect for decoders which do not support random 
+// seeks on a given stream type
+//
+// Warning: some decoders may need to implement seeking by reparsing
+// the entire stream up to the specified offset, through multiple calls
+// to the data-fetch callback.  This operation may be extremely
+// time-consuming on large files or slow network connections.
+//
+// A stream_offset value of -1 may be used to inform the decoder that the
+// application has changed the input stream offset on its own, e.g. for a
+// double-buffering application where the ASI decoder is not accessing the
+// stream directly.  ASI decoders should respond to this by flushing all
+// internal buffers and resynchronizing themselves to the data stream.
+//
+
+typedef ASIRESULT (AILCALL FAR *ASI_STREAM_SEEK)    (HASISTREAM stream,
+                                                     S32        stream_offset);
+
+//
+// Retrieve an ASI stream attribute or preference value by index
+//
+
+typedef S32 (AILCALL FAR *ASI_STREAM_ATTRIBUTE) (HASISTREAM stream,
+                                                 HATTRIB    attrib);
+
+//
+// Set an ASI stream preference value by index
+//
+
+typedef S32 (AILCALL FAR *ASI_STREAM_SET_PREFERENCE) (HASISTREAM stream,
+                                                      HATTRIB    preference,
+                                                      void const FAR  *  value);
+
+//
+// Close stream, freeing handle and all internally-allocated resources
+//
+
+typedef ASIRESULT (AILCALL FAR *ASI_STREAM_CLOSE) (HASISTREAM stream);
+
+#endif
+
+//############################################################################
+//##                                                                        ##
+//## Interface "MSS 3D audio services"                                      ##
+//##                                                                        ##
+//############################################################################
+
+//
+// 3D positioning services
+//
+
+
+typedef struct h3DPOBJECT
+{
+  U32 junk;
+} h3DPOBJECT;
+
+typedef h3DPOBJECT FAR * H3DPOBJECT;
+typedef H3DPOBJECT H3DSAMPLE;
+
+//
+// M3D result codes
+//
+
+typedef S32 M3DRESULT;
+
+#define M3D_NOERR                   0   // Success -- no error
+#define M3D_NOT_ENABLED             1   // M3D not enabled
+#define M3D_ALREADY_STARTED         2   // M3D already started
+#define M3D_INVALID_PARAM           3   // Invalid parameters used
+#define M3D_INTERNAL_ERR            4   // Internal error in M3D driver
+#define M3D_OUT_OF_MEM              5   // Out of system RAM
+#define M3D_ERR_NOT_IMPLEMENTED     6   // Feature not implemented
+#define M3D_NOT_FOUND               7   // M3D supported device not found
+#define M3D_NOT_INIT                8   // M3D not initialized
+#define M3D_CLOSE_ERR               9   // M3D not closed correctly
+
+
+typedef void (AILCALLBACK FAR* AIL3DSAMPLECB)   (H3DSAMPLE sample);
+
+typedef M3DRESULT (AILCALL FAR *M3D_STARTUP)(void);
+
+typedef M3DRESULT (AILCALL FAR *M3D_SHUTDOWN)(void);
+
+typedef C8 FAR *  (AILCALL FAR *M3D_ERROR)(void);
+
+typedef S32       (AILCALL FAR *M3D_SET_PROVIDER_PREFERENCE)(HATTRIB preference,
+                                                             void const FAR *  value);
+
+typedef M3DRESULT  (AILCALL FAR * M3D_ACTIVATE)(S32 enable);
+
+typedef H3DSAMPLE  (AILCALL FAR * M3D_ALLOCATE_3D_SAMPLE_HANDLE)(void);
+
+
+typedef void       (AILCALL FAR * M3D_RELEASE_3D_SAMPLE_HANDLE)(H3DSAMPLE samp);
+                                       
+
+typedef void       (AILCALL FAR * M3D_START_3D_SAMPLE)(H3DSAMPLE samp);
+
+
+typedef void       (AILCALL FAR * M3D_STOP_3D_SAMPLE)(H3DSAMPLE samp);
+                                       
+
+typedef void       (AILCALL FAR * M3D_RESUME_3D_SAMPLE)(H3DSAMPLE samp);
+                                      
+typedef void       (AILCALL FAR * M3D_END_3D_SAMPLE)(H3DSAMPLE samp);
+
+typedef S32        (AILCALL FAR * M3D_SET_3D_SAMPLE_DATA)(H3DSAMPLE         samp,
+                                                          AILSOUNDINFO const FAR  *info);
+
+typedef void       (AILCALL FAR * M3D_SET_3D_SAMPLE_VOLUME)(H3DSAMPLE samp,
+                                                            S32       volume);
+
+typedef void       (AILCALL FAR * M3D_SET_3D_SAMPLE_PLAYBACK_RATE)(H3DSAMPLE samp,
+                                                                   S32       playback_rate);
+
+typedef void       (AILCALL FAR * M3D_SET_3D_SAMPLE_OFFSET)(H3DSAMPLE samp,
+                                                            U32       offset);
+
+
+typedef void       (AILCALL FAR * M3D_SET_3D_SAMPLE_LOOP_COUNT)(H3DSAMPLE samp,
+                                                                U32       loops);
+
+typedef void       (AILCALL FAR * M3D_SET_3D_SAMPLE_LOOP_BLOCK)(H3DSAMPLE S,
+                                                                S32       loop_start_offset,
+                                                                S32       loop_end_offset);
+
+typedef U32        (AILCALL FAR * M3D_3D_SAMPLE_STATUS)(H3DSAMPLE samp);
+
+typedef U32        (AILCALL FAR * M3D_3D_SAMPLE_ATTRIBUTE)(H3DSAMPLE samp, HATTRIB index);
+
+typedef S32        (AILCALL FAR * M3D_3D_SET_SAMPLE_PREFERENCE)(H3DSAMPLE samp, HATTRIB preference, void const FAR * value);
+
+typedef S32        (AILCALL FAR * M3D_3D_SAMPLE_VOLUME)(H3DSAMPLE samp);
+
+typedef S32        (AILCALL FAR * M3D_3D_SAMPLE_PLAYBACK_RATE)(H3DSAMPLE samp);
+
+typedef U32        (AILCALL FAR * M3D_3D_SAMPLE_OFFSET)(H3DSAMPLE     samp);
+
+typedef U32        (AILCALL FAR * M3D_3D_SAMPLE_LENGTH)(H3DSAMPLE     samp);
+
+typedef U32        (AILCALL FAR * M3D_3D_SAMPLE_LOOP_COUNT)(H3DSAMPLE samp);
+
+typedef void       (AILCALL FAR * M3D_SET_3D_SAMPLE_DISTANCES)(H3DSAMPLE samp,
+                                                               F32       max_dist,
+                                                               F32       min_dist);
+
+
+typedef void       (AILCALL FAR * M3D_3D_SAMPLE_DISTANCES)(H3DSAMPLE samp,
+                                                           F32 FAR * max_dist,
+                                                           F32 FAR * min_dist);
+
+typedef  S32      (AILCALL FAR * M3D_ACTIVE_3D_SAMPLE_COUNT)(void);
+
+typedef H3DPOBJECT (AILCALL FAR * M3D_3D_OPEN_LISTENER)(void);
+
+typedef void       (AILCALL FAR * M3D_3D_CLOSE_LISTENER)(H3DPOBJECT listener);
+
+typedef H3DPOBJECT (AILCALL FAR * M3D_3D_OPEN_OBJECT)(void);
+
+typedef void       (AILCALL FAR * M3D_3D_CLOSE_OBJECT)(H3DPOBJECT obj);
+
+typedef void       (AILCALL FAR * M3D_SET_3D_POSITION)(H3DPOBJECT obj,
+                                                       F32     X,
+                                                       F32     Y,
+                                                       F32     Z);
+
+typedef void       (AILCALL FAR * M3D_SET_3D_VELOCITY)(H3DPOBJECT obj,
+                                                       F32     dX_per_ms,
+                                                       F32     dY_per_ms,
+                                                       F32     dZ_per_ms,
+                                                       F32     magnitude);
+
+typedef void       (AILCALL FAR * M3D_SET_3D_VELOCITY_VECTOR)(H3DPOBJECT obj,
+                                                              F32     dX_per_ms,
+                                                              F32     dY_per_ms,
+                                                              F32     dZ_per_ms);
+
+typedef void       (AILCALL FAR * M3D_SET_3D_ORIENTATION)(H3DPOBJECT obj,
+                                                          F32     X_face,
+                                                          F32     Y_face,
+                                                          F32     Z_face,
+                                                          F32     X_up,
+                                                          F32     Y_up,
+                                                          F32     Z_up);
+
+typedef void       (AILCALL FAR * M3D_3D_POSITION)(H3DPOBJECT  obj,
+                                                   F32 FAR *X,
+                                                   F32 FAR *Y,
+                                                   F32 FAR *Z);
+
+typedef void       (AILCALL FAR * M3D_3D_VELOCITY)(H3DPOBJECT  obj,
+                                                   F32 FAR *dX_per_ms,
+                                                   F32 FAR *dY_per_ms,
+                                                   F32 FAR *dZ_per_ms);
+
+typedef void       (AILCALL FAR * M3D_3D_ORIENTATION)(H3DPOBJECT  obj,
+                                                      F32 FAR *X_face,
+                                                      F32 FAR *Y_face,
+                                                      F32 FAR *Z_face,
+                                                      F32 FAR *X_up,
+                                                      F32 FAR *Y_up,
+                                                      F32 FAR *Z_up);
+
+typedef void       (AILCALL FAR * M3D_3D_UPDATE_POSITION)(H3DPOBJECT obj,
+                                                          F32     dt_milliseconds);
+
+typedef void       (AILCALL FAR * M3D_3D_AUTO_UPDATE_POSITION)(H3DPOBJECT obj,
+                                                               S32        enable);
+
+typedef S32        (AILCALL FAR * M3D_3D_ROOM_TYPE)(void);
+typedef void       (AILCALL FAR * M3D_SET_3D_ROOM_TYPE)(S32 EAX_room_type);
+typedef S32        (AILCALL FAR * M3D_3D_SPEAKER_TYPE)(void);
+typedef void       (AILCALL FAR * M3D_SET_3D_SPEAKER_TYPE)(S32 speaker_type);
+typedef void       (AILCALL FAR * M3D_SET_3D_SAMPLE_OBSTRUCTION)(H3DSAMPLE samp, F32 obstruction);
+typedef void       (AILCALL FAR * M3D_SET_3D_SAMPLE_OCCLUSION)(H3DSAMPLE samp, F32 occlusion);
+typedef void       (AILCALL FAR * M3D_SET_3D_SAMPLE_EFFECTS_LEVEL)(H3DSAMPLE samp, F32 effects_level);
+typedef F32        (AILCALL FAR * M3D_3D_SAMPLE_OBSTRUCTION)(H3DSAMPLE samp);
+typedef F32        (AILCALL FAR * M3D_3D_SAMPLE_OCCLUSION)(H3DSAMPLE samp);
+typedef F32        (AILCALL FAR * M3D_3D_SAMPLE_EFFECTS_LEVEL)(H3DSAMPLE samp);
+
+typedef AIL3DSAMPLECB (AILCALL FAR * M3D_SET_3D_EOS)(H3DSAMPLE client,H3DSAMPLE samp,AIL3DSAMPLECB cb);
+
+typedef void       (AILCALL FAR * M3D_SET_3D_SAMPLE_CONE)(H3DSAMPLE samp, F32 inner_angle, F32 outer_angle, S32 outer_volume);
+typedef void       (AILCALL FAR * M3D_3D_SAMPLE_CONE)(H3DSAMPLE samp, F32 FAR* inner_angle, F32 FAR* outer_angle, S32 FAR* outer_volume);
+
+//############################################################################
+//##                                                                        ##
+//## Interface "MSS mixer services"                                         ##
+//##                                                                        ##
+//############################################################################
+
+//
+// Operation flags used by mixer module
+//
+
+#define M_DEST_STEREO 1       // Set to enable stereo mixer output
+#define M_SRC_16      2       // Set to enable mixing of 16-bit samples
+#define M_FILTER      4       // Set to enable filtering when resampling
+#define M_SRC_STEREO  8       // Set to enable mixing of stereo input samples
+#define M_VOL_SCALING 16      // Set to enable volume scalars other than 2047
+#define M_RESAMPLE    32      // Set to enable playback ratios other than 65536
+#define M_ORDER       64      // Set to reverse L/R stereo order for sample
+
+#ifdef IS_32
+
+//
+// Initialize mixer
+//
+// No other mixer functions may be called outside a MIXER_startup() /
+// MIXER_shutdown() pair, except for the standard RIB function
+// PROVIDER_query_attribute().  All provider attributes must be accessible
+// without starting up the module.
+//
+
+typedef void (AILCALL FAR *MIXER_STARTUP)(void);
+
+//
+// Shut down mixer
+//
+
+typedef void (AILCALL FAR *MIXER_SHUTDOWN)(void);
+
+//
+// Flush mixer buffer
+//
+
+typedef void (AILCALL FAR *MIXER_FLUSH)   (S32 FAR *dest,
+                                           S32      len,
+                                           S32 FAR *reverb_buffer,
+                                           S32      reverb_level
+#ifdef IS_X86
+                                           ,U32             MMX_available
+#endif
+                                           );
+
+//
+// Perform audio mixing operation
+//
+
+typedef void (AILCALL FAR *MIXER_MERGE)   (void const FAR * FAR *src,
+                                           U32        FAR *src_fract,
+                                           void const FAR *src_end,
+                                           S32  FAR * FAR *dest,
+                                           void FAR       *dest_end,
+                                           S32  FAR       *left_val,
+                                           S32  FAR       *right_val,
+                                           S32             playback_ratio,
+                                           S32             scale_left,
+                                           S32             scale_right,
+                                           U32             operation
+#ifdef IS_X86
+                                           ,U32             MMX_available
+#endif
+                                           );
+
+//
+// Translate mixer buffer contents to final output format
+//
+
+#ifdef IS_MAC
+
+typedef void (AILCALL FAR *MIXER_COPY) (void const FAR  *src,
+                                        S32       src_len,
+                                        void FAR *dest,
+                                        U32       operation,
+                                        U32       big_endian_output);
+#else
+
+typedef void (AILCALL FAR *MIXER_COPY) (void const FAR  *src,
+                                        S32       src_len,
+                                        void FAR *dest,
+                                        U32       operation,
+                                        U32       MMX_available);
+#endif
+#else
+
+//
+// Initialize mixer
+//
+// No other mixer functions may be called outside a MIXER_startup() /
+// MIXER_shutdown() pair, except for the standard RIB function
+// PROVIDER_query_attribute().  All provider attributes must be accessible
+// without starting up the module.
+//
+
+typedef void (AILCALL FAR *MIXER_STARTUP)(void);
+
+//
+// Shut down mixer
+//
+
+typedef void (AILCALL FAR *MIXER_SHUTDOWN)(void);
+
+//
+// Flush mixer buffer
+//
+
+typedef void (AILCALL FAR *MIXER_FLUSH)   (S32 FAR *dest,
+                                           S32      len,
+                                           S32 FAR *reverb_buffer,
+                                           S32      reverb_level,
+                                           U32      MMX_available);
+
+//
+// Perform audio mixing operation
+//
+
+typedef void (AILCALL FAR *MIXER_MERGE)   (U32             src_sel,
+                                           U32             dest_sel,
+                                           U32        FAR *src_fract,
+                                           U32        FAR *src_offset,
+                                           U32        FAR *dest_offset,
+                                           U32             src_end_offset,
+                                           U32             dest_end_offset,
+                                           S32  FAR       *left_val,
+                                           S32  FAR       *right_val,
+                                           S32             playback_ratio,
+                                           S32             scale_both,
+                                           U32             operation);
+
+//
+// Translate mixer buffer contents to final output format
+//
+
+typedef void (AILCALL FAR *MIXER_COPY) (void const FAR *src,
+                                        S32       src_len,
+                                        void FAR *dest,
+                                        U32       operation,
+                                        U32       MMX_available);
+#endif
+
+//
+// Type definitions
+//
+
+struct _DIG_DRIVER;
+
+struct _MDI_DRIVER;
+
+typedef struct _DIG_DRIVER FAR * HDIGDRIVER;    // Handle to digital driver
+
+typedef struct _MDI_DRIVER FAR * HMDIDRIVER;    // Handle to XMIDI driver
+
+typedef struct _SAMPLE FAR * HSAMPLE;           // Handle to sample
+
+typedef struct _SEQUENCE FAR * HSEQUENCE;       // Handle to sequence
+
+typedef S32 HTIMER;                             // Handle to timer
+
+
+#ifdef IS_DOS
+
+//
+// Type definitions
+//
+
+typedef struct                      // I/O parameters structure
+{
+   S16 IO;
+   S16 IRQ;
+   S16 DMA_8_bit;
+   S16 DMA_16_bit;
+   S32 IO_reserved[4];
+}
+IO_PARMS;
+
+typedef struct                      // Standard MSS 3.X VDI driver header
+{
+   S8     ID[8];                    // "AIL3xxx" ID string, followed by ^Z
+
+   U32    driver_version;
+
+   REALFAR  common_IO_configurations;
+   U16    num_IO_configurations;
+
+   REALFAR  environment_string;
+
+   IO_PARMS IO;
+
+   S16     service_rate;
+
+   U16    busy;
+
+   U16    driver_num;             // Driver number
+
+   U16    this_ISR;               // Offset of INT 66H dispatcher
+   REALFAR  prev_ISR;               // Pointer to previous INT 66H ISR
+
+   S8     scratch[128];           // Shared scratch workspace
+
+   S8     dev_name[80];           // Device name (VDI version >= 1.12 only)
+}
+VDI_HDR;
+
+typedef struct
+{
+   U16 minimum_physical_sample_rate;
+   U16 nominal_physical_sample_rate;
+   U16 maximum_physical_sample_rate;
+
+   U16 minimum_DMA_half_buffer_size;
+   U16 maximum_DMA_half_buffer_size;
+
+   U32 flags;
+}
+DIG_MODE;
+
+typedef struct
+{
+   U8    format_supported[16];
+   DIG_MODE format_data[16];
+}
+DIG_DDT;
+
+typedef struct
+{
+   REALFAR  DMA_buffer_A;
+   REALFAR  DMA_buffer_B;
+   S16     active_buffer;
+}
+DIG_DST;
+
+typedef struct
+{
+   REALFAR  library_environment;
+   REALFAR  GTL_suffix;
+
+   U16    num_voices;
+
+   U16    max_melodic_channel;
+   U16    min_melodic_channel;
+   U16    percussion_channel;
+}
+MDI_DDT;
+
+typedef struct
+{
+   S8     library_directory[128];
+   S8     GTL_filename[128];
+
+   S8     MIDI_data[512];
+}
+MDI_DST;
+
+typedef struct                   // Initialization file structure
+{
+   char     device_name[128];    // Device name
+   char     driver_name[128];    // Driver filename
+   IO_PARMS IO;                  // I/O parameters for driver
+}
+AIL_INI;
+
+typedef struct                   // Handle to driver
+{
+   REALFAR  seg;                 // Seg:off pointer to driver (off=0)
+   U32    sel;                   // Selector for driver (off=0)
+   void    *buf;                 // Protected-mode pointer to driver
+   U32    size;                  // Size of driver image
+   VDI_HDR *VHDR;                // Pointer to driver header (same as buf)
+   S32     type;                 // AIL3DIG or AIL3MDI (see below)
+
+   S32     initialized;          // 1 if hardware successfully init'd, else 0
+
+   S32     PM_ISR;               // -1 if no PM ISR hooked, else IRQ #
+
+   HTIMER   server;              // DRV_SERVE periodic timer, if requested
+
+                                 // Vector to high-level destructor, if any
+
+   void (AILCALL *destructor)(HDIGDRIVER);
+
+                                 // High-level descriptor (DIG_ or MDI_DRIVER)
+   void        *descriptor;
+}
+AIL_DRIVER;
+
+typedef struct                     // VDI interface register structure
+{
+   S16 AX;
+   S16 BX;
+   S16 CX;
+   S16 DX;
+   S16 SI;
+   S16 DI;
+}
+VDI_CALL;
+
+#endif
+
+//
+// Function pointer types
+//
+
+typedef void (AILCALLBACK FAR* AILINCB)       (void const FAR *data, S32 len, U32 user_data);
+
+typedef void (AILCALLBACK FAR* AILTIMERCB)    (U32 user);
+
+typedef void (AILCALLBACK FAR* AILSAMPLECB)   (HSAMPLE sample);
+
+typedef S32  (AILCALLBACK FAR* AILEVENTCB)    (HMDIDRIVER hmi,HSEQUENCE seq,S32 status,S32 data_1,S32 data_2);
+
+typedef S32  (AILCALLBACK FAR* AILTIMBRECB)   (HMDIDRIVER hmi,S32 bank,S32 patch);
+
+typedef S32  (AILCALLBACK FAR* AILPREFIXCB)   (HSEQUENCE seq,S32 log,S32 data);
+
+typedef void (AILCALLBACK FAR* AILTRIGGERCB)  (HSEQUENCE seq,S32 log,S32 data);
+
+typedef void (AILCALLBACK FAR* AILBEATCB)     (HMDIDRIVER hmi,HSEQUENCE seq,S32 beat,S32 measure);
+
+typedef void (AILCALLBACK FAR* AILSEQUENCECB) (HSEQUENCE seq);
+
+//
+// Handle to sample and driver being managed by pipeline filter
+//
+
+typedef S32 HSAMPLESTATE;
+typedef S32 HDRIVERSTATE;
+
+//
+// Digital pipeline stages
+//
+// These are the points at which external modules may be installed into
+// a given HSAMPLE or HDIGDRIVER's processing pipeline
+//
+
+typedef enum
+{
+   DP_ASI_DECODER=0,   // Must be "ASI codec stream" provider
+   DP_FILTER,        // Must be "MSS pipeline filter" provider
+   DP_MERGE,         // Must be "MSS mixer" provider
+   N_SAMPLE_STAGES,  // Placeholder for end of list (= # of valid stages)
+   SAMPLE_ALL_STAGES // Used to signify all pipeline stages, for shutdown
+}
+SAMPLESTAGE;
+
+typedef enum
+{
+   DP_FLUSH = 0,     // Must be "MSS mixer" provider
+   DP_DEFAULT_FILTER, // Must be "MSS pipeline filter" provider (sets the default)
+   DP_DEFAULT_MERGE,  // Must be "MSS mixer" provider (sets the default)
+   DP_COPY,          // Must be "MSS mixer" provider
+   N_DIGDRV_STAGES,  // Placeholder for end of list (= # of valid stages)
+   DIGDRV_ALL_STAGES // Used to signify all pipeline stages, for shutdown
+}
+DIGDRVSTAGE;
+
+typedef struct
+   {
+   ASI_STREAM_OPEN           ASI_stream_open;
+   ASI_STREAM_PROCESS        ASI_stream_process;
+   ASI_STREAM_SEEK           ASI_stream_seek;
+   ASI_STREAM_CLOSE          ASI_stream_close;
+   ASI_STREAM_ATTRIBUTE      ASI_stream_attribute;
+   ASI_STREAM_SET_PREFERENCE ASI_stream_set_preference;
+
+   HATTRIB INPUT_BIT_RATE;
+   HATTRIB INPUT_SAMPLE_RATE;
+   HATTRIB INPUT_BITS;
+   HATTRIB INPUT_CHANNELS;
+   HATTRIB OUTPUT_BIT_RATE;
+   HATTRIB OUTPUT_SAMPLE_RATE;
+   HATTRIB OUTPUT_BITS;
+   HATTRIB OUTPUT_CHANNELS;
+   HATTRIB POSITION;
+   HATTRIB PERCENT_DONE;
+   HATTRIB MIN_INPUT_BLOCK_SIZE;
+   HATTRIB RAW_RATE;
+   HATTRIB RAW_BITS;
+   HATTRIB RAW_CHANNELS;
+   HATTRIB REQUESTED_RATE;
+   HATTRIB REQUESTED_BITS;
+   HATTRIB REQUESTED_CHANS;
+
+   HASISTREAM stream;
+   }
+ASISTAGE;
+
+typedef struct
+   {
+   MIXER_FLUSH MSS_mixer_flush;
+   MIXER_MERGE MSS_mixer_merge;
+   MIXER_COPY  MSS_mixer_copy;
+   }
+MIXSTAGE;
+
+typedef struct
+   {
+   struct _FLTPROVIDER FAR *provider;
+   HSAMPLESTATE             sample_state;
+   }
+FLTSTAGE;
+
+typedef struct
+{
+   S32       active;    // Pass-through if 0, active if 1
+   HPROVIDER provider;
+
+   union
+      {
+      ASISTAGE ASI;
+      MIXSTAGE MIX;
+      FLTSTAGE FLT;
+      }
+   TYPE;
+}
+DPINFO;
+
+//
+// Other data types
+//
+
+typedef struct _AIL_INPUT_INFO        // Input descriptor type
+{
+   U32        device_ID;       // DS LPGUID or wave device ID
+   U32        hardware_format; // e.g., DIG_F_STEREO_16
+   U32        hardware_rate;   // e.g., 22050
+   AILINCB    callback;        // Callback function to receive incoming data
+   S32        buffer_size;     // Maximum # of bytes to be passed to callback (-1 to use DIG_INPUT_LATENCY)
+   U32        user_data;       // this is a user defined value
+}
+AIL_INPUT_INFO;
+
+typedef struct _AILTIMER                 // Timer instance
+{
+   U32      status;
+   AILTIMERCB callback;
+   U32      user;
+
+   S32      elapsed;
+   S32      value;
+   S32      callingCT;           // Calling EXE's task number (16 bit only)
+   S32      callingDS;           // Calling EXE's DS (used in 16 bit only)
+   S32      IsWin32s;            // Is this a Win32s callback
+} AILTIMERSTR;
+
+typedef struct _ADPCMDATATAG
+{
+  U32 blocksize;
+  U32 extrasamples;
+  U32 blockleft;
+  U32 step;
+  U32 savesrc;
+  U32 sample;
+  U32 destend;
+  U32 srcend;
+  U32 samplesL;
+  U32 samplesR;
+  U16 moresamples[16];
+} ADPCMDATA;
+
+typedef struct _SAMPLE           // Sample instance
+{
+   char       tag[4];            // HSAM
+
+   HDIGDRIVER driver;            // Driver for playback
+
+   U32      status;              // SMP_ flags: _FREE, _DONE, _PLAYING
+
+   void const FAR *start[2];     // Sample buffer address (W)
+   U32       len  [2];           // Sample buffer size in bytes (W)
+   U32       pos  [2];           // Index to next byte (R/W)
+   U32       done [2];           // Nonzero if buffer with len=0 sent by app
+   S32       reset_ASI [2];      // Reset the ASI decoder at the end of the buffer
+
+   U32      src_fract;           // Fractional part of source address
+   S32      left_val;            // Mixer source value from end of last buffer
+   S32      right_val;           // Mixer source value from end of last buffer
+
+   S32      current_buffer;      // Buffer # active (0/1)
+   S32      last_buffer;         // Last active buffer (for double-buffering)
+   S32      starved;             // Buffer stream has run out of data
+
+   S32      loop_count;          // # of cycles-1 (1=one-shot, 0=indefinite)
+   S32      loop_start;          // Starting offset of loop block (0=SOF)
+   S32      loop_end;            // End offset of loop block (-1=EOF)
+
+   S32      format;              // DIG_F format (8/16 bits, mono/stereo)
+   U32      flags;               // DIG_PCM_SIGN / DIG_PCM_ORDER (stereo only)
+
+   S32      playback_rate;       // Playback rate in hertz
+
+   S32      volume;              // Sample volume 0-127
+   S32      pan;                 // Mono panpot/stereo balance (0=L ... 127=R)
+
+   S32      left_scale;          // Left/mono volume scalar 0-2047
+   S32      right_scale;         // Right volume scalar 0-2047
+
+   S32      service_type;        // 1 if single-buffered; 2 if streamed
+
+   AILSAMPLECB  SOB;             // Start-of-block callback function
+   AILSAMPLECB  EOB;             // End-of-buffer callback function
+   AILSAMPLECB  EOS;             // End-of-sample callback function
+
+   S32      user_data  [8];      // Miscellaneous user data
+   S32      system_data[8];      // Miscellaneous system data
+
+   ADPCMDATA adpcm;
+
+#ifdef IS_WINDOWS
+
+   S32      SOB_IsWin32s;        // Is this a Win32s callback
+   S32      EOB_IsWin32s;        // Is this a Win32s callback
+   S32      EOS_IsWin32s;        // Is this a Win32s callback
+
+   //
+   // DirectSound-specific data
+   //
+
+   S32      secondary_buffer;    // Secondary buffer index
+
+   S32      service_interval;    // Service sample every n ms
+   S32      service_tick;        // Current service countdown value
+   S32      buffer_segment_size; // Buffer segment size to fill
+
+   S32      prev_segment;        // Previous segment # (0...n)
+   S32      prev_cursor;         // Previous play cursor location
+
+   S32      bytes_remaining;     // # of bytes left to play (if not -1)
+
+   S32      direct_control;      // 1 if app controls buffer, 0 if MSS
+
+#endif
+
+   S32      doeob;               // Flags to trigger callbacks
+   S32      dosob;
+   S32      doeos;
+
+   //
+   // Sample pipeline stages
+   //
+
+   DPINFO   pipeline[N_SAMPLE_STAGES];
+
+   //
+   // Reverb parms
+   //
+
+   F32      reverb_level;           // Level [0.0, 1.0]
+   F32      reverb_reflect_time;    // Reflect time in milliseconds
+   F32      reverb_decay_time;      // Decay time [0.1, 20.0]
+   S32      base_scale;             // Original 12-bit volume scalar
+}
+SAMPLE;
+
+#if defined(IS_WINDOWS) || defined(IS_MAC)
+
+DXDEC  U32     AILCALL  AIL_get_timer_highest_delay   (void);
+
+DXDEC  void         AILCALL AIL_serve(void);
+
+#ifdef IS_MAC
+
+typedef void * LPSTR;
+
+#define WHDR_DONE 0
+
+typedef struct _WAVEIN
+{
+  long temp;
+} * HWAVEIN;
+
+typedef struct _WAVEHDR
+{
+  S32  dwFlags;
+  S32  dwBytesRecorded;
+  S32  dwUser;
+  S32  temp;
+  void * lpData;
+  S32  dwBufferLength;
+  S32  longdwLoops;
+  S32  dwLoops;
+  void * lpNext;
+  U32  * reserved;
+
+} WAVEHDR, * LPWAVEHDR;
+
+#endif
+
+typedef struct _DIG_INPUT_DRIVER FAR *HDIGINPUT; // Handle to digital input driver
+
+typedef struct _DIG_INPUT_DRIVER    // Handle to digital input driver
+{
+   C8     tag[4];                   // HDIN
+
+   HTIMER background_timer;         // Background timer handle
+
+   AIL_INPUT_INFO info;             // Input device descriptor
+   
+   S32       input_enabled;         // 1 if enabled, 0 if not
+
+#ifndef IS_MAC
+
+   U32          callback_user;      // Callback user value
+
+   //
+   // Provider-independent data
+   //
+
+   U32       DMA_size;              // Size of each DMA sub-buffer in bytes
+   void FAR *DMA[2];                // Simulated DMA buffers
+
+   U8        silence;               // Silence value for current format (0 or 128)
+
+   S32       device_active;         // 1 if buffers submittable, 0 if not
+
+   //
+   // waveOut-specific data
+   //
+
+   HWAVEIN          hWaveIn;        // Handle to wave input device
+   volatile WAVEHDR wavehdr[2];     // Handles to wave headers
+
+#else
+  Boolean  timer_started;
+  Boolean  locked;
+  Boolean  enter_lock;
+  U32      saved_period;
+
+  void*    my_vars;
+
+  //
+  // Input related
+  //
+
+  U32    input_buffer_size;
+  char   * input_buffers[2];
+
+  //
+  //   Mix related
+  //
+
+  char * build_buffer;
+  U32  build_buffer_size;
+
+  //
+  // Output related
+  //
+  struct
+  {
+    S8 * buffer;
+    S8 * buffer_end;
+
+    U32  size;
+    S8 * right_margine;
+    S8 * current_head;
+    S8 * current_tail;
+  } output_buffer;
+
+  S32  mix_operation;
+  S32  playback_ratio;
+  U32  src_fract;
+  S8 * current_head;
+  S32  left_val;
+  S32  right_val;
+
+  U32  stored_sample_size;
+  U32  stored_number_of_channels;
+
+  U32  last_rw_delta;
+  U32  period;
+
+#endif
+}
+DIG_INPUT_DRIVER;
+
+#endif
+
+typedef struct _DIG_DRIVER          // Handle to digital audio driver
+{
+   char     tag[4];                 // HDIG
+
+   HTIMER      backgroundtimer;     // Background timer handle
+
+   S32         quiet;               // # of consecutive quiet sample periods
+
+   S32         n_active_samples;    // # of samples being processed
+
+   S32         master_volume;       // Master sample volume 0-127
+
+   S32         DMA_rate;            // Hardware sample rate
+   S32         hw_format;           // DIG_F code in use
+   U32         hw_mode_flags;       // DIG_PCM_ flags for mode in use
+
+   S32         channels_per_sample; // # of channels per sample (1 or 2)
+   S32         bytes_per_channel;   // # of bytes per channel (1 or 2)
+   S32         channels_per_buffer; // # of channels per half-buffer
+   S32         samples_per_buffer;  // # of samples per half-buffer
+
+   S32         playing;             // Playback active if non-zero
+
+#ifdef IS_MAC
+   U32         n_samples_allocated;
+   U32         n_samples_used;
+   U32         n_samples_played;
+   SAMPLE      *samples;             // Pointer to SAMPLEs
+
+   HDIGDRIVER  next;                // Pointer to next HDIGDRIVER in use
+   U32         reset_works;         // TRUE if OK to do waveOutReset
+   U32         request_reset;       // If nonzero, do waveOutReset ASAP
+   S32         released;            // has the sound manager been released?
+
+   ExtSoundHeader sound_header;
+   SndChannelPtr  sound_channel;
+   SndCallBackUPP global_callback;
+   Ptr            buffers[2];
+   Boolean        loaded[2];
+   U32            work_buffer;
+   U32            play_buffer;
+   U32            load_pos;
+   U32            load_size;
+   Boolean        load;
+   U32            start_time;
+   void*          background_processor;
+
+#else
+   HSAMPLE     samples;             // Pointer to list of SAMPLEs
+#endif
+
+   S32         n_samples;           // # of SAMPLEs
+
+   S32         build_size;          // # of bytes in build buffer
+   S32    FAR *build_buffer;        // Build buffer (4 * samples_per_buffer)
+
+   S32         system_data[8];      // Miscellaneous system data
+
+   S32         buffer_size;         // Size of each output buffer
+
+#ifdef IS_WINDOWS
+
+   //
+   // waveOut-specific interface data
+   //
+
+   HWAVEOUT    hWaveOut;            // Wave output driver
+
+   U32         reset_works;         // TRUE if OK to do waveOutReset
+   U32         request_reset;       // If nonzero, do waveOutReset ASAP
+
+   LPWAVEHDR   first;               // Pointer to first WAVEHDR in chain
+   S32         n_buffers;           // # of output WAVEHDRs in chain
+
+   LPWAVEHDR volatile FAR *return_list; // Circular list of returned WAVEHDRs
+   S32       volatile      return_head; // Head of WAVEHDR list (insertion point)
+   S32       volatile      return_tail; // Tail of WAVEHDR list (retrieval point)
+
+
+   U32         deviceid;            // id from waveout open
+   PCMWAVEFORMAT  wformat;          // format from waveout open
+
+   //
+   // DirectSound-specific interface data
+   //
+
+   U32                    guid;        // The guid id of the ds driver
+   AILLPDIRECTSOUND       pDS;         // DirectSound output driver (don't
+                                       // use with Smacker directly anymore!)
+
+   U32                    ds_priority; // priority opened with
+
+   S32                    emulated_ds; // is ds emulated or not?
+   AILLPDIRECTSOUNDBUFFER lppdsb;      // primary buffer or null
+
+   U32                    dsHwnd;      // HWND used with DirectSound
+
+   AILLPDIRECTSOUNDBUFFER FAR * lpbufflist;   // List of pointers to secondary buffers
+   HSAMPLE         FAR *samp_list;      // HSAMPLE associated with each buffer
+   S32             FAR *sec_format;     // DIG_F_ format for secondary buffer
+   S32                  max_buffs;      // Max. allowable # of secondary buffers
+
+   //
+   // Misc. data
+   //
+
+   S32         released;            // has the sound manager been released?
+
+   U32         foreground_timer;    // Foreground timer handle
+
+   HDIGDRIVER  next;                // Pointer to next HDIGDRIVER in use
+   S32      callingCT;              // Calling EXE's task number (16 bit only)
+   S32      callingDS;              // Calling EXE's DS (used in 16 bit only)
+
+   //
+   // Vars for waveOut emulation
+   //
+
+   S32 DS_initialized;
+
+   AILLPDIRECTSOUNDBUFFER DS_sec_buff;    // Secondary buffer (or NULL if none)
+   AILLPDIRECTSOUNDBUFFER DS_out_buff;    // Output buffer (may be sec or prim)
+   S32 DS_buffer_size;                    // Size of entire output buffer
+
+   S32 DS_frag_cnt;                 // Total fragment count and size, and
+   S32 DS_frag_size;                // last fragment occupied by play cursor
+   S32 DS_last_frag;
+   S32 DS_last_write;
+   S32 DS_last_timer;
+   S32 DS_skip_time;
+
+   S32 DS_use_default_format;       // 1 to force use of default DS primary buffer format
+
+#else
+
+   #ifdef IS_DOS
+
+   // must be first in the DOS section
+   void       *DMA[2];              // Protected-mode pointers to half-buffers
+                                    // (note that DMA[0] may != DMA_buf)
+
+
+   REALFAR     DMA_seg;             // Seg:off pointer to DMA buffers (off=0)
+   U32         DMA_sel;             // Selector for DMA buffers (off=0)
+   void       *DMA_buf;             // Protected-mode pointer to DMA buffers
+
+   S16        *buffer_flag;         // Protected-mode pointer to buffer flag
+   S32         last_buffer;         // Last active buffer flag value in driver
+
+   AIL_DRIVER *drvr;                // Base driver descriptor
+
+   DIG_DDT    *DDT;                 // Protected-mode pointer to DDT
+   DIG_DST    *DST;                 // Protected-mode pointer to DST
+   
+   #endif
+
+#endif
+
+#ifdef IS_X86
+   S32         use_MMX;             // Use MMX with this driver if TRUE
+#endif
+
+   void   FAR *decode_buffer;       // Buffer used by optional ASI pipeline decoder
+   S32         decode_buffer_size;  // # of bytes in decode buffer
+
+   U32 us_count;
+   U32 ms_count;
+   U32 last_ms_polled;
+   U32 last_percent;
+
+   //
+   // Digital driver pipeline stages
+   //
+
+   DPINFO   pipeline[N_DIGDRV_STAGES];
+
+   //
+   // Reverb buffer
+   //
+
+   S32 FAR *reverb_buffer;
+   S32      reverb_buffer_size;
+   S32      reverb_buffer_position;
+
+#ifdef IS_WINDOWS
+   S32                  no_wom_done;    // don't process WOM_DONEs on this driver
+   U32                  wom_done_buffers;
+#endif
+}
+DIG_DRIVER;
+
+typedef struct                      // MIDI status log structure
+   {
+   S32      program   [NUM_CHANS];  // Program Change
+   S32      pitch_l   [NUM_CHANS];  // Pitch Bend LSB
+   S32      pitch_h   [NUM_CHANS];  // Pitch Bend MSB
+
+   S32      c_lock    [NUM_CHANS];  // Channel Lock
+   S32      c_prot    [NUM_CHANS];  // Channel Lock Protection
+   S32      c_mute    [NUM_CHANS];  // Channel Mute
+   S32      c_v_prot  [NUM_CHANS];  // Voice Protection
+   S32      bank      [NUM_CHANS];  // Patch Bank Select
+   S32      gm_bank_l [NUM_CHANS];  // GM Bank Select
+   S32      gm_bank_m [NUM_CHANS];  // GM Bank Select
+   S32      indirect  [NUM_CHANS];  // ICA indirect controller value
+   S32      callback  [NUM_CHANS];  // Callback Trigger
+
+   S32      mod       [NUM_CHANS];  // Modulation
+   S32      vol       [NUM_CHANS];  // Volume
+   S32      pan       [NUM_CHANS];  // Panpot
+   S32      exp       [NUM_CHANS];  // Expression
+   S32      sus       [NUM_CHANS];  // Sustain
+   S32      reverb    [NUM_CHANS];  // Reverb
+   S32      chorus    [NUM_CHANS];  // Chorus
+
+   S32      bend_range[NUM_CHANS];  // Bender Range (data MSB, RPN 0 assumed)
+
+   S32      RPN_L     [NUM_CHANS];  // RPN # LSB
+   S32      RPN_M     [NUM_CHANS];  // RPN # MSB
+   }
+CTRL_LOG;
+
+typedef struct _SEQUENCE                  // XMIDI sequence state table
+{
+   char     tag[4];                       // HSEQ
+
+   HMDIDRIVER driver;                     // Driver for playback
+
+   U32      status;                       // SEQ_ flags
+
+   void const   FAR *TIMB;                // XMIDI IFF chunk pointers
+   void const   FAR *RBRN;
+   void const   FAR *EVNT;
+
+   U8 const     FAR *EVNT_ptr;            // Current event pointer
+
+   U8      FAR *ICA;                      // Indirect Controller Array
+
+   AILPREFIXCB   prefix_callback;         // XMIDI Callback Prefix handler
+   AILTRIGGERCB  trigger_callback;        // XMIDI Callback Trigger handler
+   AILBEATCB     beat_callback;           // XMIDI beat/bar change handler
+   AILSEQUENCECB EOS;                     // End-of-sequence callback function
+
+   S32      loop_count;                   // 0=one-shot, -1=indefinite, ...
+
+   S32      interval_count;               // # of intervals until next event
+   S32      interval_num;                 // # of intervals since start
+
+   S32      volume;                       // Sequence volume 0-127
+   S32      volume_target;                // Target sequence volume 0-127
+   S32      volume_accum;                 // Accumulated volume period
+   S32      volume_period;                // Period for volume stepping
+
+   S32      tempo_percent;                // Relative tempo percentage 0-100
+   S32      tempo_target;                 // Target tempo 0-100
+   S32      tempo_accum;                  // Accumulated tempo period
+   S32      tempo_period;                 // Period for tempo stepping
+   S32      tempo_error;                  // Error counter for tempo DDA
+
+   S32      beat_count;                   // Sequence playback position
+   S32      measure_count;
+
+   S32      time_numerator;               // Sequence timing data
+   S32      time_fraction;
+   S32      beat_fraction;
+   S32      time_per_beat;
+
+   void const FAR *FOR_ptrs[FOR_NEST];    // Loop stack
+   S32      FOR_loop_count [FOR_NEST];
+
+   S32      chan_map       [NUM_CHANS];   // Physical channel map for sequence
+
+   CTRL_LOG shadow;                       // Controller values for sequence
+
+   S32      note_count;                   // # of notes "on"
+
+   S32      note_chan      [MAX_NOTES];   // Channel for queued note (-1=free)
+   S32      note_num       [MAX_NOTES];   // Note # for queued note
+   S32      note_time      [MAX_NOTES];   // Remaining duration in intervals
+
+   S32      user_data  [8];               // Miscellaneous user data
+   S32      system_data[8];               // Miscellaneous system data
+
+#ifdef IS_WINDOWS
+   S32      PREFIX_IsWin32s;              // Is this a Win32s callback
+   S32      TRIGGER_IsWin32s;             // Is this a Win32s callback
+   S32      BEAT_IsWin32s;                // Is this a Win32s callback
+   S32      EOS_IsWin32s;                 // Is this a Win32s callback
+#endif
+} SEQUENCE;
+
+#ifdef IS_MAC
+
+struct MIDIHDR;
+struct MIDIOUT;
+typedef struct MIDIOUT* HMIDIOUT;
+
+#endif
+
+typedef struct _MDI_DRIVER          // Handle to XMIDI driver
+{
+   char     tag[4];                 // HMDI
+
+   HTIMER      timer;               // XMIDI quantization timer
+   S32         interval_time;       // XMIDI quantization timer interval in uS
+
+   S32         disable;             // > 0 to disable XMIDI service
+
+   HSEQUENCE   sequences;           // Pointer to list of SEQUENCEs
+   S32         n_sequences;         // # of SEQUENCEs
+
+   S32         lock  [NUM_CHANS];   // 1 if locked, 2 if protected, else 0
+   HSEQUENCE   locker[NUM_CHANS];   // HSEQUENCE which locked channel
+   HSEQUENCE   owner [NUM_CHANS];   // HSEQUENCE which owned locked channel
+   HSEQUENCE   user  [NUM_CHANS];   // Last sequence to use channel
+   S32         state [NUM_CHANS];   // Lock state prior to being locked
+
+   S32         notes [NUM_CHANS];   // # of active notes in channel
+
+   AILEVENTCB  event_trap;          // MIDI event trap callback function
+   AILTIMBRECB timbre_trap;         // Timbre request callback function
+
+   S32         master_volume;       // Master XMIDI note volume 0-127
+
+   S32         system_data[8];      // Miscellaneous system data
+
+#if defined(IS_WINDOWS) || defined(IS_MAC)
+   
+   S32         released;            // has the hmidiout handle been released
+   U32         deviceid;            // ID of the MIDI device
+   U8      FAR *sysdata;            // SysEx buffer
+
+#endif
+
+#ifdef IS_WINDOWS
+
+   S32      EVENT_IsWin32s;         // Is this a Win32s callback
+   S32      TIMBRE_IsWin32s;        // Is this a Win32s callback
+
+   MIDIHDR FAR *mhdr;               // SysEx header
+
+   HMDIDRIVER  next;                // Pointer to next HMDIDRIVER in use
+   S32      callingCT;              // Calling EXE's task number (16 bit only)
+   S32      callingDS;              // Calling EXE's DS (used in 16 bit only)
+
+   HMIDIOUT    hMidiOut;            // MIDI output driver
+
+#else
+
+   #ifdef IS_DOS
+
+   S32        message_count;       // MIDI message count
+   S32        offset;              // MIDI buffer offset
+
+   AIL_DRIVER *drvr;               // Base driver descriptor
+
+   MDI_DDT    *DDT;                // Protected-mode pointer to DDT
+   MDI_DST    *DST;                // Protected-mode pointer to DST
+   #else
+     #ifdef IS_MAC
+       struct MIDIHDR FAR *mhdr;               // SysEx header
+       HMDIDRIVER  next;                // Pointer to next HMDIDRIVER in use
+       HMIDIOUT    hMidiOut;            // MIDI output driver
+       U32      last_us_time;
+       long     period_counter;
+       long     current_period_sum;
+     #endif
+   #endif
+
+#endif
+
+}
+MDI_DRIVER;
+
+typedef struct                      // XMIDI TIMB IFF chunk
+   {
+   S8    name[4];
+
+   U8    msb;
+   U8    lsb;
+   U8    lsb2;
+   U8    lsb3;
+
+   U16   n_entries;
+
+   U16   timbre[1];
+   }
+TIMB_chunk;
+
+typedef struct                      // XMIDI RBRN IFF entry
+   {
+   S16   bnum;
+   U32   offset;
+   }
+RBRN_entry;
+
+typedef struct                      // Wave library entry
+{
+   S32   bank;                      // XMIDI bank, MIDI patch for sample
+   S32   patch;
+
+   S32   root_key;                  // Root MIDI note # for sample (or -1)
+
+   U32   file_offset;               // Offset of wave data from start-of-file
+   U32   size;                      // Size of wave sample in bytes
+
+   S32   format;                    // DIG_F format (8/16 bits, mono/stereo)
+   U32   flags;                     // DIG_PCM_SIGN / DIG_PCM_ORDER (stereo)
+   S32   playback_rate;             // Playback rate in hertz
+}
+WAVE_ENTRY;
+
+typedef struct                      // Virtual "wave synthesizer" descriptor
+{
+   HMDIDRIVER mdi;                  // MIDI driver for use with synthesizer
+   HDIGDRIVER dig;                  // Digital driver for use with synthesizer
+
+   WAVE_ENTRY FAR *library;         // Pointer to wave library
+
+   AILEVENTCB  prev_event_fn;       // Previous MIDI event trap function
+   AILTIMBRECB prev_timb_fn;        // Previous timbre request trap function
+
+   CTRL_LOG    controls;            // MIDI controller states
+
+   WAVE_ENTRY FAR *wave [NUM_CHANS];// Pointer to WAVE_ENTRY for each channel
+
+   HSAMPLE     S    [MAX_W_VOICES]; // List of HSAMPLE voices
+   S32         n_voices;            // Actual # of voices allocated to synth
+
+   S32         chan [MAX_W_VOICES]; // MIDI channel for each voice, or -1
+   S32         note [MAX_W_VOICES]; // MIDI note number for voice
+   S32         root [MAX_W_VOICES]; // MIDI root note for voice
+   S32         rate [MAX_W_VOICES]; // Playback rate for voice
+   S32         vel  [MAX_W_VOICES]; // MIDI note velocity for voice
+   U32         time [MAX_W_VOICES]; // Timestamp for voice
+
+   U32         event;               // Event counter for LRU timestamps
+}
+WAVE_SYNTH;
+
+typedef WAVE_SYNTH FAR * HWAVESYNTH;// Handle to virtual wave synthesizer
+
+//
+// Handle to thread which called AIL_startup()
+//
+// This thread is suspended by MSS callback threads, to simulate DOS-style
+// interrupt handler behavior
+//
+
+#ifdef IS_WIN32
+
+extern HANDLE hAppThread;
+
+#endif
+
+//
+// Background flag for timers
+//
+
+extern volatile S32   AIL_bkgnd_flag;
+
+//
+// Global preference array
+//
+
+extern S32            AIL_preference   [N_PREFS];
+
+//
+// DIG_DRIVER list
+//
+
+extern HDIGDRIVER     DIG_first;
+
+//
+// MDI_DRIVER list
+//
+
+extern HMDIDRIVER     MDI_first;
+
+//
+// Miscellaneous system services
+//
+
+#define FILE_READ_WITH_SIZE ((void FAR*)(S32)-1)
+
+#ifndef NO_OLD_SYS_FUNCTIONS
+
+#define MEM_alloc_lock AIL_mem_alloc_lock
+#define MEM_free_lock  AIL_mem_free_lock
+#define FILE_error     AIL_file_error
+#define FILE_size      AIL_file_size
+#define FILE_read      AIL_file_read
+#define FILE_write     AIL_file_write
+
+#ifdef IS_DOS
+
+#define MEM_alloc        AIL_mem_alloc
+#define MEM_free         AIL_mem_free
+#define MEM_use_malloc   AIL_mem_use_malloc
+#define MEM_use_free     AIL_mem_use_free
+#define MEM_alloc_DOS    AIL_mem_alloc_DOS
+#define MEM_free_DOS     AIL_mem_free_DOS
+#define VMM_lock_range   AIL_vmm_lock_range
+#define VMM_unlock_range AIL_vmm_unlock_range
+#define VMM_lock         AIL_vmm_lock
+#define VMM_unlock       AIL_vmm_unlock
+
+#endif
+
+#endif
+
+extern S32 AILCALLBACK DP_ASI_DECODER_callback(U32       user,
+                                               void FAR *dest,
+                                               S32       bytes_requested,
+                                               S32       offset);
+
+DXDEC  void FAR * AILCALL AIL_mem_alloc_lock(U32       size);
+DXDEC  void       AILCALL AIL_mem_free_lock (void FAR *ptr);
+
+DXDEC  S32        AILCALL AIL_file_error   (void);
+
+DXDEC  S32        AILCALL AIL_file_size    (char const FAR  *filename);
+
+DXDEC  void FAR * AILCALL AIL_file_read    (char const FAR   *filename,
+                                           void FAR *dest);
+
+DXDEC  S32        AILCALL AIL_file_write   (char const FAR    *filename,
+                                            void const FAR  *buf,
+                                            U32       len);
+
+DXDEC  S32        AILCALL AIL_WAV_file_write
+                                           (char const FAR    *filename,
+                                            void const FAR  *buf,
+                                            U32       len,
+                                            S32       rate,
+                                            S32       format);
+
+DXDEC  S32        AILCALL AIL_file_append  (char const FAR *filename,
+                                            void const FAR *buf, U32 len);
+
+#ifdef IS_MAC
+
+
+DXDEC  S32        AILCALL AIL_file_fss_size(FSSpec const FAR  *filename);
+
+DXDEC  void FAR * AILCALL AIL_file_fss_read(FSSpec const FAR   *filename,
+                                            void FAR *dest);
+
+DXDEC  S32        AILCALL AIL_file_fss_write(FSSpec const FAR    *filename,
+                                             void const FAR  *buf,
+                                             U32       len);
+
+DXDEC  S32        AILCALL AIL_file_fss_attrib_write
+                                            (FSSpec const FAR    *filename,
+                                             void const FAR  *buf,
+                                             U32       len,
+                                             U32       type,
+                                             U32       creator );
+
+DXDEC  S32        AILCALL AIL_WAV_file_fss_write
+                                           (FSSpec const FAR    *filename,
+                                            void const FAR  *buf,
+                                            U32       len,
+                                            S32       rate,
+                                            S32       format);
+
+DXDEC void * AILCALL AIL_mem_use_malloc(void * AILCALLBACK (*fn)(U32));
+DXDEC void * AILCALL AIL_mem_use_free  (void AILCALLBACK (*fn)(void *));
+
+#endif
+
+#ifdef IS_DOS
+
+extern void * AILCALLBACK (*AIL_mem_alloc) (U32);
+extern void   AILCALLBACK (*AIL_mem_free)  (void *);
+
+void * cdecl AIL_mem_use_malloc(void * AILCALLBACK (*fn)(U32));
+void * cdecl AIL_mem_use_free  (void AILCALLBACK (*fn)(void *));
+
+//
+// Other memory-management functions
+//
+
+DXDEC  S32   AILCALL AIL_mem_alloc_DOS (U32  n_paras,
+                                        void **protected_ptr,
+                                        U32 *segment_far_ptr,
+                                        U32 *selector);
+
+DXDEC  void  AILCALL AIL_mem_free_DOS (void  *protected_ptr,
+                                       U32  segment_far_ptr,
+                                       U32  selector);
+
+DXDEC  S32   AILCALL AIL_vmm_lock_range   (void  *p1, void *p2);
+DXDEC  S32   AILCALL AIL_vmm_unlock_range (void  *p1, void *p2);
+
+DXDEC  S32   AILCALL AIL_vmm_lock         (void  *start, U32 size);
+DXDEC  S32   AILCALL AIL_vmm_unlock       (void  *start, U32 size);
+
+DXDEC  U32  AILCALL AIL_sel_base         (U32  sel);
+
+DXDEC  void   AILCALL AIL_sel_set_limit  (U32  sel,
+                                          U32  limit);
+//
+// Last IO_PARMS structure used to attempt device detection
+//
+
+extern IO_PARMS       AIL_last_IO_attempt;
+
+//
+// Low-level support services
+//
+
+DXDEC REALFAR AILCALL  AIL_get_real_vect            (U32       vectnum);
+
+DXDEC void    AILCALL  AIL_set_real_vect            (U32       vectnum,
+                                                     REALFAR   real_ptr);
+
+DXDEC void    AILCALL  AIL_set_USE16_ISR            (S32        IRQ,
+                                                     REALFAR    real_base,
+                                                     U32        ISR_offset);
+
+DXDEC void    AILCALL  AIL_restore_USE16_ISR        (S32        IRQ);
+
+DXDEC U32     AILCALL  AIL_disable_interrupts       (void);
+DXDEC void    AILCALL  AIL_restore_interrupts       (U32        FD_register);
+
+DXDEC void    AILCALL  AIL_switch_stack             (void       *stack,
+                                                     U32        size,
+                                                     U32        *SS,
+                                                     void       **ESP,
+                                                     void       **EBP);
+
+DXDEC void    AILCALL  AIL_restore_stack            (U32        SS,
+                                                     void       *ESP,
+                                                     void       *EBP);
+
+DXDEC S32     AILCALL  AIL_call_driver              (AIL_DRIVER *drvr,
+                                                     S32        fn,
+                                                     VDI_CALL   *in,
+                                                     VDI_CALL   *out);
+
+DXDEC S32     AILCALL  AIL_read_INI                 (AIL_INI    *INI,
+                                                     char       *filename);
+
+DXDEC U32     AILCALL  AIL_interrupt_divisor        (void);
+
+#endif
+
+
+#ifdef __WATCOMC__
+
+void MSSBreakPoint();
+#pragma aux MSSBreakPoint = "int 3";
+
+#else
+
+#define MSSBreakPoint() __asm {int 3}
+
+#endif
+
+
+//
+// High-level support services
+//
+
+#ifdef IS_MAC
+
+#if !defined(max)
+#define max(a,b)  (((a) > (b)) ? (a) : (b))
+#endif
+#if !defined(min)
+#define min(a,b)  (((a) < (b)) ? (a) : (b))
+#endif
+
+#endif
+
+#ifdef IS_DOS
+
+#ifdef IS_WATCOM
+
+#if !defined(max) // Watcom stdlib.h doesn't define these for C++
+#define max(a,b)  (((a) > (b)) ? (a) : (b))
+#endif
+#if !defined(min)
+#define min(a,b)  (((a) < (b)) ? (a) : (b))
+#endif
+
+#endif
+
+#ifdef __SW_3R
+extern S32 AILCALL AIL_startup_reg               (void);
+#define AIL_startup AIL_startup_reg
+#else
+extern S32 AILCALL AIL_startup_stack             (void);
+#define AIL_startup AIL_startup_stack
+#endif
+
+#define AIL_quick_startup(ud,um,opr,opb,ops) AIL_quick_startup_with_start(&AIL_startup,ud,um,opr,opb,ops)
+
+#define AIL_get_preference(number) (AIL_preference[number])
+
+#else
+
+DXDEC  S32     AILCALL  AIL_startup                   (void);
+
+DXDEC  S32     AILCALL  AIL_get_preference            (U32         number);
+
+#endif
+
+DXDEC  void    AILCALL  AIL_shutdown                  (void);
+
+DXDEC  S32     AILCALL  AIL_set_preference            (U32         number,
+                                                      S32          value);
+
+DXDEC char FAR *AILCALL  AIL_last_error                (void);
+
+DXDEC  void    AILCALL  AIL_set_error                 (char const FAR * error_msg);
+
+//
+// Low-level support services
+//
+
+DXDEC  void    
+#ifndef IS_MAC
+__cdecl
+#endif
+AIL_debug_printf              (C8 const FAR *fmt, ...);
+
+#ifdef IS_X86
+
+DXDEC  U32     AILCALL  AIL_MMX_available             (void);
+
+#endif
+
+DXDEC  void    AILCALL  AIL_lock                      (void);
+DXDEC  void    AILCALL  AIL_unlock                    (void);
+
+#ifdef IS_WIN32
+
+DXDEC  void    AILCALL  AIL_lock_mutex                (void);
+DXDEC  void    AILCALL  AIL_unlock_mutex              (void);
+
+#endif
+
+DXDEC  void    AILCALL  AIL_delay                     (S32         intervals);
+
+DXDEC  S32     AILCALL  AIL_background                (void);
+
+//
+// Process services
+//
+
+DXDEC  HTIMER  AILCALL  AIL_register_timer            (AILTIMERCB  fn);
+
+DXDEC  U32     AILCALL  AIL_set_timer_user            (HTIMER      timer,
+                                                      U32         user);
+
+DXDEC  void    AILCALL  AIL_set_timer_period          (HTIMER      timer,
+                                                      U32         microseconds);
+
+DXDEC  void    AILCALL  AIL_set_timer_frequency       (HTIMER      timer,
+                                                      U32         hertz);
+
+DXDEC  void    AILCALL  AIL_set_timer_divisor         (HTIMER      timer,
+                                                      U32         PIT_divisor);
+
+DXDEC  void    AILCALL  AIL_start_timer               (HTIMER      timer);
+DXDEC  void    AILCALL  AIL_start_all_timers          (void);
+
+DXDEC  void    AILCALL  AIL_stop_timer                (HTIMER      timer);
+DXDEC  void    AILCALL  AIL_stop_all_timers           (void);
+
+DXDEC  void    AILCALL  AIL_release_timer_handle      (HTIMER      timer);
+DXDEC  void    AILCALL  AIL_release_all_timers        (void);
+
+#ifdef IS_WIN32
+
+#ifndef BUILD_MSS
+
+// static function that handles shutdown
+int __cdecl MSS_auto_cleanup(void);
+
+#ifdef _MSC_VER
+// on MSVC, automatically register a cleanup function
+//ODCODENOTE Remove
+//#define AIL_startup() (MSS_auto_cleanup(),AIL_startup())
+#endif
+
+#endif
+
+DXDEC  HWND    AILCALL  AIL_HWND                      (void);
+
+#else
+  #ifdef IS_MAC
+    DXDEC ProcessSerialNumber AIL_Process(void);
+  #endif
+#endif
+
+//
+// high-level digital services
+//
+
+DXDEC HDIGDRIVER AILCALL AIL_open_digital_driver( U32 frequency,
+                                                  S32 bits,
+                                                  S32 channel,
+                                                  U32 flags );
+
+#define AIL_OPEN_DIGITAL_FORCE_PREFERENCE 1
+
+DXDEC void AILCALL AIL_close_digital_driver( HDIGDRIVER dig );
+
+#ifdef IS_WINDOWS
+
+#define AIL_MSS_version(str,len)        \
+{                                       \
+  HINSTANCE l=LoadLibrary(MSSDLLNAME);  \
+  if ((U32)l<=32)                       \
+    *(str)=0;                           \
+  else {                                \
+    LoadString(l,1,str,len);            \
+    FreeLibrary(l);                     \
+  }                                     \
+}
+
+DXDEC  S32          AILCALL AIL_waveOutOpen          (HDIGDRIVER   FAR *drvr,
+                                                      LPHWAVEOUT   FAR  *lphWaveOut,
+                                                      S32             wDeviceID,
+                                                      LPWAVEFORMAT      lpFormat);
+
+DXDEC  void         AILCALL AIL_waveOutClose          (HDIGDRIVER drvr);
+
+DXDEC  S32          AILCALL AIL_digital_handle_release(HDIGDRIVER drvr);
+
+DXDEC  S32          AILCALL AIL_digital_handle_reacquire
+                                                     (HDIGDRIVER drvr);
+
+#else
+
+#ifdef IS_MAC
+
+typedef struct MSS_VersionType_
+{
+  Str255 version_name;
+} MSS_VersionType;
+
+#define AIL_MSS_version(str,len)                        \
+{                                                       \
+  long _res = OpenResFile("\pMiles Shared Library");    \
+  if (_res==-1)                                         \
+  {                                                     \
+    str[0]=0;                                           \
+  }                                                     \
+  else                                                  \
+  {                                                     \
+    Handle _H;                                          \
+    short _Err;                                         \
+    long _cur= CurResFile();                            \
+    UseResFile(_res);                                   \
+    _H = GetResource('vers', 2);                        \
+    _Err = ResError();                                  \
+    if((_Err != noErr) || (_H==0))                      \
+    {                                                   \
+      str[0]=0;                                         \
+      UseResFile(_cur);                                 \
+      CloseResFile(_res);                               \
+    }                                                   \
+    else                                                \
+    {                                                   \
+      if (GetHandleSize(_H)==0)                         \
+      {                                                 \
+        str[0]=0;                                       \
+        UseResFile(_cur);                               \
+        CloseResFile(_res);                             \
+      }                                                 \
+      else                                              \
+      {                                                 \
+        MSS_VersionType * _vt = (MSS_VersionType*)*_H;  \
+        if ((U32)_vt->version_name[6]>4)                \
+          _vt->version_name[6]-=4;                      \
+        else                                            \
+          _vt->version_name[6]=0;                       \
+        if (((U32)len) <= ((U32)_vt->version_name[6]))  \
+          _vt->version_name[6] = (U8)len-1;             \
+        memcpy( str, _vt->version_name+11, _vt->version_name[6] ); \
+        str[_vt->version_name[6]]=0;                    \
+        UseResFile(_cur);                               \
+        CloseResFile(_res);                             \
+      }                                                 \
+      ReleaseResource(_H);                              \
+    }                                                   \
+  }                                                     \
+}
+
+DXDEC  S32          AILCALL AIL_digital_handle_release(HDIGDRIVER drvr);
+
+DXDEC  S32          AILCALL AIL_digital_handle_reacquire
+                                                     (HDIGDRIVER drvr);
+
+#else
+
+//
+// DOS installation services
+//
+
+DXDEC IO_PARMS *   AILCALL AIL_get_IO_environment    (AIL_DRIVER *drvr);
+
+DXDEC AIL_DRIVER*  AILCALL AIL_install_driver        (U8 const     *driver_image,
+                                                      U32       n_bytes);
+
+DXDEC void         AILCALL AIL_uninstall_driver      (AIL_DRIVER *drvr);
+
+DXDEC S32         AILCALL AIL_install_DIG_INI       (HDIGDRIVER *dig);
+
+DXDEC HDIGDRIVER   AILCALL AIL_install_DIG_driver_file
+                                                    (char const *filename,
+                                                     IO_PARMS   *IO);
+
+DXDEC void         AILCALL AIL_uninstall_DIG_driver  (HDIGDRIVER  dig);
+
+
+DXDEC HDIGDRIVER   AILCALL AIL_install_DIG_driver_image
+                                                    (void const    *driver_image,
+                                                     U32     size,
+                                                     IO_PARMS *IO);
+#endif
+#endif
+
+DXDEC char FAR*     AILCALL AIL_set_redist_directory(char const FAR*dir);
+
+DXDEC  S32          AILCALL AIL_digital_CPU_percent   (HDIGDRIVER dig);
+
+DXDEC  S32          AILCALL AIL_digital_latency       (HDIGDRIVER dig);
+
+DXDEC  HSAMPLE      AILCALL AIL_allocate_sample_handle
+                                                      (HDIGDRIVER dig);
+
+DXDEC  HSAMPLE      AILCALL AIL_allocate_file_sample  (HDIGDRIVER dig,
+                                                       void const       FAR *file_image,
+                                                       S32         block);
+
+DXDEC  void         AILCALL AIL_release_sample_handle (HSAMPLE S);
+
+DXDEC  void         AILCALL AIL_init_sample           (HSAMPLE S);
+
+DXDEC  S32          AILCALL AIL_set_sample_file       (HSAMPLE   S,
+                                                       void const FAR *file_image,
+                                                       S32       block);
+
+DXDEC  S32          AILCALL AIL_set_named_sample_file (HSAMPLE   S,
+                                                       C8 const   FAR *file_type_suffix,
+                                                       void const FAR *file_image,
+                                                       S32       file_size,
+                                                       S32       block);
+
+DXDEC  HPROVIDER    AILCALL AIL_set_sample_processor  (HSAMPLE     S,
+                                                       SAMPLESTAGE pipeline_stage,
+                                                       HPROVIDER   provider);
+
+DXDEC  HPROVIDER    AILCALL AIL_set_digital_driver_processor
+                                                      (HDIGDRIVER  dig,
+                                                       DIGDRVSTAGE pipeline_stage,
+                                                       HPROVIDER   provider);
+
+DXDEC  void         AILCALL AIL_set_sample_adpcm_block_size
+                                                     (HSAMPLE S,
+                                                     U32     blocksize);
+
+DXDEC  void         AILCALL AIL_set_sample_address    (HSAMPLE S,
+                                                     void const   FAR *start,
+                                                     U32     len);
+
+DXDEC  void         AILCALL AIL_set_sample_type       (HSAMPLE S,
+                                                     S32     format,
+                                                     U32     flags);
+
+DXDEC  void         AILCALL AIL_start_sample          (HSAMPLE S);
+
+DXDEC  void         AILCALL AIL_stop_sample           (HSAMPLE S);
+
+DXDEC  void         AILCALL AIL_resume_sample         (HSAMPLE S);
+
+DXDEC  void         AILCALL AIL_end_sample            (HSAMPLE S);
+
+DXDEC  void         AILCALL AIL_set_sample_playback_rate
+                                                     (HSAMPLE S,
+                                                     S32     playback_rate);
+
+DXDEC  void         AILCALL AIL_set_sample_volume     (HSAMPLE S,
+                                                     S32     volume);
+
+DXDEC  void         AILCALL AIL_set_sample_pan        (HSAMPLE S,
+                                                     S32     pan);
+
+DXDEC  void         AILCALL AIL_set_sample_loop_count (HSAMPLE S,
+                                                     S32     loop_count);
+
+DXDEC  void         AILCALL AIL_set_sample_loop_block (HSAMPLE S,
+                                                     S32     loop_start_offset,
+                                                     S32     loop_end_offset);
+
+DXDEC  U32          AILCALL AIL_sample_status         (HSAMPLE S);
+
+DXDEC  S32          AILCALL AIL_sample_playback_rate  (HSAMPLE S);
+
+DXDEC  S32          AILCALL AIL_sample_volume         (HSAMPLE S);
+
+DXDEC  S32          AILCALL AIL_sample_pan            (HSAMPLE S);
+
+DXDEC  S32          AILCALL AIL_sample_loop_count     (HSAMPLE S);
+
+DXDEC  void         AILCALL AIL_set_digital_master_volume
+                                                     (HDIGDRIVER dig,
+                                                     S32         master_volume);
+
+DXDEC  S32          AILCALL AIL_digital_master_volume (HDIGDRIVER dig);
+
+DXDEC  void         AILCALL AIL_set_sample_reverb(HSAMPLE S,
+                                                        F32     reverb_level,
+                                                        F32     reverb_reflect_time,
+                                                        F32     reverb_decay_time);
+
+DXDEC  void         AILCALL AIL_sample_reverb    (HSAMPLE S,
+                                                        F32 FAR *reverb_level,
+                                                        F32 FAR *reverb_reflect_time,
+                                                        F32 FAR *reverb_decay_time);
+
+//
+// low-level digital services
+//
+
+DXDEC  S32      AILCALL AIL_minimum_sample_buffer_size(HDIGDRIVER dig,
+                                                     S32         playback_rate,
+                                                     S32         format);
+
+DXDEC  S32      AILCALL AIL_sample_buffer_ready      (HSAMPLE S);
+
+DXDEC  void     AILCALL AIL_load_sample_buffer       (HSAMPLE S,
+                                                     U32     buff_num,
+                                                     void const   FAR *buffer,
+                                                     U32     len);
+
+DXDEC  void     AILCALL AIL_request_EOB_ASI_reset   (HSAMPLE S,
+                                                     U32     buff_num);
+
+DXDEC  S32      AILCALL AIL_sample_buffer_info      (HSAMPLE S, //)
+                                                    U32     FAR *pos0,
+                                                    U32     FAR *len0,
+                                                    U32     FAR *pos1,
+                                                    U32     FAR *len1);
+
+DXDEC  U32      AILCALL AIL_sample_granularity      (HSAMPLE S);
+
+DXDEC  void     AILCALL AIL_set_sample_position      (HSAMPLE S,
+                                                      U32     pos);
+
+DXDEC  U32      AILCALL AIL_sample_position          (HSAMPLE S);
+
+DXDEC  AILSAMPLECB AILCALL AIL_register_SOB_callback
+                                                    (HSAMPLE S,
+                                                     AILSAMPLECB SOB);
+
+DXDEC  AILSAMPLECB AILCALL AIL_register_EOB_callback
+                                                    (HSAMPLE S,
+                                                     AILSAMPLECB EOB);
+
+DXDEC  AILSAMPLECB AILCALL AIL_register_EOS_callback
+                                                    (HSAMPLE S,
+                                                     AILSAMPLECB EOS);
+
+DXDEC  AILSAMPLECB AILCALL AIL_register_EOF_callback
+                                                    (HSAMPLE S,
+                                                     AILSAMPLECB EOFILE);
+
+DXDEC  void     AILCALL AIL_set_sample_user_data   (HSAMPLE S,
+                                                     U32     index,
+                                                     S32     value);
+
+DXDEC  S32      AILCALL AIL_sample_user_data       (HSAMPLE S,
+                                                     U32     index);
+
+DXDEC  S32      AILCALL AIL_active_sample_count    (HDIGDRIVER dig);
+
+DXDEC  void     AILCALL AIL_digital_configuration  (HDIGDRIVER dig,
+                                                      S32   FAR *rate,
+                                                      S32   FAR *format,
+                                                      char  FAR *string);
+#ifdef IS_WIN32
+
+DXDEC  S32      AILCALL AIL_set_direct_buffer_control (HSAMPLE S,
+                                                     U32      command);
+
+DXDEC  void     AILCALL AIL_get_DirectSound_info  (HSAMPLE              S,
+                                                   AILLPDIRECTSOUND    *lplpDS,
+                                                   AILLPDIRECTSOUNDBUFFER *lplpDSB);
+
+DXDEC  S32      AILCALL AIL_set_DirectSound_HWND(HDIGDRIVER dig, HWND wnd);
+
+#endif
+
+DXDEC  void     AILCALL AIL_set_sample_ms_position (HSAMPLE    S, //)
+                                                    S32        milliseconds);
+
+DXDEC  void     AILCALL AIL_sample_ms_position     (HSAMPLE    S, //)
+                                                    S32 FAR *  total_milliseconds,
+                                                    S32 FAR *  current_milliseconds);
+
+
+//
+// Digital input services
+//
+
+#if defined(IS_WINDOWS) || defined (IS_MAC)
+
+DXDEC HDIGINPUT AILCALL AIL_open_input             (AIL_INPUT_INFO FAR *info);
+
+DXDEC void      AILCALL AIL_close_input            (HDIGINPUT         dig);
+
+DXDEC AIL_INPUT_INFO FAR *
+                AILCALL AIL_get_input_info         (HDIGINPUT         dig);
+
+DXDEC S32       AILCALL AIL_set_input_state        (HDIGINPUT         dig,
+                                                    S32               enable);
+#endif
+
+
+//
+// High-level XMIDI services
+//
+
+DXDEC HMDIDRIVER AILCALL AIL_open_XMIDI_driver( U32 flags );
+
+#define AIL_OPEN_XMIDI_NULL_DRIVER 1
+
+DXDEC void AILCALL AIL_close_XMIDI_driver( HMDIDRIVER mdi );
+
+#ifdef IS_MAC
+
+DXDEC  S32          AILCALL AIL_MIDI_handle_release
+                                                 (HMDIDRIVER mdi);
+
+DXDEC  S32          AILCALL AIL_MIDI_handle_reacquire
+                                                 (HMDIDRIVER mdi);
+
+#else
+
+#ifdef IS_WINDOWS
+
+DXDEC  S32          AILCALL AIL_midiOutOpen(HMDIDRIVER FAR *drvr,
+                                            LPHMIDIOUT FAR *lphMidiOut,
+                                            S32           dwDeviceID);
+
+DXDEC  void         AILCALL AIL_midiOutClose      (HMDIDRIVER mdi);
+
+DXDEC  S32          AILCALL AIL_MIDI_handle_release
+                                                 (HMDIDRIVER mdi);
+
+DXDEC  S32          AILCALL AIL_MIDI_handle_reacquire
+                                                 (HMDIDRIVER mdi);
+
+#else
+
+#ifdef IS_DOS
+
+DXDEC S32         AILCALL AIL_install_MDI_INI       (HMDIDRIVER *mdi);
+
+DXDEC HMDIDRIVER   AILCALL AIL_install_MDI_driver_file
+                                                    (char const *filename,
+                                                     IO_PARMS   *IO);
+
+DXDEC void         AILCALL AIL_uninstall_MDI_driver  (HMDIDRIVER  mdi);
+
+
+DXDEC HMDIDRIVER   AILCALL AIL_install_MDI_driver_image
+                                                    (void const *driver_image,
+                                                     U32       size,
+                                                     IO_PARMS   *IO);
+
+DXDEC S32     AILCALL AIL_MDI_driver_type           (HMDIDRIVER  mdi);
+
+DXDEC void    AILCALL AIL_set_GTL_filename_prefix   (char const*prefix);
+
+DXDEC S32     AILCALL AIL_timbre_status             (HMDIDRIVER  mdi,
+                                                     S32        bank,
+                                                     S32        patch);
+
+DXDEC S32     AILCALL AIL_install_timbre            (HMDIDRIVER  mdi,
+                                                     S32        bank,
+                                                     S32        patch);
+
+DXDEC void    AILCALL AIL_protect_timbre            (HMDIDRIVER  mdi,
+                                                     S32        bank,
+                                                     S32        patch);
+
+DXDEC void    AILCALL AIL_unprotect_timbre          (HMDIDRIVER  mdi,
+                                                     S32        bank,
+                                                     S32        patch);
+
+#endif
+
+#endif
+
+#endif
+
+DXDEC  HSEQUENCE    AILCALL AIL_allocate_sequence_handle
+                                                     (HMDIDRIVER mdi);
+
+DXDEC  void         AILCALL AIL_release_sequence_handle
+                                                     (HSEQUENCE S);
+
+DXDEC  S32          AILCALL AIL_init_sequence         (HSEQUENCE S,
+                                                     void const     FAR *start,
+                                                     S32       sequence_num);
+
+DXDEC  void         AILCALL AIL_start_sequence        (HSEQUENCE S);
+
+DXDEC  void         AILCALL AIL_stop_sequence         (HSEQUENCE S);
+
+DXDEC  void         AILCALL AIL_resume_sequence       (HSEQUENCE S);
+
+DXDEC  void         AILCALL AIL_end_sequence          (HSEQUENCE S);
+
+DXDEC  void         AILCALL AIL_set_sequence_tempo    (HSEQUENCE S,
+                                                     S32       tempo,
+                                                     S32       milliseconds);
+
+DXDEC  void         AILCALL AIL_set_sequence_volume   (HSEQUENCE S,
+                                                     S32       volume,
+                                                     S32       milliseconds);
+
+DXDEC  void         AILCALL AIL_set_sequence_loop_count
+                                                     (HSEQUENCE S,
+                                                     S32       loop_count);
+
+DXDEC  U32          AILCALL AIL_sequence_status       (HSEQUENCE S);
+
+DXDEC  S32          AILCALL AIL_sequence_tempo        (HSEQUENCE S);
+
+DXDEC  S32          AILCALL AIL_sequence_volume       (HSEQUENCE S);
+
+DXDEC  S32          AILCALL AIL_sequence_loop_count   (HSEQUENCE S);
+
+DXDEC  void         AILCALL AIL_set_XMIDI_master_volume
+                                                     (HMDIDRIVER mdi,
+                                                     S32         master_volume);
+
+DXDEC  S32          AILCALL AIL_XMIDI_master_volume   (HMDIDRIVER mdi);
+
+
+//
+// Low-level XMIDI services
+//
+
+DXDEC  S32      AILCALL AIL_active_sequence_count     (HMDIDRIVER mdi);
+
+DXDEC  S32      AILCALL AIL_controller_value          (HSEQUENCE S,
+                                                      S32       channel,
+                                                      S32       controller_num);
+
+DXDEC  S32      AILCALL AIL_channel_notes             (HSEQUENCE S,
+                                                      S32       channel);
+
+DXDEC  void     AILCALL AIL_sequence_position         (HSEQUENCE S,
+                                                      S32      FAR *beat,
+                                                      S32      FAR *measure);
+
+DXDEC  void     AILCALL AIL_branch_index              (HSEQUENCE  S,
+                                                      U32        marker);
+
+DXDEC  AILPREFIXCB AILCALL AIL_register_prefix_callback
+                                                     (HSEQUENCE  S,
+                                                      AILPREFIXCB callback);
+
+DXDEC  AILTRIGGERCB AILCALL AIL_register_trigger_callback
+                                                     (HSEQUENCE  S,
+                                                      AILTRIGGERCB callback);
+
+DXDEC  AILSEQUENCECB AILCALL AIL_register_sequence_callback
+                                                     (HSEQUENCE  S,
+                                                      AILSEQUENCECB callback);
+
+DXDEC  AILBEATCB AILCALL AIL_register_beat_callback   (HSEQUENCE  S,
+                                                      AILBEATCB callback);
+
+DXDEC  AILEVENTCB AILCALL AIL_register_event_callback (HMDIDRIVER mdi,
+                                                      AILEVENTCB callback);
+
+DXDEC  AILTIMBRECB AILCALL AIL_register_timbre_callback
+                                                     (HMDIDRIVER mdi,
+                                                      AILTIMBRECB callback);
+
+DXDEC  void     AILCALL AIL_set_sequence_user_data    (HSEQUENCE S,
+                                                      U32       index,
+                                                      S32       value);
+
+DXDEC  S32      AILCALL AIL_sequence_user_data        (HSEQUENCE S,
+                                                      U32       index);
+
+DXDEC  void     AILCALL AIL_register_ICA_array        (HSEQUENCE S,
+                                                      U8       FAR *array);
+
+DXDEC  S32      AILCALL AIL_lock_channel              (HMDIDRIVER mdi);
+
+DXDEC  void     AILCALL AIL_release_channel           (HMDIDRIVER mdi,
+                                                      S32         channel);
+
+DXDEC  void     AILCALL AIL_map_sequence_channel      (HSEQUENCE S,
+                                                      S32       seq_channel,
+                                                      S32       new_channel);
+
+DXDEC  S32      AILCALL AIL_true_sequence_channel     (HSEQUENCE S,
+                                                      S32       seq_channel);
+
+DXDEC  void     AILCALL AIL_send_channel_voice_message
+                                                     (HMDIDRIVER  mdi,
+                                                      HSEQUENCE   S,
+                                                      S32         status,
+                                                      S32         data_1,
+                                                      S32         data_2);
+
+DXDEC  void     AILCALL AIL_send_sysex_message        (HMDIDRIVER mdi,
+                                                       void const       FAR *buffer);
+
+DXDEC  HWAVESYNTH
+                AILCALL AIL_create_wave_synthesizer   (HDIGDRIVER dig,
+                                                    HMDIDRIVER mdi,
+                                                       void const       FAR *wave_lib,
+                                                       S32         polyphony);
+
+DXDEC  void     AILCALL AIL_destroy_wave_synthesizer  (HWAVESYNTH W);
+
+DXDEC  void     AILCALL AIL_set_sequence_ms_position  (HSEQUENCE S, //)
+                                                       S32       milliseconds);
+
+DXDEC  void     AILCALL AIL_sequence_ms_position(HSEQUENCE S, //)
+                                                 S32 FAR *total_milliseconds,
+                                                 S32 FAR *current_milliseconds);
+
+
+
+//
+// red book functions
+//
+
+#ifdef IS_DOS
+typedef struct _REDBOOKTRACKINFO {
+  U32 tracks;
+  U32 trackstarts[100];
+} REDBOOKTRACKINFO;
+#endif
+
+typedef struct _REDBOOK {
+  U32 DeviceID;
+  U32 paused;
+  U32 pausedsec;
+  U32 lastendsec;
+#ifdef IS_DOS
+  U32 readcontents;
+  REDBOOKTRACKINFO info;
+#endif
+#ifdef IS_MAC
+  short vDRefNum;
+#endif
+} REDBOOK;
+
+typedef struct _REDBOOK FAR* HREDBOOK;
+
+#define REDBOOK_ERROR    0
+#define REDBOOK_PLAYING  1
+#define REDBOOK_PAUSED   2
+#define REDBOOK_STOPPED  3
+
+
+DXDEC  HREDBOOK   AILCALL AIL_redbook_open(U32 which);
+
+#ifdef IS_MAC
+DXDEC  HREDBOOK   AILCALL AIL_redbook_open_volume(char const * drive);
+#else
+DXDEC  HREDBOOK   AILCALL AIL_redbook_open_drive(S32 drive);
+#endif
+
+DXDEC  void       AILCALL AIL_redbook_close(HREDBOOK hand);
+
+DXDEC  void       AILCALL AIL_redbook_eject(HREDBOOK hand);
+
+DXDEC  void       AILCALL AIL_redbook_retract(HREDBOOK hand);
+
+DXDEC  U32        AILCALL AIL_redbook_status(HREDBOOK hand);
+
+DXDEC  U32        AILCALL AIL_redbook_tracks(HREDBOOK hand);
+
+DXDEC  U32        AILCALL AIL_redbook_track(HREDBOOK hand);
+
+DXDEC  void       AILCALL AIL_redbook_track_info(HREDBOOK hand,U32 tracknum,
+                                                     U32 FAR* startmsec,U32 FAR* endmsec);
+
+DXDEC  U32        AILCALL AIL_redbook_id(HREDBOOK hand);
+
+DXDEC  U32        AILCALL AIL_redbook_position(HREDBOOK hand);
+
+DXDEC  U32        AILCALL AIL_redbook_play(HREDBOOK hand,U32 startmsec, U32 endmsec);
+
+DXDEC  U32        AILCALL AIL_redbook_stop(HREDBOOK hand);
+
+DXDEC  U32        AILCALL AIL_redbook_pause(HREDBOOK hand);
+
+DXDEC  U32        AILCALL AIL_redbook_resume(HREDBOOK hand);
+
+DXDEC  S32        AILCALL AIL_redbook_volume(HREDBOOK hand);
+
+DXDEC  S32        AILCALL AIL_redbook_set_volume(HREDBOOK hand, S32 volume);
+
+#ifdef IS_WIN16
+  #define AIL_ms_count timeGetTime
+  DXDEC U32 AILCALL AIL_us_count(void);
+#else
+  DXDEC U32 AILCALL AIL_ms_count(void);
+  DXDEC U32 AILCALL AIL_us_count(void);
+#endif
+
+
+typedef struct _STREAM FAR* HSTREAM;           // Handle to stream
+
+typedef void (AILCALLBACK FAR* AILSTREAMCB)   (HSTREAM stream);
+
+typedef struct _STREAM {
+
+  S32 block_oriented; // 1 if this is an ADPCM or ASI-compressed stream
+  S32 using_ASI;      // 1 if using ASI decoder to uncompress stream data
+  ASISTAGE FAR *ASI;  // handy pointer to our ASI coded
+
+  HSAMPLE samp;       // the sample handle
+
+  U32 fileh;          // the open file handle
+
+  U8 FAR* bufs[3];    // the data buffers
+  U32 bufsizes[3];    // the size of each buffer
+  S32 reset_ASI[3];   // should we reset the ASI at the end of the buffer?
+  S32 bufstart[3];    // offset of where this buffer started
+  void FAR* asyncs[3];// async read structures
+
+  S32 loadedbufstart[2]; // offset of where the loaded buffer started
+  S32 loadedorder[2]; // order of the buffers as they were loaded
+  S32 loadorder;      // incremented as each buffer is loaded
+
+  S32 bufsize;        // size of each buffer
+  S32 readsize;       // size of each read block
+
+  U32 buf1;           // 0,1,2 (current buffer that we are reading into)
+  S32 size1;          // holds the current amount of data read
+
+  U32 buf2;           // 0,1,2 (the next buffer that we are reading into)
+  S32 size2;          // next buffer loaded up to
+
+  U32 buf3;           // 0,1,2 (the next buffer that we are reading into)
+  S32 size3;          // next buffer loaded up to
+
+  U32 datarate;       // datarate in bytes per second
+  S32 filerate;       // original datarate of the file
+  S32 filetype;       // file format type
+  U32 fileflags;      // file format flags (signed or unsigned)
+  S32 totallen;       // total length of the sound data
+
+  S32 substart;       // subblock loop start
+  S32 sublen;         // subblock loop len
+  S32 subpadding;     // amount to pad the final block
+
+  U32 blocksize;      // ADPCM block size
+  S32 padding;        // padding to be done
+  S32 padded;         // padding done
+
+  S32 loadedsome;     // have we done any loads?
+
+  U32 startpos;       // point that the sound data begins
+  U32 totalread;      // total bytes read from the disk
+
+  U32 loopsleft;      // how many loops are left
+
+  U32 error;          // read error has occurred
+
+  S32 preload;        // preload the file into the first buffer
+  U32 preloadpos;     // position to use in preload
+  S32 noback;         // no background processing
+  S32 alldone;        // alldone
+  S32 primeamount;    // amount to load after a seek
+  S32 readatleast;    // forced amount to read on next service
+
+  S32 playcontrol;    // control: 0=stopped, 1=started, |8=paused, |16=sample paused
+
+  AILSTREAMCB callback;  // end of stream callback
+
+  S32 user_data[8];   // Miscellaneous user data
+  void FAR* next;     // pointer to next stream
+
+#if defined(IS_WINDOWS) || defined(IS_MAC)
+  S32 autostreaming;  // are we autostreaming this stream
+#endif
+
+#ifdef IS_WINDOWS
+  S32 cb_IsWin32s;    // Is the callback win32s?
+#endif
+
+  S32 docallback;     // set when it time to poll for a callback
+
+#ifdef IS_MAC
+  IOParam  stream_param;
+  S32      donext;
+  S32      donext1;
+  U32      fillup;
+  U32      session;
+  U32      tamt;
+  U32      buf;
+  S32*     size;
+  S32*     done;
+  S32      done1;
+  S32      done2;
+  S32      done3;
+  Boolean  force_quit;
+#endif
+
+} MSTREAM_TYPE;
+
+
+DXDEC HSTREAM AILCALL AIL_open_stream(HDIGDRIVER dig, char const FAR * filename, S32 stream_mem);
+
+DXDEC void AILCALL AIL_close_stream(HSTREAM stream);
+
+DXDEC S32 AILCALL AIL_service_stream(HSTREAM stream, S32 fillup);
+
+DXDEC void AILCALL AIL_start_stream(HSTREAM stream);
+
+DXDEC void AILCALL AIL_pause_stream(HSTREAM stream, S32 onoff);
+
+DXDEC void AILCALL AIL_set_stream_volume(HSTREAM stream,S32 volume);
+
+DXDEC void AILCALL AIL_set_stream_pan(HSTREAM stream,S32 pan);
+
+DXDEC S32 AILCALL AIL_stream_volume(HSTREAM stream);
+
+DXDEC S32 AILCALL AIL_stream_pan(HSTREAM stream);
+
+DXDEC void AILCALL AIL_set_stream_playback_rate(HSTREAM stream, S32 rate);
+
+DXDEC S32 AILCALL AIL_stream_playback_rate(HSTREAM stream);
+
+DXDEC S32 AILCALL AIL_stream_loop_count(HSTREAM stream);
+
+DXDEC void AILCALL AIL_set_stream_loop_count(HSTREAM stream, S32 count);
+
+DXDEC void AILCALL AIL_set_stream_loop_block (HSTREAM S,
+                                              S32     loop_start_offset,
+                                              S32     loop_end_offset);
+
+DXDEC S32 AILCALL AIL_stream_status(HSTREAM stream);
+
+DXDEC void AILCALL AIL_set_stream_position(HSTREAM stream,S32 offset);
+
+DXDEC S32 AILCALL AIL_stream_position(HSTREAM stream);
+
+DXDEC void AILCALL AIL_stream_info(HSTREAM stream, S32 FAR* datarate, S32 FAR* sndtype, S32 FAR* length, S32 FAR* memory);
+
+DXDEC AILSTREAMCB AILCALL AIL_register_stream_callback(HSTREAM stream, AILSTREAMCB callback);
+
+DXDEC void AILCALL AIL_auto_service_stream(HSTREAM stream, S32 onoff);
+
+DXDEC void     AILCALL AIL_set_stream_user_data   (HSTREAM S,
+                                                     U32     index,
+                                                     S32     value);
+
+DXDEC S32      AILCALL AIL_stream_user_data       (HSTREAM S,
+                                                     U32     index);
+
+DXDEC  void     AILCALL AIL_set_stream_ms_position   (HSTREAM S,
+                                                      S32        milliseconds);
+
+DXDEC  void     AILCALL AIL_stream_ms_position     (HSTREAM    S, //)
+                                                    S32 FAR *  total_milliseconds,
+                                                    S32 FAR *  current_milliseconds);
+
+DXDEC  void     AILCALL AIL_set_stream_reverb(HSTREAM S,
+                                              F32     reverb_level,
+                                              F32     reverb_reflect_time,
+                                              F32     reverb_decay_time);
+
+DXDEC  void    AILCALL AIL_stream_reverb     (HSTREAM S,
+                                              F32 FAR *reverb_level,
+                                              F32 FAR *reverb_reflect_time,
+                                              F32 FAR *reverb_decay_time);
+
+DXDEC  HPROVIDER    AILCALL AIL_set_stream_processor  (HSTREAM     S,
+                                                       SAMPLESTAGE pipeline_stage,
+                                                       HPROVIDER   provider);
+
+#ifdef IS_MAC
+typedef struct MSS_FILE
+{
+  S32 file_type; // 0 = char*, 1 = FSSpec*
+  void const FAR* file;
+} MSS_FILE;
+#else
+typedef char MSS_FILE;
+#endif
+
+typedef U32  (AILCALLBACK FAR*AIL_file_open_callback)  (MSS_FILE const FAR* Filename,
+                                                        U32 FAR* FileHandle);
+
+typedef void (AILCALLBACK FAR*AIL_file_close_callback) (U32 FileHandle);
+
+#define AIL_FILE_SEEK_BEGIN   0
+#define AIL_FILE_SEEK_CURRENT 1
+#define AIL_FILE_SEEK_END     2
+
+typedef S32  (AILCALLBACK FAR*AIL_file_seek_callback)  (U32 FileHandle,
+                                                        S32 Offset,
+                                                        U32 Type);
+
+typedef U32  (AILCALLBACK FAR*AIL_file_read_callback)  (U32 FileHandle,
+                                                        void FAR* Buffer,
+                                                        U32 Bytes);
+
+DXDEC  void  AILCALL AIL_set_file_callbacks  (AIL_file_open_callback opencb,
+                                              AIL_file_close_callback closecb,
+                                              AIL_file_seek_callback seekcb,
+                                              AIL_file_read_callback readcb);
+
+#ifdef IS_32
+
+typedef void FAR* (AILCALLBACK FAR*AIL_file_async_read_callback) (U32 FileHandle,
+                                                                  void FAR* Buffer,
+                                                                  U32 Bytes);
+
+typedef S32 (AILCALLBACK FAR*AIL_file_async_status_callback)  (void FAR* async,
+                                                               S32 wait,
+                                                               U32 FAR* BytesRead);
+
+DXDEC  void  AILCALL AIL_set_file_async_callbacks (AIL_file_open_callback opencb,
+                                                   AIL_file_close_callback closecb,
+                                                   AIL_file_seek_callback seekcb,
+                                                   AIL_file_async_read_callback areadcb,
+                                                   AIL_file_async_status_callback statuscb);
+
+#endif
+
+//
+// High-level DLS functions
+//
+
+typedef struct _DLSFILEID {
+  S32 id;
+  struct _DLSFILEID FAR* next;
+} DLSFILEID;
+
+typedef struct _DLSFILEID FAR* HDLSFILEID;
+
+typedef struct _DLSDEVICE {
+  void FAR* pGetPref;
+  void FAR* pSetPref;
+  void FAR* pMSSOpen;
+  void FAR* pOpen;
+  void FAR* pClose;
+  void FAR* pLoadFile;
+  void FAR* pLoadMem;
+  void FAR* pUnloadFile;
+  void FAR* pUnloadAll;
+  void FAR* pGetInfo;
+  void FAR* pCompact;
+  void FAR* pSetAttr;
+  S32 DLSHandle;
+  U32 format;
+  U32 buffer_size;
+  void FAR* buffer[2];
+  HSAMPLE sample;
+  HMDIDRIVER mdi;
+  HDIGDRIVER dig;
+  HDLSFILEID first;
+#ifdef IS_WINDOWS
+  HMODULE lib;
+#else
+  #ifdef IS_DOS
+  char FAR* DOSname;
+  #endif
+#endif
+} DLSDEVICE;
+
+typedef struct _DLSDEVICE FAR* HDLSDEVICE;
+
+typedef struct _AILDLSINFO {
+  char Description[128];
+  S32 MaxDLSMemory;
+  S32 CurrentDLSMemory;
+  S32 LargestSize;
+  S32 GMAvailable;
+  S32 GMBankSize;
+} AILDLSINFO;
+
+#ifdef IS_DOS
+
+typedef struct _AILDOSDLS {
+  char FAR* description;
+  void FAR* pDLSOpen;
+  void FAR* pMSSOpen;
+  void FAR* pOpen;
+  void FAR* pClose;
+  void FAR* pLoadFile;
+  void FAR* pLoadMem;
+  void FAR* pUnloadFile;
+  void FAR* pUnloadAll;
+  void FAR* pGetInfo;
+  void FAR* pCompact;
+  void FAR* pSetAttr;
+} AILDOSDLS;
+
+#endif
+
+
+DXDEC  HDLSDEVICE AILCALL AIL_DLS_open(HMDIDRIVER mdi, HDIGDRIVER dig,
+#if defined(IS_WINDOWS) || defined(IS_MAC)
+                                          char const FAR * libname,
+#else
+                                          AILDOSDLS const FAR * dosdls,
+#endif
+                                          U32 flags, U32 rate, S32 bits, S32 channels);
+
+//
+// Parameters for the dwFlag used in DLSClose() and flags in AIL_DLS_close
+//
+
+#define RETAIN_DLS_COLLECTION   0x00000001
+#define RETURN_TO_BOOTUP_STATE  0x00000002
+#define RETURN_TO_GM_ONLY_STATE 0x00000004
+#define DLS_COMPACT_MEMORY      0x00000008
+
+DXDEC  void   AILCALL AIL_DLS_close(HDLSDEVICE dls, U32 flags);
+
+DXDEC  HDLSFILEID AILCALL AIL_DLS_load_file(HDLSDEVICE dls, char const FAR* filename, U32 flags);
+
+DXDEC  HDLSFILEID AILCALL AIL_DLS_load_memory(HDLSDEVICE dls, void const FAR* memfile, U32 flags);
+
+//
+// other parameters for AIL_DLS_unload
+//
+
+#define AIL_DLS_UNLOAD_MINE 0
+#define AIL_DLS_UNLOAD_ALL  ((HDLSFILEID)(U32)(S32)-1)
+
+DXDEC  void   AILCALL AIL_DLS_unload(HDLSDEVICE dls, HDLSFILEID dlsid);
+
+DXDEC  void   AILCALL AIL_DLS_compact(HDLSDEVICE dls);
+
+DXDEC  void   AILCALL AIL_DLS_get_info(HDLSDEVICE dls, AILDLSINFO FAR* info, S32 FAR* PercentCPU);
+
+DXDEC  void   AILCALL AIL_DLS_set_reverb(HDLSDEVICE dls,
+                                         F32     reverb_level,
+                                         F32     reverb_reflect_time,
+                                         F32     reverb_decay_time);
+
+DXDEC  void   AILCALL AIL_DLS_get_reverb(HDLSDEVICE dls,
+                                         F32 FAR*    reverb_level,
+                                         F32 FAR*    reverb_reflect_time,
+                                         F32 FAR*    reverb_decay_time);
+
+DXDEC  HPROVIDER    AILCALL AIL_set_DLS_processor     (HDLSDEVICE  dev,
+                                                       SAMPLESTAGE pipeline_stage,
+                                                       HPROVIDER   provider);
+
+
+//
+// Quick-integration service functions and data types
+//
+
+typedef struct
+{
+   U32 const FAR *data;
+   S32  size;
+   S32  type;
+   void FAR *handle;
+   S32  status;
+   void FAR* next;
+   S32  speed;
+   S32  volume;
+   S32  extravol;
+   F32  rlevel;
+   F32  rrtime;
+   F32  rdtime;
+   HDLSFILEID dlsid;
+   void FAR* dlsmem;
+   void FAR* dlsmemunc;
+   S32  milliseconds;
+   S32  length;
+   S32  userdata;
+}
+AUDIO_TYPE;
+
+
+#define QSTAT_DONE          1       // Data has finished playing
+#define QSTAT_LOADED        2       // Data has been loaded, but not yet played
+#define QSTAT_PLAYING       3       // Data is currently playing
+
+typedef AUDIO_TYPE FAR * HAUDIO;        // Generic handle to any audio data type
+
+#define AIL_QUICK_USE_WAVEOUT             2
+#define AIL_QUICK_MIDI_AND_DLS            2
+#define AIL_QUICK_DLS_ONLY                3
+#define AIL_QUICK_MIDI_AND_VORTEX_DLS     4
+#define AIL_QUICK_MIDI_AND_SONICVIBES_DLS 5
+
+DXDEC S32     AILCALL
+#if defined(IS_WINDOWS) || defined(IS_MAC)
+                       AIL_quick_startup           (
+#else
+                       AIL_quick_startup_with_start(void*       startup,
+#endif
+                                                    S32         use_digital,
+                                                    S32         use_MIDI,
+                                                    U32         output_rate,
+                                                    S32         output_bits,
+                                                    S32         output_channels);
+
+DXDEC void    AILCALL AIL_quick_shutdown            (void);
+
+DXDEC void    AILCALL AIL_quick_handles             (HDIGDRIVER FAR* pdig,
+                                                     HMDIDRIVER FAR* pmdi,
+                                                     HDLSDEVICE FAR* pdls );
+
+DXDEC HAUDIO  AILCALL AIL_quick_load                (char const   FAR *filename);
+
+#ifdef IS_MAC
+DXDEC HAUDIO  AILCALL AIL_quick_fss_load            (FSSpec const   FAR *filename);
+#endif
+
+DXDEC HAUDIO  AILCALL AIL_quick_load_mem            (void const   FAR *mem,
+                                                    U32    size);
+
+DXDEC HAUDIO  AILCALL AIL_quick_copy                (HAUDIO      audio);
+
+DXDEC void    AILCALL AIL_quick_unload              (HAUDIO      audio);
+
+DXDEC S32     AILCALL AIL_quick_play                (HAUDIO      audio,
+                                                    U32         loop_count);
+
+DXDEC void    AILCALL AIL_quick_halt                (HAUDIO      audio);
+
+DXDEC S32     AILCALL AIL_quick_status              (HAUDIO      audio);
+
+DXDEC HAUDIO  AILCALL AIL_quick_load_and_play       (char const   FAR *filename,
+                                                    U32         loop_count,
+                                                    S32         wait_request);
+
+#ifdef IS_MAC
+DXDEC HAUDIO  AILCALL AIL_quick_fss_load_and_play  (FSSpec const   FAR *filename,
+                                                    U32         loop_count,
+                                                    S32         wait_request);
+#endif
+
+DXDEC void   AILCALL AIL_quick_set_speed (HAUDIO audio, S32 speed);
+
+DXDEC void   AILCALL AIL_quick_set_volume (HAUDIO audio, S32 volume, S32 extravol);
+
+DXDEC void   AILCALL AIL_quick_set_reverb (HAUDIO audio,
+                                           F32     reverb_level,
+                                           F32     reverb_reflect_time,
+                                           F32     reverb_decay_time);
+
+DXDEC void   AILCALL AIL_quick_set_ms_position(HAUDIO audio,S32 milliseconds);
+
+DXDEC S32    AILCALL AIL_quick_ms_position(HAUDIO audio);
+
+DXDEC S32    AILCALL AIL_quick_ms_length(HAUDIO audio);
+
+
+#define AIL_QUICK_XMIDI_TYPE        1
+#define AIL_QUICK_DIGITAL_TYPE      2
+#define AIL_QUICK_DLS_XMIDI_TYPE    3
+#define AIL_QUICK_MPEG_DIGITAL_TYPE 4
+
+DXDEC S32    AILCALL AIL_quick_type(HAUDIO audio);
+
+//
+// used for AIL_process
+//
+
+typedef struct _AILMIXINFO {
+  AILSOUNDINFO Info;
+  ADPCMDATA mss_adpcm;
+  U32 src_fract;
+  S32 left_val;
+  S32 right_val;
+} AILMIXINFO;
+
+
+
+DXDEC S32 AILCALL AIL_WAV_info(void const FAR* data, AILSOUNDINFO FAR* info);
+
+DXDEC S32 AILCALL AIL_size_processed_digital_audio(
+                                 U32             dest_rate,
+                                 U32             dest_format,
+                                 S32             num_srcs,
+                                 AILMIXINFO const FAR* src);
+
+DXDEC S32 AILCALL AIL_process_digital_audio(
+                                 void FAR       *dest_buffer,
+                                 S32             dest_buffer_size,
+                                 U32             dest_rate,
+                                 U32             dest_format,
+                                 S32             num_srcs,
+                                 AILMIXINFO FAR* src);
+
+#define AIL_LENGTHY_INIT           0
+#define AIL_LENGTHY_SET_PREFERENCE 1
+#define AIL_LENGTHY_UPDATE         2
+#define AIL_LENGTHY_DONE           3
+
+typedef S32 (AILCALLBACK FAR* AILLENGTHYCB)(U32 state,U32 user);
+
+typedef S32 (AILCALLBACK FAR* AILCODECSETPREF)(char const FAR* preference,U32 value);
+
+DXDEC S32 AILCALL AIL_compress_ASI(AILSOUNDINFO const FAR * info, //)
+                                   char const FAR* filename_ext,
+                                   void FAR* FAR* outdata,
+                                   U32 FAR* outsize,
+                                   AILLENGTHYCB callback);
+
+DXDEC S32 AILCALL AIL_decompress_ASI(void const FAR* indata, //)
+                                     U32 insize,
+                                     char const FAR* filename_ext,
+                                     void FAR* FAR* wav,
+                                     U32 FAR* wavsize,
+                                     AILLENGTHYCB callback);
+
+DXDEC S32 AILCALL AIL_compress_ADPCM(AILSOUNDINFO const FAR * info,
+                                     void FAR* FAR* outdata, U32 FAR* outsize);
+
+DXDEC S32 AILCALL AIL_decompress_ADPCM(AILSOUNDINFO const FAR * info,
+                                       void FAR* FAR* outdata, U32 FAR* outsize);
+
+DXDEC S32 AILCALL AIL_compress_DLS(void const FAR* dls,
+                                   char const FAR* compression_extension,
+                                   void FAR* FAR* mls, U32 FAR* mlssize,
+                                   AILLENGTHYCB callback);
+
+DXDEC S32 AILCALL AIL_merge_DLS_with_XMI(void const FAR* xmi, void const FAR* dls,
+                                         void FAR* FAR* mss, U32 FAR* msssize);
+
+DXDEC  S32 AILCALL AIL_extract_DLS( void const FAR *source_image, //)
+                                    U32             source_size,
+                                    void FAR * FAR *XMI_output_data,
+                                    U32  FAR       *XMI_output_size,
+                                    void FAR * FAR *DLS_output_data,
+                                    U32  FAR       *DLS_output_size,
+                                    AILLENGTHYCB   callback);
+
+#define AILFILTERDLS_USINGLIST 1
+
+DXDEC S32 AILCALL AIL_filter_DLS_with_XMI(void const FAR* xmi, void const FAR* dls,
+                                         void FAR* FAR* dlsout, U32 FAR* dlssize,
+                                         S32  flags, AILLENGTHYCB callback);
+
+#define AILMIDITOXMI_USINGLIST 1
+#define AILMIDITOXMI_TOLERANT  2
+
+DXDEC  S32 AILCALL AIL_MIDI_to_XMI       (void const FAR*  MIDI,
+                                         U32        MIDI_size,
+                                         void FAR*  FAR*XMIDI,
+                                         U32  FAR*  XMIDI_size,
+                                         S32        flags);
+
+#define AILMIDILIST_ROLANDSYSEX 1
+#define AILMIDILIST_ROLANDUN    2
+#define AILMIDILIST_ROLANDAB    4
+
+DXDEC  S32          AILCALL AIL_list_MIDI         (void const FAR* MIDI,
+                                                  U32       MIDI_size,
+                                                  char FAR* FAR* lst,
+                                                  U32  FAR* lst_size,
+                                                  S32       flags);
+#define AILDLSLIST_ARTICULATION 1
+#define AILDLSLIST_DUMP_WAVS    2
+
+DXDEC  S32          AILCALL AIL_list_DLS          (void const FAR* DLS,
+                                                   char FAR* FAR* lst,
+                                                   U32  FAR* lst_size,
+                                                   S32       flags,
+                                                   C8   FAR* title);
+
+#define AILFILETYPE_UNKNOWN     0
+#define AILFILETYPE_PCM_WAV     1
+#define AILFILETYPE_ADPCM_WAV   2
+#define AILFILETYPE_OTHER_WAV   3
+#define AILFILETYPE_VOC         4
+#define AILFILETYPE_MIDI        5
+#define AILFILETYPE_XMIDI       6
+#define AILFILETYPE_XMIDI_DLS   7
+#define AILFILETYPE_XMIDI_MLS   8
+#define AILFILETYPE_DLS         9
+#define AILFILETYPE_MLS        10
+#define AILFILETYPE_MPEG_L1_AUDIO 11
+#define AILFILETYPE_MPEG_L2_AUDIO 12
+#define AILFILETYPE_MPEG_L3_AUDIO 13
+#define AILFILETYPE_OTHER_ASI_WAV 14
+
+
+DXDEC S32 AILCALL AIL_file_type(void const FAR* data, U32 size);
+
+DXDEC S32 AILCALL AIL_find_DLS       (void const FAR*      data, U32 size,
+                                      void FAR* FAR* xmi, U32 FAR* xmisize,
+                                      void FAR* FAR* dls, U32 FAR* dlssize);
+
+#if defined(IS_WIN32) || defined(IS_MAC)
+
+//
+// Auxiliary 2D interface calls
+//
+
+DXDEC HDIGDRIVER AILCALL AIL_primary_digital_driver  (HDIGDRIVER new_primary);
+
+//
+// Filter result codes
+//
+
+typedef S32 FLTRESULT;
+
+#define FLT_NOERR                   0   // Success -- no error
+#define FLT_NOT_ENABLED             1   // FLT not enabled
+#define FLT_ALREADY_STARTED         2   // FLT already started
+#define FLT_INVALID_PARAM           3   // Invalid parameters used
+#define FLT_INTERNAL_ERR            4   // Internal error in FLT driver
+#define FLT_OUT_OF_MEM              5   // Out of system RAM
+#define FLT_ERR_NOT_IMPLEMENTED     6   // Feature not implemented
+#define FLT_NOT_FOUND               7   // FLT supported device not found
+#define FLT_NOT_INIT                8   // FLT not initialized
+#define FLT_CLOSE_ERR               9   // FLT not closed correctly
+
+//############################################################################
+//##                                                                        ##
+//## Interface "MSS pipeline filter"                                        ##
+//##                                                                        ##
+//############################################################################
+
+typedef FLTRESULT (AILCALL FAR *FLT_STARTUP)(void);
+
+typedef FLTRESULT (AILCALL FAR *FLT_SHUTDOWN)(void);
+
+typedef C8 FAR *  (AILCALL FAR *FLT_ERROR)(void);
+
+typedef S32       (AILCALL FAR *FLT_SET_PROVIDER_PREFERENCE)(HATTRIB preference,
+                                                             void const FAR*   value);
+
+typedef HDRIVERSTATE (AILCALL FAR *FLT_OPEN_DRIVER) (HDIGDRIVER dig,
+                                                     S32 FAR   *build_buffer,
+                                                     S32        build_buffer_size);
+
+typedef FLTRESULT    (AILCALL FAR *FLT_CLOSE_DRIVER) (HDRIVERSTATE state);
+
+typedef void         (AILCALL FAR *FLT_PREMIX_PROCESS) (HDRIVERSTATE driver
+#ifdef IS_MAC
+                                                       ,U32 buffer_size
+#endif
+);
+
+typedef void         (AILCALL FAR *FLT_POSTMIX_PROCESS) (HDRIVERSTATE driver
+#ifdef IS_MAC
+                                                       ,U32 buffer_size
+#endif
+);
+
+//############################################################################
+//##                                                                        ##
+//## Interface "Pipeline filter sample services"                            ##
+//##                                                                        ##
+//############################################################################
+
+typedef HSAMPLESTATE (AILCALL FAR * FLTSMP_OPEN_SAMPLE) (HDRIVERSTATE driver,
+                                                         HSAMPLE      S);
+
+typedef FLTRESULT    (AILCALL FAR * FLTSMP_CLOSE_SAMPLE) (HSAMPLESTATE state);
+
+typedef S32          (AILCALL FAR * FLTSMP_SAMPLE_PROCESS) (HSAMPLESTATE    state,
+                                                            void const FAR * FAR *orig_src,
+                                                            U32  FAR *      orig_src_fract,
+                                                            void FAR *      orig_src_end,
+                                                            S32  FAR * FAR *build_dest,
+                                                            void FAR *      build_dest_end,
+                                                            S32  FAR *      left_val,
+                                                            S32  FAR *      right_val,
+                                                            S32             playback_ratio,
+                                                            S32             left_scale,
+                                                            S32             right_scale,
+                                                            S32             base_scale,
+                                                            MIXSTAGE FAR *  mixer_provider,
+                                                            U32             mixer_operation);
+
+typedef S32          (AILCALL FAR * FLTSMP_SAMPLE_ATTRIBUTE) (HSAMPLESTATE state,
+                                                              HATTRIB      attribute);
+
+typedef S32          (AILCALL FAR * FLTSMP_SET_SAMPLE_PREFERENCE) (HSAMPLESTATE state,
+                                                                   HATTRIB      preference,
+                                                                   void const FAR*    value);
+
+//
+// Pipeline filter calls
+//
+
+DXDEC S32        AILCALL AIL_enumerate_filters  (HPROENUM  FAR *next,
+                                                 HPROVIDER FAR *dest,
+                                                 C8  FAR * FAR *name);
+
+DXDEC HDRIVERSTATE
+                 AILCALL AIL_open_filter        (HPROVIDER  lib,
+                                                 HDIGDRIVER dig);
+
+DXDEC void       AILCALL AIL_close_filter       (HDRIVERSTATE filter);
+
+DXDEC S32        AILCALL AIL_enumerate_filter_attributes
+                                                (HPROVIDER                  lib,
+                                                 HINTENUM FAR *             next,
+                                                 RIB_INTERFACE_ENTRY FAR *  dest);
+
+DXDEC void       AILCALL AIL_filter_attribute   (HPROVIDER  lib,
+                                                 C8 const FAR*   name,
+                                                 void FAR * val);
+
+DXDEC void       AILCALL AIL_set_filter_preference
+                                                (HPROVIDER  lib,
+                                                 C8 const FAR*   name,
+                                                 void const FAR* val);
+
+DXDEC  S32      AILCALL AIL_enumerate_filter_sample_attributes
+                                                (HPROVIDER                 lib,
+                                                 HINTENUM FAR *            next,
+                                                 RIB_INTERFACE_ENTRY FAR * dest);
+
+DXDEC  void     AILCALL AIL_filter_sample_attribute
+                                                (HSAMPLE    S,
+                                                 C8 const FAR*   name,
+                                                 void FAR * val);
+
+DXDEC  void     AILCALL AIL_filter_stream_attribute
+                                                (HSTREAM    S,
+                                                 C8 const FAR*   name,
+                                                 void FAR* val);
+
+DXDEC  void     AILCALL AIL_filter_DLS_attribute
+                                                (HDLSDEVICE dls,
+                                                 C8 const FAR*   name,
+                                                 void FAR * val);
+
+DXDEC  void     AILCALL AIL_set_filter_sample_preference
+                                                (HSAMPLE    S,
+                                                 C8 const FAR *   name,
+                                                 void const FAR * val);
+
+DXDEC  void     AILCALL AIL_set_filter_stream_preference
+                                                (HSTREAM    S,
+                                                 C8 const FAR *   name,
+                                                 void const FAR * val);
+
+DXDEC  void     AILCALL AIL_set_filter_DLS_preference
+                                                (HDLSDEVICE dls,
+                                                 C8 const FAR *   name,
+                                                 void const FAR * val);
+
+typedef struct _FLTPROVIDER
+{
+   PROVIDER_QUERY_ATTRIBUTE        PROVIDER_query_attribute;
+
+   FLT_STARTUP                     startup;
+   FLT_ERROR                       error;
+   FLT_SHUTDOWN                    shutdown;
+   FLT_SET_PROVIDER_PREFERENCE     set_provider_preference;
+   FLT_OPEN_DRIVER                 open_driver;
+   FLT_CLOSE_DRIVER                close_driver;
+   FLT_PREMIX_PROCESS              premix_process;
+   FLT_POSTMIX_PROCESS             postmix_process;
+
+   FLTSMP_OPEN_SAMPLE              open_sample;
+   FLTSMP_CLOSE_SAMPLE             close_sample;
+   FLTSMP_SAMPLE_PROCESS           sample_process;
+   FLTSMP_SAMPLE_ATTRIBUTE         sample_attribute;
+   FLTSMP_SET_SAMPLE_PREFERENCE    set_sample_preference;
+
+   HDIGDRIVER   dig;
+   HPROVIDER    provider;
+   HDRIVERSTATE driver_state;
+
+   struct _FLTPROVIDER FAR *next;
+}
+FLTPROVIDER;
+
+//
+// 3D provider calls
+//
+
+DXDEC S32        AILCALL AIL_enumerate_3D_providers  (HPROENUM  FAR *next,
+                                                      HPROVIDER FAR *dest,
+                                                      C8  FAR * FAR *name);
+
+DXDEC M3DRESULT  AILCALL AIL_open_3D_provider        (HPROVIDER lib);
+
+DXDEC void       AILCALL AIL_close_3D_provider       (HPROVIDER lib);
+
+DXDEC S32        AILCALL AIL_enumerate_3D_provider_attributes
+                                                     (HPROVIDER                  lib,
+                                                      HINTENUM FAR *             next,
+                                                      RIB_INTERFACE_ENTRY FAR *  dest);
+
+DXDEC void       AILCALL AIL_3D_provider_attribute   (HPROVIDER   lib,
+                                                      C8 const FAR*    name,
+                                                      void FAR *  val);
+
+DXDEC void       AILCALL AIL_set_3D_provider_preference(HPROVIDER   lib,
+                                                        C8 const FAR*    name,
+                                                        void const FAR*  val);
+
+struct H3D
+{
+   H3DPOBJECT actual;
+   HPROVIDER  owner;
+   S32        user_data[8];
+};
+
+typedef struct _M3DPROVIDER
+{
+   PROVIDER_QUERY_ATTRIBUTE        PROVIDER_query_attribute;
+   M3D_STARTUP                     startup;
+   M3D_ERROR                       error;
+   M3D_SHUTDOWN                    shutdown;
+   M3D_SET_PROVIDER_PREFERENCE     set_provider_preference;
+   M3D_ACTIVATE                    activate;
+   M3D_ALLOCATE_3D_SAMPLE_HANDLE   allocate_3D_sample_handle;
+   M3D_RELEASE_3D_SAMPLE_HANDLE    release_3D_sample_handle;
+   M3D_START_3D_SAMPLE             start_3D_sample;
+   M3D_STOP_3D_SAMPLE              stop_3D_sample;
+   M3D_RESUME_3D_SAMPLE            resume_3D_sample;
+   M3D_END_3D_SAMPLE               end_3D_sample;
+   M3D_SET_3D_SAMPLE_DATA          set_3D_sample_data;
+   M3D_SET_3D_SAMPLE_VOLUME        set_3D_sample_volume;
+   M3D_SET_3D_SAMPLE_PLAYBACK_RATE set_3D_sample_playback_rate;
+   M3D_SET_3D_SAMPLE_OFFSET        set_3D_sample_offset;
+   M3D_SET_3D_SAMPLE_LOOP_COUNT    set_3D_sample_loop_count;
+   M3D_SET_3D_SAMPLE_LOOP_BLOCK    set_3D_sample_loop_block;
+   M3D_3D_SAMPLE_STATUS            sample_status;
+   M3D_3D_SAMPLE_VOLUME            sample_volume;
+   M3D_3D_SAMPLE_PLAYBACK_RATE     sample_playback_rate;
+   M3D_3D_SAMPLE_OFFSET            sample_offset;
+   M3D_3D_SAMPLE_LENGTH            sample_length;
+   M3D_3D_SAMPLE_LOOP_COUNT        sample_loop_count;
+   M3D_SET_3D_SAMPLE_DISTANCES     set_3D_sample_distances;
+   M3D_3D_SAMPLE_DISTANCES         sample_distances;
+   M3D_ACTIVE_3D_SAMPLE_COUNT      active_3D_sample_count;
+   M3D_3D_OPEN_LISTENER            open_listener;
+   M3D_3D_CLOSE_LISTENER           close_listener;
+   M3D_3D_OPEN_OBJECT              open_object;
+   M3D_3D_CLOSE_OBJECT             close_object;
+   M3D_SET_3D_POSITION             set_3D_position;
+   M3D_SET_3D_VELOCITY             set_3D_velocity;
+   M3D_SET_3D_VELOCITY_VECTOR      set_3D_velocity_vector;
+   M3D_SET_3D_ORIENTATION          set_3D_orientation;
+   M3D_3D_POSITION                 position;
+   M3D_3D_VELOCITY                 velocity;
+   M3D_3D_ORIENTATION              orientation;
+   M3D_3D_UPDATE_POSITION          update_position;
+   M3D_3D_AUTO_UPDATE_POSITION     auto_update_position;
+   M3D_3D_SAMPLE_ATTRIBUTE         sample_query_attribute;
+   M3D_3D_SET_SAMPLE_PREFERENCE    set_sample_preference;
+   M3D_3D_ROOM_TYPE                room_type;
+   M3D_SET_3D_ROOM_TYPE            set_3D_room_type;
+   M3D_3D_SPEAKER_TYPE             speaker_type;
+   M3D_SET_3D_SPEAKER_TYPE         set_3D_speaker_type;
+   M3D_SET_3D_SAMPLE_OBSTRUCTION   set_3D_sample_obstruction;
+   M3D_SET_3D_SAMPLE_OCCLUSION     set_3D_sample_occlusion;
+   M3D_SET_3D_SAMPLE_CONE          set_3D_sample_cone;
+   M3D_SET_3D_SAMPLE_EFFECTS_LEVEL set_3D_sample_effects_level;
+   M3D_3D_SAMPLE_OBSTRUCTION       sample_obstruction;
+   M3D_3D_SAMPLE_OCCLUSION         sample_occlusion;
+   M3D_3D_SAMPLE_CONE              sample_cone;
+   M3D_3D_SAMPLE_EFFECTS_LEVEL     sample_effects_level;
+   M3D_SET_3D_EOS                  set_3D_EOS;
+} M3DPROVIDER;
+
+//
+// Sample calls
+//
+
+DXDEC H3DSAMPLE  AILCALL AIL_allocate_3D_sample_handle
+                                                     (HPROVIDER lib);
+
+
+DXDEC void       AILCALL AIL_release_3D_sample_handle
+                                                     (H3DSAMPLE S);
+
+
+DXDEC void       AILCALL AIL_start_3D_sample         (H3DSAMPLE S);
+
+
+DXDEC void       AILCALL AIL_stop_3D_sample          (H3DSAMPLE S);
+
+
+DXDEC void       AILCALL AIL_resume_3D_sample        (H3DSAMPLE S);
+
+DXDEC void       AILCALL AIL_end_3D_sample           (H3DSAMPLE S);
+
+DXDEC S32        AILCALL AIL_set_3D_sample_file      (H3DSAMPLE S,
+                                                      void const FAR*file_image);
+
+DXDEC S32        AILCALL AIL_set_3D_sample_info      (H3DSAMPLE         S,
+                                                      AILSOUNDINFO const FAR*info);
+
+DXDEC void       AILCALL AIL_set_3D_sample_volume    (H3DSAMPLE S,
+                                                      S32       volume);
+
+DXDEC void       AILCALL AIL_set_3D_sample_offset    (H3DSAMPLE S,
+                                                      U32       offset);
+
+DXDEC void       AILCALL AIL_set_3D_sample_playback_rate
+                                                     (H3DSAMPLE S,
+                                                      S32       playback_rate);
+
+DXDEC void       AILCALL AIL_set_3D_sample_loop_count(H3DSAMPLE S,
+                                                      U32       loops);
+
+DXDEC void       AILCALL AIL_set_3D_sample_loop_block(H3DSAMPLE S,
+                                                      S32       loop_start_offset,
+                                                      S32       loop_end_offset);
+
+DXDEC U32        AILCALL AIL_3D_sample_status        (H3DSAMPLE S);
+
+DXDEC S32        AILCALL AIL_3D_sample_volume        (H3DSAMPLE S);
+
+DXDEC U32        AILCALL AIL_3D_sample_offset        (H3DSAMPLE S);
+
+DXDEC S32        AILCALL AIL_3D_sample_playback_rate (H3DSAMPLE S);
+
+DXDEC U32        AILCALL AIL_3D_sample_length        (H3DSAMPLE S);
+
+DXDEC U32        AILCALL AIL_3D_sample_loop_count    (H3DSAMPLE S);
+
+
+DXDEC  S32      AILCALL AIL_3D_room_type             (HPROVIDER lib);
+
+DXDEC  void     AILCALL AIL_set_3D_room_type         (HPROVIDER lib,
+                                                      S32       room_type);
+
+#define AIL_3D_2_SPEAKER  0
+#define AIL_3D_HEADPHONE  1
+#define AIL_3D_SURROUND   2
+#define AIL_3D_4_SPEAKER  3
+
+
+DXDEC  S32      AILCALL AIL_3D_speaker_type          (HPROVIDER lib);
+
+DXDEC  void     AILCALL AIL_set_3D_speaker_type      (HPROVIDER lib,
+                                                      S32       speaker_type);
+
+
+//
+// Changed the definition of distances to only be max and min, vs. front
+//   min/max and back min/max.  Only RSX supported the concept of different
+//   front and distances, so we changed the API to make it more orthogonal
+//   to most of the 3D providers. Sorry in advance.
+//
+
+DXDEC void       AILCALL AIL_set_3D_sample_distances (H3DSAMPLE S,
+                                                      F32       max_dist,
+                                                      F32       min_dist);
+
+
+DXDEC void       AILCALL AIL_3D_sample_distances     (H3DSAMPLE S,
+                                                      F32 FAR * max_dist,
+                                                      F32 FAR * min_dist);
+
+DXDEC  S32      AILCALL AIL_active_3D_sample_count   (HPROVIDER lib);
+
+DXDEC  S32      AILCALL AIL_enumerate_3D_sample_attributes
+                                                     (HPROVIDER                  lib,
+                                                      HINTENUM FAR *             next,
+                                                      RIB_INTERFACE_ENTRY FAR *  dest);
+
+DXDEC  void     AILCALL AIL_3D_sample_attribute      (H3DSAMPLE   samp,
+                                                      C8 const FAR*    name,
+                                                      void FAR *  val);
+
+
+DXDEC  void     AILCALL AIL_set_3D_sample_preference (H3DSAMPLE   samp,
+                                                      C8 const FAR*    name,
+                                                      void const FAR*  val);
+
+DXDEC void       AILCALL AIL_set_3D_sample_obstruction (H3DSAMPLE S,
+                                                        F32       obstruction);
+
+DXDEC void       AILCALL AIL_set_3D_sample_occlusion   (H3DSAMPLE S,
+                                                        F32       occlusion);
+
+DXDEC void       AILCALL AIL_set_3D_sample_cone        (H3DSAMPLE S,
+                                                        F32       inner_angle,
+                                                        F32       outer_angle,
+                                                        S32       outer_volume);
+
+DXDEC void       AILCALL AIL_set_3D_sample_effects_level 
+                                                       (H3DSAMPLE S,
+                                                        F32       effects_level);
+
+DXDEC F32        AILCALL AIL_3D_sample_obstruction     (H3DSAMPLE S);
+
+DXDEC F32        AILCALL AIL_3D_sample_occlusion       (H3DSAMPLE S);
+
+DXDEC void       AILCALL AIL_3D_sample_cone            (H3DSAMPLE S,
+                                                        F32 FAR*  inner_angle,
+                                                        F32 FAR*  outer_angle,
+                                                        S32 FAR*  outer_volume);
+
+DXDEC F32        AILCALL AIL_3D_sample_effects_level   (H3DSAMPLE S);
+
+
+DXDEC AIL3DSAMPLECB AILCALL AIL_register_3D_EOS_callback
+                                                       (H3DSAMPLE S,
+                                                        AIL3DSAMPLECB EOS);
+
+
+//
+// Positioning-object allocation calls
+//
+
+DXDEC H3DPOBJECT AILCALL AIL_open_3D_listener        (HPROVIDER lib);
+
+DXDEC void       AILCALL AIL_close_3D_listener       (H3DPOBJECT listener);
+
+DXDEC H3DPOBJECT AILCALL AIL_open_3D_object          (HPROVIDER lib);
+
+DXDEC void       AILCALL AIL_close_3D_object         (H3DPOBJECT obj);
+
+//
+// 3D object calls
+//
+
+DXDEC void       AILCALL AIL_set_3D_position         (H3DPOBJECT obj,
+                                                      F32     X,
+                                                      F32     Y,
+                                                      F32     Z);
+
+DXDEC void       AILCALL AIL_set_3D_velocity         (H3DPOBJECT obj,
+                                                      F32     dX_per_ms,
+                                                      F32     dY_per_ms,
+                                                      F32     dZ_per_ms,
+                                                      F32     magnitude);
+
+DXDEC void       AILCALL AIL_set_3D_velocity_vector  (H3DPOBJECT obj,
+                                                      F32     dX_per_ms,
+                                                      F32     dY_per_ms,
+                                                      F32     dZ_per_ms);
+
+DXDEC void       AILCALL AIL_set_3D_orientation      (H3DPOBJECT obj,
+                                                      F32     X_face,
+                                                      F32     Y_face,
+                                                      F32     Z_face,
+                                                      F32     X_up,
+                                                      F32     Y_up,
+                                                      F32     Z_up);
+
+DXDEC void       AILCALL AIL_3D_position             (H3DPOBJECT  obj,
+                                                      F32 FAR *X,
+                                                      F32 FAR *Y,
+                                                      F32 FAR *Z);
+
+DXDEC void       AILCALL AIL_3D_velocity             (H3DPOBJECT  obj,
+                                                      F32 FAR *dX_per_ms,
+                                                      F32 FAR *dY_per_ms,
+                                                      F32 FAR *dZ_per_ms);
+
+DXDEC void       AILCALL AIL_3D_orientation          (H3DPOBJECT  obj,
+                                                      F32 FAR *X_face,
+                                                      F32 FAR *Y_face,
+                                                      F32 FAR *Z_face,
+                                                      F32 FAR *X_up,
+                                                      F32 FAR *Y_up,
+                                                      F32 FAR *Z_up);
+
+DXDEC void       AILCALL AIL_update_3D_position      (H3DPOBJECT obj,
+                                                      F32     dt_milliseconds);
+
+DXDEC void       AILCALL AIL_auto_update_3D_position (H3DPOBJECT obj,
+                                                      S32        enable);
+
+DXDEC  void     AILCALL AIL_set_3D_user_data         (H3DPOBJECT obj,
+                                                      U32        index,
+                                                      S32        value);
+
+DXDEC  S32      AILCALL AIL_3D_user_data             (H3DPOBJECT obj,
+                                                      U32        index);
+
+// Obsolete 3D function names:
+#define AIL_set_3D_object_user_data AIL_set_3D_user_data
+#define AIL_3D_object_user_data AIL_3D_user_data
+#define AIL_3D_open_listener AIL_open_3D_listener
+#define AIL_3D_close_listener AIL_close_3D_listener
+#define AIL_3D_open_object AIL_open_3D_object
+#define AIL_3D_close_object AIL_close_3D_object
+
+//
+// RAD room types - currently the same as EAX
+//
+
+enum
+{
+    ENVIRONMENT_GENERIC,                // factory default
+    ENVIRONMENT_PADDEDCELL,
+    ENVIRONMENT_ROOM,                   // standard environments
+    ENVIRONMENT_BATHROOM,
+    ENVIRONMENT_LIVINGROOM,
+    ENVIRONMENT_STONEROOM,
+    ENVIRONMENT_AUDITORIUM,
+    ENVIRONMENT_CONCERTHALL,
+    ENVIRONMENT_CAVE,
+    ENVIRONMENT_ARENA,
+    ENVIRONMENT_HANGAR,
+    ENVIRONMENT_CARPETEDHALLWAY,
+    ENVIRONMENT_HALLWAY,
+    ENVIRONMENT_STONECORRIDOR,
+    ENVIRONMENT_ALLEY,
+    ENVIRONMENT_FOREST,
+    ENVIRONMENT_CITY,
+    ENVIRONMENT_MOUNTAINS,
+    ENVIRONMENT_QUARRY,
+    ENVIRONMENT_PLAIN,
+    ENVIRONMENT_PARKINGLOT,
+    ENVIRONMENT_SEWERPIPE,
+    ENVIRONMENT_UNDERWATER,
+    ENVIRONMENT_DRUGGED,
+    ENVIRONMENT_DIZZY,
+    ENVIRONMENT_PSYCHOTIC,
+
+    ENVIRONMENT_COUNT           // total number of environments
+};
+
+//
+// enumerated values for EAX
+//
+
+#ifndef EAX_H_INCLUDED
+
+enum
+{
+    EAX_ENVIRONMENT_GENERIC,                // factory default
+    EAX_ENVIRONMENT_PADDEDCELL,
+    EAX_ENVIRONMENT_ROOM,              // standard environments
+    EAX_ENVIRONMENT_BATHROOM,
+    EAX_ENVIRONMENT_LIVINGROOM,
+    EAX_ENVIRONMENT_STONEROOM,
+    EAX_ENVIRONMENT_AUDITORIUM,
+    EAX_ENVIRONMENT_CONCERTHALL,
+    EAX_ENVIRONMENT_CAVE,
+    EAX_ENVIRONMENT_ARENA,
+    EAX_ENVIRONMENT_HANGAR,
+    EAX_ENVIRONMENT_CARPETEDHALLWAY,
+    EAX_ENVIRONMENT_HALLWAY,
+    EAX_ENVIRONMENT_STONECORRIDOR,
+    EAX_ENVIRONMENT_ALLEY,
+    EAX_ENVIRONMENT_FOREST,
+    EAX_ENVIRONMENT_CITY,
+    EAX_ENVIRONMENT_MOUNTAINS,
+    EAX_ENVIRONMENT_QUARRY,
+    EAX_ENVIRONMENT_PLAIN,
+    EAX_ENVIRONMENT_PARKINGLOT,
+    EAX_ENVIRONMENT_SEWERPIPE,
+    EAX_ENVIRONMENT_UNDERWATER,
+    EAX_ENVIRONMENT_DRUGGED,
+    EAX_ENVIRONMENT_DIZZY,
+    EAX_ENVIRONMENT_PSYCHOTIC,
+
+    EAX_ENVIRONMENT_COUNT           // total number of environments
+};
+
+#define EAX_REVERBMIX_USEDISTANCE (-1.0F)
+
+#endif
+
+#else
+
+typedef struct _FLTPROVIDER
+{
+  U32 junk;
+} FLTPROVIDER;
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#if defined(_PUSHPOP_SUPPORTED) || PRAGMA_STRUCT_PACKPUSH
+  #pragma pack(pop)
+#else
+  #pragma pack()
+#endif
+
+
+#endif
diff --git a/milessdk/lib/mss32.lib b/milessdk/lib/mss32.lib
new file mode 100644
index 00000000..031fd1bd
--- /dev/null
+++ b/milessdk/lib/mss32.lib
diff --git a/premake5.lua b/premake5.lua
index 0d28573b..8b2373a1 100644
--- a/premake5.lua
+++ b/premake5.lua
@@ -17,6 +17,7 @@ workspace "re3"
 	files { "src/skel/win/*.*" }
 	files { "src/vehicles/*.*" }
 	files { "src/weapons/*.*" }
+	files { "eax/*.*" }
 
 	includedirs { "src" }
 	includedirs { "src/animation" }
@@ -33,11 +34,15 @@ workspace "re3"
 	includedirs { "src/skel/win" }
 	includedirs { "src/vehicles" }
 	includedirs { "src/weapons" }
+	includedirs { "eax" }
 
 	includedirs { "dxsdk/include" }
 	includedirs { "rwsdk/include/d3d8" }
+	includedirs { "milessdk/include" }
+	includedirs { "eax" }
 
 	libdirs { "dxsdk/lib" }
+	libdirs { "milessdk/lib" }
 	
     pbcommands = { 
        "setlocal EnableDelayedExpansion",
diff --git a/src/audio/AudioManager.cpp b/src/audio/AudioManager.cpp
index bffdc27f..bd99628e 100644
--- a/src/audio/AudioManager.cpp
+++ b/src/audio/AudioManager.cpp
@@ -14,7 +14,7 @@
 #include "Plane.h"
 #include "PlayerPed.h"
 #include "Pools.h"
-#include "SampleManager.h"
+#include "sampman.h"
 #include "Stats.h"
 #include "Vehicle.h"
 #include "Plane.h"
@@ -149,9 +149,9 @@ cAudioManager::AddPlayerCarSample(uint8 emittingVolume, int32 freq, uint32 sampl
 		}
 		m_sQueueSample.m_bEmittingVolume = emittingVolume;
 		m_sQueueSample.m_nLoopStart =
-		    cSampleManager.GetSampleLoopStartOffset(m_sQueueSample.m_nSampleIndex);
+		    SampleManager.GetSampleLoopStartOffset(m_sQueueSample.m_nSampleIndex);
 		m_sQueueSample.m_nLoopEnd =
-		    cSampleManager.GetSampleLoopEndOffset(m_sQueueSample.m_nSampleIndex);
+		    SampleManager.GetSampleLoopEndOffset(m_sQueueSample.m_nSampleIndex);
 		m_sQueueSample.field_48 = 6.0f;
 		m_sQueueSample.m_fSoundIntensity = 50.0f;
 		m_sQueueSample.field_56 = 0;
@@ -351,9 +351,9 @@ cAudioManager::AgeCrimes()
 }
 
 int8
-cAudioManager::AutoDetect3DProviders()
+cAudioManager::GetCurrent3DProviderIndex()
 {
-	if(m_bIsInitialised) return cSampleManager.AutoDetect3DProviders();
+	if(m_bIsInitialised) return SampleManager.GetCurrent3DProviderIndex();
 
 	return -1;
 }
@@ -370,7 +370,7 @@ cAudioManager::CalculateDistance(bool *ptr, float dist)
 bool
 cAudioManager::CheckForAnAudioFileOnCD()
 {
-	return cSampleManager.CheckForAnAudioFileOnCD();
+	return SampleManager.CheckForAnAudioFileOnCD();
 }
 
 void
@@ -522,12 +522,12 @@ cAudioManager::DoPoliceRadioCrackle()
 	m_sQueueSample.m_bIsDistant = 1;
 	m_sQueueSample.field_16 = 10;
 	m_sQueueSample.m_nFrequency =
-	    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_POLICE_SCANNER_CRACKLE);
+	    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_POLICE_SCANNER_CRACKLE);
 	m_sQueueSample.m_bVolume = m_anRandomTable[2] % 20u + 15;
 	m_sQueueSample.m_nLoopCount = 0;
 	m_sQueueSample.m_bEmittingVolume = m_sQueueSample.m_bVolume;
-	m_sQueueSample.m_nLoopStart = cSampleManager.GetSampleLoopStartOffset(188);
-	m_sQueueSample.m_nLoopEnd = cSampleManager.GetSampleLoopEndOffset(188);
+	m_sQueueSample.m_nLoopStart = SampleManager.GetSampleLoopStartOffset(188);
+	m_sQueueSample.m_nLoopEnd = SampleManager.GetSampleLoopEndOffset(188);
 	m_sQueueSample.field_56 = 0;
 	m_sQueueSample.m_bReverbFlag = 0;
 	m_sQueueSample.m_bOffset = 63;
@@ -569,9 +569,9 @@ cAudioManager::Initialise()
 {
 	if(!m_bIsInitialised) {
 		PreInitialiseGameSpecificSetup();
-		m_bIsInitialised = cSampleManager.Initialise();
+		m_bIsInitialised = SampleManager.Initialise();
 		if(m_bIsInitialised) {
-			m_bActiveSamples = cSampleManager.GetActiveSamples();
+			m_bActiveSamples = SampleManager.GetMaximumSupportedChannels();
 			if(m_bActiveSamples <= 1u) {
 				Terminate();
 			} else {
@@ -651,10 +651,10 @@ cAudioManager::Terminate()
 		PreTerminateGameSpecificShutdown();
 
 		for(uint32 i = 0; i < 2; i++) {
-			if(cSampleManager.IsSampleBankLoaded(i)) cSampleManager.UnloadSampleBank(i);
+			if(SampleManager.IsSampleBankLoaded(i)) SampleManager.UnloadSampleBank(i);
 		}
 
-		cSampleManager.Terminate();
+		SampleManager.Terminate();
 
 		m_bIsInitialised = 0;
 		PostTerminateGameSpecificShutdown();
@@ -678,14 +678,14 @@ cAudioManager::GetMissionAudioLoadingStatus()
 uint8
 cAudioManager::GetNum3DProvidersAvailable()
 {
-	if(m_bIsInitialised) return num3DProvidersAvailable;
+	if(m_bIsInitialised) return SampleManager.GetNum3DProvidersAvailable();
 	return 0;
 }
 
 bool
 cAudioManager::IsMP3RadioChannelAvailable()
 {
-	if(m_bIsInitialised) return cSampleManager.IsMP3RadioChannelAvailable();
+	if(m_bIsInitialised) return SampleManager.IsMP3RadioChannelAvailable();
 
 	return 0;
 }
@@ -693,7 +693,7 @@ cAudioManager::IsMP3RadioChannelAvailable()
 uint8
 cAudioManager::GetCDAudioDriveLetter()
 {
-	if(m_bIsInitialised) return cSampleManager.GetCDAudioDriveLetter();
+	if(m_bIsInitialised) return SampleManager.GetCDAudioDriveLetter();
 
 	return 0;
 }
@@ -701,31 +701,31 @@ cAudioManager::GetCDAudioDriveLetter()
 void
 cAudioManager::SetEffectsMasterVolume(uint8 volume)
 {
-	cSampleManager.SetEffectsMasterVolume(volume);
+	SampleManager.SetEffectsMasterVolume(volume);
 }
 
 void
 cAudioManager::SetMusicMasterVolume(uint8 volume)
 {
-	cSampleManager.SetMusicMasterVolume(volume);
+	SampleManager.SetMusicMasterVolume(volume);
 }
 
 void
-cAudioManager::SetEffectsFadeVol(uint8 volume)
+cAudioManager::SetEffectsFadeVolume(uint8 volume)
 {
-	cSampleManager.SetEffectsFadeVol(volume);
+	SampleManager.SetEffectsFadeVolume(volume);
 }
 
 void
-cAudioManager::SetMusicFadeVol(uint8 volume)
+cAudioManager::SetMusicFadeVolume(uint8 volume)
 {
-	cSampleManager.SetMusicFadeVol(volume);
+	SampleManager.SetMusicFadeVolume(volume);
 }
 
 void
 cAudioManager::SetSpeakerConfig(int32 conf)
 {
-	cSampleManager.SetSpeakerConfig(conf);
+	SampleManager.SetSpeakerConfig(conf);
 }
 
 WRAPPER
@@ -803,8 +803,8 @@ char *
 cAudioManager::Get3DProviderName(uint8 id)
 {
 	if(!m_bIsInitialised) return 0;
-	if(id >= num3DProvidersAvailable) return 0;
-	return asName3DProviders[id];
+	if(id >= SampleManager.GetNum3DProvidersAvailable()) return 0;
+	return SampleManager.Get3DProviderName(id);
 }
 
 bool
@@ -825,16 +825,16 @@ cAudioManager::SetupJumboFlySound(uint8 emittingVol)
 		m_sQueueSample.m_bEmittingVolume = emittingVol;
 		m_sQueueSample.m_nLoopCount = 0;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_JUMBO_FLY_SOUND);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_JUMBO_FLY_SOUND);
 		m_sQueueSample.m_nLoopStart =
-		    cSampleManager.GetSampleLoopStartOffset(m_sQueueSample.m_nSampleIndex);
+		    SampleManager.GetSampleLoopStartOffset(m_sQueueSample.m_nSampleIndex);
 		m_sQueueSample.m_fSoundIntensity = 440.0f;
 		m_sQueueSample.field_56 = 0;
 		m_sQueueSample.field_48 = 4.0;
 		m_sQueueSample.m_bReverbFlag = 1;
 		m_sQueueSample.field_76 = 5;
 		m_sQueueSample.m_nLoopEnd =
-		    cSampleManager.GetSampleLoopEndOffset(m_sQueueSample.m_nSampleIndex);
+		    SampleManager.GetSampleLoopEndOffset(m_sQueueSample.m_nSampleIndex);
 		AddSampleToRequestedQueue();
 	}
 	return 1;
@@ -854,13 +854,13 @@ cAudioManager::SetupJumboRumbleSound(uint8 emittingVol)
 		m_sQueueSample.m_bIsDistant = 1;
 		m_sQueueSample.field_16 = 1;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_JUMBO_RUMBLE_SOUND);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_JUMBO_RUMBLE_SOUND);
 		m_sQueueSample.m_nLoopCount = 0;
 		m_sQueueSample.m_bEmittingVolume = emittingVol;
 		m_sQueueSample.m_nLoopStart =
-		    cSampleManager.GetSampleLoopStartOffset(m_sQueueSample.m_nSampleIndex);
+		    SampleManager.GetSampleLoopStartOffset(m_sQueueSample.m_nSampleIndex);
 		m_sQueueSample.m_nLoopEnd =
-		    cSampleManager.GetSampleLoopEndOffset(m_sQueueSample.m_nSampleIndex);
+		    SampleManager.GetSampleLoopEndOffset(m_sQueueSample.m_nSampleIndex);
 		m_sQueueSample.field_48 = 4.0;
 		m_sQueueSample.m_fSoundIntensity = 240.0;
 		m_sQueueSample.field_56 = 0;
@@ -903,9 +903,9 @@ cAudioManager::SetupJumboTaxiSound(uint8 vol)
 		m_sQueueSample.m_nLoopCount = 0;
 		m_sQueueSample.m_bEmittingVolume = emittingVol;
 		m_sQueueSample.m_nLoopStart =
-		    cSampleManager.GetSampleLoopStartOffset(m_sQueueSample.m_nSampleIndex);
+		    SampleManager.GetSampleLoopStartOffset(m_sQueueSample.m_nSampleIndex);
 		m_sQueueSample.m_nLoopEnd =
-		    cSampleManager.GetSampleLoopEndOffset(m_sQueueSample.m_nSampleIndex);
+		    SampleManager.GetSampleLoopEndOffset(m_sQueueSample.m_nSampleIndex);
 		m_sQueueSample.field_48 = 4.0f;
 		m_sQueueSample.m_fSoundIntensity = 180.0f;
 		m_sQueueSample.field_56 = 0;
@@ -934,9 +934,9 @@ cAudioManager::SetupJumboWhineSound(uint8 emittingVol, int32 freq)
 		m_sQueueSample.m_nLoopCount = 0;
 		m_sQueueSample.m_bEmittingVolume = emittingVol;
 		m_sQueueSample.m_nLoopStart =
-		    cSampleManager.GetSampleLoopStartOffset(m_sQueueSample.m_nSampleIndex);
+		    SampleManager.GetSampleLoopStartOffset(m_sQueueSample.m_nSampleIndex);
 		m_sQueueSample.m_nLoopEnd =
-		    cSampleManager.GetSampleLoopEndOffset(m_sQueueSample.m_nSampleIndex);
+		    SampleManager.GetSampleLoopEndOffset(m_sQueueSample.m_nSampleIndex);
 		m_sQueueSample.field_48 = 4.0f;
 		m_sQueueSample.m_fSoundIntensity = 170.0f;
 		m_sQueueSample.field_56 = 0;
@@ -972,7 +972,7 @@ void
 cAudioManager::ResetPoliceRadio()
 {
 	if(m_bIsInitialised) {
-		if(cSampleManager.GetChannelUsedFlag(28)) cSampleManager.StopChannel(28);
+		if(SampleManager.GetChannelUsedFlag(28)) SampleManager.StopChannel(28);
 		InitialisePoliceRadio();
 	}
 }
@@ -1044,13 +1044,13 @@ cAudioManager::RandomDisplacement(uint32 seed)
 void
 cAudioManager::ReleaseDigitalHandle()
 {
-	if(m_bIsInitialised) { cSampleManager.ReleaseDigitalHandle(); }
+	if(m_bIsInitialised) { SampleManager.ReleaseDigitalHandle(); }
 }
 
 void
-cAudioManager::RequireDigitalHandle()
+cAudioManager::ReacquireDigitalHandle()
 {
-	if(m_bIsInitialised) { cSampleManager.RequireDigitalHandle(); }
+	if(m_bIsInitialised) { SampleManager.ReacquireDigitalHandle(); }
 }
 
 void
@@ -1142,7 +1142,7 @@ uint8 &jumboVolOffset = *(uint8 *)0x6508ED;
 void
 cAudioManager::DoJumboVolOffset()
 {
-	if(!(m_nTimeOfRecentCrime % (m_anRandomTable[0] % 6u + 3)))
+	if(!(m_FrameCounter % (m_anRandomTable[0] % 6u + 3)))
 		jumboVolOffset = m_anRandomTable[1] % 60u;
 }
 
@@ -3448,7 +3448,7 @@ cAudioManager::ProcessActiveQueues()
 				v6 = (v6 + 92);
 			}
 			if(v5->m_nLoopCount) {
-				if(m_nTimeOfRecentCrime & 1) {
+				if(m_FrameCounter & 1) {
 					if(!(j & 1)) {
 						v8 = 0;
 						goto LABEL_17;
@@ -3460,7 +3460,7 @@ cAudioManager::ProcessActiveQueues()
 					v8 = 0;
 				}
 			LABEL_17:
-				if(v8 && !cSampleManager.GetChannelUsedFlag(j)) {
+				if(v8 && !SampleManager.GetChannelUsedFlag(j)) {
 					v5->m_bLoopEnded = 1;
 					m_asActiveSamples[0].m_bLoopEnded = 1;
 					m_asActiveSamples[0].m_nSampleIndex = NO_SAMPLE;
@@ -3483,8 +3483,8 @@ cAudioManager::ProcessActiveQueues()
 					} else {
 						v43 = v5->m_bEmittingVolume;
 					}
-					cSampleManager.SetChannelFrequency(j, v5->m_nFrequency);
-					cSampleManager.SetChannelEmittingVolume(j, v43);
+					SampleManager.SetChannelFrequency(j, v5->m_nFrequency);
+					SampleManager.SetChannelEmittingVolume(j, v43);
 				} else {
 					v10 = m_asActiveSamples[0].m_fDistance;
 					v11 = v5->m_fDistance;
@@ -3506,7 +3506,7 @@ cAudioManager::ProcessActiveQueues()
 							newFreq = activeSampleFreq + 6000;
 						}
 						v7->m_nFrequency = newFreq;
-						cSampleManager.SetChannelFrequency(j, newFreq);
+						SampleManager.SetChannelFrequency(j, newFreq);
 					}
 					v40 = v7->m_bEmittingVolume;
 					v17 = v5->m_bEmittingVolume;
@@ -3528,16 +3528,16 @@ cAudioManager::ProcessActiveQueues()
 						} else {
 							v19 = v41;
 						}
-						cSampleManager.SetChannelEmittingVolume(j, v19);
+						SampleManager.SetChannelEmittingVolume(j, v19);
 						v7->m_bEmittingVolume = v41;
 					}
 					TranslateEntity(&v5->m_vecPos, &a2);
-					cSampleManager.SetChannel3DPosition(j, a2.x, a2.y, a2.z);
+					SampleManager.SetChannel3DPosition(j, a2.x, a2.y, a2.z);
 					v20 = 0.25f * v5->m_fSoundIntensity;
-					cSampleManager.SetChannel3DDistances(
+					SampleManager.SetChannel3DDistances(
 					    j, v5->m_fSoundIntensity, v20);
 				}
-				cSampleManager.SetChannelReverbFlag(j, v5->m_bReverbFlag);
+				SampleManager.SetChannelReverbFlag(j, v5->m_bReverbFlag);
 				continue;
 			}
 			v5->m_bIsProcessed = 0;
@@ -3551,7 +3551,7 @@ cAudioManager::ProcessActiveQueues()
 	for(uint32 i = 0; v22 < m_bActiveSamples; i++) {
 		if(v23->m_asActiveSamples[0].m_nSampleIndex != NO_SAMPLE &&
 		   !v23->m_asActiveSamples[0].m_bIsProcessed) {
-			cSampleManager.StopChannel(i);
+			SampleManager.StopChannel(i);
 			v23->m_asActiveSamples[0].m_nSampleIndex = NO_SAMPLE;
 			v23->m_asActiveSamples[0].m_nEntityIndex = -5;
 		}
@@ -3578,7 +3578,7 @@ cAudioManager::ProcessActiveQueues()
 						if(!v26->m_nLoopCount) goto LABEL_80;
 						v28 = v26->m_nFrequency / field_19192;
 						v29 = v26->m_nLoopCount *
-						      cSampleManager.GetSampleLength(
+						      SampleManager.GetSampleLength(
 						          v26->m_nSampleIndex);
 						if(v28) {
 							v26->field_76 = v29 / v28 + 1;
@@ -3604,28 +3604,28 @@ cAudioManager::ProcessActiveQueues()
 								v45 = v27->m_asActiveSamples[0]
 								          .m_bEmittingVolume;
 							}
-							if(cSampleManager.InitialiseChannel(
+							if(SampleManager.InitialiseChannel(
 							       l,
 							       v27->m_asActiveSamples[0]
 							           .m_nSampleIndex,
 							       v27->m_asActiveSamples[0]
 							           .m_bBankIndex)) {
-								cSampleManager.SetChannelFrequency(
+								SampleManager.SetChannelFrequency(
 								    l, v27->m_asActiveSamples[0]
 								           .m_nFrequency);
 								cSampleManager
 								    .SetChannelEmittingVolume(l,
 								                              v45);
-								cSampleManager.SetChannelLoopPoints(
+								SampleManager.SetChannelLoopPoints(
 								    l,
 								    v27->m_asActiveSamples[0]
 								        .m_nLoopStart,
 								    v27->m_asActiveSamples[0]
 								        .m_nLoopEnd);
-								cSampleManager.SetChannelLoopCount(
+								SampleManager.SetChannelLoopCount(
 								    l, v27->m_asActiveSamples[0]
 								           .m_nLoopCount);
-								cSampleManager.SetChannelReverbFlag(
+								SampleManager.SetChannelReverbFlag(
 								    l, v27->m_asActiveSamples[0]
 								           .m_bReverbFlag);
 								if(v27->m_asActiveSamples[0]
@@ -3656,7 +3656,7 @@ cAudioManager::ProcessActiveQueues()
 								v35 = v34;
 								v36 = v33;
 								v37 = v32;
-								cSampleManager.SetChannel3DPosition(
+								SampleManager.SetChannel3DPosition(
 								    l, v37, v36, v35);
 								v38 = 0.25f *
 								      v27->m_asActiveSamples[0]
@@ -3667,7 +3667,7 @@ cAudioManager::ProcessActiveQueues()
 								        v27->m_asActiveSamples[0]
 								            .m_fSoundIntensity,
 								        v38);
-								cSampleManager.StartChannel(l);
+								SampleManager.StartChannel(l);
 							}
 							v27->m_asActiveSamples[0].m_bIsProcessed =
 							    1;
@@ -3706,7 +3706,7 @@ cAudioManager::ProcessAirBrakes(cVehicleParams *params)
 		m_sQueueSample.field_4 = 13;
 		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_VEHICLE_AIR_BRAKES;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_VEHICLE_AIR_BRAKES);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_VEHICLE_AIR_BRAKES);
 		m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency >> 4);
 		m_sQueueSample.m_bBankIndex = 0;
 		m_sQueueSample.m_bIsDistant = 0;
@@ -3759,7 +3759,7 @@ cAudioManager::ProcessAirportScriptObject(uint8 sound)
 				m_sQueueSample.m_nSampleIndex =
 				    (m_anRandomTable[1] & 3) + AUDIO_SAMPLE_AIRPORT_1;
 				m_sQueueSample.m_bBankIndex = 0;
-				m_sQueueSample.m_nFrequency = cSampleManager.GetSampleBaseFrequency(
+				m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(
 				    m_sQueueSample.m_nSampleIndex);
 				m_sQueueSample.field_4 = counter++;
 				m_sQueueSample.m_bIsDistant = 0;
@@ -3815,9 +3815,9 @@ cAudioManager::ProcessBridgeMotor()
 			m_sQueueSample.m_nLoopCount = 0;
 			m_sQueueSample.m_bEmittingVolume = 127;
 			m_sQueueSample.m_nLoopStart =
-			    cSampleManager.GetSampleLoopStartOffset(m_sQueueSample.m_nSampleIndex);
+			    SampleManager.GetSampleLoopStartOffset(m_sQueueSample.m_nSampleIndex);
 			m_sQueueSample.m_nLoopEnd =
-			    cSampleManager.GetSampleLoopEndOffset(m_sQueueSample.m_nSampleIndex);
+			    SampleManager.GetSampleLoopEndOffset(m_sQueueSample.m_nSampleIndex);
 			m_sQueueSample.field_48 = 2.0f;
 			m_sQueueSample.m_fSoundIntensity = 400.0f;
 			m_sQueueSample.field_56 = 0;
@@ -3847,13 +3847,13 @@ cAudioManager::ProcessBridgeWarning()
 			m_sQueueSample.m_bIsDistant = 0;
 			m_sQueueSample.field_16 = 1;
 			m_sQueueSample.m_nFrequency =
-			    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_BRIDGE_WARNING);
+			    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_BRIDGE_WARNING);
 			m_sQueueSample.m_nLoopCount = 0;
 			m_sQueueSample.m_bEmittingVolume = 100;
 			m_sQueueSample.m_nLoopStart =
-			    cSampleManager.GetSampleLoopStartOffset(m_sQueueSample.m_nSampleIndex);
+			    SampleManager.GetSampleLoopStartOffset(m_sQueueSample.m_nSampleIndex);
 			m_sQueueSample.m_nLoopEnd =
-			    cSampleManager.GetSampleLoopEndOffset(m_sQueueSample.m_nSampleIndex);
+			    SampleManager.GetSampleLoopEndOffset(m_sQueueSample.m_nSampleIndex);
 			m_sQueueSample.field_48 = 2.0f;
 			m_sQueueSample.m_fSoundIntensity = 450.0f;
 			m_sQueueSample.field_56 = 0;
@@ -3910,7 +3910,7 @@ cAudioManager::ProcessCinemaScriptObject(uint8 sound)
 			if(m_sQueueSample.m_bVolume) {
 				m_sQueueSample.m_nSampleIndex = counter % 3 + AUDIO_SAMPLE_CINEMA_1;
 				m_sQueueSample.m_bBankIndex = 0;
-				m_sQueueSample.m_nFrequency = cSampleManager.GetSampleBaseFrequency(
+				m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(
 				    m_sQueueSample.m_nSampleIndex);
 				m_sQueueSample.m_nFrequency +=
 				    RandomDisplacement(m_sQueueSample.m_nFrequency >> 2);
@@ -3972,7 +3972,7 @@ cAudioManager::ProcessDocksScriptObject(uint8 sound)
 				m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_DOCKS;
 				m_sQueueSample.m_bBankIndex = 0;
 				m_sQueueSample.m_nFrequency =
-				    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_DOCKS);
+				    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_DOCKS);
 				m_sQueueSample.m_nFrequency +=
 				    RandomDisplacement(m_sQueueSample.m_nFrequency >> 3);
 				m_sQueueSample.field_4 = counter++;
@@ -4100,9 +4100,9 @@ cAudioManager::ProcessFireHydrant()
 			m_sQueueSample.m_nLoopCount = 0;
 			m_sQueueSample.m_bEmittingVolume = 40;
 			m_sQueueSample.m_nLoopStart =
-			    cSampleManager.GetSampleLoopStartOffset(m_sQueueSample.m_nSampleIndex);
+			    SampleManager.GetSampleLoopStartOffset(m_sQueueSample.m_nSampleIndex);
 			m_sQueueSample.m_nLoopEnd =
-			    cSampleManager.GetSampleLoopEndOffset(m_sQueueSample.m_nSampleIndex);
+			    SampleManager.GetSampleLoopEndOffset(m_sQueueSample.m_nSampleIndex);
 			m_sQueueSample.field_48 = 2.0f;
 			m_sQueueSample.m_fSoundIntensity = 35.0f;
 			m_sQueueSample.field_56 = 0;
@@ -4249,7 +4249,7 @@ cAudioManager::ProcessFrontEnd()
 				m_sQueueSample.m_nFrequency = 48000;
 		} else {
 			m_sQueueSample.m_nFrequency =
-			    cSampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
+			    SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
 		}
 		m_sQueueSample.m_bVolume = 110;
 		m_sQueueSample.field_4 = counter++;
@@ -4317,7 +4317,7 @@ cAudioManager::ProcessHomeScriptObject(uint8 sound)
 				m_sQueueSample.m_nSampleIndex =
 				    m_anRandomTable[0] % 5u + AUDIO_SAMPLE_HOME_1;
 				m_sQueueSample.m_bBankIndex = 0;
-				m_sQueueSample.m_nFrequency = cSampleManager.GetSampleBaseFrequency(
+				m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(
 				    m_sQueueSample.m_nSampleIndex);
 				m_sQueueSample.m_nFrequency +=
 				    RandomDisplacement(m_sQueueSample.m_nFrequency >> 4);
@@ -4478,7 +4478,7 @@ cAudioManager::ProcessLaunderetteScriptObject(uint8 sound)
 			m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_LAUNDERETTE_1;
 			m_sQueueSample.m_bBankIndex = 0;
 			m_sQueueSample.m_nFrequency =
-			    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_LAUNDERETTE_1);
+			    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_LAUNDERETTE_1);
 			m_sQueueSample.field_4 = 0;
 			m_sQueueSample.m_bIsDistant = 0;
 			m_sQueueSample.m_nLoopCount = 0;
@@ -4487,9 +4487,9 @@ cAudioManager::ProcessLaunderetteScriptObject(uint8 sound)
 			m_sQueueSample.field_48 = 2.0f;
 			m_sQueueSample.m_bEmittingVolume = 45;
 			m_sQueueSample.m_nLoopStart =
-			    cSampleManager.GetSampleLoopStartOffset(m_sQueueSample.m_nSampleIndex);
+			    SampleManager.GetSampleLoopStartOffset(m_sQueueSample.m_nSampleIndex);
 			m_sQueueSample.m_nLoopEnd =
-			    cSampleManager.GetSampleLoopEndOffset(m_sQueueSample.m_nSampleIndex);
+			    SampleManager.GetSampleLoopEndOffset(m_sQueueSample.m_nSampleIndex);
 			m_sQueueSample.m_bReverbFlag = 1;
 			m_sQueueSample.m_bRequireReflection = 0;
 			AddSampleToRequestedQueue();
@@ -4500,7 +4500,7 @@ cAudioManager::ProcessLaunderetteScriptObject(uint8 sound)
 			m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_LAUNDERETTE_2;
 			m_sQueueSample.m_bBankIndex = 0;
 			m_sQueueSample.m_nFrequency =
-			    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_LAUNDERETTE_2);
+			    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_LAUNDERETTE_2);
 			m_sQueueSample.field_4 = 1;
 			m_sQueueSample.m_bIsDistant = 0;
 			m_sQueueSample.m_nLoopCount = 0;
@@ -4509,9 +4509,9 @@ cAudioManager::ProcessLaunderetteScriptObject(uint8 sound)
 			m_sQueueSample.field_48 = 2.0f;
 			m_sQueueSample.m_bEmittingVolume = 110;
 			m_sQueueSample.m_nLoopStart =
-			    cSampleManager.GetSampleLoopStartOffset(m_sQueueSample.m_nSampleIndex);
+			    SampleManager.GetSampleLoopStartOffset(m_sQueueSample.m_nSampleIndex);
 			m_sQueueSample.m_nLoopEnd =
-			    cSampleManager.GetSampleLoopEndOffset(m_sQueueSample.m_nSampleIndex);
+			    SampleManager.GetSampleLoopEndOffset(m_sQueueSample.m_nSampleIndex);
 			m_sQueueSample.m_bReverbFlag = 1;
 			m_sQueueSample.m_bRequireReflection = 0;
 			AddSampleToRequestedQueue();
@@ -4534,7 +4534,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 127;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_1);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_1);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -4546,7 +4546,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 127;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_1);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_1);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -4558,7 +4558,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 127;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_2);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_2);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -4570,7 +4570,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 127;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_2);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_2);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -4582,7 +4582,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 127;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_3);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_3);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -4594,7 +4594,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 127;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_3);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_3);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -4606,7 +4606,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 127;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_4);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_4);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -4618,7 +4618,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 127;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_4);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_4);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -4630,7 +4630,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 127;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_5);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_5);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -4642,7 +4642,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 127;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_5);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_5);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -4654,7 +4654,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 127;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_6);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_6);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -4666,7 +4666,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 127;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_6);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_6);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -4678,7 +4678,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 127;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_7);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_7);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -4690,7 +4690,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 127;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_7);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_7);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -4702,7 +4702,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 127;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_8);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_8);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -4714,7 +4714,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 127;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_8);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_8);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -4726,7 +4726,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 127;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_9);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_9);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -4738,7 +4738,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 127;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_9);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_9);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -4750,7 +4750,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 127;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_10);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_10);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -4762,7 +4762,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 127;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_10);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_10);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -4774,7 +4774,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 127;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_11);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_11);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -4786,7 +4786,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 127;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_11);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_11);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -4798,7 +4798,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 127;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_12);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_12);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -4810,7 +4810,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 127;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_12);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_12);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -4822,7 +4822,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 127;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_13);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_13);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -4834,7 +4834,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 127;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_13);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_13);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -4846,7 +4846,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 127;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_STRIP_CLUB_1);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_STRIP_CLUB_1);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -4858,7 +4858,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 127;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_STRIP_CLUB_1);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_STRIP_CLUB_1);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -4870,7 +4870,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 127;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_STRIP_CLUB_2);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_STRIP_CLUB_2);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -4882,7 +4882,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 127;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_STRIP_CLUB_2);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_STRIP_CLUB_2);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -4900,7 +4900,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 110;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_409);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_409);
 		m_sQueueSample.field_16 = 6;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -4912,7 +4912,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 110;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_409);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_409);
 		m_sQueueSample.field_16 = 6;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -4926,7 +4926,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 110;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_CHINATOWN_RESTAURANT);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_CHINATOWN_RESTAURANT);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -4938,7 +4938,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 110;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_CHINATOWN_RESTAURANT);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_CHINATOWN_RESTAURANT);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -4950,7 +4950,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 110;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_CIPRIANI_RESTAURANT);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_CIPRIANI_RESTAURANT);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -4962,7 +4962,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 110;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_CIPRIANI_RESTAURANT);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_CIPRIANI_RESTAURANT);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -4974,7 +4974,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 110;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_414);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_414);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -4986,7 +4986,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 110;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_414);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_414);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -4998,7 +4998,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 110;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_MARCO_BISTRO);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_MARCO_BISTRO);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -5010,7 +5010,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 110;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_MARCO_BISTRO);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_MARCO_BISTRO);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -5032,7 +5032,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 127;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_FRANKIE_PIANO);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_FRANKIE_PIANO);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -5044,7 +5044,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 127;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_1);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_1);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -5064,7 +5064,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 90;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_BANK_ALARM);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_BANK_ALARM);
 		m_sQueueSample.field_16 = 2;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -5076,7 +5076,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 90;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_BANK_ALARM);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_BANK_ALARM);
 		m_sQueueSample.field_16 = 2;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -5088,7 +5088,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 127;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_POLICE_BALL);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_POLICE_BALL);
 		m_sQueueSample.field_16 = 2;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -5100,7 +5100,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 127;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_POLICE_BALL);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_POLICE_BALL);
 		m_sQueueSample.field_16 = 2;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -5112,7 +5112,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 127;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_RAVE_INDUSTRIAL);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_RAVE_INDUSTRIAL);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -5124,7 +5124,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 127;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_RAVE_INDUSTRIAL);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_RAVE_INDUSTRIAL);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -5141,7 +5141,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 127;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
+		    SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -5154,7 +5154,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 127;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
+		    SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -5166,7 +5166,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 127;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_RAVE_2);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_RAVE_2);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -5178,7 +5178,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 127;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_RAVE_2);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_RAVE_2);
 		m_sQueueSample.field_16 = 3;
 		m_sQueueSample.field_76 = 3;
 		m_sQueueSample.field_48 = 2.0f;
@@ -5190,7 +5190,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		m_sQueueSample.m_bBankIndex = 0;
 		emittingVolume = 80;
 		m_sQueueSample.m_nFrequency =
-		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_FIRE_ENTITY);
+		    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_FIRE_ENTITY);
 		m_sQueueSample.field_16 = 8;
 		m_sQueueSample.field_76 = 10;
 		m_sQueueSample.field_48 = 2.0f;
@@ -5211,9 +5211,9 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 			m_sQueueSample.m_bReverbFlag = 1;
 			m_sQueueSample.m_bEmittingVolume = emittingVolume;
 			m_sQueueSample.m_nLoopStart =
-			    cSampleManager.GetSampleLoopStartOffset(m_sQueueSample.m_nSampleIndex);
+			    SampleManager.GetSampleLoopStartOffset(m_sQueueSample.m_nSampleIndex);
 			m_sQueueSample.m_nLoopEnd =
-			    cSampleManager.GetSampleLoopEndOffset(m_sQueueSample.m_nSampleIndex);
+			    SampleManager.GetSampleLoopEndOffset(m_sQueueSample.m_nSampleIndex);
 			m_sQueueSample.m_bRequireReflection = 0;
 			AddSampleToRequestedQueue();
 		}
@@ -5323,7 +5323,7 @@ cAudioManager::ProcessPornCinema(uint8 sound)
 			    ComputeVolume(maxVolume, m_sQueueSample.m_fSoundIntensity,
 			                  m_sQueueSample.m_fDistance);
 			if(m_sQueueSample.m_bVolume) {
-				m_sQueueSample.m_nFrequency = cSampleManager.GetSampleBaseFrequency(
+				m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(
 				    m_sQueueSample.m_nSampleIndex);
 				m_sQueueSample.field_4 = 0;
 				m_sQueueSample.m_bIsDistant = 0;
@@ -5333,9 +5333,9 @@ cAudioManager::ProcessPornCinema(uint8 sound)
 				m_sQueueSample.field_48 = 2.0f;
 				m_sQueueSample.m_bEmittingVolume = maxVolume;
 				m_sQueueSample.m_nLoopStart =
-				    cSampleManager.GetSampleLoopStartOffset(
+				    SampleManager.GetSampleLoopStartOffset(
 				        m_sQueueSample.m_nSampleIndex);
-				m_sQueueSample.m_nLoopEnd = cSampleManager.GetSampleLoopEndOffset(
+				m_sQueueSample.m_nLoopEnd = SampleManager.GetSampleLoopEndOffset(
 				    m_sQueueSample.m_nSampleIndex);
 				m_sQueueSample.m_bReverbFlag = 1;
 				m_sQueueSample.m_bRequireReflection = 0;
@@ -5350,7 +5350,7 @@ cAudioManager::ProcessPornCinema(uint8 sound)
 			if(m_sQueueSample.m_bVolume) {
 				rand = m_anRandomTable[1] & 1;
 				m_sQueueSample.m_nSampleIndex = rand + sample;
-				m_sQueueSample.m_nFrequency = cSampleManager.GetSampleBaseFrequency(
+				m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(
 				    m_sQueueSample.m_nSampleIndex);
 				m_sQueueSample.m_nFrequency +=
 				    RandomDisplacement(m_sQueueSample.m_nFrequency >> 4);
@@ -5402,7 +5402,7 @@ cAudioManager::ProcessSawMillScriptObject(uint8 sound)
 			m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_SAWMILL_1;
 			m_sQueueSample.m_bBankIndex = 0;
 			m_sQueueSample.m_nFrequency =
-			    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_SAWMILL_1);
+			    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_SAWMILL_1);
 			m_sQueueSample.field_4 = 0;
 			m_sQueueSample.m_bIsDistant = 0;
 			m_sQueueSample.m_nLoopCount = 0;
@@ -5411,9 +5411,9 @@ cAudioManager::ProcessSawMillScriptObject(uint8 sound)
 			m_sQueueSample.field_48 = 2.0f;
 			m_sQueueSample.m_bEmittingVolume = 30;
 			m_sQueueSample.m_nLoopStart =
-			    cSampleManager.GetSampleLoopStartOffset(m_sQueueSample.m_nSampleIndex);
+			    SampleManager.GetSampleLoopStartOffset(m_sQueueSample.m_nSampleIndex);
 			m_sQueueSample.m_nLoopEnd =
-			    cSampleManager.GetSampleLoopEndOffset(m_sQueueSample.m_nSampleIndex);
+			    SampleManager.GetSampleLoopEndOffset(m_sQueueSample.m_nSampleIndex);
 			m_sQueueSample.m_bReverbFlag = 1;
 			m_sQueueSample.m_bRequireReflection = 0;
 			AddSampleToRequestedQueue();
@@ -5425,7 +5425,7 @@ cAudioManager::ProcessSawMillScriptObject(uint8 sound)
 			if(m_sQueueSample.m_bVolume) {
 				m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_SAWMILL_2;
 				m_sQueueSample.m_bBankIndex = 0;
-				m_sQueueSample.m_nFrequency = cSampleManager.GetSampleBaseFrequency(
+				m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(
 				    m_sQueueSample.m_nSampleIndex);
 				m_sQueueSample.field_4 = 1;
 				m_sQueueSample.m_bIsDistant = 0;
@@ -5476,7 +5476,7 @@ cAudioManager::ProcessShopScriptObject(uint8 sound)
 			m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_SHOP_1;
 			m_sQueueSample.m_bBankIndex = 0;
 			m_sQueueSample.m_nFrequency =
-			    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_SHOP_1);
+			    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_SHOP_1);
 			m_sQueueSample.field_4 = 0;
 			m_sQueueSample.m_bIsDistant = 0;
 			m_sQueueSample.m_nLoopCount = 0;
@@ -5485,9 +5485,9 @@ cAudioManager::ProcessShopScriptObject(uint8 sound)
 			m_sQueueSample.field_48 = 2.0f;
 			m_sQueueSample.m_bEmittingVolume = 30;
 			m_sQueueSample.m_nLoopStart =
-			    cSampleManager.GetSampleLoopStartOffset(m_sQueueSample.m_nSampleIndex);
+			    SampleManager.GetSampleLoopStartOffset(m_sQueueSample.m_nSampleIndex);
 			m_sQueueSample.m_nLoopEnd =
-			    cSampleManager.GetSampleLoopEndOffset(m_sQueueSample.m_nSampleIndex);
+			    SampleManager.GetSampleLoopEndOffset(m_sQueueSample.m_nSampleIndex);
 			m_sQueueSample.m_bReverbFlag = 1;
 			m_sQueueSample.m_bRequireReflection = 0;
 			cAudioManager::AddSampleToRequestedQueue();
@@ -5500,7 +5500,7 @@ cAudioManager::ProcessShopScriptObject(uint8 sound)
 				rand = m_anRandomTable[1] & 1;
 				m_sQueueSample.m_nSampleIndex = rand + AUDIO_SAMPLE_SHOP_2;
 				m_sQueueSample.m_bBankIndex = 0;
-				m_sQueueSample.m_nFrequency = cSampleManager.GetSampleBaseFrequency(
+				m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(
 				    m_sQueueSample.m_nSampleIndex);
 				m_sQueueSample.field_4 = rand + 1;
 				m_sQueueSample.m_bIsDistant = 0;
@@ -5526,8 +5526,8 @@ cAudioManager::ProcessSpecial()
 	if(m_bUserPause) {
 		if(!m_bPreviousUserPause) {
 			MusicManager.ChangeMusicMode(0);
-			cSampleManager.SetEffectsFadeVol(maxVolume);
-			cSampleManager.SetMusicFadeVol(maxVolume);
+			SampleManager.SetEffectsFadeVolume(maxVolume);
+			SampleManager.SetMusicFadeVolume(maxVolume);
 		}
 	} else {
 		if(m_bPreviousUserPause) {
@@ -5539,7 +5539,7 @@ cAudioManager::ProcessSpecial()
 			const PedState &state = playerPed->m_nPedState;
 			if(state != PED_ENTER_CAR && state != PED_STEAL_CAR &&
 			   !playerPed->bInVehicle)
-				cSampleManager.StopChannel(m_bActiveSamples);
+				SampleManager.StopChannel(m_bActiveSamples);
 		}
 	}
 }
@@ -5592,7 +5592,7 @@ cAudioManager::ProcessWorkShopScriptObject(uint8 sound)
 			m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_WORK_SHOP;
 			m_sQueueSample.m_bBankIndex = 0;
 			m_sQueueSample.m_nFrequency =
-			    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_WORK_SHOP);
+			    SampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_WORK_SHOP);
 			m_sQueueSample.field_4 = 0;
 			m_sQueueSample.m_bIsDistant = 0;
 			m_sQueueSample.m_nLoopCount = 0;
@@ -5601,9 +5601,9 @@ cAudioManager::ProcessWorkShopScriptObject(uint8 sound)
 			m_sQueueSample.field_48 = 2.0;
 			m_sQueueSample.m_bEmittingVolume = 30;
 			m_sQueueSample.m_nLoopStart =
-			    cSampleManager.GetSampleLoopStartOffset(m_sQueueSample.m_nSampleIndex);
+			    SampleManager.GetSampleLoopStartOffset(m_sQueueSample.m_nSampleIndex);
 			m_sQueueSample.m_nLoopEnd =
-			    cSampleManager.GetSampleLoopEndOffset(m_sQueueSample.m_nSampleIndex);
+			    SampleManager.GetSampleLoopEndOffset(m_sQueueSample.m_nSampleIndex);
 			m_sQueueSample.m_bReverbFlag = 1;
 			m_sQueueSample.m_bRequireReflection = 0;
 			AddSampleToRequestedQueue();
@@ -5623,7 +5623,7 @@ InjectHook(0x56AD30, &cAudioManager::AddPlayerCarSample, PATCH_JUMP);
 InjectHook(0x57B300, &cAudioManager::AddReflectionsToRequestedQueue, PATCH_JUMP);
 // InjectHook(0x57B8D0, &cAudioManager::AddReleasingSounds, PATCH_JUMP);
 InjectHook(0x57B070, &cAudioManager::AddSampleToRequestedQueue, PATCH_JUMP);
-InjectHook(0x57A8F0, &cAudioManager::AutoDetect3DProviders, PATCH_JUMP);
+InjectHook(0x57A8F0, &cAudioManager::GetCurrent3DProviderIndex, PATCH_JUMP);
 // InjectHook(0x580AF0, &cAudioManager::AgeCrimes, PATCH_JUMP);
 
 InjectHook(0x5697A0, &cAudioManager::CalculateDistance, PATCH_JUMP);
@@ -5657,8 +5657,8 @@ InjectHook(0x57AA30, &cAudioManager::GetCDAudioDriveLetter, PATCH_JUMP);
 
 InjectHook(0x57A730, &cAudioManager::SetEffectsMasterVolume, PATCH_JUMP);
 InjectHook(0x57A750, &cAudioManager::SetMusicMasterVolume, PATCH_JUMP);
-InjectHook(0x57A770, &cAudioManager::SetEffectsFadeVol, PATCH_JUMP);
-InjectHook(0x57A790, &cAudioManager::SetMusicFadeVol, PATCH_JUMP);
+InjectHook(0x57A770, &cAudioManager::SetEffectsFadeVolume, PATCH_JUMP);
+InjectHook(0x57A790, &cAudioManager::SetMusicFadeVolume, PATCH_JUMP);
 
 InjectHook(0x57A9A0, &cAudioManager::SetSpeakerConfig, PATCH_JUMP);
 
@@ -5694,7 +5694,7 @@ InjectHook(0x579650, &cAudioManager::IsMissionAudioSampleFinished, PATCH_JUMP);
 InjectHook(0x57AF90, &cAudioManager::RandomDisplacement, PATCH_JUMP);
 
 InjectHook(0x57A9E0, &cAudioManager::ReleaseDigitalHandle, PATCH_JUMP);
-InjectHook(0x57A9F0, &cAudioManager::RequireDigitalHandle, PATCH_JUMP);
+InjectHook(0x57A9F0, &cAudioManager::ReacquireDigitalHandle, PATCH_JUMP);
 InjectHook(0x57AA00, &cAudioManager::SetDynamicAcousticModelingStatus, PATCH_JUMP);
 
 InjectHook(0x57AA50, &cAudioManager::IsAudioInitialised, PATCH_JUMP);
diff --git a/src/audio/AudioManager.h b/src/audio/AudioManager.h
index 1ae50b2f..0cbd742d 100644
--- a/src/audio/AudioManager.h
+++ b/src/audio/AudioManager.h
@@ -187,6 +187,24 @@ struct cAudioScriptObject {
 
 static_assert(sizeof(cAudioScriptObject) == 0x14, "cAudioScriptObject: error");
 
+enum
+{
+	/*
+	REFLECTION_YMAX = 0, top
+	REFLECTION_YMIN = 1, bottom
+	REFLECTION_XMIN = 2, left
+	REFLECTION_XMAX = 3, right
+	REFLECTION_ZMAX = 4,
+	*/
+
+	REFLECTION_TOP = 0,
+	REFLECTION_BOTTOM,
+	REFLECTION_LEFT,
+	REFLECTION_RIGHT,
+	REFLECTION_UP,
+	MAX_REFLECTIONS,
+};
+	
 class cAudioManager
 {
 public:
@@ -234,7 +252,13 @@ public:
 	uint8 m_bUserPause;
 	uint8 m_bPreviousUserPause;
 	uint8 field_19195;
-	int32 m_nTimeOfRecentCrime;
+	uint32 m_FrameCounter;
+	
+	inline uint32 GetFrameCounter(void) { return m_FrameCounter; }
+	float GetReflectionsDistance(int32 idx) { return m_afReflectionsDistances[idx]; }
+	int32 GetRandomTabe(int32 idx) { return m_anRandomTable[idx]; }
+	
+	//
 
 	void AddDetailsToRequestedOrderList(uint8 sample); /// ok
 	void AddPlayerCarSample(uint8 emittingVolume, int32 freq, uint32 sample, uint8 unk1,
@@ -243,7 +267,7 @@ public:
 	void AddReleasingSounds();                            // todo (difficult)
 	void AddSampleToRequestedQueue();                     /// ok
 	void AgeCrimes();                                     // todo
-	int8 AutoDetect3DProviders();                         /// ok
+	int8 GetCurrent3DProviderIndex();                         /// ok
 
 	void CalculateDistance(bool *ptr, float dist); /// ok
 	bool CheckForAnAudioFileOnCD();                /// ok
@@ -283,8 +307,8 @@ public:
 
 	void SetEffectsMasterVolume(uint8 volume);
 	void SetMusicMasterVolume(uint8 volume);
-	void SetEffectsFadeVol(uint8 volume);
-	void SetMusicFadeVol(uint8 volume);
+	void SetEffectsFadeVolume(uint8 volume);
+	void SetMusicFadeVolume(uint8 volume);
 
 	void SetSpeakerConfig(int32 conf);
 
@@ -324,7 +348,7 @@ public:
 	int32 RandomDisplacement(uint32 seed);
 
 	void ReleaseDigitalHandle();
-	void RequireDigitalHandle();
+	void ReacquireDigitalHandle();
 	void SetDynamicAcousticModelingStatus(bool status);
 
 	bool IsAudioInitialised() const;
diff --git a/src/audio/AudioSamples.h b/src/audio/AudioSamples.h
index ba7bf7a8..7d71be54 100644
--- a/src/audio/AudioSamples.h
+++ b/src/audio/AudioSamples.h
@@ -3037,6 +3037,14 @@ enum eAudioSamples : uint32 {
 	AUDIO_SAMPLE_AMMUNATION_WELCOME_3 = 3031,
 	TOTAL_AUDIO_SAMPLES = 3032,
 	NO_SAMPLE = 3033,
+	
+	// shorthands
+	SAMPLEBANK_START     = AUDIO_SAMPLE_VEHICLE_HORN_0,
+	SAMPLEBANK_END       = AUDIO_SAMPLE_PAGER,
+	SAMPLEBANK_MAX       = AUDIO_SAMPLE_PAGER+1,
+	SAMPLEBANK_PED_START = AUDIO_SAMPLE_POLICE_COP_1_ARREST_1,
+	SAMPLEBANK_PED_END   = AUDIO_SAMPLE_AMMUNATION_WELCOME_3,
+	SAMPLEBANK_PED_MAX   = AUDIO_SAMPLE_AMMUNATION_WELCOME_3+1,
 };
 
 enum eScriptSounds : int16
diff --git a/src/audio/MusicManager.cpp b/src/audio/MusicManager.cpp
index 71cc594b..0700ee63 100644
--- a/src/audio/MusicManager.cpp
+++ b/src/audio/MusicManager.cpp
@@ -8,7 +8,7 @@
 #include "Camera.h"
 #include "World.h"
 #include "ModelIndices.h"
-#include "SampleManager.h"
+#include "sampman.h"
 #include "Replay.h"
 
 cMusicManager &MusicManager = *(cMusicManager*)0x8F3964;
@@ -57,7 +57,7 @@ void cMusicManager::DisplayRadioStationName()
 		if (MusicManager.m_bPlayerInCar && !MusicManager.m_bPreviousPlayerInCar)
 			pCurrentStation = nil;
 
-		if (cSampleManager.IsMP3RadioChannelAvailable()) {
+		if (SampleManager.IsMP3RadioChannelAvailable()) {
 			gStreamedSound = MusicManager.m_nCurrentStreamedSound;
 
 			if (gStreamedSound != STREAMED_SOUND_CITY_AMBIENT && gStreamedSound != STREAMED_SOUND_WATER_AMBIENT) {
@@ -140,7 +140,7 @@ void cMusicManager::DisplayRadioStationName()
 			return;
 		};
 
-		if (pRetune > CHATTERBOX && !CSampleManager::IsMP3RadioChannelAvailable()) {
+		if (pRetune > CHATTERBOX && !SampleManager.IsMP3RadioChannelAvailable()) {
 			return;
 		}
 
diff --git a/src/audio/MusicManager.h b/src/audio/MusicManager.h
index 6a08882f..cdea65ec 100644
--- a/src/audio/MusicManager.h
+++ b/src/audio/MusicManager.h
@@ -16,6 +16,15 @@ enum eRadioStation
 	RADIO_OFF,
 };
 
+enum eMusicMode
+{
+	MUSICMODE_FRONTEND = 0,
+	MUSICMODE_GAME,
+	MUSICMODE_CUTSCENE,
+	MUSICMODE_OFF,
+	MUSICMODE_4,
+};
+
 enum eStreamedSounds
 {
 	STREAMED_SOUND_RADIO_HEAD = 0,
@@ -264,6 +273,10 @@ public:
 	uint8 field_2395;
 
 public:
+	bool IsInitialised() { return m_bIsInitialised; }
+	uint32 GetMusicMode() { return m_nMusicMode; }
+	uint8 GetCurrentTrack() { return m_nCurrentStreamedSound; }
+
 	void Initialise();
 	void Terminate();
 
diff --git a/src/audio/SampleManager.cpp b/src/audio/SampleManager.cpp
deleted file mode 100644
index b2f0cf35..00000000
--- a/src/audio/SampleManager.cpp
+++ /dev/null
@@ -1,176 +0,0 @@
-#include "SampleManager.h"
-#include "common.h"
-#include "patcher.h"
-
-CSampleManager &cSampleManager = *(CSampleManager *)0x7341E0;
-
-uint32 &nNumOfMp3Files = *(uint32 *)0x95CC00;
-uint8 &num3DProvidersAvailable = *(uint8 *)0x734237;
-char **asName3DProviders = (char **)0x734238;
-
-bool
-CSampleManager::IsMP3RadioChannelAvailable()
-{
-	return nNumOfMp3Files != 0;
-}
-
-WRAPPER
-void CSampleManager::SetChannelFrequency(int32, int32) { EAXJMP(0x5679D0); }
-
-WRAPPER
-void CSampleManager::SetChannelEmittingVolume(int32, uint32) { EAXJMP(0x567820); }
-
-WRAPPER
-void
-CSampleManager::SetChannel3DPosition(int32, float, float, float)
-{
-	EAXJMP(0x567890);
-}
-
-WRAPPER
-void CSampleManager::SetChannelLoopCount(int32, int32) { EAXJMP(0x567AA0); }
-
-WRAPPER
-void CSampleManager::SetChannel3DDistances(int32, int32, int32) { EAXJMP(0x5678D0); }
-
-WRAPPER
-void CSampleManager::SetChannelReverbFlag(int32, uint8) { EAXJMP(0x567630); }
-
-WRAPPER
-int32 CSampleManager::GetSampleLength(int32) { EAXJMP(0x567300); }
-
-WRAPPER
-bool CSampleManager::InitialiseChannel(int32, int32, uint32, uint32) { EAXJMP(0x5676A0); }
-
-WRAPPER
-void CSampleManager::SetChannelLoopPoints(int32, int32, int32) { EAXJMP(0x567A30); }
-
-WRAPPER
-bool
-CSampleManager::CheckForAnAudioFileOnCD()
-{
-	EAXJMP(0x566EA0);
-}
-
-WRAPPER
-int32 CSampleManager::GetSampleBaseFrequency(int32) { EAXJMP(0x5672A0); }
-
-WRAPPER
-int32 CSampleManager::GetSampleLoopStartOffset(int32) { EAXJMP(0x5672C0); }
-
-WRAPPER
-int32 CSampleManager::GetSampleLoopEndOffset(int32) { EAXJMP(0x5672E0); }
-
-WRAPPER
-bool CSampleManager::IsSampleBankLoaded(uint8) { EAXJMP(0x567130); }
-
-WRAPPER
-void CSampleManager::UnloadSampleBank(uint8) { EAXJMP(0x567110); }
-
-WRAPPER
-void
-CSampleManager::Terminate()
-{
-	EAXJMP(0x566DC0);
-}
-
-WRAPPER
-bool
-CSampleManager::Initialise()
-{
-	EAXJMP(0x566530);
-}
-
-WRAPPER
-int32
-CSampleManager::GetActiveSamples()
-{
-	EAXJMP(0x565970);
-}
-
-WRAPPER void
-CSampleManager::ReleaseDigitalHandle()
-{
-	EAXJMP(0x5664B0);
-}
-
-WRAPPER
-void
-CSampleManager::RequireDigitalHandle()
-{
-	EAXJMP(0x5664F0);
-}
-
-WRAPPER
-char
-CSampleManager::AutoDetect3DProviders()
-{
-	EAXJMP(0x565990);
-}
-
-WRAPPER
-uint8
-CSampleManager::GetCDAudioDriveLetter()
-{
-	EAXJMP(0x566F20);
-}
-
-WRAPPER
-void
-CSampleManager::SetEffectsMasterVolume(uint8 volume)
-{
-	EAXJMP(0x567010);
-}
-
-WRAPPER
-void
-CSampleManager::SetMusicMasterVolume(uint8 volume)
-{
-	EAXJMP(0x567020);
-}
-
-WRAPPER
-void
-CSampleManager::SetEffectsFadeVol(uint8 volume)
-{
-	EAXJMP(0x567030);
-}
-
-WRAPPER
-void
-CSampleManager::SetMusicFadeVol(uint8 volume)
-{
-	EAXJMP(0x567040);
-}
-
-WRAPPER
-void
-CSampleManager::SetSpeakerConfig(uint32 config)
-{
-	EAXJMP(0x565900);
-}
-
-WRAPPER
-bool
-CSampleManager::GetChannelUsedFlag(int32 id)
-{
-	EAXJMP(0x567B00);
-}
-
-WRAPPER
-void
-CSampleManager::StartChannel(int32 id)
-{
-	EAXJMP(0x567B80);
-}
-
-WRAPPER
-void
-CSampleManager::StopChannel(int32 id)
-{
-	EAXJMP(0x567BE0);
-}
-
-STARTPATCHES
-InjectHook(0x566490, CSampleManager::IsMP3RadioChannelAvailable, PATCH_JUMP);
-ENDPATCHES
\ No newline at end of file
diff --git a/src/audio/SampleManager.h b/src/audio/SampleManager.h
deleted file mode 100644
index dc46e7ec..00000000
--- a/src/audio/SampleManager.h
+++ /dev/null
@@ -1,68 +0,0 @@
-#pragma once
-
-#include "common.h"
-
-struct tSample {
-	int m_nOffset;
-	unsigned int m_nSize;
-	int m_nFrequency;
-	int m_nLoopStart;
-	int m_nLoopEnd;
-};
-
-class CSampleManager
-{
-public:
-	void SetChannelFrequency(int32, int32);
-	void SetChannelEmittingVolume(int32, uint32);
-	void SetChannel3DPosition(int32, float, float, float);
-	void SetChannelLoopCount(int32, int32);
-
-	void SetChannel3DDistances(int32, int32, int32);
-	void SetChannelReverbFlag(int32, uint8);
-
-	int32 GetSampleLength(int32);
-
-	bool InitialiseChannel(int32, int32, uint32, uint32 something = 0);
-
-	void SetChannelLoopPoints(int32, int32, int32);
-
-	bool CheckForAnAudioFileOnCD();
-
-	int32 GetSampleBaseFrequency(int32);
-	int32 GetSampleLoopStartOffset(int32);
-	int32 GetSampleLoopEndOffset(int32);
-
-	bool IsSampleBankLoaded(uint8);
-	void UnloadSampleBank(uint8);
-	void Terminate();
-
-	bool Initialise();
-	int32 GetActiveSamples();
-
-	void ReleaseDigitalHandle();
-	void RequireDigitalHandle();
-
-	char AutoDetect3DProviders();
-	uint8 GetCDAudioDriveLetter();
-
-	void SetEffectsMasterVolume(uint8 volume);
-	void SetMusicMasterVolume(uint8 volume);
-	void SetEffectsFadeVol(uint8 volume);
-	void SetMusicFadeVol(uint8 volume);
-
-	void SetSpeakerConfig(uint32 config);
-
-	bool GetChannelUsedFlag(int32 id);
-
-	void StartChannel(int32 id);
-	void StopChannel(int32 id);
-
-	static bool IsMP3RadioChannelAvailable();
-};
-
-extern uint32 &nNumOfMp3Files;
-extern uint8 &num3DProvidersAvailable;
-extern char **asName3DProviders;
-
-extern CSampleManager &cSampleManager;
\ No newline at end of file
diff --git a/src/audio/sampman.cpp b/src/audio/sampman.cpp
new file mode 100644
index 00000000..c758fc9f
--- /dev/null
+++ b/src/audio/sampman.cpp
@@ -0,0 +1,2331 @@
+#include <windows.h>
+#include <shobjidl.h>
+#include <shlguid.h>
+
+#include <time.h>
+
+#include "eax.h"
+#include "eax-util.h"
+#include "mss.h"
+
+#include "sampman.h"
+#include "AudioManager.h"
+#include "MusicManager.h"
+#include "Frontend.h"
+#include "Timer.h"
+#include "patcher.h"
+
+#pragma comment( lib, "mss32.lib" )
+
+cSampleManager &SampleManager = *(cSampleManager *)0x7341E0;
+int32 (&BankStartOffset)[2] = *(int32 (*)[2])*(int *)0x6FAB70;
+
+///////////////////////////////////////////////////////////////
+
+char SampleBankDescFilename[] = "AUDIO\\SFX.SDT";
+char SampleBankDataFilename[] = "AUDIO\\SFX.RAW";
+
+FILE *fpSampleDescHandle;
+FILE *fpSampleDataHandle;
+bool  bSampleBankLoaded            [MAX_SAMPLEBANKS];
+int32 nSampleBankDiscStartOffset   [MAX_SAMPLEBANKS];
+int32 nSampleBankSize              [MAX_SAMPLEBANKS];
+int32 nSampleBankMemoryStartAddress[MAX_SAMPLEBANKS];
+int32 _nSampleDataEndOffset;
+
+int32 nPedSlotSfx    [MAX_PEDSFX];
+int32 nPedSlotSfxAddr[MAX_PEDSFX];
+int32 nCurrentPedSlot;
+
+uint8 nChannelVolume[MAXCHANNELS+MAX2DCHANNELS];
+
+uint32 nStreamLength[TOTAL_STREAMED_SOUNDS];
+
+///////////////////////////////////////////////////////////////
+struct tMP3Entry
+{
+	char aFilename[MAX_PATH];
+	
+	uint32 nTrackLength;
+	uint32 nTrackStreamPos;
+	
+	tMP3Entry *pNext;
+	char *pLinkPath;
+};
+
+uint32 nNumMP3s;
+tMP3Entry *_pMP3List;
+char _mp3DirectoryPath[MAX_PATH];
+HSTREAM mp3Stream [MAX_MP3STREAMS];
+int8 nStreamPan   [MAX_MP3STREAMS];
+int8 nStreamVolume[MAX_MP3STREAMS];
+uint32 _CurMP3Index;
+int32 _CurMP3Pos;
+bool _bIsMp3Active;
+
+#if defined(GTA3_1_1_PATCH) || defined(GTA3_STEAM_PATCH) || defined(NO_CDCHECK)
+bool _bUseHDDAudio;
+char _aHDDPath[MAX_PATH];
+#endif
+///////////////////////////////////////////////////////////////
+
+
+bool _bSampmanInitialised = false;
+
+//
+// Miscellaneous globals / defines
+
+//	Env		Size	Diffus	Room	RoomHF	RoomLF	DecTm	DcHF	DcLF	Refl	RefDel	Ref Pan				Revb	RevDel		Rev Pan				EchTm	EchDp	ModTm	ModDp	AirAbs	HFRef		LFRef	RRlOff	FLAGS
+
+EAXLISTENERPROPERTIES StartEAX3 =
+	{26,	1.7f,	0.8f,	-1000,	-1000,	-100,	4.42f,	0.14f,	1.00f,	429,	0.014f,	0.00f,0.00f,0.00f,	1023,	0.021f,		0.00f,0.00f,0.00f,	0.250f,	0.000f,	0.250f,	0.000f,	-5.0f,	2727.1f,	250.0f,	0.00f,	0x3f };
+
+EAXLISTENERPROPERTIES FinishEAX3 =
+	{26,	100.0f,	1.0f,	0,		-1000,	-2200,	20.0f,	1.39f,	1.00f,	1000,	0.069f,	0.00f,0.00f,0.00f,	400,	0.100f,		0.00f,0.00f,0.00f,	0.250f,	1.000f,	3.982f,	0.000f,	-18.0f,	3530.8f,	417.9f,	6.70f,	0x3f };
+
+EAXLISTENERPROPERTIES EAX3Params;
+
+S32         prevprovider=-1;
+S32         curprovider=-1;
+S32         usingEAX=0;
+S32         usingEAX3=0;
+HPROVIDER   opened_provider=0;
+H3DSAMPLE   opened_samples[MAXCHANNELS] = {0};
+HSAMPLE     opened_2dsamples[MAX2DCHANNELS] = {0};
+HDIGDRIVER  DIG;
+S32         speaker_type=0;
+
+U32 _maxSamples;
+float _fPrevEaxRatioDestination;
+bool _usingMilesFast2D;
+float _fEffectsLevel;
+
+
+struct
+{
+	HPROVIDER id;
+	char name[80];
+}providers[MAXPROVIDERS];
+
+typedef struct provider_stuff
+{
+  char* name;
+  HPROVIDER id;
+} provider_stuff;
+
+
+static int __cdecl comp(const provider_stuff*s1,const provider_stuff*s2)
+{
+  return( _stricmp(s1->name,s2->name) );
+}
+
+static void
+add_providers()
+{
+	provider_stuff pi[MAXPROVIDERS];
+	U32   n,i,j;
+	
+	SampleManager.SetNum3DProvidersAvailable(0);
+	
+	HPROENUM next = HPROENUM_FIRST;
+	
+	n=0;
+	while (AIL_enumerate_3D_providers(&next, &pi[n].id, &pi[n].name) && (n<MAXPROVIDERS))
+	{
+		++n;
+	}
+	
+	qsort(pi,n,sizeof(pi[0]), (int(__cdecl*)(void const*, void const*))comp);
+	
+	for(i=0;i<n;i++)
+	{
+		providers[i].id=pi[i].id;
+		strcpy(providers[i].name, pi[i].name);
+		SampleManager.Set3DProviderName(i, providers[i].name);
+	}
+	
+	SampleManager.SetNum3DProvidersAvailable(n);
+	
+	for(j=n;j<MAXPROVIDERS;j++)
+		SampleManager.Set3DProviderName(j, NULL);
+}
+
+static void
+release_existing()
+{
+	for ( U32 i = 0; i < _maxSamples; i++ )
+	{
+		if ( opened_samples[i] )
+		{
+			AIL_release_3D_sample_handle(opened_samples[i]);
+			opened_samples[i] = NULL;
+		}
+	}
+
+	if ( opened_provider )
+	{
+		AIL_close_3D_provider(opened_provider);
+		opened_provider = NULL;
+	}
+
+	_fPrevEaxRatioDestination = 0.0f;
+	_usingMilesFast2D = false;
+	_fEffectsLevel = 0.0f;
+}
+
+static bool
+set_new_provider(S32 index)
+{
+	DWORD result;
+	
+	if ( curprovider == index )
+		return true;
+
+	//close the already opened provider
+	curprovider = index;
+	
+	release_existing();
+	
+	if ( curprovider != -1 )
+	{
+		if ( !strcmp(providers[index].name, "Dolby Surround") )
+			_maxSamples = MAXCHANNELS_SURROUND;
+		else
+			_maxSamples = MAXCHANNELS;
+		
+		AIL_set_3D_provider_preference(providers[index].id, "Maximum supported samples", &_maxSamples);
+		
+		//load the new provider
+		result = AIL_open_3D_provider(providers[index].id);
+		
+		if (result != M3D_NOERR) 
+		{
+			curprovider=-1;
+			
+			OutputDebugStringA(AIL_last_error());
+			
+			release_existing();
+			
+			return false;
+		}
+		else
+		{
+			opened_provider=providers[index].id;
+			
+			//see if we're running under an EAX compatible provider
+			
+			if ( !strcmp(providers[index].name, "Creative Labs EAX 3 (TM)") )
+			{
+				usingEAX = 1;
+				usingEAX3 = 1;
+			}
+			else
+			{
+				usingEAX3 = 0;
+
+				result=AIL_3D_room_type(opened_provider);
+				usingEAX=(((S32)result)!=-1)?1:0; // will be something other than -1 on EAX				
+			}
+			
+			if ( usingEAX3 )
+			{
+				OutputDebugString("DOING SPECIAL EAX 3 STUFF!");
+				AIL_set_3D_provider_preference(opened_provider, "EAX all parameters", &FinishEAX3);
+			}
+			else if ( usingEAX )
+			{
+				AIL_set_3D_room_type(opened_provider, ENVIRONMENT_CAVE);
+				
+				if ( !strcmp(providers[index].name, "Miles Fast 2D Positional Audio") )
+					_usingMilesFast2D = true;
+			}
+			
+			AIL_3D_provider_attribute(opened_provider, "Maximum supported samples", &_maxSamples);
+			
+			if ( _maxSamples > MAXCHANNELS )
+				_maxSamples = MAXCHANNELS;
+			
+			SampleManager.SetSpeakerConfig(speaker_type);
+			
+			//obtain a 3D sample handles
+			for ( U32 i = 0; i < _maxSamples; ++i )
+			{
+				opened_samples[i] = AIL_allocate_3D_sample_handle(opened_provider);
+				if ( opened_samples[i] != NULL )
+					AIL_set_3D_sample_effects_level(opened_samples[i], 0.0f);
+			}
+			
+			return true;
+		}	
+	}
+	
+	return false;
+}
+
+void
+cSampleManager::SetSpeakerConfig(int32 which)
+{
+	switch ( which )
+	{
+		case 1:
+			speaker_type=AIL_3D_2_SPEAKER;
+			break;
+		
+		case 2:
+			speaker_type=AIL_3D_HEADPHONE;
+			break;
+		
+		case 3:
+			speaker_type=AIL_3D_4_SPEAKER;
+			break;
+			
+		default:
+			return;
+			break;
+	}
+	
+	if (opened_provider)
+		AIL_set_3D_speaker_type(opened_provider, speaker_type);
+}
+
+uint32
+cSampleManager::GetMaximumSupportedChannels(void) //[Y]
+{
+	if ( _maxSamples > MAXCHANNELS )
+		return MAXCHANNELS;
+	
+	return _maxSamples;
+}
+
+int8
+cSampleManager::GetCurrent3DProviderIndex(void)
+{
+	return curprovider;
+}
+
+int8
+cSampleManager::SetCurrent3DProvider(uint8 nProvider)
+{
+	S32 savedprovider = curprovider;
+	
+	if ( nProvider < m_nNumberOfProviders )
+	{
+		if ( set_new_provider(nProvider) )
+			return curprovider;
+		else if ( savedprovider != -1 && savedprovider < m_nNumberOfProviders && set_new_provider(savedprovider) )
+			return curprovider;
+		else
+			return -1;
+	}
+	else
+		return curprovider;
+}
+
+static bool
+_ResolveLink(char const *path, char *out)
+{
+	IShellLink* psl;
+	WIN32_FIND_DATA fd;
+	char filepath[MAX_PATH];
+	
+	CoInitialize(NULL);
+									   
+	if (SUCCEEDED( CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_IShellLink, (LPVOID*)&psl ) ))
+	{
+		IPersistFile *ppf;
+
+		if (SUCCEEDED(psl->QueryInterface(IID_IPersistFile, (LPVOID*)&ppf)))
+		{
+			WCHAR wpath[MAX_PATH];
+			
+			MultiByteToWideChar(CP_ACP, 0, path, -1, wpath, MAX_PATH);
+			
+			if (SUCCEEDED(ppf->Load(wpath, STGM_READ)))
+			{
+				/* Resolve the link */
+				if (SUCCEEDED(psl->Resolve(NULL, SLR_ANY_MATCH|SLR_NO_UI|SLR_NOSEARCH)))
+				{
+					strcpy(filepath, path);
+					
+					if (SUCCEEDED(psl->GetPath(filepath, MAX_PATH, &fd, SLGP_UNCPRIORITY)))
+					{
+						OutputDebugString(fd.cFileName);
+						
+						strcpy(out, filepath);
+						
+						return true;
+					}
+				}
+			}
+			
+			ppf->Release();
+		}
+		psl->Release();
+	}
+	
+	return false;
+}
+
+static void
+_FindMP3s(void)
+{
+	tMP3Entry *pList;
+	bool bShortcut;	
+	bool bInitFirstEntry;	
+	HANDLE hFind;
+	char path[MAX_PATH];
+	char filepath[MAX_PATH*2];
+	S32 total_ms;
+	WIN32_FIND_DATA fd;
+	
+	
+	if ( GetCurrentDirectory(MAX_PATH, _mp3DirectoryPath) == 0 )
+	{
+		GetLastError();
+		return;
+	}
+	
+	OutputDebugString("Finding MP3s...");
+	strcpy(path, _mp3DirectoryPath);
+	strcat(path, "\\MP3\\");
+	
+	strcpy(_mp3DirectoryPath, path);
+	OutputDebugString(_mp3DirectoryPath);
+	
+	strcat(path, "*");
+	
+	hFind = FindFirstFile(path, &fd);
+	
+	if ( hFind == INVALID_HANDLE_VALUE ) 
+	{
+		GetLastError();
+		return;
+	}
+	
+	strcpy(filepath, _mp3DirectoryPath);
+	strcat(filepath, fd.cFileName);
+	
+	int32 filepathlen = strlen(filepath);
+	
+	if ( filepathlen <= 0)
+	{
+		FindClose(hFind);
+		return;
+	}
+	
+	FILE *f = fopen("MP3\\MP3Report.txt", "w");
+	
+	if ( f )
+	{
+		fprintf(f, "MP3 Report File\n\n");
+		fprintf(f, "\"%s\"", fd.cFileName);
+	}
+	
+
+	if ( filepathlen > 4 )
+	{
+		if ( !strcmp(&filepath[filepathlen - 4], ".lnk") )
+		{
+			if ( _ResolveLink(filepath, filepath) )
+			{
+				OutputDebugString("Resolving Link");
+				OutputDebugString(filepath);
+				
+				if ( f )
+					fprintf(f, " - shortcut to \"%s\"", filepath);
+			}
+			else
+			{
+				if ( f )
+					fprintf(f, " - couldn't resolve shortcut");
+			}
+			
+			bShortcut = true;
+		}
+		else
+		{
+			bShortcut = false;
+		}
+	}
+	
+	mp3Stream[0] = AIL_open_stream(DIG, filepath, 0);
+	if ( mp3Stream[0] )
+	{
+		AIL_stream_ms_position(mp3Stream[0], &total_ms, NULL);
+		
+		AIL_close_stream(mp3Stream[0]);
+		mp3Stream[0] = NULL;
+		
+		OutputDebugString(fd.cFileName);
+		
+		_pMP3List = new tMP3Entry;
+		
+		if ( _pMP3List == NULL )
+		{
+			FindClose(hFind);
+			
+			if ( f )
+				fclose(f);
+			
+			return;
+		}
+		
+		nNumMP3s = 1;
+		
+		strcpy(_pMP3List->aFilename, fd.cFileName);
+		
+		_pMP3List->nTrackLength = total_ms;
+		
+		_pMP3List->pNext = NULL;
+		
+		pList = _pMP3List;
+		
+		if ( bShortcut )
+		{
+			_pMP3List->pLinkPath = new char[MAX_PATH*2];
+			strcpy(_pMP3List->pLinkPath, filepath);
+		}
+		else
+		{
+			_pMP3List->pLinkPath = NULL;
+		}
+		
+		if ( f )
+			fprintf(f, " - OK\n");
+		
+		bInitFirstEntry = false;
+	}
+	else
+	{
+		strcat(filepath, " - NOT A VALID MP3");
+		
+		OutputDebugString(filepath);
+
+		if ( f )
+			fprintf(f, " - not an MP3 or supported MP3 type\n");
+		
+		bInitFirstEntry = true;
+	}
+	
+	while ( true )
+	{
+		if ( !FindNextFile(hFind, &fd) )
+		{
+			if ( f )
+			{
+				fprintf(f, "\nTOTAL SUPPORTED MP3s: %d\n", nNumMP3s);
+				fclose(f);
+			}
+			
+            FindClose(hFind);
+            
+			return;
+		}
+		
+		if ( bInitFirstEntry )
+		{
+			strcpy(filepath, _mp3DirectoryPath);
+			strcat(filepath, fd.cFileName);
+			
+			int32 filepathlen = strlen(filepath);
+			
+			if ( f )
+				fprintf(f, "\"%s\"", fd.cFileName);
+			
+			if ( filepathlen > 0 )
+			{
+				if ( filepathlen > 4 )
+				{
+					if ( !strcmp(&filepath[filepathlen - 4], ".lnk") )
+					{
+						if ( _ResolveLink(filepath, filepath) )
+						{
+							OutputDebugString("Resolving Link");
+							OutputDebugString(filepath);
+							
+							if ( f )
+								fprintf(f, " - shortcut to \"%s\"", filepath);
+						}
+						else
+						{
+							if ( f )
+								fprintf(f, " - couldn't resolve shortcut");
+						}
+						
+						bShortcut = true;
+					}
+					else
+					{
+						bShortcut = false;
+						
+						if ( filepathlen > MAX_PATH )
+						{
+							if ( f )
+								fprintf(f, " - Filename and path too long - %s - IGNORED)\n", filepath);
+							
+							continue;
+						}
+					}
+				}
+				
+				mp3Stream[0] = AIL_open_stream(DIG, filepath, 0);
+				if ( mp3Stream[0] )
+				{
+					AIL_stream_ms_position(mp3Stream[0], &total_ms, NULL);
+					
+					AIL_close_stream(mp3Stream[0]);
+					mp3Stream[0] = NULL;
+					
+					OutputDebugString(fd.cFileName);
+					
+					_pMP3List = new tMP3Entry;
+					
+					if ( _pMP3List  == NULL)
+					{
+						if ( f )
+						{
+							fprintf(f, "\nTOTAL SUPPORTED MP3s: %d\n", nNumMP3s);
+							fclose(f);
+						}
+						FindClose(hFind);
+						return;
+					}
+					
+					nNumMP3s = 1;
+					
+					strcpy(_pMP3List->aFilename, fd.cFileName);
+					
+					_pMP3List->nTrackLength = total_ms;
+					_pMP3List->pNext = NULL;
+					
+					if ( bShortcut )
+					{
+						_pMP3List->pLinkPath = new char [MAX_PATH*2];
+						strcpy(_pMP3List->pLinkPath, filepath);
+					}
+					else
+					{
+						_pMP3List->pLinkPath = NULL;
+					}
+					
+					pList = _pMP3List;
+					
+					if ( f )
+						fprintf(f, " - OK\n");
+					
+					bInitFirstEntry = false;
+				}
+				else
+				{
+					strcat(filepath, " - NOT A VALID MP3");
+					OutputDebugString(filepath);
+					
+					if ( f )
+						fprintf(f, " - not an MP3 or supported MP3 type\n");
+				}
+			}
+		}
+		else
+		{
+			strcpy(filepath, _mp3DirectoryPath);
+			strcat(filepath, fd.cFileName);
+			
+			int32 filepathlen = strlen(filepath);
+			
+			if ( filepathlen > 0 )
+			{
+				if ( f )
+					fprintf(f, "\"%s\"", fd.cFileName);
+			
+				if ( filepathlen > 4 )
+				{
+					if ( !strcmp(&filepath[filepathlen - 4], ".lnk") )
+					{
+						if ( _ResolveLink(filepath, filepath) )
+						{
+							OutputDebugString("Resolving Link");
+							OutputDebugString(filepath);
+							
+							if ( f )
+								fprintf(f, " - shortcut to \"%s\"", filepath);
+						}
+						else
+						{
+							if ( f )
+								fprintf(f, " - couldn't resolve shortcut");
+						}
+						
+						bShortcut = true;
+					}
+					else
+					{
+						bShortcut = false;
+					}
+				}
+				
+				mp3Stream[0] = AIL_open_stream(DIG, filepath, 0);
+				if ( mp3Stream[0] )
+				{
+					AIL_stream_ms_position(mp3Stream[0], &total_ms, NULL);
+					
+					AIL_close_stream(mp3Stream[0]);
+					mp3Stream[0] = NULL;
+					
+					pList->pNext = new tMP3Entry;
+					
+					tMP3Entry *e = pList->pNext;
+					
+					if ( e == NULL)
+					{
+						if ( f )
+						{
+							fprintf(f, "\nTOTAL SUPPORTED MP3s: %d\n", nNumMP3s);
+							fclose(f);
+						}
+						FindClose(hFind);
+						return;
+					}
+					
+					pList = pList->pNext;
+					
+					strcpy(e->aFilename, fd.cFileName);
+					e->nTrackLength = total_ms;
+					e->pNext = NULL;
+					
+					if ( bShortcut )
+					{
+						e->pLinkPath = new char [MAX_PATH*2];
+						strcpy(e->pLinkPath, filepath);
+					}
+					else
+					{
+						e->pLinkPath = NULL;
+					}
+					
+					nNumMP3s++;
+					
+					OutputDebugString(fd.cFileName);
+					
+					if ( f )
+						fprintf(f, " - OK\n");
+				}
+				else
+				{
+					strcat(filepath, " - NOT A VALID MP3");
+					OutputDebugString(filepath);
+					
+					if ( f )
+						fprintf(f, " - not an MP3 or supported MP3 type\n");
+				}
+			}
+		}
+	}
+}
+
+static void
+_DeleteMP3Entries(void)
+{
+	tMP3Entry *e = _pMP3List;
+
+	while ( e != NULL )
+	{
+		tMP3Entry *next = e->pNext;
+		
+		if ( next == NULL )
+			next = NULL;
+		
+		if ( e->pLinkPath != NULL )
+		{
+#ifndef FIX_BUGS
+			delete   e->pLinkPath; // BUG: should be delete []
+#else
+			delete[] e->pLinkPath;
+#endif
+			e->pLinkPath = NULL;
+		}
+		
+		delete e;
+		
+		if ( next )
+			e = next;
+		else
+			e = NULL;
+		
+		nNumMP3s--;
+	}
+	
+	
+	if ( nNumMP3s != 0 )
+	{
+		OutputDebugString("Not all MP3 entries were deleted");
+		nNumMP3s = 0;
+	}
+	
+	_pMP3List = NULL;
+}
+
+static tMP3Entry *
+_GetMP3EntryByIndex(uint32 idx)
+{
+	uint32 n = ( idx < nNumMP3s ) ? idx : 0;
+	
+	if ( _pMP3List != NULL )
+	{
+		tMP3Entry *e = _pMP3List;
+		
+		for ( uint32 i = 0; i < n; i++ )
+			e = e->pNext;
+		
+		return e;
+			
+	}
+	
+	return NULL;
+}
+
+static inline bool
+_GetMP3PosFromStreamPos(uint32 *pPosition, tMP3Entry **pEntry)
+{
+	_CurMP3Index = 0;
+	
+	for ( *pEntry = _pMP3List; *pEntry != NULL; *pEntry = (*pEntry)->pNext )
+	{
+		if (   *pPosition >= (*pEntry)->nTrackStreamPos
+			&& *pPosition <  (*pEntry)->nTrackLength + (*pEntry)->nTrackStreamPos )
+		{
+			*pPosition -= (*pEntry)->nTrackStreamPos;
+			_CurMP3Pos = *pPosition;
+			
+			return true;
+		}
+		
+		_CurMP3Index++;
+	}
+				
+	*pPosition = 0;
+	*pEntry = _pMP3List;
+	_CurMP3Pos = 0;
+	_CurMP3Index = 0;
+	
+	return false;
+}
+
+bool
+cSampleManager::IsMP3RadioChannelAvailable(void)
+{
+	return nNumMP3s != 0;
+}
+
+void
+cSampleManager::ReleaseDigitalHandle(void)
+{
+	if ( DIG )
+	{
+		prevprovider = curprovider;
+		release_existing();
+		curprovider = -1;
+		AIL_digital_handle_release(DIG);
+	}
+}
+
+void
+cSampleManager::ReacquireDigitalHandle(void)
+{
+	if ( DIG )
+	{
+		AIL_digital_handle_reacquire(DIG);
+		if ( prevprovider != -1 )
+			set_new_provider(prevprovider);
+	}
+}
+
+bool
+cSampleManager::Initialise(void)
+{
+	TRACE("start");
+	
+	if ( _bSampmanInitialised )
+		return true;
+
+	{
+		for ( int32 i = 0; i < TOTAL_AUDIO_SAMPLES; i++ )
+		{
+			m_aSamples[i].nOffset    = 0;
+			m_aSamples[i].nSize      = 0;
+			m_aSamples[i].nFrequency = 22050;
+			m_aSamples[i].nLoopStart = 0;
+			m_aSamples[i].nLoopEnd   = -1;
+		}
+		
+		m_nEffectsVolume     = 127;
+		m_nMusicVolume       = 127;
+		m_nEffectsFadeVolume = 127;
+		m_nMusicFadeVolume   = 127;
+		
+		m_nMonoMode = 0;
+	}
+	
+	// miles 
+	TRACE("MILES");
+	{
+		curprovider = -1;
+		prevprovider = -1;
+		
+		_usingMilesFast2D = false;
+		usingEAX=0;
+		usingEAX3=0;
+		
+		_fEffectsLevel = 0.0f;
+		
+		_maxSamples = 0;
+	
+		opened_provider = NULL;
+		DIG = NULL;
+		
+		for ( int32 i = 0; i < MAXCHANNELS; i++ )
+			opened_samples[i] = NULL;
+	}
+	
+	// banks
+	TRACE("banks");
+	{
+		fpSampleDescHandle = NULL;
+		fpSampleDataHandle = NULL;
+		
+		_nSampleDataEndOffset = 0;
+		
+		for ( int32 i = 0; i < MAX_SAMPLEBANKS; i++ )
+		{
+			bSampleBankLoaded[i]             = false;
+			nSampleBankDiscStartOffset[i]    = 0;
+			nSampleBankSize[i]               = 0;
+			nSampleBankMemoryStartAddress[i] = 0;
+		}
+	}
+	
+	// pedsfx
+	TRACE("pedsfx");
+	{
+		for ( int32 i = 0; i < MAX_PEDSFX; i++ )
+		{
+			nPedSlotSfx[i]     = NO_SAMPLE;
+			nPedSlotSfxAddr[i] = 0;
+		}
+		
+		nCurrentPedSlot = 0;
+	}
+	
+	// channel volume
+	TRACE("vol");
+	{
+		for ( int32 i = 0; i < MAXCHANNELS+MAX2DCHANNELS; i++ )
+			nChannelVolume[i] = 0;
+	}
+	
+	TRACE("mss");
+	{
+		AIL_set_redist_directory( "mss" );
+		
+		AIL_startup();
+		
+		AIL_set_preference(DIG_MIXER_CHANNELS, MAX_DIGITAL_MIXER_CHANNELS);
+		
+		DIG = AIL_open_digital_driver(DIGITALRATE, DIGITALBITS, DIGITALCHANNELS, 0);
+		if ( DIG == NULL )
+		{
+			OutputDebugString(AIL_last_error());
+			Terminate();
+			return false;
+		}
+		
+		add_providers();
+		
+		if ( !InitialiseSampleBanks() )
+		{
+			Terminate();
+			return false;
+		}
+		
+		nSampleBankMemoryStartAddress[0] = (int32)AIL_mem_alloc_lock(nSampleBankSize[0]);
+		if ( !nSampleBankMemoryStartAddress[0] )
+		{
+			Terminate();
+			return false;
+		}
+
+		nSampleBankMemoryStartAddress[1] = (int32)AIL_mem_alloc_lock(PED_BLOCKSIZE*MAX_PEDSFX);
+		
+	}
+	
+	TRACE("cdrom");
+	
+	S32 tatalms;
+	char filepath[MAX_PATH];
+
+	{
+		m_bInitialised = false;
+		
+		while (true)
+		{
+			int32 drive = 'C';
+			
+			do
+			{
+				char latter[2];
+				
+				latter[0] = drive;
+				latter[1] = '\0';
+				
+				strcpy(m_szCDRomRootPath, latter);
+				strcat(m_szCDRomRootPath, ":\\");
+				
+				if ( GetDriveType(m_szCDRomRootPath) == DRIVE_CDROM )
+				{
+					strcpy(filepath, m_szCDRomRootPath);
+					strcat(filepath, StreamedNameTable[0]);
+					
+					FILE *f = fopen(filepath, "rb");
+					
+					if ( f )
+					{
+						fclose(f);
+						
+						bool bFileNotFound = false;
+
+						for ( int32 i = 0; i < TOTAL_STREAMED_SOUNDS; i++ )
+						{
+							strcpy(filepath, m_szCDRomRootPath);
+							strcat(filepath, StreamedNameTable[i]);
+							
+							mp3Stream[0] = AIL_open_stream(DIG, filepath, 0);
+							
+							if ( mp3Stream[0] )
+							{
+								AIL_stream_ms_position(mp3Stream[0], &tatalms, NULL);
+								
+								AIL_close_stream(mp3Stream[0]);
+								mp3Stream[0] = NULL;
+								
+								nStreamLength[i] = tatalms;
+							}
+							else
+							{
+								bFileNotFound = true;
+								break;
+							}
+						}
+						
+						if ( !bFileNotFound )
+						{
+							m_bInitialised = true;
+							break;
+						}
+						else
+						{
+							m_bInitialised = false;
+							continue;
+						}
+					}
+				}
+				
+			} while ( ++drive <= 'Z' );
+					
+			if ( !m_bInitialised )
+			{
+#if !defined(GTA3_STEAM_PATCH) && !defined(NO_CDCHECK)
+				FrontEndMenuManager.WaitForUserCD();
+				if ( FrontEndMenuManager.m_bQuitGameNoCD )
+				{
+					Terminate();
+					return false;
+				}
+				continue;
+#else
+				m_bInitialised = true;
+#endif
+			}
+			
+			break;
+		}
+	}
+
+#if defined(GTA3_1_1_PATCH) || defined(GTA3_STEAM_PATCH) || defined(NO_CDCHECK)
+	// hddaudio
+	/**
+		Option for user to play audio files directly from hard disk.
+		Copy the contents of the PLAY discs Audio directory into your installed Grand Theft Auto III Audio directory.
+		Grand Theft Auto III still requires the presence of the PLAY disc when started.
+		This may give better performance on some machines (though worse on others).
+	**/
+	TRACE("hddaudio 1.1 patch");
+	{
+		int32 streamLength[TOTAL_STREAMED_SOUNDS];
+		
+		bool bFileNotFound = false;
+		char rootpath[MAX_PATH];
+		
+		strcpy(_aHDDPath, m_szCDRomRootPath);
+		rootpath[0] = '\0';
+		
+		FILE *f = fopen(StreamedNameTable[0], "rb");
+		
+		if ( f )
+		{
+			fclose(f);
+			
+			for ( int32 i = 0; i < TOTAL_STREAMED_SOUNDS; i++ )
+			{
+				strcpy(filepath, rootpath);
+				strcat(filepath, StreamedNameTable[i]);
+				
+				mp3Stream[0] = AIL_open_stream(DIG, filepath, 0);
+				
+				if ( mp3Stream[0] )
+				{
+					AIL_stream_ms_position(mp3Stream[0], &tatalms, NULL);
+					
+					AIL_close_stream(mp3Stream[0]);
+					mp3Stream[0] = NULL;
+					
+					streamLength[i] = tatalms;
+				}
+				else
+				{
+					bFileNotFound = true;
+					break;
+				}
+			}
+								
+		}
+		else
+			bFileNotFound = true;
+		
+		if ( !bFileNotFound )
+		{
+			strcpy(m_szCDRomRootPath, rootpath);
+			
+			for ( int32 i = 0; i < TOTAL_STREAMED_SOUNDS; i++ )
+				nStreamLength[i] = streamLength[i];
+			
+			_bUseHDDAudio = true;
+		}
+		else
+			_bUseHDDAudio = false;
+	}
+#endif
+	
+	TRACE("stream");
+	{
+		for ( int32 i = 0; i < MAX_MP3STREAMS; i++ )
+		{
+			mp3Stream    [i] = NULL;
+			nStreamPan   [i] = 63;
+			nStreamVolume[i] = 100;
+		}
+	}
+	
+	for ( int32 i = 0; i < MAX2DCHANNELS; i++ )
+	{
+		opened_2dsamples[i] = AIL_allocate_sample_handle(DIG);
+		if ( opened_2dsamples[i] )
+		{
+			AIL_init_sample(opened_2dsamples[i]);
+			AIL_set_sample_type(opened_2dsamples[i], DIG_F_MONO_16, DIG_PCM_SIGN);
+		}
+	}
+	
+	TRACE("providerset");
+	{
+		_bSampmanInitialised = true;
+		
+		U32 n = 0;
+		
+		while ( n < m_nNumberOfProviders )
+		{
+			if ( !strcmp(providers[n].name, "Miles Fast 2D Positional Audio") )
+			{
+				set_new_provider(n);
+				break;
+			}
+			n++;
+		}
+		
+		if ( n == m_nNumberOfProviders )
+		{
+			Terminate();
+			return false;
+		}
+	}
+	
+	TRACE("bank");
+	
+	LoadSampleBank(0);
+	
+	// mp3
+	TRACE("mp3");
+	{
+		nNumMP3s = 0;
+		
+		_pMP3List = NULL;
+		
+		_FindMP3s();
+		
+		if ( nNumMP3s != 0 )
+		{
+			nStreamLength[STREAMED_SOUND_RADIO_MP3_PLAYER] = 0;
+			
+			for ( tMP3Entry *e = _pMP3List; e != NULL; e = e->pNext )
+			{
+				e->nTrackStreamPos = nStreamLength[STREAMED_SOUND_RADIO_MP3_PLAYER];
+				nStreamLength[STREAMED_SOUND_RADIO_MP3_PLAYER] += e->nTrackLength;
+			}
+			
+			time_t t = time(NULL);
+			tm *localtm;
+			bool bUseRandomTable;
+			
+			if ( t == -1 )
+				bUseRandomTable = true;
+			else
+			{
+				bUseRandomTable = 0;
+				localtm = localtime(&t);
+			}
+			
+			int32 randval;
+			if ( bUseRandomTable )
+				randval = AudioManager.GetRandomTabe(1);
+			else
+				randval = localtm->tm_sec * localtm->tm_min;
+			
+			_CurMP3Index = randval % nNumMP3s;
+			
+			tMP3Entry *randmp3 = _pMP3List;
+			for ( int32 i = randval % nNumMP3s; i > 0; --i)
+				randmp3 = randmp3->pNext;
+			
+			if ( bUseRandomTable )
+				_CurMP3Pos = AudioManager.GetRandomTabe(0)     % randmp3->nTrackLength;
+			else
+			{
+				if ( localtm->tm_sec > 0 )
+				{
+					int32 s = localtm->tm_sec;
+					_CurMP3Pos = s*s*s*s*s*s*s*s                % randmp3->nTrackLength;
+				}
+				else
+					_CurMP3Pos = AudioManager.GetRandomTabe(0) % randmp3->nTrackLength;
+			}
+		}
+		else
+			_CurMP3Pos = 0;
+		
+		_bIsMp3Active = false;
+	}
+	
+	TRACE("end");
+	
+	return true;
+}
+
+void
+cSampleManager::Terminate(void)
+{
+	for ( int32 i = 0; i < MAX_MP3STREAMS; i++ )
+	{
+		if ( mp3Stream[i] )
+		{
+			AIL_pause_stream(mp3Stream[i], 1);
+			AIL_close_stream(mp3Stream[i]);
+			mp3Stream[i] = NULL;
+		}
+	}
+	
+	for ( int32 i = 0; i < MAX2DCHANNELS; i++ )
+	{
+		if ( opened_2dsamples[i] )
+		{
+			AIL_release_sample_handle(opened_2dsamples[i]);
+			opened_2dsamples[i] = NULL;
+		}
+	}
+	
+	release_existing();
+	
+	_DeleteMP3Entries();
+	
+	if ( nSampleBankMemoryStartAddress[0] != 0 )
+	{
+		AIL_mem_free_lock((void *)nSampleBankMemoryStartAddress[0]);
+		nSampleBankMemoryStartAddress[0] = 0;
+	}
+
+	if ( nSampleBankMemoryStartAddress[1] != 0 )
+	{
+		AIL_mem_free_lock((void *)nSampleBankMemoryStartAddress[1]);
+		nSampleBankMemoryStartAddress[1] = 0;
+	}
+	
+	if ( DIG )
+	{
+		AIL_close_digital_driver(DIG);
+		DIG = NULL;
+	}
+	
+	AIL_shutdown();
+	
+	_bSampmanInitialised = false;
+}
+
+bool
+cSampleManager::CheckForAnAudioFileOnCD(void)
+{
+	char filepath[MAX_PATH];
+
+#if !defined(GTA3_STEAM_PATCH) && !defined(NO_CDCHECK)
+	
+#if defined(GTA3_1_1_PATCH)
+	if (_bUseHDDAudio)
+		strcpy(filepath, _aHDDPath);
+	else
+		strcpy(filepath, m_szCDRomRootPath);
+#else
+	strcpy(filepath, m_szCDRomRootPath);
+#endif // #if defined(GTA3_1_1_PATCH)
+
+	strcat(filepath, StreamedNameTable[AudioManager.GetRandomTabe(1) % TOTAL_STREAMED_SOUNDS]);
+	
+	FILE *f = fopen(filepath, "rb");
+	
+	if ( f )
+	{
+		fclose(f);
+
+		return true;
+	}
+	
+	return false;
+	
+#else
+	return true;
+#endif // #if !defined(GTA3_STEAM_PATCH) && !defined(NO_CDCHECK)
+}
+
+char
+cSampleManager::GetCDAudioDriveLetter(void)
+{
+#if defined(GTA3_1_1_PATCH) || defined(GTA3_STEAM_PATCH) || defined(NO_CDCHECK)
+	if (_bUseHDDAudio)
+	{
+		if ( strlen(_aHDDPath) != 0 )
+			return _aHDDPath[0];
+		else
+			return '\0';
+	}
+	else
+	{
+		if ( strlen(m_szCDRomRootPath) != 0 )
+			return m_szCDRomRootPath[0];
+		else
+			return '\0';
+	}
+#else
+	if ( strlen(m_szCDRomRootPath) != 0 )
+		return m_szCDRomRootPath[0];
+	else
+		return '\0';
+#endif
+}
+
+void
+cSampleManager::UpdateEffectsVolume(void) //[Y], cSampleManager::UpdateSoundBuffers ?
+{
+	if ( _bSampmanInitialised )
+	{
+		for ( int32 i = 0; i < MAXCHANNELS+MAX2DCHANNELS; i++ )
+		{
+			if ( i < MAXCHANNELS )
+			{
+				if ( opened_samples[i] && GetChannelUsedFlag(i) )
+				{
+					if ( nChannelVolume[i] )
+					{
+						AIL_set_3D_sample_volume(opened_samples[i],
+								m_nEffectsFadeVolume * nChannelVolume[i] * m_nEffectsVolume >> 14);
+					}
+				}
+			}
+			else
+			{
+				if ( opened_2dsamples[i - MAXCHANNELS] )
+				{
+					if ( GetChannelUsedFlag(i - MAXCHANNELS) )
+					{
+						if ( nChannelVolume[i - MAXCHANNELS] )
+						{
+							AIL_set_sample_volume(opened_2dsamples[i - MAXCHANNELS],
+									m_nEffectsFadeVolume * nChannelVolume[i - MAXCHANNELS] * m_nEffectsVolume >> 14);
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+void
+cSampleManager::SetEffectsMasterVolume(uint8 nVolume)
+{
+	m_nEffectsVolume = nVolume;
+	UpdateEffectsVolume();
+}
+
+void
+cSampleManager::SetMusicMasterVolume(uint8 nVolume)
+{
+	m_nMusicVolume = nVolume;
+}
+
+void
+cSampleManager::SetEffectsFadeVolume(uint8 nVolume)
+{
+	m_nEffectsFadeVolume = nVolume;
+	UpdateEffectsVolume();
+}
+
+void
+cSampleManager::SetMusicFadeVolume(uint8 nVolume)
+{
+	m_nMusicFadeVolume = nVolume;
+}
+
+bool
+cSampleManager::LoadSampleBank(uint8 nBank)
+{
+	if ( CTimer::GetIsCodePaused() )
+		return false;
+	
+	if ( MusicManager.IsInitialised()
+		&& MusicManager.GetMusicMode() == MUSICMODE_CUTSCENE
+		&& nBank != 0 )
+	{
+		return false;
+	}
+	
+	if ( fseek(fpSampleDataHandle, nSampleBankDiscStartOffset[nBank], SEEK_SET) != 0 )
+		return false;
+	
+	if ( fread((void *)nSampleBankMemoryStartAddress[nBank], 1, nSampleBankSize[nBank],fpSampleDataHandle) != nSampleBankSize[nBank] )
+		return false;
+	
+	bSampleBankLoaded[nBank] = true;
+	
+	return true;
+}
+
+void
+cSampleManager::UnloadSampleBank(uint8 nBank)
+{
+	bSampleBankLoaded[nBank] = false;
+}
+
+bool
+cSampleManager::IsSampleBankLoaded(uint8 nBank)
+{
+	return bSampleBankLoaded[nBank];
+}
+
+bool
+cSampleManager::IsPedCommentLoaded(uint32 nComment)
+{
+	int32 slot;
+
+	for ( int32 i = 0; i < _TODOCONST(3); i++ )
+	{
+		slot = nCurrentPedSlot - i - 1;
+		if ( nComment == nPedSlotSfx[slot] )
+			return true;
+	}
+	
+	return false;
+}
+
+int32
+cSampleManager::_GetPedCommentSlot(uint32 nComment)
+{
+	int32 slot;
+
+	for ( int32 i = 0; i < _TODOCONST(3); i++ )
+	{
+		slot = nCurrentPedSlot - i - 1;
+		if ( nComment == nPedSlotSfx[slot] )
+			return slot;
+	}
+	
+	return -1;
+}
+
+bool
+cSampleManager::LoadPedComment(uint32 nComment)
+{
+	if ( CTimer::GetIsCodePaused() )
+		return false;
+	
+	// no talking peds during cutsenes or the game end
+	if ( MusicManager.IsInitialised() )
+	{
+		switch ( MusicManager.GetMusicMode() )
+		{
+			case MUSICMODE_CUTSCENE:
+			{
+				return false;
+
+				break;
+			}
+			
+			case MUSICMODE_FRONTEND:
+			{
+				if ( MusicManager.GetCurrentTrack() == STREAMED_SOUND_GAME_COMPLETED )
+					return false;
+
+				break;
+			}
+		}
+	}
+	
+	if ( fseek(fpSampleDataHandle, m_aSamples[nComment].nOffset, SEEK_SET) != 0 )
+		return false;
+	
+	if ( fread((void *)(nSampleBankMemoryStartAddress[1] + PED_BLOCKSIZE*nCurrentPedSlot), 1, m_aSamples[nComment].nSize, fpSampleDataHandle) != m_aSamples[nComment].nSize )
+		return false;
+	
+	nPedSlotSfxAddr[nCurrentPedSlot] = nSampleBankMemoryStartAddress[1] + PED_BLOCKSIZE*nCurrentPedSlot;
+	nPedSlotSfx    [nCurrentPedSlot] = nComment;
+	
+	if ( ++nCurrentPedSlot >= MAX_PEDSFX )
+		nCurrentPedSlot = 0;
+	
+	return true;
+}
+
+int32
+cSampleManager::GetSampleBaseFrequency(uint32 nSample)
+{
+	return m_aSamples[nSample].nFrequency;
+}
+
+int32
+cSampleManager::GetSampleLoopStartOffset(uint32 nSample)
+{
+	return m_aSamples[nSample].nLoopStart;
+}
+
+int32
+cSampleManager::GetSampleLoopEndOffset(uint32 nSample)
+{
+	return m_aSamples[nSample].nLoopEnd;
+}
+
+uint32
+cSampleManager::GetSampleLength(uint32 nSample)
+{
+	return m_aSamples[nSample].nSize >> 1;
+}
+
+bool
+cSampleManager::UpdateReverb(void)
+{
+	if ( !usingEAX )
+		return false;
+	
+	if ( AudioManager.GetFrameCounter() & 15 )
+		return false;
+			
+	float y = AudioManager.GetReflectionsDistance(REFLECTION_TOP)  + AudioManager.GetReflectionsDistance(REFLECTION_BOTTOM);
+	float x = AudioManager.GetReflectionsDistance(REFLECTION_LEFT) + AudioManager.GetReflectionsDistance(REFLECTION_RIGHT);
+	float z = AudioManager.GetReflectionsDistance(REFLECTION_UP);
+	
+	float normy = norm(y, 5.0f, 40.0f);
+	float normx = norm(x, 5.0f, 40.0f);
+	float normz = norm(z, 5.0f, 40.0f);
+
+	float fRatio;
+	
+	if ( normy == 0.0f )
+	{
+		if ( normx == 0.0f )
+		{
+			if ( normz == 0.0f )
+				fRatio = 0.3f;
+			else
+				fRatio = 0.5f;
+		}
+		else
+		{
+			fRatio = 0.3f;
+		}
+	}
+	else
+	{
+		if ( normx == 0.0f )
+		{
+			if ( normz == 0.0f )
+				fRatio = 0.3f;
+			else
+				fRatio = 0.5f;
+		}
+		else
+		{
+			if ( normz == 0.0f )
+				fRatio = 0.3f;
+			else
+				fRatio = (normy+normx+normz) / 3.0f;
+		}
+	}
+	
+	fRatio = clamp(fRatio, usingEAX3==1 ? 0.0f : 0.30f, 1.0f);
+	
+	if ( fRatio == _fPrevEaxRatioDestination )
+		return false;
+	
+	if ( usingEAX3 )
+	{
+		if ( EAX3ListenerInterpolate(&StartEAX3, &FinishEAX3, fRatio, &EAX3Params, false) )
+		{
+			AIL_set_3D_provider_preference(opened_provider, "EAX all parameters", &EAX3Params);
+			_fEffectsLevel = 1.0f - fRatio * 0.5f;
+		}
+	}
+	else
+	{
+		if ( _usingMilesFast2D )
+			_fEffectsLevel = (1.0f - fRatio) * 0.4f;
+		else
+			_fEffectsLevel = (1.0f - fRatio) * 0.7f;
+	}
+
+	_fPrevEaxRatioDestination = fRatio;
+	
+	return true;
+}
+
+void
+cSampleManager::SetChannelReverbFlag(uint32 nChannel, uint8 nReverbFlag)
+{
+	bool b2d = false;
+	
+	switch ( nChannel )
+	{
+		case CHANNEL2D:
+		{
+			b2d = true;
+			break;
+		}
+	}
+	
+	if ( usingEAX )
+	{
+		if ( nReverbFlag != 0 )
+		{
+			if ( !b2d )
+				AIL_set_3D_sample_effects_level(opened_samples[nChannel], _fEffectsLevel);
+		}
+		else
+		{
+			if ( !b2d )
+				AIL_set_3D_sample_effects_level(opened_samples[nChannel], 0.0f);
+		}
+	}
+}
+
+bool
+cSampleManager::InitialiseChannel(uint32 nChannel, uint32 nSfx, uint8 nBank)
+{
+	bool b2d = false;
+
+	switch ( nChannel )
+	{
+		case CHANNEL2D:
+		{
+			b2d = true;
+			break;
+		}
+	}
+	
+	int32 addr;
+	
+	if ( nSfx < SAMPLEBANK_MAX )
+	{
+		if ( !IsSampleBankLoaded(nBank) )
+			return false;
+		
+		addr = nSampleBankMemoryStartAddress[nBank] + m_aSamples[nSfx].nOffset - m_aSamples[BankStartOffset[nBank]].nOffset;
+	}
+	else
+	{	
+		if ( !IsPedCommentLoaded(nSfx) )
+			return false;
+		
+		int32 slot = _GetPedCommentSlot(nSfx);
+		
+		addr = nPedSlotSfxAddr[slot];
+	}
+	
+	if ( b2d )
+	{
+		if ( opened_2dsamples[nChannel - MAXCHANNELS] )
+		{
+			AIL_set_sample_address(opened_2dsamples[nChannel - MAXCHANNELS], (void *)addr, m_aSamples[nSfx].nSize);
+			return true;
+		}
+		else
+			return false;
+	}
+	else
+	{
+		AILSOUNDINFO info;
+		
+		info.format   = WAVE_FORMAT_PCM;
+		info.data_ptr = (void *)addr;
+		info.channels = 1;
+		info.data_len = m_aSamples[nSfx].nSize;
+		info.rate     = m_aSamples[nSfx].nFrequency;
+		info.bits     = 16;
+	
+		if ( AIL_set_3D_sample_info(opened_samples[nChannel], &info) == 0 )
+		{
+			OutputDebugString(AIL_last_error());
+			return false;
+		}
+			
+		return true;
+	}
+}
+
+void
+cSampleManager::SetChannelEmittingVolume(uint32 nChannel, uint32 nVolume)
+{
+	uint32 vol = nVolume;
+	if ( vol > 127 ) vol = 127;
+	
+	nChannelVolume[nChannel] = vol;
+	
+	// increase the volume for JB.MP3 and S4_BDBD.MP3
+	if (   MusicManager.GetMusicMode()    == MUSICMODE_CUTSCENE
+		&& MusicManager.GetCurrentTrack() != STREAMED_SOUND_NEWS_INTRO
+		&& MusicManager.GetCurrentTrack() != STREAMED_SOUND_CUTSCENE_SAL4_BDBD )
+	{
+		nChannelVolume[nChannel] >>= 2;
+	}
+
+	if ( opened_samples[nChannel] )
+		AIL_set_3D_sample_volume(opened_samples[nChannel], m_nEffectsFadeVolume*nChannelVolume[nChannel]*m_nEffectsVolume >> 14);
+
+}
+
+void
+cSampleManager::SetChannel3DPosition(uint32 nChannel, float fX, float fY, float fZ)
+{
+	if ( opened_samples[nChannel] )
+		AIL_set_3D_position(opened_samples[nChannel], -fX, fY, fZ);
+}
+
+void
+cSampleManager::SetChannel3DDistances(uint32 nChannel, float fMax, float fMin)
+{
+	if ( opened_samples[nChannel] )
+		AIL_set_3D_sample_distances(opened_samples[nChannel], fMax, fMin);
+}
+
+void
+cSampleManager::SetChannelVolume(uint32 nChannel, uint32 nVolume)
+{
+	uint32 vol = nVolume;
+	if ( vol > 127 ) vol = 127;
+	
+	switch ( nChannel )
+	{
+		case CHANNEL2D:
+		{
+			nChannelVolume[nChannel] = vol;
+			
+			// increase the volume for JB.MP3 and S4_BDBD.MP3
+			if (   MusicManager.GetMusicMode()    == MUSICMODE_CUTSCENE
+				&& MusicManager.GetCurrentTrack() != STREAMED_SOUND_NEWS_INTRO
+				&& MusicManager.GetCurrentTrack() != STREAMED_SOUND_CUTSCENE_SAL4_BDBD )
+			{
+				nChannelVolume[nChannel] >>= 2;
+			}
+
+			if ( opened_2dsamples[nChannel - MAXCHANNELS] )
+			{
+				AIL_set_sample_volume(opened_2dsamples[nChannel - MAXCHANNELS],
+						m_nEffectsFadeVolume*vol*m_nEffectsVolume >> 14);
+			}
+			
+			break;
+		}
+	}
+}
+
+void
+cSampleManager::SetChannelPan(uint32 nChannel, uint32 nPan)
+{
+	switch ( nChannel )
+	{
+		case CHANNEL2D:
+		{
+#ifndef FIX_BUGS
+			if ( opened_samples[nChannel - MAXCHANNELS] ) // BUG
+#else
+			if ( opened_2dsamples[nChannel - MAXCHANNELS] )
+#endif
+				AIL_set_sample_pan(opened_2dsamples[nChannel - MAXCHANNELS], nPan);
+
+			break;
+		}
+	}
+}
+
+void
+cSampleManager::SetChannelFrequency(uint32 nChannel, uint32 nFreq)
+{
+	bool b2d = false;
+
+	switch ( nChannel )
+	{
+		case CHANNEL2D:
+		{
+			b2d = true;
+			break;
+		}
+	}
+
+	if ( b2d )
+	{
+		if ( opened_2dsamples[nChannel - MAXCHANNELS] )
+			AIL_set_sample_playback_rate(opened_2dsamples[nChannel - MAXCHANNELS], nFreq);
+	}
+	else
+	{
+		if ( opened_samples[nChannel] )
+			AIL_set_3D_sample_playback_rate(opened_samples[nChannel], nFreq);
+	}
+}
+
+void
+cSampleManager::SetChannelLoopPoints(uint32 nChannel, uint32 nLoopStart, int32 nLoopEnd)
+{
+	bool b2d = false;
+
+	switch ( nChannel )
+	{
+		case CHANNEL2D:
+		{
+			b2d = true;
+			break;
+		}
+	}
+	
+	if ( b2d )
+	{
+		if ( opened_2dsamples[nChannel - MAXCHANNELS] )
+			AIL_set_sample_loop_block(opened_2dsamples[nChannel - MAXCHANNELS], nLoopStart, nLoopEnd);
+	}
+	else
+	{
+		if ( opened_samples[nChannel] )
+			AIL_set_3D_sample_loop_block(opened_samples[nChannel], nLoopStart, nLoopEnd);
+	}
+}
+
+void
+cSampleManager::SetChannelLoopCount(uint32 nChannel, uint32 nLoopCount)
+{
+	bool b2d = false;
+
+	switch ( nChannel )
+	{
+		case CHANNEL2D:
+		{
+			b2d = true;
+			break;
+		}
+	}
+	
+	if ( b2d )
+	{
+		if ( opened_2dsamples[nChannel - MAXCHANNELS] )
+			AIL_set_sample_loop_count(opened_2dsamples[nChannel - MAXCHANNELS], nLoopCount);
+	}
+	else
+	{
+		if ( opened_samples[nChannel] )
+			AIL_set_3D_sample_loop_count(opened_samples[nChannel], nLoopCount);
+	}
+}
+
+bool
+cSampleManager::GetChannelUsedFlag(uint32 nChannel)
+{
+	bool b2d = false;
+
+	switch ( nChannel )
+	{
+		case CHANNEL2D:
+		{
+			b2d = true;
+			break;
+		}
+	}
+	
+	if ( b2d )
+	{
+		if ( opened_2dsamples[nChannel - MAXCHANNELS] )
+			return AIL_sample_status(opened_2dsamples[nChannel - MAXCHANNELS]) == SMP_PLAYING;
+		else
+			return false;
+	}
+	else
+	{
+		if ( opened_samples[nChannel] )
+			return AIL_3D_sample_status(opened_samples[nChannel]) == SMP_PLAYING;
+		else
+			return false;
+	}
+	
+}
+
+void
+cSampleManager::StartChannel(uint32 nChannel)
+{
+	bool b2d = false;
+
+	switch ( nChannel )
+	{
+		case CHANNEL2D:
+		{
+			b2d = true;
+			break;
+		}
+	}
+
+	if ( b2d )
+	{
+		if ( opened_2dsamples[nChannel - MAXCHANNELS] )
+			AIL_start_sample(opened_2dsamples[nChannel - MAXCHANNELS]);
+	}
+	else
+	{
+		if ( opened_samples[nChannel] )
+			AIL_start_3D_sample(opened_samples[nChannel]);
+	}
+}
+
+void
+cSampleManager::StopChannel(uint32 nChannel)
+{
+	bool b2d = false;
+
+	switch ( nChannel )
+	{
+		case CHANNEL2D:
+		{
+			b2d = true;
+			break;
+		}
+	}
+	
+	if ( b2d )
+	{
+		if ( opened_2dsamples[nChannel - MAXCHANNELS] )
+			AIL_end_sample(opened_2dsamples[nChannel - MAXCHANNELS]);
+	}
+	else
+	{
+		if ( opened_samples[nChannel] )
+		{
+			if ( AIL_3D_sample_status(opened_samples[nChannel]) == SMP_PLAYING )
+				AIL_end_3D_sample(opened_samples[nChannel]);
+		}
+	}
+}
+
+void
+cSampleManager::PreloadStreamedFile(uint8 nFile, uint8 nStream)
+{
+	if ( m_bInitialised  )
+	{
+		if ( nFile < TOTAL_STREAMED_SOUNDS )
+		{
+			if ( mp3Stream[nStream] )
+			{
+				AIL_pause_stream(mp3Stream[nStream], 1);
+				AIL_close_stream(mp3Stream[nStream]);
+			}
+			
+			char filepath[MAX_PATH];
+			
+			strcpy(filepath, m_szCDRomRootPath);
+			strcat(filepath, StreamedNameTable[nFile]);
+			
+			mp3Stream[nStream] = AIL_open_stream(DIG, filepath, 0);
+	
+			if ( mp3Stream[nStream] )
+			{
+				AIL_set_stream_loop_count(mp3Stream[nStream], 1);
+				AIL_service_stream(mp3Stream[nStream], 1);
+			}
+			else
+				OutputDebugString(AIL_last_error());
+		}
+	}
+}
+
+void
+cSampleManager::PauseStream(uint8 nPauseFlag, uint8 nStream)
+{
+	if ( m_bInitialised )
+	{
+		if ( mp3Stream[nStream] )
+			AIL_pause_stream(mp3Stream[nStream], nPauseFlag != 0);
+	}
+}
+
+void
+cSampleManager::StartPreloadedStreamedFile(uint8 nStream)
+{
+	if ( m_bInitialised )
+	{
+		if ( mp3Stream[nStream] )
+			AIL_start_stream(mp3Stream[nStream]);
+	}
+}
+
+bool
+cSampleManager::StartStreamedFile(uint8 nFile, uint32 nPos, uint8 nStream)
+{
+	uint32 position = nPos;
+	char filename[MAX_PATH];
+	
+	if ( m_bInitialised && nFile < TOTAL_STREAMED_SOUNDS )
+	{
+		if ( mp3Stream[nStream] )
+		{
+			AIL_pause_stream(mp3Stream[nStream], 1);
+			AIL_close_stream(mp3Stream[nStream]);
+		}
+		
+		if ( nFile == STREAMED_SOUND_RADIO_MP3_PLAYER )
+		{
+			uint32 i = 0;
+			
+			if ( !_bIsMp3Active ) goto FIND_MP3TRACK;
+			
+			do
+			{
+				if ( ++_CurMP3Index >= nNumMP3s )
+					_CurMP3Index = 0;
+				
+				_CurMP3Pos = 0;
+				
+				tMP3Entry *mp3 = _GetMP3EntryByIndex(_CurMP3Index);
+			
+				if ( mp3 )
+				{
+					mp3 = _pMP3List;
+					if ( mp3 == NULL )
+					{
+						_bIsMp3Active = false;
+						nFile = 0;
+						goto PLAY_STREAMEDTRACK;
+					}
+				}
+			
+				if ( mp3->pLinkPath != NULL )
+					mp3Stream[nStream] = AIL_open_stream(DIG, mp3->pLinkPath, 0);
+				else
+				{
+					strcpy(filename, _mp3DirectoryPath);
+					strcat(filename, mp3->aFilename);
+					
+					mp3Stream[nStream] = AIL_open_stream(DIG, filename, 0);
+				}
+				
+				if ( mp3Stream[nStream] )
+				{
+					AIL_set_stream_loop_count(mp3Stream[nStream], 1);
+					AIL_set_stream_ms_position(mp3Stream[nStream], 0);
+					AIL_pause_stream(mp3Stream[nStream], 0);
+					return true;
+				}
+				
+				goto NEXT_MP3TRACK;
+				
+FIND_MP3TRACK:
+				if ( nPos > nStreamLength[STREAMED_SOUND_RADIO_MP3_PLAYER] )
+					position = 0;
+				
+				tMP3Entry *e;
+				if ( !_GetMP3PosFromStreamPos(&position, &e) )
+				{
+					if ( e == NULL )
+					{
+						nFile = 0;
+						goto PLAY_STREAMEDTRACK;
+					}
+				}
+				
+				if ( e->pLinkPath != NULL )
+					mp3Stream[nStream] = AIL_open_stream(DIG, e->pLinkPath, 0);
+				else
+				{
+					strcpy(filename, _mp3DirectoryPath);
+					strcat(filename, e->aFilename);
+				
+					mp3Stream[nStream] = AIL_open_stream(DIG, filename, 0);
+				}
+									
+				if ( mp3Stream[nStream] )
+				{
+					AIL_set_stream_loop_count(mp3Stream[nStream], 1);
+					AIL_set_stream_ms_position(mp3Stream[nStream], position);
+					AIL_pause_stream(mp3Stream[nStream], 0);
+					
+					_bIsMp3Active = true;
+			
+					return true;
+				}
+				
+NEXT_MP3TRACK:			
+				_bIsMp3Active = false;
+	
+			} while ( ++i < nNumMP3s );
+			
+			position = 0;
+			nFile = 0;
+			goto PLAY_STREAMEDTRACK;
+		}
+		
+PLAY_STREAMEDTRACK:
+		strcpy(filename, m_szCDRomRootPath);
+		strcat(filename, StreamedNameTable[nFile]);
+		
+		mp3Stream[nStream] = AIL_open_stream(DIG, filename, 0);
+		if ( mp3Stream[nStream] )
+		{
+			AIL_set_stream_loop_count(mp3Stream[nStream], 1);
+			AIL_set_stream_ms_position(mp3Stream[nStream], position);
+			AIL_pause_stream(mp3Stream[nStream], 0);
+			return true;
+		}
+	}
+	
+	return false;
+}
+
+void
+cSampleManager::StopStreamedFile(uint8 nStream)
+{
+	if ( m_bInitialised )
+	{
+		if ( mp3Stream[nStream] )
+		{
+			AIL_pause_stream(mp3Stream[nStream], 1);
+			
+			AIL_close_stream(mp3Stream[nStream]);
+			mp3Stream[nStream] = NULL;
+			
+			if ( nStream == 0 )
+				_bIsMp3Active = false;
+		}
+	}
+}
+
+int32
+cSampleManager::GetStreamedFilePosition(uint8 nStream)
+{
+	S32 currentms;
+	
+	if ( m_bInitialised )
+	{
+		if ( mp3Stream[nStream] )
+		{
+			if ( _bIsMp3Active )
+			{
+				tMP3Entry *mp3 = _GetMP3EntryByIndex(_CurMP3Index);
+				
+				if ( mp3 != NULL )
+				{
+					AIL_stream_ms_position(mp3Stream[nStream], NULL, &currentms);
+					return currentms + mp3->nTrackStreamPos;
+				}
+				else
+					return 0;
+			}
+			else
+			{
+				AIL_stream_ms_position(mp3Stream[nStream], NULL, &currentms);
+				return currentms;
+			}
+		}
+	}
+	
+	return 0;
+}
+
+void
+cSampleManager::SetStreamedVolumeAndPan(uint8 nVolume, uint8 nPan, uint8 nEffectFlag, uint8 nStream)
+{
+	uint8 vol = nVolume;
+	
+	if ( m_bInitialised )
+	{
+		if ( vol > 127 ) vol = 127;
+		if ( vol > 127 ) vol = 127;
+		
+		nStreamVolume[nStream] = vol;
+		nStreamPan[nStream]    = nPan;
+		
+		if ( mp3Stream[nStream] )
+		{
+			if ( nEffectFlag )
+				AIL_set_stream_volume(mp3Stream[nStream], m_nEffectsFadeVolume*vol*m_nEffectsVolume >> 14);
+			else
+				AIL_set_stream_volume(mp3Stream[nStream], m_nMusicFadeVolume*vol*m_nMusicVolume >> 14);
+			
+			AIL_set_stream_pan(mp3Stream[nStream], nPan);
+		}
+	}
+}
+
+int32
+cSampleManager::GetStreamedFileLength(uint8 nStream)
+{
+	if ( m_bInitialised )
+		return nStreamLength[nStream];
+	
+	return 0;
+}
+
+bool
+cSampleManager::IsStreamPlaying(uint8 nStream)
+{
+	if ( m_bInitialised )
+	{
+		if ( mp3Stream[nStream] )
+		{
+			if ( AIL_stream_status(mp3Stream[nStream]) == SMP_PLAYING )
+				return true;
+			else
+				return false;
+		}
+	}
+	
+	return false;
+}
+
+bool
+cSampleManager::InitialiseSampleBanks(void)
+{
+	int32 nBank = 0;
+	
+	fpSampleDescHandle = fopen(SampleBankDescFilename, "rb");
+	if ( fpSampleDescHandle == NULL )
+		return false;
+	
+	fpSampleDataHandle = fopen(SampleBankDataFilename, "rb");
+	if ( fpSampleDataHandle == NULL )
+	{
+		fclose(fpSampleDescHandle);
+		fpSampleDescHandle = NULL;
+		
+		return false;
+	}
+	
+	fseek(fpSampleDataHandle, 0, SEEK_END);
+	_nSampleDataEndOffset = ftell(fpSampleDataHandle);
+	rewind(fpSampleDataHandle);
+	
+	fread(m_aSamples, sizeof(tSample), TOTAL_AUDIO_SAMPLES, fpSampleDescHandle);
+	
+	fclose(fpSampleDescHandle);
+	fpSampleDescHandle = NULL;
+	
+	for ( int32 i = 0; i < TOTAL_AUDIO_SAMPLES; i++ )
+	{
+		if ( BankStartOffset[nBank] == BankStartOffset[0] + i )
+		{
+			nSampleBankDiscStartOffset[nBank] = m_aSamples[i].nOffset;
+			nBank++;
+		}
+	}
+
+	nSampleBankSize[0] = nSampleBankDiscStartOffset[1] - nSampleBankDiscStartOffset[0];
+	nSampleBankSize[1] = _nSampleDataEndOffset         - nSampleBankDiscStartOffset[1];
+	
+	return true;
+}
+
+STARTPATCHES
+	//InjectHook(0x565500, cSampleManager::cSampleManager, PATCH_JUMP);
+	//InjectHook(0x565510, cSampleManager::~cSampleManager, PATCH_JUMP);
+	InjectHook(0x565520, comp, PATCH_JUMP);
+	InjectHook(0x565540, add_providers, PATCH_JUMP);
+	InjectHook(0x565680, release_existing, PATCH_JUMP);
+	InjectHook(0x5656F0, set_new_provider, PATCH_JUMP);
+	InjectHook(0x565900, &cSampleManager::SetSpeakerConfig, PATCH_JUMP);
+	InjectHook(0x565970, &cSampleManager::GetMaximumSupportedChannels, PATCH_JUMP);
+	InjectHook(0x565990, &cSampleManager::GetCurrent3DProviderIndex, PATCH_JUMP);
+	InjectHook(0x5659A0, &cSampleManager::SetCurrent3DProvider, PATCH_JUMP);
+	InjectHook(0x565A10, _ResolveLink, PATCH_JUMP);
+	InjectHook(0x565B40, _FindMP3s, PATCH_JUMP);
+	InjectHook(0x566380, _DeleteMP3Entries, PATCH_JUMP);
+	InjectHook(0x566400, _GetMP3EntryByIndex, PATCH_JUMP);
+	InjectHook(0x566490, &cSampleManager::IsMP3RadioChannelAvailable, PATCH_JUMP);
+	InjectHook(0x5664B0, &cSampleManager::ReleaseDigitalHandle, PATCH_JUMP);
+	InjectHook(0x5664F0, &cSampleManager::ReacquireDigitalHandle, PATCH_JUMP);
+	InjectHook(0x566530, &cSampleManager::Initialise, PATCH_JUMP);
+	InjectHook(0x566DC0, &cSampleManager::Terminate, PATCH_JUMP);
+	InjectHook(0x566EA0, &cSampleManager::CheckForAnAudioFileOnCD, PATCH_JUMP);
+	InjectHook(0x566F20, &cSampleManager::GetCDAudioDriveLetter, PATCH_JUMP);
+	InjectHook(0x566F50, &cSampleManager::UpdateEffectsVolume, PATCH_JUMP);
+	InjectHook(0x567010, &cSampleManager::SetEffectsMasterVolume, PATCH_JUMP);
+	InjectHook(0x567020, &cSampleManager::SetMusicMasterVolume, PATCH_JUMP);
+	InjectHook(0x567030, &cSampleManager::SetEffectsFadeVolume, PATCH_JUMP);
+	InjectHook(0x567040, &cSampleManager::SetMusicFadeVolume, PATCH_JUMP);
+	InjectHook(0x567050, &cSampleManager::LoadSampleBank, PATCH_JUMP);
+	InjectHook(0x567110, &cSampleManager::UnloadSampleBank, PATCH_JUMP);
+	InjectHook(0x567130, &cSampleManager::IsSampleBankLoaded, PATCH_JUMP);
+	InjectHook(0x567150, &cSampleManager::IsPedCommentLoaded, PATCH_JUMP);
+	InjectHook(0x5671A0, &cSampleManager::LoadPedComment, PATCH_JUMP);
+	InjectHook(0x5672A0, &cSampleManager::GetSampleBaseFrequency, PATCH_JUMP);
+	InjectHook(0x5672C0, &cSampleManager::GetSampleLoopStartOffset, PATCH_JUMP);
+	InjectHook(0x5672E0, &cSampleManager::GetSampleLoopEndOffset, PATCH_JUMP);
+	InjectHook(0x567300, &cSampleManager::GetSampleLength, PATCH_JUMP);
+	InjectHook(0x567320, &cSampleManager::UpdateReverb, PATCH_JUMP);
+	InjectHook(0x567630, &cSampleManager::SetChannelReverbFlag, PATCH_JUMP);
+	InjectHook(0x5676A0, &cSampleManager::InitialiseChannel, PATCH_JUMP);
+	InjectHook(0x567820, &cSampleManager::SetChannelEmittingVolume, PATCH_JUMP);
+	InjectHook(0x567890, &cSampleManager::SetChannel3DPosition, PATCH_JUMP);
+	InjectHook(0x5678D0, &cSampleManager::SetChannel3DDistances, PATCH_JUMP);
+	InjectHook(0x567900, &cSampleManager::SetChannelVolume, PATCH_JUMP);
+	InjectHook(0x567980, &cSampleManager::SetChannelPan, PATCH_JUMP);
+	InjectHook(0x5679D0, &cSampleManager::SetChannelFrequency, PATCH_JUMP);
+	InjectHook(0x567A30, &cSampleManager::SetChannelLoopPoints, PATCH_JUMP);
+	InjectHook(0x567AA0, &cSampleManager::SetChannelLoopCount, PATCH_JUMP);
+	InjectHook(0x567B00, &cSampleManager::GetChannelUsedFlag, PATCH_JUMP);
+	InjectHook(0x567B80, &cSampleManager::StartChannel, PATCH_JUMP);
+	InjectHook(0x567BE0, &cSampleManager::StopChannel, PATCH_JUMP);
+	InjectHook(0x567C50, &cSampleManager::PreloadStreamedFile, PATCH_JUMP);
+	InjectHook(0x567D30, &cSampleManager::PauseStream, PATCH_JUMP);
+	InjectHook(0x567D60, &cSampleManager::StartPreloadedStreamedFile, PATCH_JUMP);
+	InjectHook(0x567D80, &cSampleManager::StartStreamedFile, PATCH_JUMP);
+	InjectHook(0x5680E0, &cSampleManager::StopStreamedFile, PATCH_JUMP);
+	InjectHook(0x568130, &cSampleManager::GetStreamedFilePosition, PATCH_JUMP);
+	InjectHook(0x5681D0, &cSampleManager::SetStreamedVolumeAndPan, PATCH_JUMP);
+	InjectHook(0x568270, &cSampleManager::GetStreamedFileLength, PATCH_JUMP);
+	InjectHook(0x568290, &cSampleManager::IsStreamPlaying, PATCH_JUMP);
+	InjectHook(0x5682D0, &cSampleManager::InitialiseSampleBanks, PATCH_JUMP);
+	//InjectHook(0x5683F0, `global constructor keyed to'sampman.cpp, PATCH_JUMP);
+ENDPATCHES
\ No newline at end of file
diff --git a/src/audio/sampman.h b/src/audio/sampman.h
new file mode 100644
index 00000000..ba2381b5
--- /dev/null
+++ b/src/audio/sampman.h
@@ -0,0 +1,334 @@
+#pragma once
+#include "common.h"
+#include "AudioSamples.h"
+
+struct tSample {
+	int32 nOffset;
+	uint32 nSize;
+	int32 nFrequency;
+	int32 nLoopStart;
+	int32 nLoopEnd;
+};
+
+#define MAXPROVIDERS 64
+
+#define MAXCHANNELS  28
+#define MAXCHANNELS_SURROUND  24
+#define MAX2DCHANNELS  1
+#define CHANNEL2D MAXCHANNELS
+
+
+#define MAX_MP3STREAMS 2
+
+
+#define MAX_SAMPLEBANKS 2
+#define MAX_PEDSFX 7
+#define PED_BLOCKSIZE 79000
+
+
+#define MAX_DIGITAL_MIXER_CHANNELS 32
+
+#define DIGITALRATE       32000
+#define DIGITALBITS       16
+#define DIGITALCHANNELS   2
+
+
+
+class cSampleManager
+{
+	uint8   m_nEffectsVolume;
+	uint8   m_nMusicVolume;
+	uint8   m_nEffectsFadeVolume;
+	uint8   m_nMusicFadeVolume;
+	uint8   m_nMonoMode;
+	char _pad0[1];
+	char    m_szCDRomRootPath[80];
+	bool    m_bInitialised;
+	uint8   m_nNumberOfProviders;
+	char   *m_aAudioProviders[MAXPROVIDERS];
+	tSample m_aSamples[TOTAL_AUDIO_SAMPLES];
+
+public:
+	
+	
+
+	cSampleManager(void) :
+		m_nNumberOfProviders(0)
+	{ }
+
+	~cSampleManager(void)
+	{ }
+	
+	void SetSpeakerConfig(int32 nConfig);
+	uint32 GetMaximumSupportedChannels(void);
+	
+	uint32 GetNum3DProvidersAvailable()          { return m_nNumberOfProviders; }
+	void SetNum3DProvidersAvailable(uint32 num)  { m_nNumberOfProviders = num; }
+	
+	char *Get3DProviderName(uint8 id)            { return m_aAudioProviders[id]; }
+	void Set3DProviderName(uint8 id, char *name) { m_aAudioProviders[id] = name; }
+	
+	int8 GetCurrent3DProviderIndex(void);
+	int8 SetCurrent3DProvider(uint8 which);
+	
+	bool IsMP3RadioChannelAvailable(void);
+	
+	void ReleaseDigitalHandle  (void);
+	void ReacquireDigitalHandle(void);
+	
+	bool Initialise(void);
+	void Terminate (void);
+	
+	bool CheckForAnAudioFileOnCD(void);
+	char GetCDAudioDriveLetter  (void);
+	
+	void UpdateEffectsVolume(void);
+
+	void SetEffectsMasterVolume(uint8 nVolume);
+	void SetMusicMasterVolume  (uint8 nVolume);
+	void SetEffectsFadeVolume  (uint8 nVolume);
+	void SetMusicFadeVolume    (uint8 nVolume);
+	
+	bool LoadSampleBank    (uint8 nBank);
+	void UnloadSampleBank  (uint8 nBank);
+	bool IsSampleBankLoaded(uint8 nBank);
+	
+	bool IsPedCommentLoaded(uint32 nComment);
+	bool LoadPedComment    (uint32 nComment);
+
+	int32 _GetPedCommentSlot(uint32 nComment);
+	
+	int32  GetSampleBaseFrequency (uint32 nSample);
+	int32  GetSampleLoopStartOffset(uint32 nSample);
+	int32  GetSampleLoopEndOffset  (uint32 nSample);
+	uint32 GetSampleLength         (uint32 nSample);
+	
+	bool  UpdateReverb(void);
+	
+	void  SetChannelReverbFlag    (uint32 nChannel, uint8 nReverbFlag);
+	bool  InitialiseChannel       (uint32 nChannel, uint32 nSfx, uint8 nBank);
+	void  SetChannelEmittingVolume(uint32 nChannel, uint32 nVolume);
+	void  SetChannel3DPosition    (uint32 nChannel, float fX, float fY, float fZ);
+	void  SetChannel3DDistances   (uint32 nChannel, float fMax, float fMin);
+	void  SetChannelVolume        (uint32 nChannel, uint32 nVolume);
+	void  SetChannelPan           (uint32 nChannel, uint32 nPan);
+	void  SetChannelFrequency     (uint32 nChannel, uint32 nFreq);
+	void  SetChannelLoopPoints    (uint32 nChannel, uint32 nLoopStart, int32 nLoopEnd);
+	void  SetChannelLoopCount     (uint32 nChannel, uint32 nLoopCount);
+	bool  GetChannelUsedFlag      (uint32 nChannel);
+	void  StartChannel            (uint32 nChannel);
+	void  StopChannel             (uint32 nChannel);
+	
+	void  PreloadStreamedFile                                     (uint8 nFile, uint8 nStream);
+	void  PauseStream                                        (uint8 nPauseFlag, uint8 nStream);
+	void  StartPreloadedStreamedFile                                           (uint8 nStream);
+	bool  StartStreamedFile                          (uint8 nFile, uint32 nPos, uint8 nStream);
+	void  StopStreamedFile                                                     (uint8 nStream);
+	int32 GetStreamedFilePosition                                              (uint8 nStream);
+	void  SetStreamedVolumeAndPan(uint8 nVolume, uint8 nPan, uint8 nEffectFlag, uint8 nStream);
+	int32 GetStreamedFileLength                                                (uint8 nStream);
+	bool  IsStreamPlaying                                                      (uint8 nStream);
+	bool  InitialiseSampleBanks(void);
+};
+
+extern cSampleManager &SampleManager;
+
+static char StreamedNameTable[][25]=
+{
+	"AUDIO\\HEAD.WAV",
+	"AUDIO\\CLASS.WAV",
+	"AUDIO\\KJAH.WAV",
+	"AUDIO\\RISE.WAV",
+	"AUDIO\\LIPS.WAV",
+	"AUDIO\\GAME.WAV",
+	"AUDIO\\MSX.WAV",
+	"AUDIO\\FLASH.WAV",
+	"AUDIO\\CHAT.WAV",
+	"AUDIO\\HEAD.WAV",
+	"AUDIO\\POLICE.WAV",
+	"AUDIO\\CITY.WAV",
+	"AUDIO\\WATER.WAV",
+	"AUDIO\\COMOPEN.WAV",
+	"AUDIO\\SUBOPEN.WAV",
+	"AUDIO\\JB.MP3",
+	"AUDIO\\BET.MP3",
+	"AUDIO\\L1_LG.MP3",
+	"AUDIO\\L2_DSB.MP3",
+	"AUDIO\\L3_DM.MP3",
+	"AUDIO\\L4_PAP.MP3",
+	"AUDIO\\L5_TFB.MP3",
+	"AUDIO\\J0_DM2.MP3",
+	"AUDIO\\J1_LFL.MP3",
+	"AUDIO\\J2_KCL.MP3",
+	"AUDIO\\J3_VH.MP3",
+	"AUDIO\\J4_ETH.MP3",
+	"AUDIO\\J5_DST.MP3",
+	"AUDIO\\J6_TBJ.MP3",
+	"AUDIO\\T1_TOL.MP3",
+	"AUDIO\\T2_TPU.MP3",
+	"AUDIO\\T3_MAS.MP3",
+	"AUDIO\\T4_TAT.MP3",
+	"AUDIO\\T5_BF.MP3",
+	"AUDIO\\S0_MAS.MP3",
+	"AUDIO\\S1_PF.MP3",
+	"AUDIO\\S2_CTG.MP3",
+	"AUDIO\\S3_RTC.MP3",
+	"AUDIO\\S5_LRQ.MP3",
+	"AUDIO\\S4_BDBA.MP3",
+	"AUDIO\\S4_BDBB.MP3",
+	"AUDIO\\S2_CTG2.MP3",
+	"AUDIO\\S4_BDBD.MP3",
+	"AUDIO\\S5_LRQB.MP3",
+	"AUDIO\\S5_LRQC.MP3",
+	"AUDIO\\A1_SSO.WAV",
+	"AUDIO\\A2_PP.WAV",
+	"AUDIO\\A3_SS.WAV",
+	"AUDIO\\A4_PDR.WAV",
+	"AUDIO\\A5_K2FT.WAV",
+	"AUDIO\\K1_KBO.MP3",
+	"AUDIO\\K2_GIS.MP3",
+	"AUDIO\\K3_DS.MP3",
+	"AUDIO\\K4_SHI.MP3",
+	"AUDIO\\K5_SD.MP3",
+	"AUDIO\\R0_PDR2.MP3",
+	"AUDIO\\R1_SW.MP3",
+	"AUDIO\\R2_AP.MP3",
+	"AUDIO\\R3_ED.MP3",
+	"AUDIO\\R4_GF.MP3",
+	"AUDIO\\R5_PB.MP3",
+	"AUDIO\\R6_MM.MP3",
+	"AUDIO\\D1_STOG.MP3",
+	"AUDIO\\D2_KK.MP3",
+	"AUDIO\\D3_ADO.MP3",
+	"AUDIO\\D5_ES.MP3",
+	"AUDIO\\D7_MLD.MP3",
+	"AUDIO\\D4_GTA.MP3",
+	"AUDIO\\D4_GTA2.MP3",
+	"AUDIO\\D6_STS.MP3",
+	"AUDIO\\A6_BAIT.WAV",
+	"AUDIO\\A7_ETG.WAV",
+	"AUDIO\\A8_PS.WAV",
+	"AUDIO\\A9_ASD.WAV",
+	"AUDIO\\K4_SHI2.MP3",
+	"AUDIO\\C1_TEX.MP3",
+	"AUDIO\\EL_PH1.MP3",
+	"AUDIO\\EL_PH2.MP3",
+	"AUDIO\\EL_PH3.MP3",
+	"AUDIO\\EL_PH4.MP3",
+	"AUDIO\\YD_PH1.MP3",
+	"AUDIO\\YD_PH2.MP3",
+	"AUDIO\\YD_PH3.MP3",
+	"AUDIO\\YD_PH4.MP3",
+	"AUDIO\\HD_PH1.MP3",
+	"AUDIO\\HD_PH2.MP3",
+	"AUDIO\\HD_PH3.MP3",
+	"AUDIO\\HD_PH4.MP3",
+	"AUDIO\\HD_PH5.MP3",
+	"AUDIO\\MT_PH1.MP3",
+	"AUDIO\\MT_PH2.MP3",
+	"AUDIO\\MT_PH3.MP3",
+	"AUDIO\\MT_PH4.MP3",
+	"AUDIO\\MISCOM.WAV",
+	"AUDIO\\END.MP3",
+	"AUDIO\\lib_a1.WAV",
+	"AUDIO\\lib_a2.WAV",
+	"AUDIO\\lib_a.WAV",
+	"AUDIO\\lib_b.WAV",
+	"AUDIO\\lib_c.WAV",
+	"AUDIO\\lib_d.WAV",
+	"AUDIO\\l2_a.WAV",
+	"AUDIO\\j4t_1.WAV",
+	"AUDIO\\j4t_2.WAV",
+	"AUDIO\\j4t_3.WAV",
+	"AUDIO\\j4t_4.WAV",
+	"AUDIO\\j4_a.WAV",
+	"AUDIO\\j4_b.WAV",
+	"AUDIO\\j4_c.WAV",
+	"AUDIO\\j4_d.WAV",
+	"AUDIO\\j4_e.WAV",
+	"AUDIO\\j4_f.WAV",
+	"AUDIO\\j6_1.WAV",
+	"AUDIO\\j6_a.WAV",
+	"AUDIO\\j6_b.WAV",
+	"AUDIO\\j6_c.WAV",
+	"AUDIO\\j6_d.WAV",
+	"AUDIO\\t4_a.WAV",
+	"AUDIO\\s1_a.WAV",
+	"AUDIO\\s1_a1.WAV",
+	"AUDIO\\s1_b.WAV",
+	"AUDIO\\s1_c.WAV",
+	"AUDIO\\s1_c1.WAV",
+	"AUDIO\\s1_d.WAV",
+	"AUDIO\\s1_e.WAV",
+	"AUDIO\\s1_f.WAV",
+	"AUDIO\\s1_g.WAV",
+	"AUDIO\\s1_h.WAV",
+	"AUDIO\\s1_i.WAV",
+	"AUDIO\\s1_j.WAV",
+	"AUDIO\\s1_k.WAV",
+	"AUDIO\\s1_l.WAV",
+	"AUDIO\\s3_a.WAV",
+	"AUDIO\\s3_b.WAV",
+	"AUDIO\\el3_a.WAV",
+	"AUDIO\\mf1_a.WAV",
+	"AUDIO\\mf2_a.WAV",
+	"AUDIO\\mf3_a.WAV",
+	"AUDIO\\mf3_b.WAV",
+	"AUDIO\\mf3_b1.WAV",
+	"AUDIO\\mf3_c.WAV",
+	"AUDIO\\mf4_a.WAV",
+	"AUDIO\\mf4_b.WAV",
+	"AUDIO\\mf4_c.WAV",
+	"AUDIO\\a1_a.WAV",
+	"AUDIO\\a3_a.WAV",
+	"AUDIO\\a5_a.WAV",
+	"AUDIO\\a4_a.WAV",
+	"AUDIO\\a4_b.WAV",
+	"AUDIO\\a4_c.WAV",
+	"AUDIO\\a4_d.WAV",
+	"AUDIO\\k1_a.WAV",
+	"AUDIO\\k3_a.WAV",
+	"AUDIO\\r1_a.WAV",
+	"AUDIO\\r2_a.WAV",
+	"AUDIO\\r2_b.WAV",
+	"AUDIO\\r2_c.WAV",
+	"AUDIO\\r2_d.WAV",
+	"AUDIO\\r2_e.WAV",
+	"AUDIO\\r2_f.WAV",
+	"AUDIO\\r2_g.WAV",
+	"AUDIO\\r2_h.WAV",
+	"AUDIO\\r5_a.WAV",
+	"AUDIO\\r6_a.WAV",
+	"AUDIO\\r6_a1.WAV",
+	"AUDIO\\r6_b.WAV",
+	"AUDIO\\lo2_a.WAV",
+	"AUDIO\\lo6_a.WAV",
+	"AUDIO\\yd2_a.WAV",
+	"AUDIO\\yd2_b.WAV",
+	"AUDIO\\yd2_c.WAV",
+	"AUDIO\\yd2_c1.WAV",
+	"AUDIO\\yd2_d.WAV",
+	"AUDIO\\yd2_e.WAV",
+	"AUDIO\\yd2_f.WAV",
+	"AUDIO\\yd2_g.WAV",
+	"AUDIO\\yd2_h.WAV",
+	"AUDIO\\yd2_ass.WAV",
+	"AUDIO\\yd2_ok.WAV",
+	"AUDIO\\h5_a.WAV",
+	"AUDIO\\h5_b.WAV",
+	"AUDIO\\h5_c.WAV",
+	"AUDIO\\ammu_a.WAV",
+	"AUDIO\\ammu_b.WAV",
+	"AUDIO\\ammu_c.WAV",
+	"AUDIO\\door_1.WAV",
+	"AUDIO\\door_2.WAV",
+	"AUDIO\\door_3.WAV",
+	"AUDIO\\door_4.WAV",
+	"AUDIO\\door_5.WAV",
+	"AUDIO\\door_6.WAV",
+	"AUDIO\\t3_a.WAV",
+	"AUDIO\\t3_b.WAV",
+	"AUDIO\\t3_c.WAV",
+	"AUDIO\\k1_b.WAV",
+	"AUDIO\\cat1.WAV"
+};
\ No newline at end of file
diff --git a/src/core/Timer.h b/src/core/Timer.h
index 9e6d447e..8f3b77c2 100644
--- a/src/core/Timer.h
+++ b/src/core/Timer.h
@@ -35,6 +35,7 @@ public:
 
 	static bool GetIsPaused() { return m_UserPause || m_CodePause; }
 	static bool GetIsUserPaused() { return m_UserPause; }
+	static bool GetIsCodePaused() { return m_CodePause; }
 	static void SetCodePause(bool pause) { m_CodePause = pause; }
 	
 	static void Initialise(void);
diff --git a/src/core/common.h b/src/core/common.h
index 9a5683c6..97a25a3f 100644
--- a/src/core/common.h
+++ b/src/core/common.h
@@ -180,6 +180,7 @@ void re3_assert(const char *expr, const char *filename, unsigned int lineno, con
 #define max(a, b)  (((a) > (b)) ? (a) : (b)) 
 #define min(a, b)  (((a) < (b)) ? (a) : (b))
 #define ABS(a)  (((a) < 0) ? (-a) : (a))
+#define norm(value, min, max) (((value) < (min)) ? 0 : (((value) > (max)) ? 1 : (((value) - (min)) / ((max) - (min)))))
 
 
 #define STRINGIFY(x)                    #x
diff --git a/src/core/config.h b/src/core/config.h
index 85d79a01..52d1dab8 100644
--- a/src/core/config.h
+++ b/src/core/config.h
@@ -93,6 +93,7 @@ enum Config {
 #	define RANDOMSPLASH
 #elif defined GTA_PC
 #	define GTA3_1_1_PATCH
+//#	define GTA3_STEAM_PATCH
 #	ifdef GTA_PS2_STUFF
 //#		define USE_PS2_RAND	// this is unsafe until we have the game reversed
 #		define RANDOMSPLASH	// use random splash as on PS2
@@ -114,6 +115,7 @@ enum Config {
 	// not in any game
 #	define NASTY_GAME	// nasty game for all languages
 #	define NO_MOVIES	// disable intro videos
+#   define NO_CDCHECK
 #	define CHATTYSPLASH	// print what the game is loading
 #endif
 
diff --git a/src/skel/win/gta3.ico b/src/skel/win/gta3.ico
new file mode 100644
index 00000000..2017c811
--- /dev/null
+++ b/src/skel/win/gta3.ico