1 files changed, 2331 insertions, 0 deletions

diff --git a/src/audio/sampman.cpp b/src/audio/sampman.cpp
new file mode 100644
index 00000000..c758fc9f
--- /dev/null
+++ b/src/audio/sampman.cpp
@@ -0,0 +1,2331 @@
+#include <windows.h>
+#include <shobjidl.h>
+#include <shlguid.h>
+
+#include <time.h>
+
+#include "eax.h"
+#include "eax-util.h"
+#include "mss.h"
+
+#include "sampman.h"
+#include "AudioManager.h"
+#include "MusicManager.h"
+#include "Frontend.h"
+#include "Timer.h"
+#include "patcher.h"
+
+#pragma comment( lib, "mss32.lib" )
+
+cSampleManager &SampleManager = *(cSampleManager *)0x7341E0;
+int32 (&BankStartOffset)[2] = *(int32 (*)[2])*(int *)0x6FAB70;
+
+///////////////////////////////////////////////////////////////
+
+char SampleBankDescFilename[] = "AUDIO\\SFX.SDT";
+char SampleBankDataFilename[] = "AUDIO\\SFX.RAW";
+
+FILE *fpSampleDescHandle;
+FILE *fpSampleDataHandle;
+bool  bSampleBankLoaded            [MAX_SAMPLEBANKS];
+int32 nSampleBankDiscStartOffset   [MAX_SAMPLEBANKS];
+int32 nSampleBankSize              [MAX_SAMPLEBANKS];
+int32 nSampleBankMemoryStartAddress[MAX_SAMPLEBANKS];
+int32 _nSampleDataEndOffset;
+
+int32 nPedSlotSfx    [MAX_PEDSFX];
+int32 nPedSlotSfxAddr[MAX_PEDSFX];
+int32 nCurrentPedSlot;
+
+uint8 nChannelVolume[MAXCHANNELS+MAX2DCHANNELS];
+
+uint32 nStreamLength[TOTAL_STREAMED_SOUNDS];
+
+///////////////////////////////////////////////////////////////
+struct tMP3Entry
+{
+	char aFilename[MAX_PATH];
+	
+	uint32 nTrackLength;
+	uint32 nTrackStreamPos;
+	
+	tMP3Entry *pNext;
+	char *pLinkPath;
+};
+
+uint32 nNumMP3s;
+tMP3Entry *_pMP3List;
+char _mp3DirectoryPath[MAX_PATH];
+HSTREAM mp3Stream [MAX_MP3STREAMS];
+int8 nStreamPan   [MAX_MP3STREAMS];
+int8 nStreamVolume[MAX_MP3STREAMS];
+uint32 _CurMP3Index;
+int32 _CurMP3Pos;
+bool _bIsMp3Active;
+
+#if defined(GTA3_1_1_PATCH) || defined(GTA3_STEAM_PATCH) || defined(NO_CDCHECK)
+bool _bUseHDDAudio;
+char _aHDDPath[MAX_PATH];
+#endif
+///////////////////////////////////////////////////////////////
+
+
+bool _bSampmanInitialised = false;
+
+//
+// Miscellaneous globals / defines
+
+//	Env		Size	Diffus	Room	RoomHF	RoomLF	DecTm	DcHF	DcLF	Refl	RefDel	Ref Pan				Revb	RevDel		Rev Pan				EchTm	EchDp	ModTm	ModDp	AirAbs	HFRef		LFRef	RRlOff	FLAGS
+
+EAXLISTENERPROPERTIES StartEAX3 =
+	{26,	1.7f,	0.8f,	-1000,	-1000,	-100,	4.42f,	0.14f,	1.00f,	429,	0.014f,	0.00f,0.00f,0.00f,	1023,	0.021f,		0.00f,0.00f,0.00f,	0.250f,	0.000f,	0.250f,	0.000f,	-5.0f,	2727.1f,	250.0f,	0.00f,	0x3f };
+
+EAXLISTENERPROPERTIES FinishEAX3 =
+	{26,	100.0f,	1.0f,	0,		-1000,	-2200,	20.0f,	1.39f,	1.00f,	1000,	0.069f,	0.00f,0.00f,0.00f,	400,	0.100f,		0.00f,0.00f,0.00f,	0.250f,	1.000f,	3.982f,	0.000f,	-18.0f,	3530.8f,	417.9f,	6.70f,	0x3f };
+
+EAXLISTENERPROPERTIES EAX3Params;
+
+S32         prevprovider=-1;
+S32         curprovider=-1;
+S32         usingEAX=0;
+S32         usingEAX3=0;
+HPROVIDER   opened_provider=0;
+H3DSAMPLE   opened_samples[MAXCHANNELS] = {0};
+HSAMPLE     opened_2dsamples[MAX2DCHANNELS] = {0};
+HDIGDRIVER  DIG;
+S32         speaker_type=0;
+
+U32 _maxSamples;
+float _fPrevEaxRatioDestination;
+bool _usingMilesFast2D;
+float _fEffectsLevel;
+
+
+struct
+{
+	HPROVIDER id;
+	char name[80];
+}providers[MAXPROVIDERS];
+
+typedef struct provider_stuff
+{
+  char* name;
+  HPROVIDER id;
+} provider_stuff;
+
+
+static int __cdecl comp(const provider_stuff*s1,const provider_stuff*s2)
+{
+  return( _stricmp(s1->name,s2->name) );
+}
+
+static void
+add_providers()
+{
+	provider_stuff pi[MAXPROVIDERS];
+	U32   n,i,j;
+	
+	SampleManager.SetNum3DProvidersAvailable(0);
+	
+	HPROENUM next = HPROENUM_FIRST;
+	
+	n=0;
+	while (AIL_enumerate_3D_providers(&next, &pi[n].id, &pi[n].name) && (n<MAXPROVIDERS))
+	{
+		++n;
+	}
+	
+	qsort(pi,n,sizeof(pi[0]), (int(__cdecl*)(void const*, void const*))comp);
+	
+	for(i=0;i<n;i++)
+	{
+		providers[i].id=pi[i].id;
+		strcpy(providers[i].name, pi[i].name);
+		SampleManager.Set3DProviderName(i, providers[i].name);
+	}
+	
+	SampleManager.SetNum3DProvidersAvailable(n);
+	
+	for(j=n;j<MAXPROVIDERS;j++)
+		SampleManager.Set3DProviderName(j, NULL);
+}
+
+static void
+release_existing()
+{
+	for ( U32 i = 0; i < _maxSamples; i++ )
+	{
+		if ( opened_samples[i] )
+		{
+			AIL_release_3D_sample_handle(opened_samples[i]);
+			opened_samples[i] = NULL;
+		}
+	}
+
+	if ( opened_provider )
+	{
+		AIL_close_3D_provider(opened_provider);
+		opened_provider = NULL;
+	}
+
+	_fPrevEaxRatioDestination = 0.0f;
+	_usingMilesFast2D = false;
+	_fEffectsLevel = 0.0f;
+}
+
+static bool
+set_new_provider(S32 index)
+{
+	DWORD result;
+	
+	if ( curprovider == index )
+		return true;
+
+	//close the already opened provider
+	curprovider = index;
+	
+	release_existing();
+	
+	if ( curprovider != -1 )
+	{
+		if ( !strcmp(providers[index].name, "Dolby Surround") )
+			_maxSamples = MAXCHANNELS_SURROUND;
+		else
+			_maxSamples = MAXCHANNELS;
+		
+		AIL_set_3D_provider_preference(providers[index].id, "Maximum supported samples", &_maxSamples);
+		
+		//load the new provider
+		result = AIL_open_3D_provider(providers[index].id);
+		
+		if (result != M3D_NOERR) 
+		{
+			curprovider=-1;
+			
+			OutputDebugStringA(AIL_last_error());
+			
+			release_existing();
+			
+			return false;
+		}
+		else
+		{
+			opened_provider=providers[index].id;
+			
+			//see if we're running under an EAX compatible provider
+			
+			if ( !strcmp(providers[index].name, "Creative Labs EAX 3 (TM)") )
+			{
+				usingEAX = 1;
+				usingEAX3 = 1;
+			}
+			else
+			{
+				usingEAX3 = 0;
+
+				result=AIL_3D_room_type(opened_provider);
+				usingEAX=(((S32)result)!=-1)?1:0; // will be something other than -1 on EAX				
+			}
+			
+			if ( usingEAX3 )
+			{
+				OutputDebugString("DOING SPECIAL EAX 3 STUFF!");
+				AIL_set_3D_provider_preference(opened_provider, "EAX all parameters", &FinishEAX3);
+			}
+			else if ( usingEAX )
+			{
+				AIL_set_3D_room_type(opened_provider, ENVIRONMENT_CAVE);
+				
+				if ( !strcmp(providers[index].name, "Miles Fast 2D Positional Audio") )
+					_usingMilesFast2D = true;
+			}
+			
+			AIL_3D_provider_attribute(opened_provider, "Maximum supported samples", &_maxSamples);
+			
+			if ( _maxSamples > MAXCHANNELS )
+				_maxSamples = MAXCHANNELS;
+			
+			SampleManager.SetSpeakerConfig(speaker_type);
+			
+			//obtain a 3D sample handles
+			for ( U32 i = 0; i < _maxSamples; ++i )
+			{
+				opened_samples[i] = AIL_allocate_3D_sample_handle(opened_provider);
+				if ( opened_samples[i] != NULL )
+					AIL_set_3D_sample_effects_level(opened_samples[i], 0.0f);
+			}
+			
+			return true;
+		}	
+	}
+	
+	return false;
+}
+
+void
+cSampleManager::SetSpeakerConfig(int32 which)
+{
+	switch ( which )
+	{
+		case 1:
+			speaker_type=AIL_3D_2_SPEAKER;
+			break;
+		
+		case 2:
+			speaker_type=AIL_3D_HEADPHONE;
+			break;
+		
+		case 3:
+			speaker_type=AIL_3D_4_SPEAKER;
+			break;
+			
+		default:
+			return;
+			break;
+	}
+	
+	if (opened_provider)
+		AIL_set_3D_speaker_type(opened_provider, speaker_type);
+}
+
+uint32
+cSampleManager::GetMaximumSupportedChannels(void) //[Y]
+{
+	if ( _maxSamples > MAXCHANNELS )
+		return MAXCHANNELS;
+	
+	return _maxSamples;
+}
+
+int8
+cSampleManager::GetCurrent3DProviderIndex(void)
+{
+	return curprovider;
+}
+
+int8
+cSampleManager::SetCurrent3DProvider(uint8 nProvider)
+{
+	S32 savedprovider = curprovider;
+	
+	if ( nProvider < m_nNumberOfProviders )
+	{
+		if ( set_new_provider(nProvider) )
+			return curprovider;
+		else if ( savedprovider != -1 && savedprovider < m_nNumberOfProviders && set_new_provider(savedprovider) )
+			return curprovider;
+		else
+			return -1;
+	}
+	else
+		return curprovider;
+}
+
+static bool
+_ResolveLink(char const *path, char *out)
+{
+	IShellLink* psl;
+	WIN32_FIND_DATA fd;
+	char filepath[MAX_PATH];
+	
+	CoInitialize(NULL);
+									   
+	if (SUCCEEDED( CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_IShellLink, (LPVOID*)&psl ) ))
+	{
+		IPersistFile *ppf;
+
+		if (SUCCEEDED(psl->QueryInterface(IID_IPersistFile, (LPVOID*)&ppf)))
+		{
+			WCHAR wpath[MAX_PATH];
+			
+			MultiByteToWideChar(CP_ACP, 0, path, -1, wpath, MAX_PATH);
+			
+			if (SUCCEEDED(ppf->Load(wpath, STGM_READ)))
+			{
+				/* Resolve the link */
+				if (SUCCEEDED(psl->Resolve(NULL, SLR_ANY_MATCH|SLR_NO_UI|SLR_NOSEARCH)))
+				{
+					strcpy(filepath, path);
+					
+					if (SUCCEEDED(psl->GetPath(filepath, MAX_PATH, &fd, SLGP_UNCPRIORITY)))
+					{
+						OutputDebugString(fd.cFileName);
+						
+						strcpy(out, filepath);
+						
+						return true;
+					}
+				}
+			}
+			
+			ppf->Release();
+		}
+		psl->Release();
+	}
+	
+	return false;
+}
+
+static void
+_FindMP3s(void)
+{
+	tMP3Entry *pList;
+	bool bShortcut;	
+	bool bInitFirstEntry;	
+	HANDLE hFind;
+	char path[MAX_PATH];
+	char filepath[MAX_PATH*2];
+	S32 total_ms;
+	WIN32_FIND_DATA fd;
+	
+	
+	if ( GetCurrentDirectory(MAX_PATH, _mp3DirectoryPath) == 0 )
+	{
+		GetLastError();
+		return;
+	}
+	
+	OutputDebugString("Finding MP3s...");
+	strcpy(path, _mp3DirectoryPath);
+	strcat(path, "\\MP3\\");
+	
+	strcpy(_mp3DirectoryPath, path);
+	OutputDebugString(_mp3DirectoryPath);
+	
+	strcat(path, "*");
+	
+	hFind = FindFirstFile(path, &fd);
+	
+	if ( hFind == INVALID_HANDLE_VALUE ) 
+	{
+		GetLastError();
+		return;
+	}
+	
+	strcpy(filepath, _mp3DirectoryPath);
+	strcat(filepath, fd.cFileName);
+	
+	int32 filepathlen = strlen(filepath);
+	
+	if ( filepathlen <= 0)
+	{
+		FindClose(hFind);
+		return;
+	}
+	
+	FILE *f = fopen("MP3\\MP3Report.txt", "w");
+	
+	if ( f )
+	{
+		fprintf(f, "MP3 Report File\n\n");
+		fprintf(f, "\"%s\"", fd.cFileName);
+	}
+	
+
+	if ( filepathlen > 4 )
+	{
+		if ( !strcmp(&filepath[filepathlen - 4], ".lnk") )
+		{
+			if ( _ResolveLink(filepath, filepath) )
+			{
+				OutputDebugString("Resolving Link");
+				OutputDebugString(filepath);
+				
+				if ( f )
+					fprintf(f, " - shortcut to \"%s\"", filepath);
+			}
+			else
+			{
+				if ( f )
+					fprintf(f, " - couldn't resolve shortcut");
+			}
+			
+			bShortcut = true;
+		}
+		else
+		{
+			bShortcut = false;
+		}
+	}
+	
+	mp3Stream[0] = AIL_open_stream(DIG, filepath, 0);
+	if ( mp3Stream[0] )
+	{
+		AIL_stream_ms_position(mp3Stream[0], &total_ms, NULL);
+		
+		AIL_close_stream(mp3Stream[0]);
+		mp3Stream[0] = NULL;
+		
+		OutputDebugString(fd.cFileName);
+		
+		_pMP3List = new tMP3Entry;
+		
+		if ( _pMP3List == NULL )
+		{
+			FindClose(hFind);
+			
+			if ( f )
+				fclose(f);
+			
+			return;
+		}
+		
+		nNumMP3s = 1;
+		
+		strcpy(_pMP3List->aFilename, fd.cFileName);
+		
+		_pMP3List->nTrackLength = total_ms;
+		
+		_pMP3List->pNext = NULL;
+		
+		pList = _pMP3List;
+		
+		if ( bShortcut )
+		{
+			_pMP3List->pLinkPath = new char[MAX_PATH*2];
+			strcpy(_pMP3List->pLinkPath, filepath);
+		}
+		else
+		{
+			_pMP3List->pLinkPath = NULL;
+		}
+		
+		if ( f )
+			fprintf(f, " - OK\n");
+		
+		bInitFirstEntry = false;
+	}
+	else
+	{
+		strcat(filepath, " - NOT A VALID MP3");
+		
+		OutputDebugString(filepath);
+
+		if ( f )
+			fprintf(f, " - not an MP3 or supported MP3 type\n");
+		
+		bInitFirstEntry = true;
+	}
+	
+	while ( true )
+	{
+		if ( !FindNextFile(hFind, &fd) )
+		{
+			if ( f )
+			{
+				fprintf(f, "\nTOTAL SUPPORTED MP3s: %d\n", nNumMP3s);
+				fclose(f);
+			}
+			
+            FindClose(hFind);
+            
+			return;
+		}
+		
+		if ( bInitFirstEntry )
+		{
+			strcpy(filepath, _mp3DirectoryPath);
+			strcat(filepath, fd.cFileName);
+			
+			int32 filepathlen = strlen(filepath);
+			
+			if ( f )
+				fprintf(f, "\"%s\"", fd.cFileName);
+			
+			if ( filepathlen > 0 )
+			{
+				if ( filepathlen > 4 )
+				{
+					if ( !strcmp(&filepath[filepathlen - 4], ".lnk") )
+					{
+						if ( _ResolveLink(filepath, filepath) )
+						{
+							OutputDebugString("Resolving Link");
+							OutputDebugString(filepath);
+							
+							if ( f )
+								fprintf(f, " - shortcut to \"%s\"", filepath);
+						}
+						else
+						{
+							if ( f )
+								fprintf(f, " - couldn't resolve shortcut");
+						}
+						
+						bShortcut = true;
+					}
+					else
+					{
+						bShortcut = false;
+						
+						if ( filepathlen > MAX_PATH )
+						{
+							if ( f )
+								fprintf(f, " - Filename and path too long - %s - IGNORED)\n", filepath);
+							
+							continue;
+						}
+					}
+				}
+				
+				mp3Stream[0] = AIL_open_stream(DIG, filepath, 0);
+				if ( mp3Stream[0] )
+				{
+					AIL_stream_ms_position(mp3Stream[0], &total_ms, NULL);
+					
+					AIL_close_stream(mp3Stream[0]);
+					mp3Stream[0] = NULL;
+					
+					OutputDebugString(fd.cFileName);
+					
+					_pMP3List = new tMP3Entry;
+					
+					if ( _pMP3List  == NULL)
+					{
+						if ( f )
+						{
+							fprintf(f, "\nTOTAL SUPPORTED MP3s: %d\n", nNumMP3s);
+							fclose(f);
+						}
+						FindClose(hFind);
+						return;
+					}
+					
+					nNumMP3s = 1;
+					
+					strcpy(_pMP3List->aFilename, fd.cFileName);
+					
+					_pMP3List->nTrackLength = total_ms;
+					_pMP3List->pNext = NULL;
+					
+					if ( bShortcut )
+					{
+						_pMP3List->pLinkPath = new char [MAX_PATH*2];
+						strcpy(_pMP3List->pLinkPath, filepath);
+					}
+					else
+					{
+						_pMP3List->pLinkPath = NULL;
+					}
+					
+					pList = _pMP3List;
+					
+					if ( f )
+						fprintf(f, " - OK\n");
+					
+					bInitFirstEntry = false;
+				}
+				else
+				{
+					strcat(filepath, " - NOT A VALID MP3");
+					OutputDebugString(filepath);
+					
+					if ( f )
+						fprintf(f, " - not an MP3 or supported MP3 type\n");
+				}
+			}
+		}
+		else
+		{
+			strcpy(filepath, _mp3DirectoryPath);
+			strcat(filepath, fd.cFileName);
+			
+			int32 filepathlen = strlen(filepath);
+			
+			if ( filepathlen > 0 )
+			{
+				if ( f )
+					fprintf(f, "\"%s\"", fd.cFileName);
+			
+				if ( filepathlen > 4 )
+				{
+					if ( !strcmp(&filepath[filepathlen - 4], ".lnk") )
+					{
+						if ( _ResolveLink(filepath, filepath) )
+						{
+							OutputDebugString("Resolving Link");
+							OutputDebugString(filepath);
+							
+							if ( f )
+								fprintf(f, " - shortcut to \"%s\"", filepath);
+						}
+						else
+						{
+							if ( f )
+								fprintf(f, " - couldn't resolve shortcut");
+						}
+						
+						bShortcut = true;
+					}
+					else
+					{
+						bShortcut = false;
+					}
+				}
+				
+				mp3Stream[0] = AIL_open_stream(DIG, filepath, 0);
+				if ( mp3Stream[0] )
+				{
+					AIL_stream_ms_position(mp3Stream[0], &total_ms, NULL);
+					
+					AIL_close_stream(mp3Stream[0]);
+					mp3Stream[0] = NULL;
+					
+					pList->pNext = new tMP3Entry;
+					
+					tMP3Entry *e = pList->pNext;
+					
+					if ( e == NULL)
+					{
+						if ( f )
+						{
+							fprintf(f, "\nTOTAL SUPPORTED MP3s: %d\n", nNumMP3s);
+							fclose(f);
+						}
+						FindClose(hFind);
+						return;
+					}
+					
+					pList = pList->pNext;
+					
+					strcpy(e->aFilename, fd.cFileName);
+					e->nTrackLength = total_ms;
+					e->pNext = NULL;
+					
+					if ( bShortcut )
+					{
+						e->pLinkPath = new char [MAX_PATH*2];
+						strcpy(e->pLinkPath, filepath);
+					}
+					else
+					{
+						e->pLinkPath = NULL;
+					}
+					
+					nNumMP3s++;
+					
+					OutputDebugString(fd.cFileName);
+					
+					if ( f )
+						fprintf(f, " - OK\n");
+				}
+				else
+				{
+					strcat(filepath, " - NOT A VALID MP3");
+					OutputDebugString(filepath);
+					
+					if ( f )
+						fprintf(f, " - not an MP3 or supported MP3 type\n");
+				}
+			}
+		}
+	}
+}
+
+static void
+_DeleteMP3Entries(void)
+{
+	tMP3Entry *e = _pMP3List;
+
+	while ( e != NULL )
+	{
+		tMP3Entry *next = e->pNext;
+		
+		if ( next == NULL )
+			next = NULL;
+		
+		if ( e->pLinkPath != NULL )
+		{
+#ifndef FIX_BUGS
+			delete   e->pLinkPath; // BUG: should be delete []
+#else
+			delete[] e->pLinkPath;
+#endif
+			e->pLinkPath = NULL;
+		}
+		
+		delete e;
+		
+		if ( next )
+			e = next;
+		else
+			e = NULL;
+		
+		nNumMP3s--;
+	}
+	
+	
+	if ( nNumMP3s != 0 )
+	{
+		OutputDebugString("Not all MP3 entries were deleted");
+		nNumMP3s = 0;
+	}
+	
+	_pMP3List = NULL;
+}
+
+static tMP3Entry *
+_GetMP3EntryByIndex(uint32 idx)
+{
+	uint32 n = ( idx < nNumMP3s ) ? idx : 0;
+	
+	if ( _pMP3List != NULL )
+	{
+		tMP3Entry *e = _pMP3List;
+		
+		for ( uint32 i = 0; i < n; i++ )
+			e = e->pNext;
+		
+		return e;
+			
+	}
+	
+	return NULL;
+}
+
+static inline bool
+_GetMP3PosFromStreamPos(uint32 *pPosition, tMP3Entry **pEntry)
+{
+	_CurMP3Index = 0;
+	
+	for ( *pEntry = _pMP3List; *pEntry != NULL; *pEntry = (*pEntry)->pNext )
+	{
+		if (   *pPosition >= (*pEntry)->nTrackStreamPos
+			&& *pPosition <  (*pEntry)->nTrackLength + (*pEntry)->nTrackStreamPos )
+		{
+			*pPosition -= (*pEntry)->nTrackStreamPos;
+			_CurMP3Pos = *pPosition;
+			
+			return true;
+		}
+		
+		_CurMP3Index++;
+	}
+				
+	*pPosition = 0;
+	*pEntry = _pMP3List;
+	_CurMP3Pos = 0;
+	_CurMP3Index = 0;
+	
+	return false;
+}
+
+bool
+cSampleManager::IsMP3RadioChannelAvailable(void)
+{
+	return nNumMP3s != 0;
+}
+
+void
+cSampleManager::ReleaseDigitalHandle(void)
+{
+	if ( DIG )
+	{
+		prevprovider = curprovider;
+		release_existing();
+		curprovider = -1;
+		AIL_digital_handle_release(DIG);
+	}
+}
+
+void
+cSampleManager::ReacquireDigitalHandle(void)
+{
+	if ( DIG )
+	{
+		AIL_digital_handle_reacquire(DIG);
+		if ( prevprovider != -1 )
+			set_new_provider(prevprovider);
+	}
+}
+
+bool
+cSampleManager::Initialise(void)
+{
+	TRACE("start");
+	
+	if ( _bSampmanInitialised )
+		return true;
+
+	{
+		for ( int32 i = 0; i < TOTAL_AUDIO_SAMPLES; i++ )
+		{
+			m_aSamples[i].nOffset    = 0;
+			m_aSamples[i].nSize      = 0;
+			m_aSamples[i].nFrequency = 22050;
+			m_aSamples[i].nLoopStart = 0;
+			m_aSamples[i].nLoopEnd   = -1;
+		}
+		
+		m_nEffectsVolume     = 127;
+		m_nMusicVolume       = 127;
+		m_nEffectsFadeVolume = 127;
+		m_nMusicFadeVolume   = 127;
+		
+		m_nMonoMode = 0;
+	}
+	
+	// miles 
+	TRACE("MILES");
+	{
+		curprovider = -1;
+		prevprovider = -1;
+		
+		_usingMilesFast2D = false;
+		usingEAX=0;
+		usingEAX3=0;
+		
+		_fEffectsLevel = 0.0f;
+		
+		_maxSamples = 0;
+	
+		opened_provider = NULL;
+		DIG = NULL;
+		
+		for ( int32 i = 0; i < MAXCHANNELS; i++ )
+			opened_samples[i] = NULL;
+	}
+	
+	// banks
+	TRACE("banks");
+	{
+		fpSampleDescHandle = NULL;
+		fpSampleDataHandle = NULL;
+		
+		_nSampleDataEndOffset = 0;
+		
+		for ( int32 i = 0; i < MAX_SAMPLEBANKS; i++ )
+		{
+			bSampleBankLoaded[i]             = false;
+			nSampleBankDiscStartOffset[i]    = 0;
+			nSampleBankSize[i]               = 0;
+			nSampleBankMemoryStartAddress[i] = 0;
+		}
+	}
+	
+	// pedsfx
+	TRACE("pedsfx");
+	{
+		for ( int32 i = 0; i < MAX_PEDSFX; i++ )
+		{
+			nPedSlotSfx[i]     = NO_SAMPLE;
+			nPedSlotSfxAddr[i] = 0;
+		}
+		
+		nCurrentPedSlot = 0;
+	}
+	
+	// channel volume
+	TRACE("vol");
+	{
+		for ( int32 i = 0; i < MAXCHANNELS+MAX2DCHANNELS; i++ )
+			nChannelVolume[i] = 0;
+	}
+	
+	TRACE("mss");
+	{
+		AIL_set_redist_directory( "mss" );
+		
+		AIL_startup();
+		
+		AIL_set_preference(DIG_MIXER_CHANNELS, MAX_DIGITAL_MIXER_CHANNELS);
+		
+		DIG = AIL_open_digital_driver(DIGITALRATE, DIGITALBITS, DIGITALCHANNELS, 0);
+		if ( DIG == NULL )
+		{
+			OutputDebugString(AIL_last_error());
+			Terminate();
+			return false;
+		}
+		
+		add_providers();
+		
+		if ( !InitialiseSampleBanks() )
+		{
+			Terminate();
+			return false;
+		}
+		
+		nSampleBankMemoryStartAddress[0] = (int32)AIL_mem_alloc_lock(nSampleBankSize[0]);
+		if ( !nSampleBankMemoryStartAddress[0] )
+		{
+			Terminate();
+			return false;
+		}
+
+		nSampleBankMemoryStartAddress[1] = (int32)AIL_mem_alloc_lock(PED_BLOCKSIZE*MAX_PEDSFX);
+		
+	}
+	
+	TRACE("cdrom");
+	
+	S32 tatalms;
+	char filepath[MAX_PATH];
+
+	{
+		m_bInitialised = false;
+		
+		while (true)
+		{
+			int32 drive = 'C';
+			
+			do
+			{
+				char latter[2];
+				
+				latter[0] = drive;
+				latter[1] = '\0';
+				
+				strcpy(m_szCDRomRootPath, latter);
+				strcat(m_szCDRomRootPath, ":\\");
+				
+				if ( GetDriveType(m_szCDRomRootPath) == DRIVE_CDROM )
+				{
+					strcpy(filepath, m_szCDRomRootPath);
+					strcat(filepath, StreamedNameTable[0]);
+					
+					FILE *f = fopen(filepath, "rb");
+					
+					if ( f )
+					{
+						fclose(f);
+						
+						bool bFileNotFound = false;
+
+						for ( int32 i = 0; i < TOTAL_STREAMED_SOUNDS; i++ )
+						{
+							strcpy(filepath, m_szCDRomRootPath);
+							strcat(filepath, StreamedNameTable[i]);
+							
+							mp3Stream[0] = AIL_open_stream(DIG, filepath, 0);
+							
+							if ( mp3Stream[0] )
+							{
+								AIL_stream_ms_position(mp3Stream[0], &tatalms, NULL);
+								
+								AIL_close_stream(mp3Stream[0]);
+								mp3Stream[0] = NULL;
+								
+								nStreamLength[i] = tatalms;
+							}
+							else
+							{
+								bFileNotFound = true;
+								break;
+							}
+						}
+						
+						if ( !bFileNotFound )
+						{
+							m_bInitialised = true;
+							break;
+						}
+						else
+						{
+							m_bInitialised = false;
+							continue;
+						}
+					}
+				}
+				
+			} while ( ++drive <= 'Z' );
+					
+			if ( !m_bInitialised )
+			{
+#if !defined(GTA3_STEAM_PATCH) && !defined(NO_CDCHECK)
+				FrontEndMenuManager.WaitForUserCD();
+				if ( FrontEndMenuManager.m_bQuitGameNoCD )
+				{
+					Terminate();
+					return false;
+				}
+				continue;
+#else
+				m_bInitialised = true;
+#endif
+			}
+			
+			break;
+		}
+	}
+
+#if defined(GTA3_1_1_PATCH) || defined(GTA3_STEAM_PATCH) || defined(NO_CDCHECK)
+	// hddaudio
+	/**
+		Option for user to play audio files directly from hard disk.
+		Copy the contents of the PLAY discs Audio directory into your installed Grand Theft Auto III Audio directory.
+		Grand Theft Auto III still requires the presence of the PLAY disc when started.
+		This may give better performance on some machines (though worse on others).
+	**/
+	TRACE("hddaudio 1.1 patch");
+	{
+		int32 streamLength[TOTAL_STREAMED_SOUNDS];
+		
+		bool bFileNotFound = false;
+		char rootpath[MAX_PATH];
+		
+		strcpy(_aHDDPath, m_szCDRomRootPath);
+		rootpath[0] = '\0';
+		
+		FILE *f = fopen(StreamedNameTable[0], "rb");
+		
+		if ( f )
+		{
+			fclose(f);
+			
+			for ( int32 i = 0; i < TOTAL_STREAMED_SOUNDS; i++ )
+			{
+				strcpy(filepath, rootpath);
+				strcat(filepath, StreamedNameTable[i]);
+				
+				mp3Stream[0] = AIL_open_stream(DIG, filepath, 0);
+				
+				if ( mp3Stream[0] )
+				{
+					AIL_stream_ms_position(mp3Stream[0], &tatalms, NULL);
+					
+					AIL_close_stream(mp3Stream[0]);
+					mp3Stream[0] = NULL;
+					
+					streamLength[i] = tatalms;
+				}
+				else
+				{
+					bFileNotFound = true;
+					break;
+				}
+			}
+								
+		}
+		else
+			bFileNotFound = true;
+		
+		if ( !bFileNotFound )
+		{
+			strcpy(m_szCDRomRootPath, rootpath);
+			
+			for ( int32 i = 0; i < TOTAL_STREAMED_SOUNDS; i++ )
+				nStreamLength[i] = streamLength[i];
+			
+			_bUseHDDAudio = true;
+		}
+		else
+			_bUseHDDAudio = false;
+	}
+#endif
+	
+	TRACE("stream");
+	{
+		for ( int32 i = 0; i < MAX_MP3STREAMS; i++ )
+		{
+			mp3Stream    [i] = NULL;
+			nStreamPan   [i] = 63;
+			nStreamVolume[i] = 100;
+		}
+	}
+	
+	for ( int32 i = 0; i < MAX2DCHANNELS; i++ )
+	{
+		opened_2dsamples[i] = AIL_allocate_sample_handle(DIG);
+		if ( opened_2dsamples[i] )
+		{
+			AIL_init_sample(opened_2dsamples[i]);
+			AIL_set_sample_type(opened_2dsamples[i], DIG_F_MONO_16, DIG_PCM_SIGN);
+		}
+	}
+	
+	TRACE("providerset");
+	{
+		_bSampmanInitialised = true;
+		
+		U32 n = 0;
+		
+		while ( n < m_nNumberOfProviders )
+		{
+			if ( !strcmp(providers[n].name, "Miles Fast 2D Positional Audio") )
+			{
+				set_new_provider(n);
+				break;
+			}
+			n++;
+		}
+		
+		if ( n == m_nNumberOfProviders )
+		{
+			Terminate();
+			return false;
+		}
+	}
+	
+	TRACE("bank");
+	
+	LoadSampleBank(0);
+	
+	// mp3
+	TRACE("mp3");
+	{
+		nNumMP3s = 0;
+		
+		_pMP3List = NULL;
+		
+		_FindMP3s();
+		
+		if ( nNumMP3s != 0 )
+		{
+			nStreamLength[STREAMED_SOUND_RADIO_MP3_PLAYER] = 0;
+			
+			for ( tMP3Entry *e = _pMP3List; e != NULL; e = e->pNext )
+			{
+				e->nTrackStreamPos = nStreamLength[STREAMED_SOUND_RADIO_MP3_PLAYER];
+				nStreamLength[STREAMED_SOUND_RADIO_MP3_PLAYER] += e->nTrackLength;
+			}
+			
+			time_t t = time(NULL);
+			tm *localtm;
+			bool bUseRandomTable;
+			
+			if ( t == -1 )
+				bUseRandomTable = true;
+			else
+			{
+				bUseRandomTable = 0;
+				localtm = localtime(&t);
+			}
+			
+			int32 randval;
+			if ( bUseRandomTable )
+				randval = AudioManager.GetRandomTabe(1);
+			else
+				randval = localtm->tm_sec * localtm->tm_min;
+			
+			_CurMP3Index = randval % nNumMP3s;
+			
+			tMP3Entry *randmp3 = _pMP3List;
+			for ( int32 i = randval % nNumMP3s; i > 0; --i)
+				randmp3 = randmp3->pNext;
+			
+			if ( bUseRandomTable )
+				_CurMP3Pos = AudioManager.GetRandomTabe(0)     % randmp3->nTrackLength;
+			else
+			{
+				if ( localtm->tm_sec > 0 )
+				{
+					int32 s = localtm->tm_sec;
+					_CurMP3Pos = s*s*s*s*s*s*s*s                % randmp3->nTrackLength;
+				}
+				else
+					_CurMP3Pos = AudioManager.GetRandomTabe(0) % randmp3->nTrackLength;
+			}
+		}
+		else
+			_CurMP3Pos = 0;
+		
+		_bIsMp3Active = false;
+	}
+	
+	TRACE("end");
+	
+	return true;
+}
+
+void
+cSampleManager::Terminate(void)
+{
+	for ( int32 i = 0; i < MAX_MP3STREAMS; i++ )
+	{
+		if ( mp3Stream[i] )
+		{
+			AIL_pause_stream(mp3Stream[i], 1);
+			AIL_close_stream(mp3Stream[i]);
+			mp3Stream[i] = NULL;
+		}
+	}
+	
+	for ( int32 i = 0; i < MAX2DCHANNELS; i++ )
+	{
+		if ( opened_2dsamples[i] )
+		{
+			AIL_release_sample_handle(opened_2dsamples[i]);
+			opened_2dsamples[i] = NULL;
+		}
+	}
+	
+	release_existing();
+	
+	_DeleteMP3Entries();
+	
+	if ( nSampleBankMemoryStartAddress[0] != 0 )
+	{
+		AIL_mem_free_lock((void *)nSampleBankMemoryStartAddress[0]);
+		nSampleBankMemoryStartAddress[0] = 0;
+	}
+
+	if ( nSampleBankMemoryStartAddress[1] != 0 )
+	{
+		AIL_mem_free_lock((void *)nSampleBankMemoryStartAddress[1]);
+		nSampleBankMemoryStartAddress[1] = 0;
+	}
+	
+	if ( DIG )
+	{
+		AIL_close_digital_driver(DIG);
+		DIG = NULL;
+	}
+	
+	AIL_shutdown();
+	
+	_bSampmanInitialised = false;
+}
+
+bool
+cSampleManager::CheckForAnAudioFileOnCD(void)
+{
+	char filepath[MAX_PATH];
+
+#if !defined(GTA3_STEAM_PATCH) && !defined(NO_CDCHECK)
+	
+#if defined(GTA3_1_1_PATCH)
+	if (_bUseHDDAudio)
+		strcpy(filepath, _aHDDPath);
+	else
+		strcpy(filepath, m_szCDRomRootPath);
+#else
+	strcpy(filepath, m_szCDRomRootPath);
+#endif // #if defined(GTA3_1_1_PATCH)
+
+	strcat(filepath, StreamedNameTable[AudioManager.GetRandomTabe(1) % TOTAL_STREAMED_SOUNDS]);
+	
+	FILE *f = fopen(filepath, "rb");
+	
+	if ( f )
+	{
+		fclose(f);
+
+		return true;
+	}
+	
+	return false;
+	
+#else
+	return true;
+#endif // #if !defined(GTA3_STEAM_PATCH) && !defined(NO_CDCHECK)
+}
+
+char
+cSampleManager::GetCDAudioDriveLetter(void)
+{
+#if defined(GTA3_1_1_PATCH) || defined(GTA3_STEAM_PATCH) || defined(NO_CDCHECK)
+	if (_bUseHDDAudio)
+	{
+		if ( strlen(_aHDDPath) != 0 )
+			return _aHDDPath[0];
+		else
+			return '\0';
+	}
+	else
+	{
+		if ( strlen(m_szCDRomRootPath) != 0 )
+			return m_szCDRomRootPath[0];
+		else
+			return '\0';
+	}
+#else
+	if ( strlen(m_szCDRomRootPath) != 0 )
+		return m_szCDRomRootPath[0];
+	else
+		return '\0';
+#endif
+}
+
+void
+cSampleManager::UpdateEffectsVolume(void) //[Y], cSampleManager::UpdateSoundBuffers ?
+{
+	if ( _bSampmanInitialised )
+	{
+		for ( int32 i = 0; i < MAXCHANNELS+MAX2DCHANNELS; i++ )
+		{
+			if ( i < MAXCHANNELS )
+			{
+				if ( opened_samples[i] && GetChannelUsedFlag(i) )
+				{
+					if ( nChannelVolume[i] )
+					{
+						AIL_set_3D_sample_volume(opened_samples[i],
+								m_nEffectsFadeVolume * nChannelVolume[i] * m_nEffectsVolume >> 14);
+					}
+				}
+			}
+			else
+			{
+				if ( opened_2dsamples[i - MAXCHANNELS] )
+				{
+					if ( GetChannelUsedFlag(i - MAXCHANNELS) )
+					{
+						if ( nChannelVolume[i - MAXCHANNELS] )
+						{
+							AIL_set_sample_volume(opened_2dsamples[i - MAXCHANNELS],
+									m_nEffectsFadeVolume * nChannelVolume[i - MAXCHANNELS] * m_nEffectsVolume >> 14);
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+void
+cSampleManager::SetEffectsMasterVolume(uint8 nVolume)
+{
+	m_nEffectsVolume = nVolume;
+	UpdateEffectsVolume();
+}
+
+void
+cSampleManager::SetMusicMasterVolume(uint8 nVolume)
+{
+	m_nMusicVolume = nVolume;
+}
+
+void
+cSampleManager::SetEffectsFadeVolume(uint8 nVolume)
+{
+	m_nEffectsFadeVolume = nVolume;
+	UpdateEffectsVolume();
+}
+
+void
+cSampleManager::SetMusicFadeVolume(uint8 nVolume)
+{
+	m_nMusicFadeVolume = nVolume;
+}
+
+bool
+cSampleManager::LoadSampleBank(uint8 nBank)
+{
+	if ( CTimer::GetIsCodePaused() )
+		return false;
+	
+	if ( MusicManager.IsInitialised()
+		&& MusicManager.GetMusicMode() == MUSICMODE_CUTSCENE
+		&& nBank != 0 )
+	{
+		return false;
+	}
+	
+	if ( fseek(fpSampleDataHandle, nSampleBankDiscStartOffset[nBank], SEEK_SET) != 0 )
+		return false;
+	
+	if ( fread((void *)nSampleBankMemoryStartAddress[nBank], 1, nSampleBankSize[nBank],fpSampleDataHandle) != nSampleBankSize[nBank] )
+		return false;
+	
+	bSampleBankLoaded[nBank] = true;
+	
+	return true;
+}
+
+void
+cSampleManager::UnloadSampleBank(uint8 nBank)
+{
+	bSampleBankLoaded[nBank] = false;
+}
+
+bool
+cSampleManager::IsSampleBankLoaded(uint8 nBank)
+{
+	return bSampleBankLoaded[nBank];
+}
+
+bool
+cSampleManager::IsPedCommentLoaded(uint32 nComment)
+{
+	int32 slot;
+
+	for ( int32 i = 0; i < _TODOCONST(3); i++ )
+	{
+		slot = nCurrentPedSlot - i - 1;
+		if ( nComment == nPedSlotSfx[slot] )
+			return true;
+	}
+	
+	return false;
+}
+
+int32
+cSampleManager::_GetPedCommentSlot(uint32 nComment)
+{
+	int32 slot;
+
+	for ( int32 i = 0; i < _TODOCONST(3); i++ )
+	{
+		slot = nCurrentPedSlot - i - 1;
+		if ( nComment == nPedSlotSfx[slot] )
+			return slot;
+	}
+	
+	return -1;
+}
+
+bool
+cSampleManager::LoadPedComment(uint32 nComment)
+{
+	if ( CTimer::GetIsCodePaused() )
+		return false;
+	
+	// no talking peds during cutsenes or the game end
+	if ( MusicManager.IsInitialised() )
+	{
+		switch ( MusicManager.GetMusicMode() )
+		{
+			case MUSICMODE_CUTSCENE:
+			{
+				return false;
+
+				break;
+			}
+			
+			case MUSICMODE_FRONTEND:
+			{
+				if ( MusicManager.GetCurrentTrack() == STREAMED_SOUND_GAME_COMPLETED )
+					return false;
+
+				break;
+			}
+		}
+	}
+	
+	if ( fseek(fpSampleDataHandle, m_aSamples[nComment].nOffset, SEEK_SET) != 0 )
+		return false;
+	
+	if ( fread((void *)(nSampleBankMemoryStartAddress[1] + PED_BLOCKSIZE*nCurrentPedSlot), 1, m_aSamples[nComment].nSize, fpSampleDataHandle) != m_aSamples[nComment].nSize )
+		return false;
+	
+	nPedSlotSfxAddr[nCurrentPedSlot] = nSampleBankMemoryStartAddress[1] + PED_BLOCKSIZE*nCurrentPedSlot;
+	nPedSlotSfx    [nCurrentPedSlot] = nComment;
+	
+	if ( ++nCurrentPedSlot >= MAX_PEDSFX )
+		nCurrentPedSlot = 0;
+	
+	return true;
+}
+
+int32
+cSampleManager::GetSampleBaseFrequency(uint32 nSample)
+{
+	return m_aSamples[nSample].nFrequency;
+}
+
+int32
+cSampleManager::GetSampleLoopStartOffset(uint32 nSample)
+{
+	return m_aSamples[nSample].nLoopStart;
+}
+
+int32
+cSampleManager::GetSampleLoopEndOffset(uint32 nSample)
+{
+	return m_aSamples[nSample].nLoopEnd;
+}
+
+uint32
+cSampleManager::GetSampleLength(uint32 nSample)
+{
+	return m_aSamples[nSample].nSize >> 1;
+}
+
+bool
+cSampleManager::UpdateReverb(void)
+{
+	if ( !usingEAX )
+		return false;
+	
+	if ( AudioManager.GetFrameCounter() & 15 )
+		return false;
+			
+	float y = AudioManager.GetReflectionsDistance(REFLECTION_TOP)  + AudioManager.GetReflectionsDistance(REFLECTION_BOTTOM);
+	float x = AudioManager.GetReflectionsDistance(REFLECTION_LEFT) + AudioManager.GetReflectionsDistance(REFLECTION_RIGHT);
+	float z = AudioManager.GetReflectionsDistance(REFLECTION_UP);
+	
+	float normy = norm(y, 5.0f, 40.0f);
+	float normx = norm(x, 5.0f, 40.0f);
+	float normz = norm(z, 5.0f, 40.0f);
+
+	float fRatio;
+	
+	if ( normy == 0.0f )
+	{
+		if ( normx == 0.0f )
+		{
+			if ( normz == 0.0f )
+				fRatio = 0.3f;
+			else
+				fRatio = 0.5f;
+		}
+		else
+		{
+			fRatio = 0.3f;
+		}
+	}
+	else
+	{
+		if ( normx == 0.0f )
+		{
+			if ( normz == 0.0f )
+				fRatio = 0.3f;
+			else
+				fRatio = 0.5f;
+		}
+		else
+		{
+			if ( normz == 0.0f )
+				fRatio = 0.3f;
+			else
+				fRatio = (normy+normx+normz) / 3.0f;
+		}
+	}
+	
+	fRatio = clamp(fRatio, usingEAX3==1 ? 0.0f : 0.30f, 1.0f);
+	
+	if ( fRatio == _fPrevEaxRatioDestination )
+		return false;
+	
+	if ( usingEAX3 )
+	{
+		if ( EAX3ListenerInterpolate(&StartEAX3, &FinishEAX3, fRatio, &EAX3Params, false) )
+		{
+			AIL_set_3D_provider_preference(opened_provider, "EAX all parameters", &EAX3Params);
+			_fEffectsLevel = 1.0f - fRatio * 0.5f;
+		}
+	}
+	else
+	{
+		if ( _usingMilesFast2D )
+			_fEffectsLevel = (1.0f - fRatio) * 0.4f;
+		else
+			_fEffectsLevel = (1.0f - fRatio) * 0.7f;
+	}
+
+	_fPrevEaxRatioDestination = fRatio;
+	
+	return true;
+}
+
+void
+cSampleManager::SetChannelReverbFlag(uint32 nChannel, uint8 nReverbFlag)
+{
+	bool b2d = false;
+	
+	switch ( nChannel )
+	{
+		case CHANNEL2D:
+		{
+			b2d = true;
+			break;
+		}
+	}
+	
+	if ( usingEAX )
+	{
+		if ( nReverbFlag != 0 )
+		{
+			if ( !b2d )
+				AIL_set_3D_sample_effects_level(opened_samples[nChannel], _fEffectsLevel);
+		}
+		else
+		{
+			if ( !b2d )
+				AIL_set_3D_sample_effects_level(opened_samples[nChannel], 0.0f);
+		}
+	}
+}
+
+bool
+cSampleManager::InitialiseChannel(uint32 nChannel, uint32 nSfx, uint8 nBank)
+{
+	bool b2d = false;
+
+	switch ( nChannel )
+	{
+		case CHANNEL2D:
+		{
+			b2d = true;
+			break;
+		}
+	}
+	
+	int32 addr;
+	
+	if ( nSfx < SAMPLEBANK_MAX )
+	{
+		if ( !IsSampleBankLoaded(nBank) )
+			return false;
+		
+		addr = nSampleBankMemoryStartAddress[nBank] + m_aSamples[nSfx].nOffset - m_aSamples[BankStartOffset[nBank]].nOffset;
+	}
+	else
+	{	
+		if ( !IsPedCommentLoaded(nSfx) )
+			return false;
+		
+		int32 slot = _GetPedCommentSlot(nSfx);
+		
+		addr = nPedSlotSfxAddr[slot];
+	}
+	
+	if ( b2d )
+	{
+		if ( opened_2dsamples[nChannel - MAXCHANNELS] )
+		{
+			AIL_set_sample_address(opened_2dsamples[nChannel - MAXCHANNELS], (void *)addr, m_aSamples[nSfx].nSize);
+			return true;
+		}
+		else
+			return false;
+	}
+	else
+	{
+		AILSOUNDINFO info;
+		
+		info.format   = WAVE_FORMAT_PCM;
+		info.data_ptr = (void *)addr;
+		info.channels = 1;
+		info.data_len = m_aSamples[nSfx].nSize;
+		info.rate     = m_aSamples[nSfx].nFrequency;
+		info.bits     = 16;
+	
+		if ( AIL_set_3D_sample_info(opened_samples[nChannel], &info) == 0 )
+		{
+			OutputDebugString(AIL_last_error());
+			return false;
+		}
+			
+		return true;
+	}
+}
+
+void
+cSampleManager::SetChannelEmittingVolume(uint32 nChannel, uint32 nVolume)
+{
+	uint32 vol = nVolume;
+	if ( vol > 127 ) vol = 127;
+	
+	nChannelVolume[nChannel] = vol;
+	
+	// increase the volume for JB.MP3 and S4_BDBD.MP3
+	if (   MusicManager.GetMusicMode()    == MUSICMODE_CUTSCENE
+		&& MusicManager.GetCurrentTrack() != STREAMED_SOUND_NEWS_INTRO
+		&& MusicManager.GetCurrentTrack() != STREAMED_SOUND_CUTSCENE_SAL4_BDBD )
+	{
+		nChannelVolume[nChannel] >>= 2;
+	}
+
+	if ( opened_samples[nChannel] )
+		AIL_set_3D_sample_volume(opened_samples[nChannel], m_nEffectsFadeVolume*nChannelVolume[nChannel]*m_nEffectsVolume >> 14);
+
+}
+
+void
+cSampleManager::SetChannel3DPosition(uint32 nChannel, float fX, float fY, float fZ)
+{
+	if ( opened_samples[nChannel] )
+		AIL_set_3D_position(opened_samples[nChannel], -fX, fY, fZ);
+}
+
+void
+cSampleManager::SetChannel3DDistances(uint32 nChannel, float fMax, float fMin)
+{
+	if ( opened_samples[nChannel] )
+		AIL_set_3D_sample_distances(opened_samples[nChannel], fMax, fMin);
+}
+
+void
+cSampleManager::SetChannelVolume(uint32 nChannel, uint32 nVolume)
+{
+	uint32 vol = nVolume;
+	if ( vol > 127 ) vol = 127;
+	
+	switch ( nChannel )
+	{
+		case CHANNEL2D:
+		{
+			nChannelVolume[nChannel] = vol;
+			
+			// increase the volume for JB.MP3 and S4_BDBD.MP3
+			if (   MusicManager.GetMusicMode()    == MUSICMODE_CUTSCENE
+				&& MusicManager.GetCurrentTrack() != STREAMED_SOUND_NEWS_INTRO
+				&& MusicManager.GetCurrentTrack() != STREAMED_SOUND_CUTSCENE_SAL4_BDBD )
+			{
+				nChannelVolume[nChannel] >>= 2;
+			}
+
+			if ( opened_2dsamples[nChannel - MAXCHANNELS] )
+			{
+				AIL_set_sample_volume(opened_2dsamples[nChannel - MAXCHANNELS],
+						m_nEffectsFadeVolume*vol*m_nEffectsVolume >> 14);
+			}
+			
+			break;
+		}
+	}
+}
+
+void
+cSampleManager::SetChannelPan(uint32 nChannel, uint32 nPan)
+{
+	switch ( nChannel )
+	{
+		case CHANNEL2D:
+		{
+#ifndef FIX_BUGS
+			if ( opened_samples[nChannel - MAXCHANNELS] ) // BUG
+#else
+			if ( opened_2dsamples[nChannel - MAXCHANNELS] )
+#endif
+				AIL_set_sample_pan(opened_2dsamples[nChannel - MAXCHANNELS], nPan);
+
+			break;
+		}
+	}
+}
+
+void
+cSampleManager::SetChannelFrequency(uint32 nChannel, uint32 nFreq)
+{
+	bool b2d = false;
+
+	switch ( nChannel )
+	{
+		case CHANNEL2D:
+		{
+			b2d = true;
+			break;
+		}
+	}
+
+	if ( b2d )
+	{
+		if ( opened_2dsamples[nChannel - MAXCHANNELS] )
+			AIL_set_sample_playback_rate(opened_2dsamples[nChannel - MAXCHANNELS], nFreq);
+	}
+	else
+	{
+		if ( opened_samples[nChannel] )
+			AIL_set_3D_sample_playback_rate(opened_samples[nChannel], nFreq);
+	}
+}
+
+void
+cSampleManager::SetChannelLoopPoints(uint32 nChannel, uint32 nLoopStart, int32 nLoopEnd)
+{
+	bool b2d = false;
+
+	switch ( nChannel )
+	{
+		case CHANNEL2D:
+		{
+			b2d = true;
+			break;
+		}
+	}
+	
+	if ( b2d )
+	{
+		if ( opened_2dsamples[nChannel - MAXCHANNELS] )
+			AIL_set_sample_loop_block(opened_2dsamples[nChannel - MAXCHANNELS], nLoopStart, nLoopEnd);
+	}
+	else
+	{
+		if ( opened_samples[nChannel] )
+			AIL_set_3D_sample_loop_block(opened_samples[nChannel], nLoopStart, nLoopEnd);
+	}
+}
+
+void
+cSampleManager::SetChannelLoopCount(uint32 nChannel, uint32 nLoopCount)
+{
+	bool b2d = false;
+
+	switch ( nChannel )
+	{
+		case CHANNEL2D:
+		{
+			b2d = true;
+			break;
+		}
+	}
+	
+	if ( b2d )
+	{
+		if ( opened_2dsamples[nChannel - MAXCHANNELS] )
+			AIL_set_sample_loop_count(opened_2dsamples[nChannel - MAXCHANNELS], nLoopCount);
+	}
+	else
+	{
+		if ( opened_samples[nChannel] )
+			AIL_set_3D_sample_loop_count(opened_samples[nChannel], nLoopCount);
+	}
+}
+
+bool
+cSampleManager::GetChannelUsedFlag(uint32 nChannel)
+{
+	bool b2d = false;
+
+	switch ( nChannel )
+	{
+		case CHANNEL2D:
+		{
+			b2d = true;
+			break;
+		}
+	}
+	
+	if ( b2d )
+	{
+		if ( opened_2dsamples[nChannel - MAXCHANNELS] )
+			return AIL_sample_status(opened_2dsamples[nChannel - MAXCHANNELS]) == SMP_PLAYING;
+		else
+			return false;
+	}
+	else
+	{
+		if ( opened_samples[nChannel] )
+			return AIL_3D_sample_status(opened_samples[nChannel]) == SMP_PLAYING;
+		else
+			return false;
+	}
+	
+}
+
+void
+cSampleManager::StartChannel(uint32 nChannel)
+{
+	bool b2d = false;
+
+	switch ( nChannel )
+	{
+		case CHANNEL2D:
+		{
+			b2d = true;
+			break;
+		}
+	}
+
+	if ( b2d )
+	{
+		if ( opened_2dsamples[nChannel - MAXCHANNELS] )
+			AIL_start_sample(opened_2dsamples[nChannel - MAXCHANNELS]);
+	}
+	else
+	{
+		if ( opened_samples[nChannel] )
+			AIL_start_3D_sample(opened_samples[nChannel]);
+	}
+}
+
+void
+cSampleManager::StopChannel(uint32 nChannel)
+{
+	bool b2d = false;
+
+	switch ( nChannel )
+	{
+		case CHANNEL2D:
+		{
+			b2d = true;
+			break;
+		}
+	}
+	
+	if ( b2d )
+	{
+		if ( opened_2dsamples[nChannel - MAXCHANNELS] )
+			AIL_end_sample(opened_2dsamples[nChannel - MAXCHANNELS]);
+	}
+	else
+	{
+		if ( opened_samples[nChannel] )
+		{
+			if ( AIL_3D_sample_status(opened_samples[nChannel]) == SMP_PLAYING )
+				AIL_end_3D_sample(opened_samples[nChannel]);
+		}
+	}
+}
+
+void
+cSampleManager::PreloadStreamedFile(uint8 nFile, uint8 nStream)
+{
+	if ( m_bInitialised  )
+	{
+		if ( nFile < TOTAL_STREAMED_SOUNDS )
+		{
+			if ( mp3Stream[nStream] )
+			{
+				AIL_pause_stream(mp3Stream[nStream], 1);
+				AIL_close_stream(mp3Stream[nStream]);
+			}
+			
+			char filepath[MAX_PATH];
+			
+			strcpy(filepath, m_szCDRomRootPath);
+			strcat(filepath, StreamedNameTable[nFile]);
+			
+			mp3Stream[nStream] = AIL_open_stream(DIG, filepath, 0);
+	
+			if ( mp3Stream[nStream] )
+			{
+				AIL_set_stream_loop_count(mp3Stream[nStream], 1);
+				AIL_service_stream(mp3Stream[nStream], 1);
+			}
+			else
+				OutputDebugString(AIL_last_error());
+		}
+	}
+}
+
+void
+cSampleManager::PauseStream(uint8 nPauseFlag, uint8 nStream)
+{
+	if ( m_bInitialised )
+	{
+		if ( mp3Stream[nStream] )
+			AIL_pause_stream(mp3Stream[nStream], nPauseFlag != 0);
+	}
+}
+
+void
+cSampleManager::StartPreloadedStreamedFile(uint8 nStream)
+{
+	if ( m_bInitialised )
+	{
+		if ( mp3Stream[nStream] )
+			AIL_start_stream(mp3Stream[nStream]);
+	}
+}
+
+bool
+cSampleManager::StartStreamedFile(uint8 nFile, uint32 nPos, uint8 nStream)
+{
+	uint32 position = nPos;
+	char filename[MAX_PATH];
+	
+	if ( m_bInitialised && nFile < TOTAL_STREAMED_SOUNDS )
+	{
+		if ( mp3Stream[nStream] )
+		{
+			AIL_pause_stream(mp3Stream[nStream], 1);
+			AIL_close_stream(mp3Stream[nStream]);
+		}
+		
+		if ( nFile == STREAMED_SOUND_RADIO_MP3_PLAYER )
+		{
+			uint32 i = 0;
+			
+			if ( !_bIsMp3Active ) goto FIND_MP3TRACK;
+			
+			do
+			{
+				if ( ++_CurMP3Index >= nNumMP3s )
+					_CurMP3Index = 0;
+				
+				_CurMP3Pos = 0;
+				
+				tMP3Entry *mp3 = _GetMP3EntryByIndex(_CurMP3Index);
+			
+				if ( mp3 )
+				{
+					mp3 = _pMP3List;
+					if ( mp3 == NULL )
+					{
+						_bIsMp3Active = false;
+						nFile = 0;
+						goto PLAY_STREAMEDTRACK;
+					}
+				}
+			
+				if ( mp3->pLinkPath != NULL )
+					mp3Stream[nStream] = AIL_open_stream(DIG, mp3->pLinkPath, 0);
+				else
+				{
+					strcpy(filename, _mp3DirectoryPath);
+					strcat(filename, mp3->aFilename);
+					
+					mp3Stream[nStream] = AIL_open_stream(DIG, filename, 0);
+				}
+				
+				if ( mp3Stream[nStream] )
+				{
+					AIL_set_stream_loop_count(mp3Stream[nStream], 1);
+					AIL_set_stream_ms_position(mp3Stream[nStream], 0);
+					AIL_pause_stream(mp3Stream[nStream], 0);
+					return true;
+				}
+				
+				goto NEXT_MP3TRACK;
+				
+FIND_MP3TRACK:
+				if ( nPos > nStreamLength[STREAMED_SOUND_RADIO_MP3_PLAYER] )
+					position = 0;
+				
+				tMP3Entry *e;
+				if ( !_GetMP3PosFromStreamPos(&position, &e) )
+				{
+					if ( e == NULL )
+					{
+						nFile = 0;
+						goto PLAY_STREAMEDTRACK;
+					}
+				}
+				
+				if ( e->pLinkPath != NULL )
+					mp3Stream[nStream] = AIL_open_stream(DIG, e->pLinkPath, 0);
+				else
+				{
+					strcpy(filename, _mp3DirectoryPath);
+					strcat(filename, e->aFilename);
+				
+					mp3Stream[nStream] = AIL_open_stream(DIG, filename, 0);
+				}
+									
+				if ( mp3Stream[nStream] )
+				{
+					AIL_set_stream_loop_count(mp3Stream[nStream], 1);
+					AIL_set_stream_ms_position(mp3Stream[nStream], position);
+					AIL_pause_stream(mp3Stream[nStream], 0);
+					
+					_bIsMp3Active = true;
+			
+					return true;
+				}
+				
+NEXT_MP3TRACK:			
+				_bIsMp3Active = false;
+	
+			} while ( ++i < nNumMP3s );
+			
+			position = 0;
+			nFile = 0;
+			goto PLAY_STREAMEDTRACK;
+		}
+		
+PLAY_STREAMEDTRACK:
+		strcpy(filename, m_szCDRomRootPath);
+		strcat(filename, StreamedNameTable[nFile]);
+		
+		mp3Stream[nStream] = AIL_open_stream(DIG, filename, 0);
+		if ( mp3Stream[nStream] )
+		{
+			AIL_set_stream_loop_count(mp3Stream[nStream], 1);
+			AIL_set_stream_ms_position(mp3Stream[nStream], position);
+			AIL_pause_stream(mp3Stream[nStream], 0);
+			return true;
+		}
+	}
+	
+	return false;
+}
+
+void
+cSampleManager::StopStreamedFile(uint8 nStream)
+{
+	if ( m_bInitialised )
+	{
+		if ( mp3Stream[nStream] )
+		{
+			AIL_pause_stream(mp3Stream[nStream], 1);
+			
+			AIL_close_stream(mp3Stream[nStream]);
+			mp3Stream[nStream] = NULL;
+			
+			if ( nStream == 0 )
+				_bIsMp3Active = false;
+		}
+	}
+}
+
+int32
+cSampleManager::GetStreamedFilePosition(uint8 nStream)
+{
+	S32 currentms;
+	
+	if ( m_bInitialised )
+	{
+		if ( mp3Stream[nStream] )
+		{
+			if ( _bIsMp3Active )
+			{
+				tMP3Entry *mp3 = _GetMP3EntryByIndex(_CurMP3Index);
+				
+				if ( mp3 != NULL )
+				{
+					AIL_stream_ms_position(mp3Stream[nStream], NULL, &currentms);
+					return currentms + mp3->nTrackStreamPos;
+				}
+				else
+					return 0;
+			}
+			else
+			{
+				AIL_stream_ms_position(mp3Stream[nStream], NULL, &currentms);
+				return currentms;
+			}
+		}
+	}
+	
+	return 0;
+}
+
+void
+cSampleManager::SetStreamedVolumeAndPan(uint8 nVolume, uint8 nPan, uint8 nEffectFlag, uint8 nStream)
+{
+	uint8 vol = nVolume;
+	
+	if ( m_bInitialised )
+	{
+		if ( vol > 127 ) vol = 127;
+		if ( vol > 127 ) vol = 127;
+		
+		nStreamVolume[nStream] = vol;
+		nStreamPan[nStream]    = nPan;
+		
+		if ( mp3Stream[nStream] )
+		{
+			if ( nEffectFlag )
+				AIL_set_stream_volume(mp3Stream[nStream], m_nEffectsFadeVolume*vol*m_nEffectsVolume >> 14);
+			else
+				AIL_set_stream_volume(mp3Stream[nStream], m_nMusicFadeVolume*vol*m_nMusicVolume >> 14);
+			
+			AIL_set_stream_pan(mp3Stream[nStream], nPan);
+		}
+	}
+}
+
+int32
+cSampleManager::GetStreamedFileLength(uint8 nStream)
+{
+	if ( m_bInitialised )
+		return nStreamLength[nStream];
+	
+	return 0;
+}
+
+bool
+cSampleManager::IsStreamPlaying(uint8 nStream)
+{
+	if ( m_bInitialised )
+	{
+		if ( mp3Stream[nStream] )
+		{
+			if ( AIL_stream_status(mp3Stream[nStream]) == SMP_PLAYING )
+				return true;
+			else
+				return false;
+		}
+	}
+	
+	return false;
+}
+
+bool
+cSampleManager::InitialiseSampleBanks(void)
+{
+	int32 nBank = 0;
+	
+	fpSampleDescHandle = fopen(SampleBankDescFilename, "rb");
+	if ( fpSampleDescHandle == NULL )
+		return false;
+	
+	fpSampleDataHandle = fopen(SampleBankDataFilename, "rb");
+	if ( fpSampleDataHandle == NULL )
+	{
+		fclose(fpSampleDescHandle);
+		fpSampleDescHandle = NULL;
+		
+		return false;
+	}
+	
+	fseek(fpSampleDataHandle, 0, SEEK_END);
+	_nSampleDataEndOffset = ftell(fpSampleDataHandle);
+	rewind(fpSampleDataHandle);
+	
+	fread(m_aSamples, sizeof(tSample), TOTAL_AUDIO_SAMPLES, fpSampleDescHandle);
+	
+	fclose(fpSampleDescHandle);
+	fpSampleDescHandle = NULL;
+	
+	for ( int32 i = 0; i < TOTAL_AUDIO_SAMPLES; i++ )
+	{
+		if ( BankStartOffset[nBank] == BankStartOffset[0] + i )
+		{
+			nSampleBankDiscStartOffset[nBank] = m_aSamples[i].nOffset;
+			nBank++;
+		}
+	}
+
+	nSampleBankSize[0] = nSampleBankDiscStartOffset[1] - nSampleBankDiscStartOffset[0];
+	nSampleBankSize[1] = _nSampleDataEndOffset         - nSampleBankDiscStartOffset[1];
+	
+	return true;
+}
+
+STARTPATCHES
+	//InjectHook(0x565500, cSampleManager::cSampleManager, PATCH_JUMP);
+	//InjectHook(0x565510, cSampleManager::~cSampleManager, PATCH_JUMP);
+	InjectHook(0x565520, comp, PATCH_JUMP);
+	InjectHook(0x565540, add_providers, PATCH_JUMP);
+	InjectHook(0x565680, release_existing, PATCH_JUMP);
+	InjectHook(0x5656F0, set_new_provider, PATCH_JUMP);
+	InjectHook(0x565900, &cSampleManager::SetSpeakerConfig, PATCH_JUMP);
+	InjectHook(0x565970, &cSampleManager::GetMaximumSupportedChannels, PATCH_JUMP);
+	InjectHook(0x565990, &cSampleManager::GetCurrent3DProviderIndex, PATCH_JUMP);
+	InjectHook(0x5659A0, &cSampleManager::SetCurrent3DProvider, PATCH_JUMP);
+	InjectHook(0x565A10, _ResolveLink, PATCH_JUMP);
+	InjectHook(0x565B40, _FindMP3s, PATCH_JUMP);
+	InjectHook(0x566380, _DeleteMP3Entries, PATCH_JUMP);
+	InjectHook(0x566400, _GetMP3EntryByIndex, PATCH_JUMP);
+	InjectHook(0x566490, &cSampleManager::IsMP3RadioChannelAvailable, PATCH_JUMP);
+	InjectHook(0x5664B0, &cSampleManager::ReleaseDigitalHandle, PATCH_JUMP);
+	InjectHook(0x5664F0, &cSampleManager::ReacquireDigitalHandle, PATCH_JUMP);
+	InjectHook(0x566530, &cSampleManager::Initialise, PATCH_JUMP);
+	InjectHook(0x566DC0, &cSampleManager::Terminate, PATCH_JUMP);
+	InjectHook(0x566EA0, &cSampleManager::CheckForAnAudioFileOnCD, PATCH_JUMP);
+	InjectHook(0x566F20, &cSampleManager::GetCDAudioDriveLetter, PATCH_JUMP);
+	InjectHook(0x566F50, &cSampleManager::UpdateEffectsVolume, PATCH_JUMP);
+	InjectHook(0x567010, &cSampleManager::SetEffectsMasterVolume, PATCH_JUMP);
+	InjectHook(0x567020, &cSampleManager::SetMusicMasterVolume, PATCH_JUMP);
+	InjectHook(0x567030, &cSampleManager::SetEffectsFadeVolume, PATCH_JUMP);
+	InjectHook(0x567040, &cSampleManager::SetMusicFadeVolume, PATCH_JUMP);
+	InjectHook(0x567050, &cSampleManager::LoadSampleBank, PATCH_JUMP);
+	InjectHook(0x567110, &cSampleManager::UnloadSampleBank, PATCH_JUMP);
+	InjectHook(0x567130, &cSampleManager::IsSampleBankLoaded, PATCH_JUMP);
+	InjectHook(0x567150, &cSampleManager::IsPedCommentLoaded, PATCH_JUMP);
+	InjectHook(0x5671A0, &cSampleManager::LoadPedComment, PATCH_JUMP);
+	InjectHook(0x5672A0, &cSampleManager::GetSampleBaseFrequency, PATCH_JUMP);
+	InjectHook(0x5672C0, &cSampleManager::GetSampleLoopStartOffset, PATCH_JUMP);
+	InjectHook(0x5672E0, &cSampleManager::GetSampleLoopEndOffset, PATCH_JUMP);
+	InjectHook(0x567300, &cSampleManager::GetSampleLength, PATCH_JUMP);
+	InjectHook(0x567320, &cSampleManager::UpdateReverb, PATCH_JUMP);
+	InjectHook(0x567630, &cSampleManager::SetChannelReverbFlag, PATCH_JUMP);
+	InjectHook(0x5676A0, &cSampleManager::InitialiseChannel, PATCH_JUMP);
+	InjectHook(0x567820, &cSampleManager::SetChannelEmittingVolume, PATCH_JUMP);
+	InjectHook(0x567890, &cSampleManager::SetChannel3DPosition, PATCH_JUMP);
+	InjectHook(0x5678D0, &cSampleManager::SetChannel3DDistances, PATCH_JUMP);
+	InjectHook(0x567900, &cSampleManager::SetChannelVolume, PATCH_JUMP);
+	InjectHook(0x567980, &cSampleManager::SetChannelPan, PATCH_JUMP);
+	InjectHook(0x5679D0, &cSampleManager::SetChannelFrequency, PATCH_JUMP);
+	InjectHook(0x567A30, &cSampleManager::SetChannelLoopPoints, PATCH_JUMP);
+	InjectHook(0x567AA0, &cSampleManager::SetChannelLoopCount, PATCH_JUMP);
+	InjectHook(0x567B00, &cSampleManager::GetChannelUsedFlag, PATCH_JUMP);
+	InjectHook(0x567B80, &cSampleManager::StartChannel, PATCH_JUMP);
+	InjectHook(0x567BE0, &cSampleManager::StopChannel, PATCH_JUMP);
+	InjectHook(0x567C50, &cSampleManager::PreloadStreamedFile, PATCH_JUMP);
+	InjectHook(0x567D30, &cSampleManager::PauseStream, PATCH_JUMP);
+	InjectHook(0x567D60, &cSampleManager::StartPreloadedStreamedFile, PATCH_JUMP);
+	InjectHook(0x567D80, &cSampleManager::StartStreamedFile, PATCH_JUMP);
+	InjectHook(0x5680E0, &cSampleManager::StopStreamedFile, PATCH_JUMP);
+	InjectHook(0x568130, &cSampleManager::GetStreamedFilePosition, PATCH_JUMP);
+	InjectHook(0x5681D0, &cSampleManager::SetStreamedVolumeAndPan, PATCH_JUMP);
+	InjectHook(0x568270, &cSampleManager::GetStreamedFileLength, PATCH_JUMP);
+	InjectHook(0x568290, &cSampleManager::IsStreamPlaying, PATCH_JUMP);
+	InjectHook(0x5682D0, &cSampleManager::InitialiseSampleBanks, PATCH_JUMP);
+	//InjectHook(0x5683F0, `global constructor keyed to'sampman.cpp, PATCH_JUMP);
+ENDPATCHES
\ No newline at end of file