From 6ba2b05443dd25b2451215bc73912dcb7b0e6240 Mon Sep 17 00:00:00 2001 From: Fire-Head Date: Fri, 2 Aug 2019 23:20:12 +0300 Subject: [PATCH] sampman done --- eax/eax-util.cpp | 706 +++++ eax/eax-util.h | 765 ++++++ eax/eax.h | 535 ++++ milessdk/include/mss.h | 4805 +++++++++++++++++++++++++++++++++++ milessdk/lib/mss32.lib | Bin 0 -> 246322 bytes premake5.lua | 5 + src/audio/AudioManager.cpp | 308 +-- src/audio/AudioManager.h | 34 +- src/audio/AudioSamples.h | 8 + src/audio/MusicManager.cpp | 6 +- src/audio/MusicManager.h | 13 + src/audio/SampleManager.cpp | 176 -- src/audio/SampleManager.h | 68 - src/audio/sampman.cpp | 2331 +++++++++++++++++ src/audio/sampman.h | 334 +++ src/core/Timer.h | 1 + src/core/common.h | 1 + src/core/config.h | 2 + src/skel/win/gta3.ico | Bin 0 -> 2238 bytes 19 files changed, 9692 insertions(+), 406 deletions(-) create mode 100644 eax/eax-util.cpp create mode 100644 eax/eax-util.h create mode 100644 eax/eax.h create mode 100644 milessdk/include/mss.h create mode 100644 milessdk/lib/mss32.lib delete mode 100644 src/audio/SampleManager.cpp delete mode 100644 src/audio/SampleManager.h create mode 100644 src/audio/sampman.cpp create mode 100644 src/audio/sampman.h create mode 100644 src/skel/win/gta3.ico 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 + +// 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 + +/*********************************************************************************************** +* 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 + + /* + * 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 + + #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 +#include + +#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 +#include +#include +#include // 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 0000000000000000000000000000000000000000..031fd1bd1fb9a99f565c2db10248ed4ce340d9c5 GIT binary patch literal 246322 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 num3DProvidersAvailable) return 0; - return asName3DProviders[id]; + if(id >= SampleManager.GetNum3DProvidersAvailable()) return 0; + return SampleManager.Get3DProviderName(id); } bool @@ -824,16 +824,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; @@ -853,13 +853,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; @@ -902,9 +902,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; @@ -933,9 +933,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; @@ -971,7 +971,7 @@ void cAudioManager::ResetPoliceRadio() { if(m_bIsInitialised) { - if(cSampleManager.GetChannelUsedFlag(28)) cSampleManager.StopChannel(28); + if(SampleManager.GetChannelUsedFlag(28)) SampleManager.StopChannel(28); InitialisePoliceRadio(); } } @@ -1043,13 +1043,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 @@ -1141,7 +1141,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; } @@ -3447,7 +3447,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; @@ -3459,7 +3459,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; @@ -3482,8 +3482,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; @@ -3505,7 +3505,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; @@ -3527,16 +3527,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; @@ -3550,7 +3550,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; } @@ -3577,7 +3577,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; @@ -3603,28 +3603,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] @@ -3655,7 +3655,7 @@ cAudioManager::ProcessActiveQueues() v35 = v34; v36 = v33; v37 = v32; - cSampleManager.SetChannel3DPosition( + SampleManager.SetChannel3DPosition( l, v37, v36, v35); v38 = 0.25f * v27->m_asActiveSamples[0] @@ -3666,7 +3666,7 @@ cAudioManager::ProcessActiveQueues() v27->m_asActiveSamples[0] .m_fSoundIntensity, v38); - cSampleManager.StartChannel(l); + SampleManager.StartChannel(l); } v27->m_asActiveSamples[0].m_bIsProcessed = 1; @@ -3705,7 +3705,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; @@ -3758,7 +3758,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; @@ -3814,9 +3814,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; @@ -3846,13 +3846,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; @@ -3909,7 +3909,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); @@ -3971,7 +3971,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++; @@ -4099,9 +4099,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; @@ -4248,7 +4248,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++; @@ -4316,7 +4316,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); @@ -4481,7 +4481,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; @@ -4490,9 +4490,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(); @@ -4503,7 +4503,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; @@ -4512,9 +4512,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(); @@ -4537,7 +4537,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; @@ -4549,7 +4549,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; @@ -4561,7 +4561,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; @@ -4573,7 +4573,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; @@ -4585,7 +4585,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; @@ -4597,7 +4597,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; @@ -4609,7 +4609,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; @@ -4621,7 +4621,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; @@ -4633,7 +4633,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; @@ -4645,7 +4645,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; @@ -4657,7 +4657,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; @@ -4669,7 +4669,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; @@ -4681,7 +4681,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; @@ -4693,7 +4693,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; @@ -4705,7 +4705,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; @@ -4717,7 +4717,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; @@ -4729,7 +4729,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; @@ -4741,7 +4741,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; @@ -4753,7 +4753,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; @@ -4765,7 +4765,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; @@ -4777,7 +4777,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; @@ -4789,7 +4789,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; @@ -4801,7 +4801,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; @@ -4813,7 +4813,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; @@ -4825,7 +4825,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; @@ -4837,7 +4837,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; @@ -4849,7 +4849,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; @@ -4861,7 +4861,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; @@ -4873,7 +4873,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; @@ -4885,7 +4885,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; @@ -4903,7 +4903,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; @@ -4915,7 +4915,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; @@ -4929,7 +4929,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; @@ -4941,7 +4941,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; @@ -4953,7 +4953,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; @@ -4965,7 +4965,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; @@ -4977,7 +4977,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; @@ -4989,7 +4989,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; @@ -5001,7 +5001,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; @@ -5013,7 +5013,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; @@ -5035,7 +5035,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; @@ -5047,7 +5047,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; @@ -5067,7 +5067,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; @@ -5079,7 +5079,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; @@ -5091,7 +5091,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; @@ -5103,7 +5103,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; @@ -5115,7 +5115,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; @@ -5127,7 +5127,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; @@ -5144,7 +5144,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; @@ -5157,7 +5157,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; @@ -5169,7 +5169,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; @@ -5181,7 +5181,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; @@ -5193,7 +5193,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; @@ -5214,9 +5214,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(); } @@ -5326,7 +5326,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; @@ -5336,9 +5336,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; @@ -5353,7 +5353,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); @@ -5405,7 +5405,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; @@ -5414,9 +5414,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(); @@ -5428,7 +5428,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; @@ -5479,7 +5479,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; @@ -5488,9 +5488,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(); @@ -5503,7 +5503,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; @@ -5529,8 +5529,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) { @@ -5542,7 +5542,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); } } } @@ -5595,7 +5595,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; @@ -5604,9 +5604,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(); @@ -5626,7 +5626,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); @@ -5660,8 +5660,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); @@ -5697,7 +5697,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 +#include +#include + +#include + +#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 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, ¤tms); + return currentms + mp3->nTrackStreamPos; + } + else + return 0; + } + else + { + AIL_stream_ms_position(mp3Stream[nStream], NULL, ¤tms); + 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 892a06b6..38682e22 100644 --- a/src/core/config.h +++ b/src/core/config.h @@ -91,6 +91,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 @@ -112,6 +113,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 0000000000000000000000000000000000000000..2017c8116bb76bf612babe81eb013c2c0250dbc2 GIT binary patch literal 2238 zcmb7_F=!)46o!A3fEKP$AP^PT7@U*V-j%ezD-^gQ0o%xMg^LZixI)DhA}HX(g$jqr zphATT1zc>Q!Uh!zIfM$C7~+6TRLCHRw73w73@Qv!p~8l>w1tbwzpJ&debR-@=-Zi{ ze`nsC_hwhX0_)-;-14&oe8HYf7Rfhc0UTu6|I}?JmxTv?>{I0Z{{E!lm0g^jow0QU z;r<|m(<7|T5HAhhw@Hr-h(+9I0s)9<6hhY_Qb~wR1|pw_Fbs%N38GqsI6Z}EHX+)i z*Mk@gAS?^w&W57sh{Y0ETT5YUD~;{#4BoxVV`s-eCR0W}UxQ)PQ7*SptMyQ?572C0 zqusWlD+&^^7*cC%NN;T+`}Qpg$s~%qyC~C-8vUr#j~4yt(vK_pF>Ew&cX5HJ9>wd# zYs6D==xH5^Yyzo53h81R*>Vp+5#?4HwQdddt2$cOEp+d?$k8{0zLg6ns1+M% zyuU#Eq>o->h`h0bgVG)jt2w+sJ-|ux5UpMf-9a5!RtwK|itz81@OiF^0OvpF`~dg% zoO@g1-jtSwSeJ3P$dL5O1!tf?hxqr0mg`d1{gEcs$c?uq5&8MFfl+n4I~mkJPy2i#WP|P z=2bAif_WCqx!@TP8KUF*8o0Uwx?P~v0`tgaYXDON;{eEKfxSH-nF5$b#NPl*OLR$C z^p*P)+@EOE-&2%C2|1BNQX~-*F+3CAfu!r84Tge72yK8i7!Kf&&<=7WL+CzsNRlLo zPPi4s2<_U8|B&(T_ZcU~ztIq=RvD|J;F%QMzCbc5pzDHXS0EY{2n2+;$TnMN;a%bw z%M*i?2xAGxl-YXvM*V2HYRe{geigUicH zoS&cL`1lw{M@Rqp{z7_O0L2~P7sPAn&chOPzAQj!*$ImGVR3q1Ss(k{o}wvEJNfW< zn$s*tO!rPUU5S^9|6#cen_8Fy;g0I(gCFRAD`ILRzhCV{X6yd3)`?nv)r^j2&i8Ak z`O+RmO>KOyzi=IRVNLuPYpb1zt(lrV(II*Md99+EFIR({AM$kX0qMTg%#MoSs#ck! zM@*HwR-*HC*^QjNGL7EE@O1qRH}dh7ijzCqxVL-XR^(tPWI$b~fmu2XwbL;plCzAX zSDviDKH5}GQ`)pA^F7(`m)rnZD{-I1vmr~<_<8a1!e@_d`}VdtvYmtQVg7u+TS*#+ zM?Pt`J{pgu6)mDkl9yjRTHbF-KFLtbNYHn$)6Byng{2BqIp~hL`+umS5?0~{WMiI= z=yC;NRo!?rYkIR0T$b#Rrm3On(4)@A#tKv;sK|44N%mnJGz>$2G;Mk#Id+2~S^k)= vQs)_(SzNzWWqGE^!6*CLpZDCH@iX8P@_)+0