8 files changed, 3396 insertions, 395 deletions

diff --git a/src/audio/AudioManager.cpp b/src/audio/AudioManager.cpp
index 51f45e16..07469b87 100644
--- a/src/audio/AudioManager.cpp
+++ b/src/audio/AudioManager.cpp
@@ -3,19 +3,25 @@
 
 #include "AudioManager.h"
 
+#include "Automobile.h"
+#include "Camera.h"
 #include "DMAudio.h"
+#include "Garages.h"
 #include "ModelIndices.h"
 #include "MusicManager.h"
 #include "Ped.h"
 #include "Physical.h"
+#include "Plane.h"
 #include "PlayerPed.h"
 #include "SampleManager.h"
+#include "Stats.h"
 #include "Vehicle.h"
 #include "World.h"
 
+uint32 *audioLogicTimers = (uint32 *)0x6508A0;
+
 // TODO: where is this used? Is this the right file?
-enum eVehicleModel
-{
+enum eVehicleModel {
 	LANDSTAL,
 	IDAHO,
 	STINGER,
@@ -96,21 +102,189 @@ constexpr int maxVolume = 127;
 char &g_nMissionAudioPlayingStatus = *(char *)0x60ED88;
 
 void
+cAudioManager::AddDetailsToRequestedOrderList(uint8 sample)
+{
+	uint32 i = 0;
+	if(sample != 0) {
+		for(; i < sample; i++) {
+			if(m_asSamples[m_bActiveSampleQueue]
+			              [m_abSampleQueueIndexTable[m_bActiveSampleQueue][i]]
+			                  .calculatedVolume >
+			   m_asSamples[m_bActiveSampleQueue][sample].calculatedVolume)
+				break;
+		}
+		if(i < sample) {
+			memmove(&m_abSampleQueueIndexTable[m_bActiveSampleQueue][i + 1],
+			        &m_abSampleQueueIndexTable[m_bActiveSampleQueue][i],
+			        m_bActiveSamples - i - 1);
+		}
+	}
+	m_abSampleQueueIndexTable[m_bActiveSampleQueue][i] = sample;
+}
+
+void
+cAudioManager::AddPlayerCarSample(uint8 emittingVolume, int32 freq, uint32 sample, uint8 unk1,
+                                  uint8 unk2, bool notLooping)
+{
+	m_sQueueSample.m_bVolume = ComputeVolume(emittingVolume, 50.f, m_sQueueSample.m_fDistance);
+	if(m_sQueueSample.m_bVolume) {
+		m_sQueueSample.field_4 = unk2;
+		m_sQueueSample.m_nSampleIndex = sample;
+		m_sQueueSample.m_bBankIndex = 0;
+		m_sQueueSample.m_bIsDistant = 0;
+		m_sQueueSample.field_16 = 0;
+		m_sQueueSample.m_nFrequency = freq;
+		if(notLooping) {
+			m_sQueueSample.m_nLoopCount = 0;
+			m_sQueueSample.field_76 = 8;
+		} else {
+			m_sQueueSample.m_nLoopCount = 1;
+		}
+		m_sQueueSample.m_bEmittingVolume = emittingVolume;
+		m_sQueueSample.m_nLoopStart =
+		    cSampleManager.GetSampleLoopStartOffset(m_sQueueSample.m_nSampleIndex);
+		m_sQueueSample.m_nLoopEnd =
+		    cSampleManager.GetSampleLoopEndOffset(m_sQueueSample.m_nSampleIndex);
+		m_sQueueSample.field_48 = 6.0f;
+		m_sQueueSample.m_fSoundIntensity = 50.0f;
+		m_sQueueSample.field_56 = 0;
+		m_sQueueSample.m_bReverbFlag = 1;
+		m_sQueueSample.m_bRequireReflection = 0;
+		AddSampleToRequestedQueue();
+	}
+}
+
+void
+cAudioManager::AddReflectionsToRequestedQueue()
+{
+	float reflectionDistance;
+	int32 noise;
+	uint8 emittingVolume = emittingVolume =
+	    (m_sQueueSample.m_bVolume >> 1) + (m_sQueueSample.m_bVolume >> 3);
+
+	for(uint32 i = 0; i < 5u; i++) {
+		reflectionDistance = m_afReflectionsDistances[i];
+		if(reflectionDistance > 0.0f && reflectionDistance < 100.f &&
+		   reflectionDistance < m_sQueueSample.m_fSoundIntensity) {
+			m_sQueueSample.m_bLoopsRemaining =
+			    (reflectionDistance *
+			     0.38873f); // @todo assert value, here used from VC
+			if(m_sQueueSample.m_bLoopsRemaining > 5u) {
+				m_sQueueSample.m_fDistance = m_afReflectionsDistances[i];
+				m_sQueueSample.m_bEmittingVolume = emittingVolume;
+				m_sQueueSample.m_bVolume =
+				    ComputeVolume(emittingVolume, m_sQueueSample.m_fSoundIntensity,
+				                  m_sQueueSample.m_fDistance);
+				if(m_sQueueSample.m_bVolume > emittingVolume >> 4) {
+					m_sQueueSample.field_4 += ((i + 1) << 8);
+					if(m_sQueueSample.m_nLoopCount) {
+						noise = RandomDisplacement(
+						    m_sQueueSample.m_nFrequency >> 5);
+						if(noise <= 0)
+							m_sQueueSample.m_nFrequency += noise;
+						else
+							m_sQueueSample.m_nFrequency -= noise;
+					}
+					m_sQueueSample.field_16 += 20;
+					m_sQueueSample.m_vecPos.x = m_avecReflectionsPos[i].x;
+					m_sQueueSample.m_vecPos.y = m_avecReflectionsPos[i].y;
+					m_sQueueSample.m_vecPos.z = m_avecReflectionsPos[i].z;
+					AddSampleToRequestedQueue();
+				}
+			}
+		}
+	}
+}
+
+#if 1
+WRAPPER void
+cAudioManager::AddReleasingSounds()
+{
+	EAXJMP(0x57B8D0);
+}
+#else
+void
+cAudioManager::AddReleasingSounds()
+{
+	bool isFirstSampleQueue;
+	int32 calculatedIndex;
+	tActiveSample *sample;
+	uint8 field_76;
+	uint8 field_88;
+	int sampleQueue;
+	bool toProcess[44];
+	isFirstSampleQueue = m_bActiveSampleQueue == 0;
+
+	cAudioManager *s = (this + 2484 * isFirstSampleQueue); // wtf
+
+	for(uint32 i = 0; i < m_bSampleRequestQueuesStatus[isFirstSampleQueue]; i++) {
+		calculatedIndex = i + 27 * isFirstSampleQueue;
+		sample = &s->m_asSamples[m_abSampleQueueIndexTable[calculatedIndex]];
+		if(!s->m_asSamples[m_abSampleQueueIndexTable[calculatedIndex]].m_bLoopEnded) {
+			toProcess[i] = 0;
+			sampleQueue = m_bActiveSampleQueue;
+			for(uint8 j = 0; j < m_bSampleRequestQueuesStatus[m_bActiveSampleQueue];
+			    j++) {
+				if(sample->m_nEntityIndex ==
+				       m_asSamples[27 * sampleQueue +
+				                   m_abSampleQueueIndexTable[27 * sampleQueue + j]]
+				           .m_nEntityIndex &&
+				   sample->field_4 ==
+				       m_asSamples[27 * sampleQueue +
+				                   m_abSampleQueueIndexTable[27 * sampleQueue + j]]
+				           .field_4) {
+					toProcess[i] = 1;
+					break;
+				}
+			}
+			if(!toProcess[i]) {
+				if(sample->field_4 <= 255u || !sample->m_bLoopsRemaining) {
+					field_76 = sample->field_76;
+					if(!field_76) continue;
+					if(!sample->m_nLoopCount) {
+						uint8 &vol = sample->m_bVolume;
+						if(sample->field_88 == -1) {
+							sample->field_88 = vol / field_76;
+							if(sample->field_88 <= 0)
+								sample->field_88 = 1;
+						}
+						field_88 = sample->field_88;
+						if(vol <= field_88) {
+							sample->field_76 = 0;
+							continue;
+						}
+						vol -= field_88;
+					}
+					--sample->field_76;
+					if(field_2) {
+						if(sample->field_16 < 20u) ++sample->field_16;
+					}
+					sample->field_56 = 0;
+				}
+				memcpy(&m_sQueueSample, sample, 92);
+				AddSampleToRequestedQueue();
+			}
+		}
+	}
+}
+#endif
+
+void
 cAudioManager::AddSampleToRequestedQueue()
 {
 	int32 calculatedVolume;
 	tActiveSample *sample;
-	int32 unknown1;
-	uint8 unknown2;
+	uint8 sampleIndex;
 	bool bReflections;
 
 	if(m_sQueueSample.m_nSampleIndex < TOTAL_AUDIO_SAMPLES) {
 		calculatedVolume = m_sQueueSample.field_16 * (maxVolume - m_sQueueSample.m_bVolume);
-		unknown2 = m_bSampleRequestQueuesStatus[m_bActiveSampleQueue];
-		if(unknown2 >= m_bActiveSamples) {
-			unknown1 = 27 * m_bActiveSampleQueue;
-			unknown2 = *(&m_asSamples[53].field_91 + m_bActiveSamples + unknown1);
-			if(m_asSamples[unknown1 + unknown2].calculatedVolume <= calculatedVolume)
+		sampleIndex = m_bSampleRequestQueuesStatus[m_bActiveSampleQueue];
+		if(sampleIndex >= m_bActiveSamples) {
+			sampleIndex = *(&m_asSamples[1][26].field_91 + m_bActiveSamples +
+			                27 * m_bActiveSampleQueue);
+			if(m_asSamples[m_bActiveSampleQueue][sampleIndex].calculatedVolume <=
+			   calculatedVolume)
 				return;
 		} else {
 			++m_bSampleRequestQueuesStatus[m_bActiveSampleQueue];
@@ -131,7 +305,7 @@ cAudioManager::AddSampleToRequestedQueue()
 
 		if(!m_bDynamicAcousticModelingStatus) m_sQueueSample.m_bReverbFlag = 0;
 
-		sample = &m_asSamples[27 * m_bActiveSampleQueue + unknown2];
+		sample = &m_asSamples[m_bActiveSampleQueue][sampleIndex];
 		sample->m_nEntityIndex = m_sQueueSample.m_nEntityIndex;
 		sample->field_4 = m_sQueueSample.field_4;
 		sample->m_nSampleIndex = m_sQueueSample.m_nSampleIndex;
@@ -159,69 +333,91 @@ cAudioManager::AddSampleToRequestedQueue()
 		sample->calculatedVolume = m_sQueueSample.calculatedVolume;
 		sample->field_88 = m_sQueueSample.field_88;
 
-		AddDetailsToRequestedOrderList(unknown2);
+		AddDetailsToRequestedOrderList(sampleIndex);
 		if(bReflections) AddReflectionsToRequestedQueue();
 	}
 }
 
+WRAPPER
 void
-cAudioManager::AddDetailsToRequestedOrderList(uint8 sample)
+cAudioManager::AgeCrimes()
 {
-	int32 offset;
-	uint32 i = 0;
-	if(sample != 0) {
-		for(; i < sample; i++) {
-			offset = 27 * m_bActiveSampleQueue;
-			if(m_asSamples[offset + m_abSampleQueueIndexTable[i + offset]]
-			       .calculatedVolume > m_asSamples[offset + sample].calculatedVolume)
-				break;
-		}
-		if(i < sample) {
-			memmove(&m_abSampleQueueIndexTable[offset + 1 + i],
-			        &m_abSampleQueueIndexTable[offset + i], m_bActiveSamples - i - 1);
-		}
+	EAXJMP(0x580AF0);
+}
+
+int8
+cAudioManager::AutoDetect3DProviders()
+{
+	if(m_bIsInitialised) return cSampleManager.AutoDetect3DProviders();
+
+	return -1;
+}
+
+void
+cAudioManager::CalculateDistance(bool *ptr, float dist)
+{
+	if(*ptr == false) {
+		m_sQueueSample.m_fDistance = sqrt(dist);
+		*ptr = true;
 	}
-	m_abSampleQueueIndexTable[27 * m_bActiveSampleQueue + i] = sample;
+}
+
+bool
+cAudioManager::CheckForAnAudioFileOnCD()
+{
+	return cSampleManager.CheckForAnAudioFileOnCD();
 }
 
 void
-cAudioManager::AddReflectionsToRequestedQueue()
+cAudioManager::ClearMissionAudio()
 {
-	float reflectionDistance;
-	int32 noise;
-	uint8 emittingVolume = emittingVolume =
-	    (m_sQueueSample.m_bVolume >> 1) + (m_sQueueSample.m_bVolume >> 3);
+	if(m_bIsInitialised) {
+		m_sMissionAudio.m_nSampleIndex = NO_SAMPLE;
+		m_sMissionAudio.m_bLoadingStatus = 0;
+		m_sMissionAudio.m_bPlayStatus = 0;
+		m_sMissionAudio.field_22 = 0;
+		m_sMissionAudio.m_bIsPlayed = false;
+		m_sMissionAudio.field_12 = 1;
+		m_sMissionAudio.field_24 = 0;
+	}
+}
 
-	for(uint32 i = 0; i < 5u; i++) {
-		reflectionDistance = m_afReflectionsDistances[i];
-		if(reflectionDistance > 0.0f && reflectionDistance < 100.f &&
-		   reflectionDistance < m_sQueueSample.m_fSoundIntensity) {
-			m_sQueueSample.m_bLoopsRemaining = (reflectionDistance * 0.38873f); // @todo assert value
-			if(m_sQueueSample.m_bLoopsRemaining > 5u) {
-				m_sQueueSample.m_fDistance = m_afReflectionsDistances[i];
-				m_sQueueSample.m_bEmittingVolume = emittingVolume;
-				m_sQueueSample.m_bVolume =
-				    ComputeVolume(emittingVolume, m_sQueueSample.m_fSoundIntensity,
-				                  m_sQueueSample.m_fDistance);
-				if(m_sQueueSample.m_bVolume > emittingVolume >> 4) {
-					m_sQueueSample.field_4 += ((i + 1) << 8);
-					if(m_sQueueSample.m_nLoopCount) {
-						noise = RandomDisplacement(
-						    m_sQueueSample.m_nFrequency >> 5);
-						if(noise <= 0)
-							m_sQueueSample.m_nFrequency += noise;
-						else
-							m_sQueueSample.m_nFrequency -= noise;
-					}
-					m_sQueueSample.field_16 += 20;
-					m_sQueueSample.m_vecPos.x = m_avecReflectionsPos[i].x;
-					m_sQueueSample.m_vecPos.y = m_avecReflectionsPos[i].y;
-					m_sQueueSample.m_vecPos.z = m_avecReflectionsPos[i].z;
-					AddSampleToRequestedQueue();
+void
+cAudioManager::ClearRequestedQueue()
+{
+	for(int32 i = 0; i < m_bActiveSamples; i++) {
+		m_abSampleQueueIndexTable[m_bActiveSampleQueue][i] = m_bActiveSamples;
+	}
+	m_bSampleRequestQueuesStatus[m_bActiveSampleQueue] = 0;
+}
+
+int32
+cAudioManager::ComputeDopplerEffectedFrequency(uint32 oldFreq, float position1, float position2,
+                                               float speedMultiplier)
+{
+	uint32 newFreq = oldFreq;
+	if(!TheCamera.Get_Just_Switched_Status() && speedMultiplier != 0.0f) {
+		float dist = position2 - position1;
+		if(dist != 0.0f) {
+			float speedOfSource = (dist / field_19195) * speedMultiplier;
+			if(speedOfSound > fabsf(speedOfSource)) {
+				if(speedOfSource < 0.0f) {
+					speedOfSource = max(speedOfSource, -1.5f);
+				} else {
+					speedOfSource = min(speedOfSource, 1.5f);
 				}
+				newFreq = (oldFreq * speedOfSound) / (speedOfSource + speedOfSound);
 			}
 		}
 	}
+	return newFreq;
+}
+
+WRAPPER
+int32
+cAudioManager::ComputePan(float, CVector *)
+{
+	EAXJMP(0x57AD20);
 }
 
 uint32
@@ -238,6 +434,131 @@ cAudioManager::ComputeVolume(int emittingVolume, float soundIntensity, float dis
 	return emittingVolume;
 }
 
+int32
+cAudioManager::CreateEntity(int32 type, CPhysical *entity)
+{
+	if(!m_bIsInitialised) return -4;
+	if(!entity) return -2;
+	if(type >= TOTAL_AUDIO_TYPES) return -1;
+	for(uint32 i = 0; i < 200; i++) {
+		if(!m_asAudioEntities[i].m_bIsUsed) {
+			m_asAudioEntities[i].m_bIsUsed = true;
+			m_asAudioEntities[i].m_bStatus = 0;
+			m_asAudioEntities[i].m_nType = (eAudioType)type;
+			m_asAudioEntities[i].m_pEntity = entity;
+			m_asAudioEntities[i].m_awAudioEvent[0] = SOUND_TOTAL_PED_SOUNDS;
+			m_asAudioEntities[i].m_awAudioEvent[1] = SOUND_TOTAL_PED_SOUNDS;
+			m_asAudioEntities[i].m_awAudioEvent[2] = SOUND_TOTAL_PED_SOUNDS;
+			m_asAudioEntities[i].m_awAudioEvent[3] = SOUND_TOTAL_PED_SOUNDS;
+			m_asAudioEntities[i].field_24 = 0;
+			m_anAudioEntityIndices[m_nAudioEntitiesTotal++] = i;
+			return i;
+		}
+	}
+	return -3;
+}
+
+void
+cAudioManager::DestroyAllGameCreatedEntities()
+{
+	cAudioScriptObject *entity;
+
+	if(m_bIsInitialised) {
+		for(uint32 i = 0; i < 200; i++) {
+			if(m_asAudioEntities[i].m_bIsUsed) {
+				switch(m_asAudioEntities[i].m_nType) {
+				case AUDIOTYPE_PHYSICAL:
+				case AUDIOTYPE_EXPLOSION:
+				case AUDIOTYPE_WEATHER:
+				case AUDIOTYPE_CRANE:
+				case AUDIOTYPE_GARAGE:
+				case AUDIOTYPE_HYDRANT: cAudioManager::DestroyEntity(i); break;
+				case AUDIOTYPE_ONE_SHOT:
+					entity =
+					    (cAudioScriptObject *)m_asAudioEntities[i].m_pEntity;
+					if(entity) { delete entity; }
+					DestroyEntity(i);
+					break;
+				default: break;
+				}
+			}
+		}
+		m_nScriptObjectEntityTotal = 0;
+	}
+}
+
+void
+cAudioManager::DestroyEntity(int32 id)
+{
+	if(m_bIsInitialised && id >= 0 && id < totalAudioEntitiesSlots &&
+	   m_asAudioEntities[id].m_bIsUsed) {
+		m_asAudioEntities[id].m_bIsUsed = 0;
+		for(int32 i = 0; i < m_nAudioEntitiesTotal; ++i) {
+			if(id == m_anAudioEntityIndices[i]) {
+				if(i < totalAudioEntitiesSlots - 1)
+					memmove(&m_anAudioEntityIndices[i],
+					        &m_anAudioEntityIndices[i + 1],
+					        4 * (m_nAudioEntitiesTotal - (i + 1)));
+				m_anAudioEntityIndices[--m_nAudioEntitiesTotal] =
+				    totalAudioEntitiesSlots;
+				return;
+			}
+		}
+	}
+}
+
+void
+cAudioManager::DoPoliceRadioCrackle()
+{
+	m_sQueueSample.m_nEntityIndex = m_nPoliceChannelEntity;
+	m_sQueueSample.field_4 = 0;
+	m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_POLICE_SCANNER_CRACKLE;
+	m_sQueueSample.m_bBankIndex = 0;
+	m_sQueueSample.m_bIsDistant = 1;
+	m_sQueueSample.field_16 = 10;
+	m_sQueueSample.m_nFrequency =
+	    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_POLICE_SCANNER_CRACKLE);
+	m_sQueueSample.m_bVolume = m_anRandomTable[2] % 20u + 15;
+	m_sQueueSample.m_nLoopCount = 0;
+	m_sQueueSample.m_bEmittingVolume = m_sQueueSample.m_bVolume;
+	m_sQueueSample.m_nLoopStart = cSampleManager.GetSampleLoopStartOffset(188);
+	m_sQueueSample.m_nLoopEnd = cSampleManager.GetSampleLoopEndOffset(188);
+	m_sQueueSample.field_56 = 0;
+	m_sQueueSample.m_bReverbFlag = 0;
+	m_sQueueSample.m_bOffset = 63;
+	m_sQueueSample.field_76 = 3;
+	m_sQueueSample.m_bRequireReflection = 0;
+	AddSampleToRequestedQueue();
+}
+
+void
+cAudioManager::GenerateIntegerRandomNumberTable()
+{
+	for(int32 i = 0; i < 5; i++) { m_anRandomTable[i] = rand(); }
+}
+
+float
+cAudioManager::GetDistanceSquared(CVector *v)
+{
+	const CVector &c = TheCamera.GetPosition();
+	return sq(v->x - c.x) + sq(v->y - c.y) + sq((v->z - c.z) * 0.2f);
+}
+
+void
+cAudioManager::TranslateEntity(CVector *v1, CVector *v2)
+{
+	const RwMatrix &cM = TheCamera.GetMatrix().m_matrix;
+	const CVector &cV = TheCamera.GetPosition();
+
+	float a = v1->z - cV.z;
+	float b = v1->y - cV.y;
+	float c = v1->x - cV.x;
+
+	v2->x = cM.right.y * b + cM.right.x * c + cM.right.z * a;
+	v2->y = cM.up.y * b + cM.up.x * c + cM.up.z * a;
+	v2->z = cM.at.y * b + cM.at.x * c + cM.at.z * a;
+}
+
 void
 cAudioManager::Initialise()
 {
@@ -262,27 +583,28 @@ cAudioManager::Initialise()
 void
 cAudioManager::PostInitialiseGameSpecificSetup()
 {
-	m_nFireAudioEntity = CreateEntity(
-	    AUDIOTYPE_FIRE, (CPhysical *)0x8F31D0); // last is addr of firemanager @todo change
-	if(m_nFireAudioEntity >= 0) cAudioManager::SetEntityStatus(m_nFireAudioEntity, 1);
+	m_nFireAudioEntity =
+	    CreateEntity(AUDIOTYPE_FIRE,
+	                 (CPhysical *)0x8F31D0); // last is addr of firemanager @todo change
+	if(m_nFireAudioEntity >= 0) SetEntityStatus(m_nFireAudioEntity, 1);
 
 	m_nCollisionEntity = CreateEntity(AUDIOTYPE_COLLISION, (CPhysical *)1);
-	if(m_nCollisionEntity >= 0) cAudioManager::SetEntityStatus(m_nCollisionEntity, 1);
+	if(m_nCollisionEntity >= 0) SetEntityStatus(m_nCollisionEntity, 1);
 
 	m_nFrontEndEntity = CreateEntity(AUDIOTYPE_FRONTEND, (CPhysical *)1);
-	if(m_nFrontEndEntity >= 0) cAudioManager::SetEntityStatus(m_nFrontEndEntity, 1);
+	if(m_nFrontEndEntity >= 0) SetEntityStatus(m_nFrontEndEntity, 1);
 
 	m_nProjectileEntity = CreateEntity(AUDIOTYPE_PROJECTILE, (CPhysical *)1);
-	if(m_nProjectileEntity >= 0) cAudioManager::SetEntityStatus(m_nProjectileEntity, 1);
+	if(m_nProjectileEntity >= 0) SetEntityStatus(m_nProjectileEntity, 1);
 
 	m_nWaterCannonEntity = CreateEntity(AUDIOTYPE_WATER_CANNON, (CPhysical *)1);
-	if(m_nWaterCannonEntity >= 0) cAudioManager::SetEntityStatus(m_nWaterCannonEntity, 1);
+	if(m_nWaterCannonEntity >= 0) SetEntityStatus(m_nWaterCannonEntity, 1);
 
 	m_nPoliceChannelEntity = CreateEntity(AUDIOTYPE_D, (CPhysical *)1);
-	if(m_nPoliceChannelEntity >= 0) cAudioManager::SetEntityStatus(m_nPoliceChannelEntity, 1);
+	if(m_nPoliceChannelEntity >= 0) SetEntityStatus(m_nPoliceChannelEntity, 1);
 
 	m_nBridgeEntity = CreateEntity(AUDIOTYPE_BRIDGE, (CPhysical *)1);
-	if(m_nBridgeEntity >= 0) cAudioManager::SetEntityStatus(m_nBridgeEntity, 1);
+	if(m_nBridgeEntity >= 0) SetEntityStatus(m_nBridgeEntity, 1);
 
 	m_sMissionAudio.m_nSampleIndex = NO_SAMPLE;
 	m_sMissionAudio.m_bLoadingStatus = 0;
@@ -348,7 +670,6 @@ cAudioManager::GetMissionAudioLoadingStatus()
 	return true;
 }
 
-
 uint8
 cAudioManager::GetNum3DProvidersAvailable()
 {
@@ -356,14 +677,6 @@ cAudioManager::GetNum3DProvidersAvailable()
 	return 0;
 }
 
-int8
-cAudioManager::AutoDetect3DProviders()
-{
-	if(m_bIsInitialised) return cSampleManager.AutoDetect3DProviders();
-
-	return -1;
-}
-
 bool
 cAudioManager::IsMP3RadioChannelAvailable()
 {
@@ -410,12 +723,6 @@ cAudioManager::SetSpeakerConfig(int32 conf)
 	cSampleManager.SetSpeakerConfig(conf);
 }
 
-void
-cAudioManager::ProcessJumboFlying()
-{
-	if(SetupJumboFlySound(127u)) SetupJumboEngineSound(63u, 22050);
-}
-
 WRAPPER
 bool cAudioManager::SetupJumboEngineSound(uint8, int32) { EAXJMP(0x56F140); }
 
@@ -441,15 +748,6 @@ cAudioManager::SetMissionScriptPoliceAudio(int32 sfx)
 	}
 }
 
-void
-cAudioManager::CalculateDistance(bool *ptr, float dist)
-{
-	if(*ptr == false) {
-		m_sQueueSample.m_fDistance = Sqrt(dist);
-		*ptr = true;
-	}
-}
-
 bool
 cAudioManager::UsesSiren(int32 model)
 {
@@ -496,30 +794,154 @@ cAudioManager::MissionScriptAudioUsesPoliceChannel(int32 soundMission)
 	}
 }
 
-uint8
+char *
 cAudioManager::Get3DProviderName(uint8 id)
 {
-	if(m_bIsInitialised) return 0;
+	if(!m_bIsInitialised) return 0;
 	if(id >= num3DProvidersAvailable) return 0;
 	return asName3DProviders[id];
 }
 
-void
-cAudioManager::ProcessJumboTaxi()
-{
-	if(SetupJumboFlySound(20u)) {
-		if(SetupJumboTaxiSound(75u)) SetupJumboWhineSound(18u, 29500);
+bool
+cAudioManager::SetupJumboFlySound(uint8 emittingVol)
+{
+	int32 vol;
+
+	if(m_sQueueSample.m_fDistance >= 440.0) return 0;
+
+	vol = ComputeVolume(emittingVol, 440.0f, m_sQueueSample.m_fDistance);
+	m_sQueueSample.m_bVolume = vol;
+	if(m_sQueueSample.m_bVolume) {
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_JUMBO_FLY_SOUND;
+		m_sQueueSample.field_4 = 0;
+		m_sQueueSample.m_bBankIndex = 0;
+		m_sQueueSample.m_bIsDistant = 0;
+		m_sQueueSample.field_16 = 1;
+		m_sQueueSample.m_bEmittingVolume = emittingVol;
+		m_sQueueSample.m_nLoopCount = 0;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_JUMBO_FLY_SOUND);
+		m_sQueueSample.m_nLoopStart =
+		    cSampleManager.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);
+		AddSampleToRequestedQueue();
 	}
+	return 1;
 }
 
-WRAPPER
-bool cAudioManager::SetupJumboFlySound(uint8) { EAXJMP(0x56F230); }
+bool
+cAudioManager::SetupJumboRumbleSound(uint8 emittingVol)
+{
+	if(m_sQueueSample.m_fDistance >= 240.f) return 0;
+
+	m_sQueueSample.m_bVolume = ComputeVolume(emittingVol, 240.f, m_sQueueSample.m_fDistance);
+
+	if(m_sQueueSample.m_bVolume) {
+		m_sQueueSample.field_4 = 5;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_JUMBO_RUMBLE_SOUND;
+		m_sQueueSample.m_bBankIndex = 0;
+		m_sQueueSample.m_bIsDistant = 1;
+		m_sQueueSample.field_16 = 1;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.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);
+		m_sQueueSample.m_nLoopEnd =
+		    cSampleManager.GetSampleLoopEndOffset(m_sQueueSample.m_nSampleIndex);
+		m_sQueueSample.field_48 = 4.0;
+		m_sQueueSample.m_fSoundIntensity = 240.0;
+		m_sQueueSample.field_56 = 0;
+		m_sQueueSample.field_76 = 12;
+		m_sQueueSample.m_bOffset = 0;
+		m_sQueueSample.m_bReverbFlag = 1;
+		m_sQueueSample.m_bRequireReflection = 0;
+		AddSampleToRequestedQueue();
+		m_sQueueSample.field_4 = 6;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_JUMBO_RUMBLE_SOUND;
+		m_sQueueSample.m_nFrequency += 200;
+		m_sQueueSample.m_bOffset = 127;
+		AddSampleToRequestedQueue();
+	}
+	return 1;
+}
 
-WRAPPER
-bool cAudioManager::SetupJumboTaxiSound(uint8) { EAXJMP(0x56EF20); }
+uint8 &gJumboVolOffsetPercentage = *(uint8 *)0x6508ED;
 
-WRAPPER
-bool cAudioManager::SetupJumboWhineSound(uint8, int32) { EAXJMP(0x56F070); }
+bool
+cAudioManager::SetupJumboTaxiSound(uint8 vol)
+{
+	uint8 emittingVol;
+
+	if(m_sQueueSample.m_fDistance >= 180.f) return 0;
+
+	emittingVol = (vol >> 1) + ((vol >> 1) * m_sQueueSample.m_fDistance * 0.0055556f);
+
+	if(m_sQueueSample.m_fDistance * 0.0055556f < 0.7f)
+		emittingVol -= emittingVol * gJumboVolOffsetPercentage / 100;
+	m_sQueueSample.m_bVolume = ComputeVolume(emittingVol, 180.f, m_sQueueSample.m_fDistance);
+
+	if(m_sQueueSample.m_bVolume) {
+		m_sQueueSample.field_4 = 1;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_JUMBO_TAXI_SOUND;
+		m_sQueueSample.m_bBankIndex = 0;
+		m_sQueueSample.m_bIsDistant = 0;
+		m_sQueueSample.field_16 = 1;
+		m_sQueueSample.m_nFrequency = GetJumboTaxiFreq();
+		m_sQueueSample.m_nLoopCount = 0;
+		m_sQueueSample.m_bEmittingVolume = emittingVol;
+		m_sQueueSample.m_nLoopStart =
+		    cSampleManager.GetSampleLoopStartOffset(m_sQueueSample.m_nSampleIndex);
+		m_sQueueSample.m_nLoopEnd =
+		    cSampleManager.GetSampleLoopEndOffset(m_sQueueSample.m_nSampleIndex);
+		m_sQueueSample.field_48 = 4.0f;
+		m_sQueueSample.m_fSoundIntensity = 180.0f;
+		m_sQueueSample.field_56 = 0;
+		m_sQueueSample.field_76 = 4;
+		m_sQueueSample.m_bReverbFlag = 1;
+		m_sQueueSample.m_bRequireReflection = 0;
+		AddSampleToRequestedQueue();
+	}
+	return 1;
+}
+
+bool
+cAudioManager::SetupJumboWhineSound(uint8 emittingVol, int32 freq)
+{
+	if(m_sQueueSample.m_fDistance >= 170.f) return 0;
+
+	m_sQueueSample.m_bVolume = ComputeVolume(emittingVol, 170.f, m_sQueueSample.m_fDistance);
+
+	if(m_sQueueSample.m_bVolume) {
+		m_sQueueSample.field_4 = 2;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_JUMBO_WHINE_SOUND;
+		m_sQueueSample.m_bBankIndex = 0;
+		m_sQueueSample.m_bIsDistant = 0;
+		m_sQueueSample.field_16 = 1;
+		m_sQueueSample.m_nFrequency = freq;
+		m_sQueueSample.m_nLoopCount = 0;
+		m_sQueueSample.m_bEmittingVolume = emittingVol;
+		m_sQueueSample.m_nLoopStart =
+		    cSampleManager.GetSampleLoopStartOffset(m_sQueueSample.m_nSampleIndex);
+		m_sQueueSample.m_nLoopEnd =
+		    cSampleManager.GetSampleLoopEndOffset(m_sQueueSample.m_nSampleIndex);
+		m_sQueueSample.field_48 = 4.0f;
+		m_sQueueSample.m_fSoundIntensity = 170.0f;
+		m_sQueueSample.field_56 = 0;
+		m_sQueueSample.field_76 = 4;
+		m_sQueueSample.m_bReverbFlag = 1;
+		m_sQueueSample.m_bRequireReflection = 0;
+		AddSampleToRequestedQueue();
+	}
+	return 1;
+}
 
 void
 cAudioManager::PlayLoadedMissionAudio()
@@ -559,20 +981,6 @@ cAudioManager::InterrogateAudioEntities()
 	}
 }
 
-void
-cAudioManager::ClearRequestedQueue()
-{
-	for(int32 i = 0; i < m_bActiveSamples; i++) {
-		m_abSampleQueueIndexTable[i + 27 * m_bActiveSampleQueue] = m_bActiveSamples;
-	}
-	m_bSampleRequestQueuesStatus[m_bActiveSampleQueue] = 0;
-}
-
-// void cAudioManager::AgeCrimes()
-//{
-
-//}
-
 bool
 cAudioManager::UsesReverseWarning(int32 model)
 {
@@ -593,59 +1001,6 @@ cAudioManager::GetJumboTaxiFreq()
 	return (60.833f * m_sQueueSample.m_fDistance) + 22050;
 }
 
-void
-cAudioManager::ProcessPhysical(int32 id)
-{
-	CPhysical *entity = m_asAudioEntities[id].m_pEntity;
-	if(entity) {
-		switch(entity->m_type & 7) {
-		case ENTITY_TYPE_VEHICLE: ProcessVehicle(m_asAudioEntities[id].m_pEntity); break;
-		case ENTITY_TYPE_PED: ProcessPed(m_asAudioEntities[id].m_pEntity); break;
-		default: return;
-		}
-	}
-}
-
-WRAPPER
-void
-cAudioManager::ProcessVehicle(CPhysical *)
-{
-	EAXJMP(0x569A00);
-}
-
-WRAPPER
-void
-cAudioManager::ProcessPed(CPhysical *)
-{
-	EAXJMP(0x56F450);
-}
-
-WRAPPER
-void
-cAudioManager::ProcessPlane(void *ptr)
-{
-	EAXJMP(0x56E860);
-}
-
-void
-cAudioManager::ClearMissionAudio()
-{
-	if(m_bIsInitialised) {
-		m_sMissionAudio.m_nSampleIndex = NO_SAMPLE;
-		m_sMissionAudio.m_bLoadingStatus = 0;
-		m_sMissionAudio.m_bPlayStatus = 0;
-		m_sMissionAudio.field_22 = 0;
-		m_sMissionAudio.m_bIsPlayed = false;
-		m_sMissionAudio.field_12 = 1;
-		m_sMissionAudio.field_24 = 0;
-	}
-}
-
-// void
-// cAudioManager::ProcessReverb()
-//{
-//}
-
 bool
 cAudioManager::IsMissionAudioSampleFinished()
 {
@@ -657,9 +1012,6 @@ cAudioManager::IsMissionAudioSampleFinished()
 }
 
 WRAPPER
-void cAudioManager::ProcessEntity(int32) { EAXJMP(0x569870); }
-
-WRAPPER
 void
 cAudioManager::InitialisePoliceRadio()
 {
@@ -708,50 +1060,6 @@ cAudioManager::IsAudioInitialised() const
 	return m_bIsInitialised;
 }
 
-int32
-cAudioManager::CreateEntity(int32 type, CPhysical *entity)
-{
-	if(!m_bIsInitialised) return -4;
-	if(!entity) return -2;
-	if(type >= TOTAL_AUDIO_TYPES) return -1;
-	for(uint32 i = 0; i < 200; i++) {
-		if(!m_asAudioEntities[i].m_bIsUsed) {
-			m_asAudioEntities[i].m_bIsUsed = true;
-			m_asAudioEntities[i].m_bStatus = 0;
-			m_asAudioEntities[i].m_nType = (eAudioType)type;
-			m_asAudioEntities[i].m_pEntity = entity;
-			m_asAudioEntities[i].m_awAudioEvent[0] = SOUND_TOTAL_PED_SOUNDS;
-			m_asAudioEntities[i].m_awAudioEvent[1] = SOUND_TOTAL_PED_SOUNDS;
-			m_asAudioEntities[i].m_awAudioEvent[2] = SOUND_TOTAL_PED_SOUNDS;
-			m_asAudioEntities[i].m_awAudioEvent[3] = SOUND_TOTAL_PED_SOUNDS;
-			m_asAudioEntities[i].field_24 = 0;
-			m_anAudioEntityIndices[m_nAudioEntitiesTotal++] = i;
-			return i;
-		}
-	}
-	return -3;
-}
-
-void
-cAudioManager::DestroyEntity(int32 id)
-{
-	if(m_bIsInitialised && id >= 0 && id < totalAudioEntitiesSlots &&
-	   m_asAudioEntities[id].m_bIsUsed) {
-		m_asAudioEntities[id].m_bIsUsed = 0;
-		for(int32 i = 0; i < m_nAudioEntitiesTotal; ++i) {
-			if(id == m_anAudioEntityIndices[i]) {
-				if(i < totalAudioEntitiesSlots - 1)
-					memmove(&m_anAudioEntityIndices[i],
-					        &m_anAudioEntityIndices[i + 1],
-					        4 * (m_nAudioEntitiesTotal - (i + 1)));
-				m_anAudioEntityIndices[--m_nAudioEntitiesTotal] =
-				    totalAudioEntitiesSlots;
-				return;
-			}
-		}
-	}
-}
-
 void
 cAudioManager::SetEntityStatus(int32 id, bool status)
 {
@@ -799,12 +1107,6 @@ cAudioManager::PostTerminateGameSpecificShutdown()
 	;
 }
 
-void
-cAudioManager::GenerateIntegerRandomNumberTable()
-{
-	for(int32 i = 0; i < 5; i++) { m_anRandomTable[i] = rand(); }
-}
-
 bool &bPlayerJustEnteredCar = *(bool *)0x6508C4;
 
 void
@@ -830,6 +1132,107 @@ cAudioManager::GetPhrase(uint32 *phrase, uint32 *prevPhrase, uint32 sample, uint
 	*prevPhrase = *phrase;
 }
 
+uint8 &jumboVolOffset = *(uint8 *)0x6508ED;
+
+void
+cAudioManager::DoJumboVolOffset()
+{
+	if(!(m_nTimeOfRecentCrime % (m_anRandomTable[0] % 6u + 3)))
+		jumboVolOffset = m_anRandomTable[1] % 60u;
+}
+
+int32
+cAudioManager::GetPedCommentSfx(CPed *ped, int32 sound)
+{
+	if(ped->IsPlayer()) return GetPlayerTalkSfx(sound);
+
+	switch(ped->m_modelIndex) {
+	case MI_COP: return GetCopTalkSfx(sound);
+	case MI_SWAT: return GetSwatTalkSfx(sound);
+	case MI_FBI: return GetFBITalkSfx(sound);
+	case MI_ARMY: return GetArmyTalkSfx(sound);
+	case MI_MEDIC: return GetMedicTalkSfx(sound);
+	case MI_FIREMAN: return GetFiremanTalkSfx(sound);
+	case MI_MALE01: return GetNormalMaleTalkSfx(sound);
+	case MI_TAXI_D: return GetTaxiDriverTalkSfx(sound);
+	case MI_PIMP: return GetPimpTalkSfx(sound);
+	case MI_GANG01:
+	case MI_GANG02: return GetMafiaTalkSfx(sound);
+	case MI_GANG03:
+	case MI_GANG04: return GetTriadTalkSfx(sound);
+	case MI_GANG05:
+	case MI_GANG06: return GetDiabloTalkSfx(sound);
+	case MI_GANG07:
+	case MI_GANG08: return GetYakuzaTalkSfx(sound);
+	case MI_GANG09:
+	case MI_GANG10: return GetYardieTalkSfx(sound);
+	case MI_GANG11:
+	case MI_GANG12: return GetColumbianTalkSfx(sound);
+	case MI_GANG13:
+	case MI_GANG14: return GetHoodTalkSfx(sound);
+	case MI_CRIMINAL01: return GetBlackCriminalTalkSfx(sound);
+	case MI_CRIMINAL02: return GetWhiteCriminalTalkSfx(sound);
+	case MI_SPECIAL01:
+	case MI_SPECIAL02:
+	case MI_SPECIAL03:
+	case MI_SPECIAL04: return GetSpecialCharacterTalkSfx(ped->m_modelIndex, sound);
+	case MI_MALE02: return GetMaleNo2TalkSfx(sound);
+	case MI_MALE03:
+	case MI_P_MAN1:
+	case MI_P_MAN2: return GetBlackProjectMaleTalkSfx(sound, ped->m_modelIndex);
+	case MI_FATMALE01: return GetWhiteFatMaleTalkSfx(sound);
+	case MI_FATMALE02: return GetBlackFatMaleTalkSfx(sound);
+	case MI_FEMALE01: return GetBlackCasualFemaleTalkSfx(sound);
+	case MI_FEMALE02:
+	case MI_CAS_WOM: return GetWhiteCasualFemaleTalkSfx(sound);
+	case MI_FEMALE03: return GetFemaleNo3TalkSfx(sound);
+	case MI_FATFEMALE01: return GetBlackFatFemaleTalkSfx(sound);
+	case MI_FATFEMALE02: return GetWhiteFatFemaleTalkSfx(sound);
+	case MI_PROSTITUTE: return GetBlackFemaleProstituteTalkSfx(sound);
+	case MI_PROSTITUTE2: return GetWhiteFemaleProstituteTalkSfx(sound);
+	case MI_P_WOM1: return GetBlackProjectFemaleOldTalkSfx(sound);
+	case MI_P_WOM2: return GetBlackProjectFemaleYoungTalkSfx(sound);
+	case MI_CT_MAN1: return GetChinatownMaleOldTalkSfx(sound);
+	case MI_CT_MAN2: return GetChinatownMaleYoungTalkSfx(sound);
+	case MI_CT_WOM1: return GetChinatownFemaleOldTalkSfx(sound);
+	case MI_CT_WOM2: return GetChinatownFemaleYoungTalkSfx(sound);
+	case MI_LI_MAN1:
+	case MI_LI_MAN2: return GetLittleItalyMaleTalkSfx(sound);
+	case MI_LI_WOM1: return GetLittleItalyFemaleOldTalkSfx(sound);
+	case MI_LI_WOM2: return GetLittleItalyFemaleYoungTalkSfx(sound);
+	case MI_DOCKER1: return GetWhiteDockerMaleTalkSfx(sound);
+	case MI_DOCKER2: return GetBlackDockerMaleTalkSfx(sound);
+	case MI_SCUM_MAN: return GetScumMaleTalkSfx(sound);
+	case MI_SCUM_WOM: return GetScumFemaleTalkSfx(sound);
+	case MI_WORKER1: return GetWhiteWorkerMaleTalkSfx(sound);
+	case MI_WORKER2: return GetBlackWorkerMaleTalkSfx(sound);
+	case MI_B_MAN1:
+	case MI_B_MAN3: return GetBusinessMaleYoungTalkSfx(sound, ped->m_modelIndex);
+	case MI_B_MAN2: return GetBusinessMaleOldTalkSfx(sound);
+	case MI_B_WOM1:
+	case MI_B_WOM2: return GetWhiteBusinessFemaleTalkSfx(sound, ped->m_modelIndex);
+	case MI_B_WOM3: return GetBlackBusinessFemaleTalkSfx(sound);
+	case MI_MOD_MAN: return GetSupermodelMaleTalkSfx(sound);
+	case MI_MOD_WOM: return GetSupermodelFemaleTalkSfx(sound);
+	case MI_ST_MAN: return GetStewardMaleTalkSfx(sound);
+	case MI_ST_WOM: return GetStewardFemaleTalkSfx(sound);
+	case MI_FAN_MAN1:
+	case MI_FAN_MAN2: return GetFanMaleTalkSfx(sound, ped->m_modelIndex);
+	case MI_FAN_WOM: return GetFanFemaleTalkSfx(sound);
+	case MI_HOS_MAN: return GetHospitalMaleTalkSfx(sound);
+	case MI_HOS_WOM: return GetHospitalFemaleTalkSfx(sound);
+	case MI_CONST1: return GetWhiteConstructionWorkerTalkSfx(sound);
+	case MI_CONST2: return GetBlackConstructionWorkerTalkSfx(sound);
+	case MI_SHOPPER1:
+	case MI_SHOPPER2:
+	case MI_SHOPPER3: return GetShopperFemaleTalkSfx(sound, ped->m_modelIndex);
+	case MI_STUD_MAN: return GetStudentMaleTalkSfx(sound);
+	case MI_STUD_WOM: return GetStudentFemaleTalkSfx(sound);
+	case MI_CAS_MAN: return GetCasualMaleOldTalkSfx(sound);
+	default: return GetGenericMaleTalkSfx(sound);
+	}
+}
+
 uint32
 cAudioManager::GetPlayerTalkSfx(int16 sound)
 {
@@ -2953,6 +3356,2260 @@ cAudioManager::GetGenericFemaleTalkSfx(int16 sound)
 	return sfx;
 }
 
+#if 1
+
+WRAPPER
+void
+cAudioManager::ProcessActiveQueues()
+{
+	EAXJMP(0x57BA60);
+}
+
+#else
+void
+cAudioManager::ProcessActiveQueues()
+{
+	int v3;               // ecx
+	cAudioManager *v4;    // edx
+	tActiveSample *v5;    // ebx
+	cAudioManager *v6;    // edi
+	tActiveSample *v7;    // esi
+	char v8;              // al
+	unsigned __int8 v9;   // dl
+	double v10;           // st7
+	double v11;           // st6
+	float a4;             // ST08_4
+	float a3;             // ST04_4
+	int activeSampleFreq; // ecx
+	int freq;             // edi
+	int newFreq;          // ecx
+	int v17;              // eax
+	char v18;             // al
+	unsigned __int8 v19;  // al
+	float v20;            // ST0C_4
+	int v21;              // edx
+	unsigned __int8 v22;  // bl
+	cAudioManager *v23;   // ebp
+	int v24;              // ecx
+	cAudioManager *v25;   // edx
+	tActiveSample *v26;   // ebx
+	cAudioManager *v27;   // ebp
+	unsigned int v28;     // edi
+	unsigned int v29;     // eax
+	unsigned __int8 v30;  // cl
+	double v31;           // st4
+	double v32;           // st7
+	double v33;           // st6
+	double v34;           // st5
+	float v35;            // ST0C_4
+	float v36;            // ST08_4
+	float v37;            // ST04_4
+	float v38;            // ST0C_4
+	int v39;              // edx
+	int v40;              // [esp+Ch] [ebp-58h]
+	int v41;              // [esp+Ch] [ebp-58h]
+	unsigned int v42;     // [esp+10h] [ebp-54h]
+	int v43;              // [esp+10h] [ebp-54h]
+	char v44;             // [esp+14h] [ebp-50h]
+	unsigned __int8 v45;  // [esp+14h] [ebp-50h]
+	unsigned __int8 l;    // [esp+24h] [ebp-40h]
+	unsigned __int8 j;    // [esp+28h] [ebp-3Ch]
+	unsigned __int8 k;    // [esp+34h] [ebp-30h]
+	unsigned __int8 i;    // [esp+38h] [ebp-2Ch]
+	CVector a2;           // [esp+48h] [ebp-1Ch]
+
+	for(uint32 i = 0; i < m_bActiveSamples; i++) {
+		m_asSamples[m_bActiveSampleQueue][i].m_bIsProcessed = 0;
+		m_asActiveSamples[i].m_bIsProcessed = 0;
+	}
+
+	for(i = 0;; ++i) {
+		v21 = m_bActiveSampleQueue;
+		if(i >= m_bSampleRequestQueuesStatus[v21]) break;
+		v3 = i + 27 * v21;
+		v4 = (this + 2484 * v21);
+		v5 = &v4->m_asSamples[m_abSampleQueueIndexTable[v3]];
+		if(v4->m_asSamples[m_abSampleQueueIndexTable[v3]].m_nSampleIndex != NO_SAMPLE) {
+			v6 = this;
+			for(j = 0;; ++j) {
+				if(j >= m_bActiveSamples) goto LABEL_58;
+				v7 = m_asActiveSamples;
+				if(v5->m_nEntityIndex == m_asActiveSamples[0].m_nEntityIndex &&
+				   v5->field_4 == m_asActiveSamples[0].field_4 &&
+				   v5->m_nSampleIndex == m_asActiveSamples[0].m_nSampleIndex) {
+					break;
+				}
+			LABEL_56:
+				v6 = (v6 + 92);
+			}
+			if(v5->m_nLoopCount) {
+				if(m_nTimeOfRecentCrime & 1) {
+					if(!(j & 1)) {
+						v8 = 0;
+						goto LABEL_17;
+					}
+				LABEL_16:
+					v8 = 1;
+				} else {
+					if(!(j & 1)) goto LABEL_16;
+					v8 = 0;
+				}
+			LABEL_17:
+				if(v8 && !cSampleManager.GetChannelUsedFlag(j)) {
+					v5->m_bLoopEnded = 1;
+					m_asActiveSamples[0].m_bLoopEnded = 1;
+					m_asActiveSamples[0].m_nSampleIndex = NO_SAMPLE;
+					v7->m_nEntityIndex = -5;
+					goto LABEL_56;
+				}
+			}
+			v5->m_bIsProcessed = 1;
+			m_asActiveSamples[0].m_bIsProcessed = 1;
+			v5->field_88 = -1;
+			if(!v5->field_56) {
+				if(v5->m_bIsDistant) {
+					if(field_4) {
+						v9 = v5->m_bEmittingVolume;
+						if(v9 >= 63u)
+							v42 = 63;
+						else
+							v42 = v9;
+						v43 = 2 * v42;
+					} else {
+						v43 = v5->m_bEmittingVolume;
+					}
+					cSampleManager.SetChannelFrequency(j, v5->m_nFrequency);
+					cSampleManager.SetChannelEmittingVolume(j, v43);
+				} else {
+					v10 = m_asActiveSamples[0].m_fDistance;
+					v11 = v5->m_fDistance;
+					m_asActiveSamples[0].m_fDistance = v5->m_fDistance;
+					a4 = v11;
+					a3 = v10;
+					v5->m_nFrequency = ComputeDopplerEffectedFrequency(
+					    v5->m_nFrequency, a3, a4, v5->field_48);
+					activeSampleFreq = m_asActiveSamples[0].m_nFrequency;
+					freq = v5->m_nFrequency;
+					if(freq != activeSampleFreq) {
+						if(freq <= activeSampleFreq) {
+							if(activeSampleFreq - 6000 > freq)
+								freq = activeSampleFreq - 6000;
+							newFreq = freq;
+						} else if(activeSampleFreq + 6000 >= freq) {
+							newFreq = v5->m_nFrequency;
+						} else {
+							newFreq = activeSampleFreq + 6000;
+						}
+						v7->m_nFrequency = newFreq;
+						cSampleManager.SetChannelFrequency(j, newFreq);
+					}
+					v40 = v7->m_bEmittingVolume;
+					v17 = v5->m_bEmittingVolume;
+					if(v17 != v40) {
+						if(v17 <= v40) {
+							if(v40 - 10 > v17) v17 = v40 - 10;
+							v41 = v17;
+						} else if(v40 + 10 >= v17) {
+							v41 = v5->m_bEmittingVolume;
+						} else {
+							v41 = v40 + 10;
+						}
+						if(field_4) {
+							if(v41 >= 63)
+								v18 = 63;
+							else
+								v18 = v41;
+							v19 = 2 * v18;
+						} else {
+							v19 = v41;
+						}
+						cSampleManager.SetChannelEmittingVolume(j, v19);
+						v7->m_bEmittingVolume = v41;
+					}
+					TranslateEntity(&v5->m_vecPos, &a2);
+					cSampleManager.SetChannel3DPosition(j, a2.x, a2.y, a2.z);
+					v20 = 0.25f * v5->m_fSoundIntensity;
+					cSampleManager.SetChannel3DDistances(
+					    j, v5->m_fSoundIntensity, v20);
+				}
+				cSampleManager.SetChannelReverbFlag(j, v5->m_bReverbFlag);
+				continue;
+			}
+			v5->m_bIsProcessed = 0;
+			m_asActiveSamples[0].m_bIsProcessed = 0;
+			goto LABEL_56;
+		}
+	LABEL_58:;
+	}
+	v22 = 0;
+	v23 = this;
+	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);
+			v23->m_asActiveSamples[0].m_nSampleIndex = NO_SAMPLE;
+			v23->m_asActiveSamples[0].m_nEntityIndex = -5;
+		}
+		v23 = (v23 + 92);
+	}
+	for(k = 0; k < m_bSampleRequestQueuesStatus[m_bActiveSampleQueue]; ++k) {
+		v24 = k + 27 * v39;
+		v25 = (this + 2484 * v39);
+		v26 = &v25->m_asSamples[m_abSampleQueueIndexTable[v24]];
+		if(!v25->m_asSamples[m_abSampleQueueIndexTable[v24]].m_bIsProcessed &&
+		   !v25->m_asSamples[m_abSampleQueueIndexTable[v24]].m_bLoopEnded &&
+		   m_asAudioEntities[v26->m_nEntityIndex].m_bIsUsed &&
+		   v25->m_asSamples[m_abSampleQueueIndexTable[v24]].m_nSampleIndex < NO_SAMPLE) {
+			if(v25->m_asSamples[m_abSampleQueueIndexTable[v24]].field_4 > 255u &&
+			   v25->m_asSamples[m_abSampleQueueIndexTable[v24]].m_nLoopCount &&
+			   v25->m_asSamples[m_abSampleQueueIndexTable[v24]].m_bLoopsRemaining) {
+				--v25->m_asSamples[m_abSampleQueueIndexTable[v24]]
+				      .m_bLoopsRemaining;
+				v26->field_76 = 1;
+			} else {
+				v27 = this;
+				for(l = 0; l < m_bActiveSamples; ++l) {
+					if(!v27->m_asActiveSamples[0].m_bIsProcessed) {
+						if(!v26->m_nLoopCount) goto LABEL_80;
+						v28 = v26->m_nFrequency / field_19192;
+						v29 = v26->m_nLoopCount *
+						      cSampleManager.GetSampleLength(
+						          v26->m_nSampleIndex);
+						if(v28) {
+							v26->field_76 = v29 / v28 + 1;
+						LABEL_80:
+							memcpy(v27->m_asActiveSamples, v26, 92);
+							if(!v27->m_asActiveSamples[0].m_bIsDistant)
+								TranslateEntity(
+								    &v27->m_asActiveSamples[0]
+								         .m_vecPos,
+								    &a2);
+							if(field_4) {
+								if(v27->m_asActiveSamples[0]
+								       .m_bEmittingVolume >= 63u)
+									v44 = 63;
+								else
+									v44 =
+									    v27
+									        ->m_asActiveSamples
+									            [0]
+									        .m_bEmittingVolume;
+								v45 = 2 * v44;
+							} else {
+								v45 = v27->m_asActiveSamples[0]
+								          .m_bEmittingVolume;
+							}
+							if(cSampleManager.InitialiseChannel(
+							       l,
+							       v27->m_asActiveSamples[0]
+							           .m_nSampleIndex,
+							       v27->m_asActiveSamples[0]
+							           .m_bBankIndex)) {
+								cSampleManager.SetChannelFrequency(
+								    l, v27->m_asActiveSamples[0]
+								           .m_nFrequency);
+								cSampleManager
+								    .SetChannelEmittingVolume(l,
+								                              v45);
+								cSampleManager.SetChannelLoopPoints(
+								    l,
+								    v27->m_asActiveSamples[0]
+								        .m_nLoopStart,
+								    v27->m_asActiveSamples[0]
+								        .m_nLoopEnd);
+								cSampleManager.SetChannelLoopCount(
+								    l, v27->m_asActiveSamples[0]
+								           .m_nLoopCount);
+								cSampleManager.SetChannelReverbFlag(
+								    l, v27->m_asActiveSamples[0]
+								           .m_bReverbFlag);
+								if(v27->m_asActiveSamples[0]
+								       .m_bIsDistant) {
+									v30 = v27->m_asActiveSamples
+									          [0]
+									              .m_bOffset;
+									if(v30 == 63) {
+										v31 = 0.0f;
+									} else if(v30 >= 63u) {
+										v31 = (v30 - 63) *
+										      15.873f;
+									} else {
+										v31 = -((63 - v30) *
+										        15.873f);
+									}
+									v32 = v31;
+									v33 = 0.0f;
+									v34 = 0.0f;
+									v27->m_asActiveSamples[0]
+									    .m_fSoundIntensity =
+									    100000.0f;
+								} else {
+									v32 = a2.x;
+									v33 = a2.y;
+									v34 = a2.z;
+								}
+								v35 = v34;
+								v36 = v33;
+								v37 = v32;
+								cSampleManager.SetChannel3DPosition(
+								    l, v37, v36, v35);
+								v38 = 0.25f *
+								      v27->m_asActiveSamples[0]
+								          .m_fSoundIntensity;
+								cSampleManager
+								    .SetChannel3DDistances(
+								        l,
+								        v27->m_asActiveSamples[0]
+								            .m_fSoundIntensity,
+								        v38);
+								cSampleManager.StartChannel(l);
+							}
+							v27->m_asActiveSamples[0].m_bIsProcessed =
+							    1;
+							v26->m_bIsProcessed = 1;
+							v26->field_88 = -1;
+							break;
+						}
+					}
+					v27 = (v27 + 92);
+				}
+			}
+		}
+	}
+}
+#endif
+
+bool
+cAudioManager::ProcessAirBrakes(cVehicleParams *params)
+{
+	CAutomobile *automobile;
+	uint8 rand;
+
+	if(params->m_fDistance > 900.0f) return 0;
+	automobile = (CAutomobile *)params->m_pVehicle;
+	if(!automobile->bEngineOn) return 1;
+
+	if((automobile->m_fVelocityChangeForAudio < 0.025f ||
+	    params->m_fVelocityChange >= 0.025f) &&
+	   (automobile->m_fVelocityChangeForAudio > -0.025f || params->m_fVelocityChange <= 0.025f))
+		return 1;
+
+	CalculateDistance((bool *)params, params->m_fDistance);
+	rand = m_anRandomTable[0] % 10u + 70;
+	m_sQueueSample.m_bVolume = ComputeVolume(rand, 30.0f, m_sQueueSample.m_fDistance);
+	if(m_sQueueSample.m_bVolume) {
+		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);
+		m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency >> 4);
+		m_sQueueSample.m_bBankIndex = 0;
+		m_sQueueSample.m_bIsDistant = 0;
+		m_sQueueSample.field_16 = 10;
+		m_sQueueSample.m_nLoopCount = 1;
+		m_sQueueSample.m_bEmittingVolume = rand;
+		m_sQueueSample.m_nLoopStart = 0;
+		m_sQueueSample.m_nLoopEnd = -1;
+		m_sQueueSample.field_48 = 0.0f;
+		m_sQueueSample.m_fSoundIntensity = 30.0f;
+		m_sQueueSample.field_56 = 1;
+		m_sQueueSample.m_bReverbFlag = 1;
+		m_sQueueSample.m_bRequireReflection = 0;
+		AddSampleToRequestedQueue();
+	}
+
+	return 1;
+}
+
+void
+cAudioManager::ProcessAirportScriptObject(uint8 sound)
+{
+
+	float dist;
+	float distSquared;
+	float maxDist;
+
+	static uint8 counter = 0;
+
+	uint32 time = CTimer::GetTimeInMilliseconds();
+	if(time > audioLogicTimers[3]) {
+		switch(sound) {
+		case SCRIPT_SOUND_AIRPORT_LOOP_S:
+			maxDist = 900.f;
+			m_sQueueSample.m_fSoundIntensity = 30.0f;
+			break;
+		case SCRIPT_SOUND_AIRPORT_LOOP_L:
+			maxDist = 6400.f;
+			m_sQueueSample.m_fSoundIntensity = 80.0f;
+			break;
+		default: break;
+		}
+		distSquared = GetDistanceSquared(&m_sQueueSample.m_vecPos);
+		if(distSquared < maxDist) {
+			dist = sqrt(distSquared);
+			m_sQueueSample.m_fDistance = dist;
+			m_sQueueSample.m_bVolume = ComputeVolume(
+			    110u, m_sQueueSample.m_fSoundIntensity, m_sQueueSample.m_fDistance);
+			if(m_sQueueSample.m_bVolume) {
+				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_nSampleIndex);
+				m_sQueueSample.field_4 = counter++;
+				m_sQueueSample.m_bIsDistant = 0;
+				m_sQueueSample.m_nLoopCount = 1;
+				m_sQueueSample.field_56 = 1;
+				m_sQueueSample.field_16 = 3;
+				m_sQueueSample.field_48 = 2.0f;
+				m_sQueueSample.m_bEmittingVolume = 110;
+				m_sQueueSample.m_nLoopStart = 0;
+				m_sQueueSample.m_nLoopEnd = -1;
+				m_sQueueSample.m_bReverbFlag = 1;
+				m_sQueueSample.m_bRequireReflection = 0;
+				AddSampleToRequestedQueue();
+				audioLogicTimers[3] = time + 10000 + m_anRandomTable[3] % 20000u;
+			}
+		}
+	}
+}
+
+WRAPPER
+bool
+cAudioManager::ProcessBoatEngine(cVehicleParams *params)
+{
+	EAXJMP(0x56DE80);
+}
+
+WRAPPER
+bool
+cAudioManager::ProcessBoatMovingOverWater(cVehicleParams *params)
+{
+	EAXJMP(0x56E500);
+}
+
+WRAPPER
+void
+cAudioManager::ProcessBridge()
+{
+	EAXJMP(0x5790D0);
+}
+
+void
+cAudioManager::ProcessBridgeMotor()
+{
+	if(m_sQueueSample.m_fDistance < 400.f) {
+		m_sQueueSample.m_bVolume = ComputeVolume(127, 400.f, m_sQueueSample.m_fDistance);
+		if(m_sQueueSample.m_bVolume) {
+			m_sQueueSample.field_4 = 1;
+			m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_MOTOR;
+			m_sQueueSample.m_bBankIndex = 0;
+			m_sQueueSample.m_bIsDistant = 0;
+			m_sQueueSample.field_16 = 1;
+			m_sQueueSample.m_nFrequency = 5500;
+			m_sQueueSample.m_nLoopCount = 0;
+			m_sQueueSample.m_bEmittingVolume = 127;
+			m_sQueueSample.m_nLoopStart =
+			    cSampleManager.GetSampleLoopStartOffset(m_sQueueSample.m_nSampleIndex);
+			m_sQueueSample.m_nLoopEnd =
+			    cSampleManager.GetSampleLoopEndOffset(m_sQueueSample.m_nSampleIndex);
+			m_sQueueSample.field_48 = 2.0f;
+			m_sQueueSample.m_fSoundIntensity = 400.0f;
+			m_sQueueSample.field_56 = 0;
+			m_sQueueSample.field_76 = 3;
+			m_sQueueSample.m_bReverbFlag = 0;
+			AddSampleToRequestedQueue();
+		}
+	}
+}
+
+WRAPPER
+void
+cAudioManager::ProcessBridgeOneShots()
+{
+	EAXJMP(0x579310);
+}
+
+void
+cAudioManager::ProcessBridgeWarning()
+{
+	if(CStats::CommercialPassed && m_sQueueSample.m_fDistance < 450.f) {
+		m_sQueueSample.m_bVolume = ComputeVolume(100u, 450.f, m_sQueueSample.m_fDistance);
+		if(m_sQueueSample.m_bVolume) {
+			m_sQueueSample.field_4 = 0;
+			m_sQueueSample.m_nSampleIndex = 457;
+			m_sQueueSample.m_bBankIndex = 0;
+			m_sQueueSample.m_bIsDistant = 0;
+			m_sQueueSample.field_16 = 1;
+			m_sQueueSample.m_nFrequency =
+			    cSampleManager.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);
+			m_sQueueSample.m_nLoopEnd =
+			    cSampleManager.GetSampleLoopEndOffset(m_sQueueSample.m_nSampleIndex);
+			m_sQueueSample.field_48 = 2.0f;
+			m_sQueueSample.m_fSoundIntensity = 450.0f;
+			m_sQueueSample.field_56 = 0;
+			m_sQueueSample.field_76 = 8;
+			m_sQueueSample.m_bReverbFlag = 0;
+			m_sQueueSample.m_bRequireReflection = 0;
+			AddSampleToRequestedQueue();
+		}
+	}
+}
+
+WRAPPER
+bool
+cAudioManager::ProcessCarBombTick(void *)
+{
+	EAXJMP(0x56CC20);
+}
+
+WRAPPER
+void
+cAudioManager::ProcessCesna(void *)
+{
+	EAXJMP(0x56ADF0);
+}
+
+void
+cAudioManager::ProcessCinemaScriptObject(uint8 sound)
+{
+	uint8 rand;
+	float distSquared;
+	float maxDist;
+
+	static uint8 counter = 0;
+
+	uint32 time = CTimer::GetTimeInMilliseconds();
+	if(time > audioLogicTimers[4]) {
+		switch(sound) {
+		case SCRIPT_SOUND_CINEMA_LOOP_S:
+			maxDist = 900.f;
+			m_sQueueSample.m_fSoundIntensity = 30.0f;
+			break;
+		case SCRIPT_SOUND_CINEMA_LOOP_L:
+			maxDist = 6400.f;
+			m_sQueueSample.m_fSoundIntensity = 80.0f;
+			break;
+		default: break;
+		}
+		distSquared = GetDistanceSquared(&m_sQueueSample.m_vecPos);
+		if(distSquared < maxDist) {
+			m_sQueueSample.m_fDistance = sqrt(distSquared);
+			rand = m_anRandomTable[0] % 90u + 30;
+			m_sQueueSample.m_bVolume = ComputeVolume(
+			    rand, m_sQueueSample.m_fSoundIntensity, m_sQueueSample.m_fDistance);
+			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_nSampleIndex);
+				m_sQueueSample.m_nFrequency +=
+				    RandomDisplacement(m_sQueueSample.m_nFrequency >> 2);
+				m_sQueueSample.field_4 = counter++;
+				m_sQueueSample.m_bIsDistant = 0;
+				m_sQueueSample.m_nLoopCount = 1;
+				m_sQueueSample.field_56 = 1;
+				m_sQueueSample.field_16 = 3;
+				m_sQueueSample.field_48 = 2.0f;
+				m_sQueueSample.m_bEmittingVolume = rand;
+				m_sQueueSample.m_nLoopStart = 0;
+				m_sQueueSample.m_nLoopEnd = -1;
+				m_sQueueSample.m_bReverbFlag = 1;
+				m_sQueueSample.m_bRequireReflection = 0;
+				AddSampleToRequestedQueue();
+				audioLogicTimers[4] = time + 1000 + m_anRandomTable[3] % 4000u;
+			}
+		}
+	}
+}
+
+WRAPPER
+void
+cAudioManager::ProcessCrane()
+{
+	EAXJMP(0x578910);
+}
+
+void
+cAudioManager::ProcessDocksScriptObject(uint8 sound)
+{
+	uint32 time;
+	uint8 rand;
+	float distSquared;
+	float maxDist;
+
+	static uint32 counter = 0;
+
+	time = CTimer::GetTimeInMilliseconds();
+	if(time > audioLogicTimers[5]) {
+		switch(sound) {
+		case SCRIPT_SOUND_DOCKS_LOOP_S:
+			maxDist = 900.f;
+			m_sQueueSample.m_fSoundIntensity = 30.0f;
+			break;
+		case SCRIPT_SOUND_DOCKS_LOOP_L:
+			maxDist = 6400.f;
+			m_sQueueSample.m_fSoundIntensity = 80.0f;
+			break;
+		default: break;
+		}
+		distSquared = GetDistanceSquared(&m_sQueueSample.m_vecPos);
+		if(distSquared < maxDist) {
+			m_sQueueSample.m_fDistance = sqrt(distSquared);
+			rand = m_anRandomTable[0] % 60u + 40;
+			m_sQueueSample.m_bVolume = ComputeVolume(
+			    rand, m_sQueueSample.m_fSoundIntensity, m_sQueueSample.m_fDistance);
+			if(m_sQueueSample.m_bVolume) {
+				m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_DOCKS;
+				m_sQueueSample.m_bBankIndex = 0;
+				m_sQueueSample.m_nFrequency =
+				    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_DOCKS);
+				m_sQueueSample.m_nFrequency +=
+				    RandomDisplacement(m_sQueueSample.m_nFrequency >> 3);
+				m_sQueueSample.field_4 = counter++;
+				m_sQueueSample.m_bIsDistant = 0;
+				m_sQueueSample.m_nLoopCount = 1;
+				m_sQueueSample.field_56 = 1;
+				m_sQueueSample.field_16 = 3;
+				m_sQueueSample.field_48 = 2.0f;
+				m_sQueueSample.m_bEmittingVolume = rand;
+				m_sQueueSample.m_nLoopStart = 0;
+				m_sQueueSample.m_nLoopEnd = -1;
+				m_sQueueSample.m_bReverbFlag = 1;
+				m_sQueueSample.m_bRequireReflection = 0;
+				AddSampleToRequestedQueue();
+				audioLogicTimers[5] = time + 10000 + m_anRandomTable[3] % 40000u;
+			}
+		}
+	}
+}
+
+void
+cAudioManager::ProcessEntity(int32 id)
+{
+	if(m_asAudioEntities[id].m_bStatus) {
+		m_sQueueSample.m_nEntityIndex = id;
+		switch(m_asAudioEntities[id].m_nType) {
+		case AUDIOTYPE_PHYSICAL:
+			if(!m_bUserPause) {
+				m_sQueueSample.m_bReverbFlag = 1;
+				cAudioManager::ProcessPhysical(id);
+			}
+			break;
+		case AUDIOTYPE_EXPLOSION:
+			if(!m_bUserPause) {
+				m_sQueueSample.m_bReverbFlag = 1;
+				cAudioManager::ProcessExplosions(id);
+			}
+			break;
+		case AUDIOTYPE_FIRE:
+			if(!m_bUserPause) {
+				m_sQueueSample.m_bReverbFlag = 1;
+				cAudioManager::ProcessFires(id);
+			}
+			break;
+		case AUDIOTYPE_WEATHER:
+			if(!m_bUserPause) {
+				m_sQueueSample.m_bReverbFlag = 1;
+				cAudioManager::ProcessWeather(id);
+			}
+			break;
+		case AUDIOTYPE_CRANE:
+			if(!m_bUserPause) {
+				m_sQueueSample.m_bReverbFlag = 1;
+				cAudioManager::ProcessCrane();
+			}
+			break;
+		case AUDIOTYPE_ONE_SHOT:
+			if(!m_bUserPause) {
+				m_sQueueSample.m_bReverbFlag = 1;
+				cAudioManager::ProcessScriptObject(id);
+			}
+			break;
+		case AUDIOTYPE_BRIDGE:
+			if(!m_bUserPause) {
+				m_sQueueSample.m_bReverbFlag = 1;
+				cAudioManager::ProcessBridgeOneShots();
+			}
+			break;
+		case AUDIOTYPE_FRONTEND:
+			m_sQueueSample.m_bReverbFlag = 0;
+			cAudioManager::ProcessFrontEnd();
+			break;
+		case AUDIOTYPE_PROJECTILE:
+			if(!m_bUserPause) {
+				m_sQueueSample.m_bReverbFlag = 1;
+				cAudioManager::ProcessProjectiles();
+			}
+			break;
+		case AUDIOTYPE_GARAGE:
+			if(!m_bUserPause) cAudioManager::ProcessGarages();
+			break;
+		case AUDIOTYPE_HYDRANT:
+			if(!m_bUserPause) {
+				m_sQueueSample.m_bReverbFlag = 1;
+				cAudioManager::ProcessFireHydrant();
+			}
+			break;
+		case AUDIOTYPE_WATER_CANNON:
+			if(!m_bUserPause) {
+				m_sQueueSample.m_bReverbFlag = 1;
+				cAudioManager::ProcessWaterCannon(id);
+			}
+			break;
+		default: return;
+		}
+	}
+}
+
+WRAPPER
+void
+cAudioManager::ProcessExplosions(int32 explosion)
+{
+	EAXJMP(0x575AC0);
+}
+
+void
+cAudioManager::ProcessFireHydrant()
+{
+	float distSquared;
+	bool something = false;
+
+	m_sQueueSample.m_vecPos =
+	    *(CVector *)((size_t)m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_pEntity + 52);
+	distSquared = GetDistanceSquared(&m_sQueueSample.m_vecPos);
+	if(distSquared < 1225.f) {
+		CalculateDistance(&something, distSquared);
+		m_sQueueSample.m_bVolume = ComputeVolume(40u, 35.f, m_sQueueSample.m_fDistance);
+		if(m_sQueueSample.m_bVolume) {
+			m_sQueueSample.field_4 = 0;
+			m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_JUMBO_TAXI_SOUND;
+			m_sQueueSample.m_bBankIndex = 0;
+			m_sQueueSample.m_bIsDistant = 0;
+			m_sQueueSample.field_16 = 4;
+			m_sQueueSample.m_nFrequency = 15591;
+			m_sQueueSample.m_nLoopCount = 0;
+			m_sQueueSample.m_bEmittingVolume = 40;
+			m_sQueueSample.m_nLoopStart =
+			    cSampleManager.GetSampleLoopStartOffset(m_sQueueSample.m_nSampleIndex);
+			m_sQueueSample.m_nLoopEnd =
+			    cSampleManager.GetSampleLoopEndOffset(m_sQueueSample.m_nSampleIndex);
+			m_sQueueSample.field_48 = 2.0f;
+			m_sQueueSample.m_fSoundIntensity = 35.0f;
+			m_sQueueSample.field_56 = 0;
+			m_sQueueSample.field_76 = 3;
+			m_sQueueSample.m_bReverbFlag = 1;
+			m_sQueueSample.m_bRequireReflection = 0;
+			AddSampleToRequestedQueue();
+		}
+	}
+}
+
+WRAPPER
+void
+cAudioManager::ProcessFires(int32 entity)
+{
+	EAXJMP(0x575CD0);
+}
+
+void
+cAudioManager::ProcessFrontEnd()
+{
+	bool processed;
+	int16 sample;
+
+	static uint32 counter = 0;
+
+	for(uint32 i = 0; i < m_asAudioEntities[m_sQueueSample.m_nEntityIndex].field_24; i++) {
+		processed = 0;
+		switch(
+		    m_asAudioEntities[0].m_awAudioEvent[i + 20 * m_sQueueSample.m_nEntityIndex]) {
+		case SOUND_WEAPON_SNIPER_SHOT_NO_ZOOM:
+			m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_SNIPER_NO_ZOOM;
+			break;
+		case SOUND_WEAPON_ROCKET_SHOT_NO_ZOOM:
+			m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_ROCKET_NO_ZOOM;
+			break;
+		case SOUND_GARAGE_NO_MONEY:
+		case SOUND_GARAGE_BAD_VEHICLE:
+		case SOUND_3C:
+			m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_PICKUP_FAIL_1;
+			processed = 1;
+			break;
+		case SOUND_GARAGE_OPENING:
+		case SOUND_GARAGE_BOMB1_SET:
+		case SOUND_GARAGE_BOMB2_SET:
+		case SOUND_GARAGE_BOMB3_SET:
+		case SOUND_41:
+		case SOUND_GARAGE_VEHICLE_DECLINED:
+		case SOUND_GARAGE_VEHICLE_ACCEPTED:
+		case SOUND_PICKUP_HEALTH:
+		case SOUND_4B:
+		case SOUND_PICKUP_ADRENALINE:
+		case SOUND_PICKUP_ARMOUR:
+		case SOUND_EVIDENCE_PICKUP:
+		case SOUND_UNLOAD_GOLD:
+			m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_PICKUP_SUCCESS_1;
+			processed = 1;
+			break;
+		case SOUND_PICKUP_WEAPON_BOUGHT:
+		case SOUND_PICKUP_WEAPON:
+			m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_PICKUP_NEUTRAL_1;
+			processed = 1;
+			break;
+		case SOUND_4A:
+			m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_PICKUP_FAIL_1;
+			processed = 1;
+			break;
+		case SOUND_PICKUP_BONUS:
+		case SOUND_PICKUP_MONEY:
+		case SOUND_PICKUP_HIDDEN_PACKAGE:
+		case SOUND_PICKUP_PACMAN_PILL:
+		case SOUND_PICKUP_PACMAN_PACKAGE:
+		case SOUND_PICKUP_FLOAT_PACKAGE:
+			m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_PICKUP_SUCCESS_3;
+			processed = 1;
+			break;
+		case SOUND_PAGER: m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_PAGER; break;
+		case SOUND_RACE_START_3:
+		case SOUND_RACE_START_2:
+		case SOUND_RACE_START_1:
+		case SOUND_CLOCK_TICK:
+			m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_FRONTEND_CLOCK_TICK;
+			break;
+		case SOUND_RACE_START_GO:
+			m_sQueueSample.m_nSampleIndex =
+			    AUDIO_SAMPLE_FRONTEND_PART_MISSION_COMPLETED;
+			break;
+		case SOUND_PART_MISSION_COMPLETE:
+			m_sQueueSample.m_nSampleIndex =
+			    AUDIO_SAMPLE_FRONTEND_PART_MISSION_COMPLETED;
+			break;
+		case SOUND_FRONTEND_MENU_STARTING:
+			processed = 1;
+			m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_FRONTEND_MENU_STARTING_1;
+			break;
+		case SOUND_FRONTEND_MENU_COMPLETED:
+			processed = 1;
+			m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_FRONTEND_MENU_COMPLETED_1;
+			break;
+		case SOUND_FRONTEND_MENU_DENIED:
+			processed = 1;
+			m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_FRONTEND_MENU_DENIED_1;
+			break;
+		case SOUND_FRONTEND_MENU_SUCCESS:
+			processed = 1;
+			m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_FRONTEND_MENU_SUCCESS_1;
+			break;
+		case SOUND_FRONTEND_EXIT:
+			processed = 1;
+			m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_FRONTEND_MENU_EXIT_1;
+			break;
+		case SOUND_9A:
+			processed = 1;
+			m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_380;
+			break;
+		case SOUND_9B: m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_382; break;
+		case SOUND_FRONTEND_AUDIO_TEST:
+			m_sQueueSample.m_nSampleIndex =
+			    m_anRandomTable[0] % 3u + AUDIO_SAMPLE_FRONTEND_MENU_AUDIO_TEST_1;
+			break;
+		case SOUND_FRONTEND_FAIL:
+			processed = 1;
+			m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_FRONTEND_MENU_FAIL_1;
+			break;
+		case SOUND_FRONTEND_NO_RADIO:
+		case SOUND_FRONTEND_RADIO_CHANGE:
+			m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_FRONTEND_GAMEPLAY_FAIL;
+			break;
+		case SOUND_A0:
+			m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_FRONTEND_GAMEPLAY_SUCCESS;
+			break;
+		default: continue;
+		}
+
+		sample =
+		    m_asAudioEntities[0].m_awAudioEvent[i + 20 * m_sQueueSample.m_nEntityIndex];
+		if(sample == AUDIO_SAMPLE_COLLISION_LOOPING_GRASS) {
+			m_sQueueSample.m_nFrequency = 28509;
+		} else if(sample == AUDIO_SAMPLE_PICKUP_NEUTRAL_1) {
+			if(1.f ==
+			   m_asAudioEntities[0].m_afVolume[i + 10 * m_sQueueSample.m_nEntityIndex])
+				m_sQueueSample.m_nFrequency = 32000;
+			else
+				m_sQueueSample.m_nFrequency = 48000;
+		} else {
+			m_sQueueSample.m_nFrequency =
+			    cSampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
+		}
+		m_sQueueSample.m_bVolume = 110;
+		m_sQueueSample.field_4 = counter++;
+		m_sQueueSample.m_nLoopCount = 1;
+		m_sQueueSample.field_56 = 1;
+		m_sQueueSample.m_bBankIndex = 0;
+		m_sQueueSample.field_16 = 0;
+		m_sQueueSample.m_bIsDistant = 1;
+		m_sQueueSample.m_bEmittingVolume = m_sQueueSample.m_bVolume;
+		m_sQueueSample.m_nLoopStart = 0;
+		m_sQueueSample.m_nLoopEnd = -1;
+		if(processed)
+			m_sQueueSample.m_bOffset = m_anRandomTable[0] & 0x1F;
+		else
+			m_sQueueSample.m_bOffset = 63;
+		m_sQueueSample.m_bReverbFlag = 0;
+		m_sQueueSample.m_bRequireReflection = 0;
+		AddSampleToRequestedQueue();
+		if(processed) {
+			++m_sQueueSample.m_nSampleIndex;
+			m_sQueueSample.field_4 = counter++;
+			m_sQueueSample.m_bOffset = 127 - m_sQueueSample.m_bOffset;
+			AddSampleToRequestedQueue();
+		}
+	}
+}
+
+WRAPPER
+void
+cAudioManager::ProcessGarages()
+{
+	EAXJMP(0x578C20);
+}
+
+void
+cAudioManager::ProcessHomeScriptObject(uint8 sound)
+{
+	uint32 time;
+	uint8 rand;
+	float dist;
+	float maxDist;
+
+	static uint8 counter = 0;
+
+	time = CTimer::GetTimeInMilliseconds();
+	if(time > audioLogicTimers[6]) {
+		switch(sound) {
+		case SCRIPT_SOUND_HOME_LOOP_S:
+			maxDist = 900.f;
+			m_sQueueSample.m_fSoundIntensity = 30.0f;
+			break;
+		case SCRIPT_SOUND_HOME_LOOP_L:
+			maxDist = 6400.f;
+			m_sQueueSample.m_fSoundIntensity = 80.0f;
+			break;
+		default: break;
+		}
+		dist = GetDistanceSquared(&m_sQueueSample.m_vecPos);
+		if(dist < maxDist) {
+			m_sQueueSample.m_fDistance = sqrt(dist);
+			rand = m_anRandomTable[0] % 30u + 40;
+			m_sQueueSample.m_bVolume = ComputeVolume(
+			    rand, m_sQueueSample.m_fSoundIntensity, m_sQueueSample.m_fDistance);
+			if(m_sQueueSample.m_bVolume) {
+				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_nSampleIndex);
+				m_sQueueSample.m_nFrequency +=
+				    RandomDisplacement(m_sQueueSample.m_nFrequency >> 4);
+				m_sQueueSample.field_4 = counter++;
+				m_sQueueSample.m_bIsDistant = 0;
+				m_sQueueSample.m_nLoopCount = 1;
+				m_sQueueSample.field_56 = 1;
+				m_sQueueSample.field_16 = 3;
+				m_sQueueSample.field_48 = 0.0f;
+				m_sQueueSample.m_bEmittingVolume = rand;
+				m_sQueueSample.m_nLoopStart = 0;
+				m_sQueueSample.m_nLoopEnd = -1;
+				m_sQueueSample.m_bReverbFlag = 1;
+				m_sQueueSample.m_bRequireReflection = 1;
+				AddSampleToRequestedQueue();
+				audioLogicTimers[6] = time + 1000 + m_anRandomTable[3] % 4000u;
+			}
+		}
+	}
+}
+
+float *PlanePathPosition = (float *)0x8F5FC8;
+float &LandingPoint = *(float *)0x8F2C7C;
+float &TakeOffPoint = *(float *)0x8E28A4;
+
+void
+cAudioManager::ProcessJumbo(cVehicleParams *params)
+{
+	CPlane *plane;
+	float position;
+
+	if(params->m_fDistance < 193600.0f) {
+		CalculateDistance((bool *)params, params->m_fDistance);
+		plane = (CPlane *)params->m_pVehicle;
+		DoJumboVolOffset();
+		position = PlanePathPosition[plane->m_wIndex];
+		if(position <= TakeOffPoint) {
+			if(plane->field_656 <= 0.10334f) {
+				ProcessJumboTaxi();
+				return;
+			}
+
+			ProcessJumboAccel(plane);
+		} else if(300.0f + TakeOffPoint >= position) {
+			ProcessJumboTakeOff(plane);
+		} else if(LandingPoint - 350.0f >= position) {
+			ProcessJumboFlying();
+		} else {
+			if(position > LandingPoint) {
+				if(plane->field_656 > 0.10334f) {
+					ProcessJumboDecel(plane);
+					return;
+				}
+				ProcessJumboTaxi();
+				return;
+			}
+			ProcessJumboLanding(plane);
+		}
+	}
+}
+
+void
+cAudioManager::ProcessJumboAccel(CPlane *plane)
+{
+	int32 engineFreq;
+	int32 vol;
+	float whineSoundFreq;
+	float modificator;
+
+	if(SetupJumboFlySound(20u)) {
+		modificator = (plane->field_656 - 0.10334f) * 1.676f;
+		if(modificator > 1.0f) modificator = 1.0f;
+		if(cAudioManager::SetupJumboRumbleSound(maxVolume * modificator) &&
+		   SetupJumboTaxiSound((1.0f - modificator) * 75.f)) {
+			if(modificator < 0.2f) {
+				whineSoundFreq = modificator * 5.f * 14600.0f + 29500;
+				vol = modificator * 5.f * maxVolume;
+				engineFreq = modificator * 5.f * 6050.f + 16000;
+			} else {
+				whineSoundFreq = 44100;
+				engineFreq = 22050;
+				vol = maxVolume;
+			}
+			SetupJumboEngineSound(vol, engineFreq);
+			SetupJumboWhineSound(18u, whineSoundFreq);
+		}
+	}
+}
+
+void
+cAudioManager::ProcessJumboDecel(CPlane *plane)
+{
+	float modificator;
+
+	if(SetupJumboFlySound(20u) && SetupJumboTaxiSound(75u)) {
+		modificator = (plane->field_656 - 0.10334f) * 1.676f;
+		if(modificator > 1.0f) modificator = 1.0f;
+		SetupJumboEngineSound(maxVolume * modificator, 6050.f * modificator + 16000);
+		SetupJumboWhineSound(18u, 29500);
+	}
+}
+
+void
+cAudioManager::ProcessJumboFlying()
+{
+	if(SetupJumboFlySound(127u)) SetupJumboEngineSound(63u, 22050);
+}
+
+void
+cAudioManager::ProcessJumboLanding(CPlane *plane)
+{
+	float modificator = (LandingPoint - PlanePathPosition[plane->m_wIndex]) * 0.0028571f;
+	if(SetupJumboFlySound(107.f * modificator + 20)) {
+		if(SetupJumboTaxiSound(75.f * (1.f - modificator))) {
+			SetupJumboEngineSound(maxVolume, 22050);
+			SetupJumboWhineSound(18.f * (1.f - modificator),
+			                     14600.f * modificator + 29500);
+		}
+	}
+}
+
+void
+cAudioManager::ProcessJumboTakeOff(CPlane *plane)
+{
+	double modificator = (PlanePathPosition[plane->m_wIndex] - TakeOffPoint) * 0.0033333f;
+
+	if(cAudioManager::SetupJumboFlySound((107.f * modificator) + 20) &&
+	   cAudioManager::SetupJumboRumbleSound(maxVolume * (1.f - modificator))) {
+		if(cAudioManager::SetupJumboEngineSound(127u, 22050))
+			cAudioManager::SetupJumboWhineSound(18.f * (1.f - modificator), 44100);
+	}
+}
+
+void
+cAudioManager::ProcessJumboTaxi()
+{
+	if(SetupJumboFlySound(20u)) {
+		if(SetupJumboTaxiSound(75u)) SetupJumboWhineSound(18u, 29500);
+	}
+}
+
+void
+cAudioManager::ProcessLaunderetteScriptObject(uint8 sound)
+{
+	float maxDist;
+	float distSquared;
+
+	switch(sound) {
+	case SCRIPT_SOUND_LAUNDERETTE_LOOP_S:
+	case SCRIPT_SOUND_LAUNDERETTE_LOOP_L:
+		maxDist = 900.f;
+		m_sQueueSample.m_fSoundIntensity = 30.0f;
+		break;
+	default: break;
+	}
+	distSquared = GetDistanceSquared(&m_sQueueSample.m_vecPos);
+	if(distSquared < maxDist) {
+		m_sQueueSample.m_fDistance = sqrt(distSquared);
+		m_sQueueSample.m_bVolume = ComputeVolume(45u, m_sQueueSample.m_fSoundIntensity,
+		                                         m_sQueueSample.m_fDistance);
+		if(m_sQueueSample.m_bVolume) {
+			m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_LAUNDERETTE_1;
+			m_sQueueSample.m_bBankIndex = 0;
+			m_sQueueSample.m_nFrequency =
+			    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_LAUNDERETTE_1);
+			m_sQueueSample.field_4 = 0;
+			m_sQueueSample.m_bIsDistant = 0;
+			m_sQueueSample.m_nLoopCount = 0;
+			m_sQueueSample.field_56 = 0;
+			m_sQueueSample.field_16 = 5;
+			m_sQueueSample.field_48 = 2.0f;
+			m_sQueueSample.m_bEmittingVolume = 45;
+			m_sQueueSample.m_nLoopStart =
+			    cSampleManager.GetSampleLoopStartOffset(m_sQueueSample.m_nSampleIndex);
+			m_sQueueSample.m_nLoopEnd =
+			    cSampleManager.GetSampleLoopEndOffset(m_sQueueSample.m_nSampleIndex);
+			m_sQueueSample.m_bReverbFlag = 1;
+			m_sQueueSample.m_bRequireReflection = 0;
+			AddSampleToRequestedQueue();
+		}
+		m_sQueueSample.m_bVolume = ComputeVolume(110u, m_sQueueSample.m_fSoundIntensity,
+		                                         m_sQueueSample.m_fDistance);
+		if(m_sQueueSample.m_bVolume) {
+			m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_LAUNDERETTE_2;
+			m_sQueueSample.m_bBankIndex = 0;
+			m_sQueueSample.m_nFrequency =
+			    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_LAUNDERETTE_2);
+			m_sQueueSample.field_4 = 1;
+			m_sQueueSample.m_bIsDistant = 0;
+			m_sQueueSample.m_nLoopCount = 0;
+			m_sQueueSample.field_56 = 0;
+			m_sQueueSample.field_16 = 3;
+			m_sQueueSample.field_48 = 2.0f;
+			m_sQueueSample.m_bEmittingVolume = 110;
+			m_sQueueSample.m_nLoopStart =
+			    cSampleManager.GetSampleLoopStartOffset(m_sQueueSample.m_nSampleIndex);
+			m_sQueueSample.m_nLoopEnd =
+			    cSampleManager.GetSampleLoopEndOffset(m_sQueueSample.m_nSampleIndex);
+			m_sQueueSample.m_bReverbFlag = 1;
+			m_sQueueSample.m_bRequireReflection = 0;
+			AddSampleToRequestedQueue();
+		}
+	}
+}
+
+void
+cAudioManager::ProcessLoopingScriptObject(uint8 sound)
+{
+	uint8 emittingVolume;
+	float maxDist;
+	float distSquared;
+
+	switch(sound) {
+	case SCRIPT_SOUND_PARTY_1_LOOP_S:
+		maxDist = 900.f;
+		m_sQueueSample.m_fSoundIntensity = 30.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_PARTY_1;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 127;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_1);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_PARTY_1_LOOP_L:
+		maxDist = 6400.f;
+		m_sQueueSample.m_fSoundIntensity = 80.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_PARTY_1;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 127;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_1);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_PARTY_2_LOOP_S:
+		maxDist = 900.f;
+		m_sQueueSample.m_fSoundIntensity = 30.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_PARTY_2;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 127;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_2);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_PARTY_2_LOOP_L:
+		maxDist = 6400.f;
+		m_sQueueSample.m_fSoundIntensity = 80.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_PARTY_2;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 127;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_2);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_PARTY_3_LOOP_S:
+		maxDist = 900.f;
+		m_sQueueSample.m_fSoundIntensity = 30.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_PARTY_3;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 127;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_3);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_PARTY_3_LOOP_L:
+		maxDist = 6400.f;
+		m_sQueueSample.m_fSoundIntensity = 80.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_PARTY_3;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 127;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_3);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_PARTY_4_LOOP_S:
+		maxDist = 900.f;
+		m_sQueueSample.m_fSoundIntensity = 30.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_PARTY_4;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 127;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_4);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_PARTY_4_LOOP_L:
+		maxDist = 6400.f;
+		m_sQueueSample.m_fSoundIntensity = 80.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_PARTY_4;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 127;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_4);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_PARTY_5_LOOP_S:
+		maxDist = 900.f;
+		m_sQueueSample.m_fSoundIntensity = 30.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_PARTY_5;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 127;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_5);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_PARTY_5_LOOP_L:
+		maxDist = 6400.f;
+		m_sQueueSample.m_fSoundIntensity = 80.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_PARTY_5;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 127;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_5);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_PARTY_6_LOOP_S:
+		maxDist = 900.f;
+		m_sQueueSample.m_fSoundIntensity = 30.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_PARTY_6;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 127;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_6);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_PARTY_6_LOOP_L:
+		maxDist = 6400.f;
+		m_sQueueSample.m_fSoundIntensity = 80.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_PARTY_6;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 127;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_6);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_PARTY_7_LOOP_S:
+		maxDist = 900.f;
+		m_sQueueSample.m_fSoundIntensity = 30.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_PARTY_7;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 127;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_7);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_PARTY_7_LOOP_L:
+		maxDist = 6400.f;
+		m_sQueueSample.m_fSoundIntensity = 80.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_PARTY_7;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 127;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_7);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_PARTY_8_LOOP_S:
+		maxDist = 900.f;
+		m_sQueueSample.m_fSoundIntensity = 30.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_PARTY_8;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 127;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_8);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_PARTY_8_LOOP_L:
+		maxDist = 6400.f;
+		m_sQueueSample.m_fSoundIntensity = 80.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_PARTY_8;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 127;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_8);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_PARTY_9_LOOP_S:
+		maxDist = 900.f;
+		m_sQueueSample.m_fSoundIntensity = 30.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_PARTY_9;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 127;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_9);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_PARTY_9_LOOP_L:
+		maxDist = 6400.f;
+		m_sQueueSample.m_fSoundIntensity = 80.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_PARTY_9;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 127;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_9);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_PARTY_10_LOOP_S:
+		maxDist = 900.f;
+		m_sQueueSample.m_fSoundIntensity = 30.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_PARTY_10;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 127;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_10);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_PARTY_10_LOOP_L:
+		maxDist = 6400.f;
+		m_sQueueSample.m_fSoundIntensity = 80.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_PARTY_10;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 127;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_10);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_PARTY_11_LOOP_S:
+		maxDist = 900.f;
+		m_sQueueSample.m_fSoundIntensity = 30.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_PARTY_11;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 127;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_11);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_PARTY_11_LOOP_L:
+		maxDist = 6400.f;
+		m_sQueueSample.m_fSoundIntensity = 80.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_PARTY_11;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 127;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_11);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_PARTY_12_LOOP_S:
+		maxDist = 900.f;
+		m_sQueueSample.m_fSoundIntensity = 30.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_PARTY_12;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 127;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_12);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_PARTY_12_LOOP_L:
+		maxDist = 6400.f;
+		m_sQueueSample.m_fSoundIntensity = 80.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_PARTY_12;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 127;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_12);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_PARTY_13_LOOP_S:
+		maxDist = 900.f;
+		m_sQueueSample.m_fSoundIntensity = 30.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_PARTY_13;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 127;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_13);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_PARTY_13_LOOP_L:
+		maxDist = 6400.f;
+		m_sQueueSample.m_fSoundIntensity = 80.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_PARTY_13;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 127;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_13);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_STRIP_CLUB_LOOP_1_S:
+		maxDist = 900.f;
+		m_sQueueSample.m_fSoundIntensity = 30.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_STRIP_CLUB_1;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 127;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_STRIP_CLUB_1);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_STRIP_CLUB_LOOP_1_L:
+		maxDist = 6400.f;
+		m_sQueueSample.m_fSoundIntensity = 80.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_STRIP_CLUB_1;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 127;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_STRIP_CLUB_1);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_STRIP_CLUB_LOOP_2_S:
+		maxDist = 900.f;
+		m_sQueueSample.m_fSoundIntensity = 30.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_STRIP_CLUB_2;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 127;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_STRIP_CLUB_2);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_STRIP_CLUB_LOOP_2_L:
+		maxDist = 6400.f;
+		m_sQueueSample.m_fSoundIntensity = 80.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_STRIP_CLUB_2;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 127;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_STRIP_CLUB_2);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_WORK_SHOP_LOOP_S:
+	case SCRIPT_SOUND_WORK_SHOP_LOOP_L:
+		cAudioManager::ProcessWorkShopScriptObject(sound);
+		return;
+	case SCRIPT_SOUND_SAWMILL_LOOP_S:
+	case SCRIPT_SOUND_SAWMILL_LOOP_L: cAudioManager::ProcessSawMillScriptObject(sound); return;
+	case SCRIPT_SOUND_38:
+		maxDist = 900.f;
+		m_sQueueSample.m_fSoundIntensity = 30.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_409;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 110;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_409);
+		m_sQueueSample.field_16 = 6;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_39:
+		maxDist = 6400.f;
+		m_sQueueSample.m_fSoundIntensity = 80.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_409;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 110;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_409);
+		m_sQueueSample.field_16 = 6;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_LAUNDERETTE_LOOP_S:
+	case SCRIPT_SOUND_LAUNDERETTE_LOOP_L: ProcessLaunderetteScriptObject(sound); return;
+	case SCRIPT_SOUND_CHINATOWN_RESTAURANT_S:
+		maxDist = 900.f;
+		m_sQueueSample.m_fSoundIntensity = 30.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_CHINATOWN_RESTAURANT;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 110;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_CHINATOWN_RESTAURANT);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_CHINATOWN_RESTAURANT_L:
+		maxDist = 6400.f;
+		m_sQueueSample.m_fSoundIntensity = 80.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_CHINATOWN_RESTAURANT;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 110;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_CHINATOWN_RESTAURANT);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_CIPRIANI_RESAURANT_S:
+		maxDist = 900.f;
+		m_sQueueSample.m_fSoundIntensity = 30.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_CIPRIANI_RESTAURANT;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 110;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_CIPRIANI_RESTAURANT);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_CIPRIANI_RESAURANT_L:
+		maxDist = 6400.f;
+		m_sQueueSample.m_fSoundIntensity = 80.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_CIPRIANI_RESTAURANT;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 110;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_CIPRIANI_RESTAURANT);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_46:
+		maxDist = 900.f;
+		m_sQueueSample.m_fSoundIntensity = 30.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_414;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 110;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_414);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_47:
+		maxDist = 6400.f;
+		m_sQueueSample.m_fSoundIntensity = 80.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_414;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 110;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_414);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_MARCO_BISTRO_S:
+		maxDist = 900.f;
+		m_sQueueSample.m_fSoundIntensity = 30.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_MARCO_BISTRO;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 110;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_MARCO_BISTRO);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_MARCO_BISTRO_L:
+		maxDist = 6400.f;
+		m_sQueueSample.m_fSoundIntensity = 80.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_MARCO_BISTRO;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 110;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_MARCO_BISTRO);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_AIRPORT_LOOP_S:
+	case SCRIPT_SOUND_AIRPORT_LOOP_L: ProcessAirportScriptObject(sound); return;
+	case SCRIPT_SOUND_SHOP_LOOP_S:
+	case SCRIPT_SOUND_SHOP_LOOP_L: ProcessShopScriptObject(sound); return;
+	case SCRIPT_SOUND_CINEMA_LOOP_S:
+	case SCRIPT_SOUND_CINEMA_LOOP_L: ProcessCinemaScriptObject(sound); return;
+	case SCRIPT_SOUND_DOCKS_LOOP_S:
+	case SCRIPT_SOUND_DOCKS_LOOP_L: cAudioManager::ProcessDocksScriptObject(sound); return;
+	case SCRIPT_SOUND_HOME_LOOP_S:
+	case SCRIPT_SOUND_HOME_LOOP_L: cAudioManager::ProcessHomeScriptObject(sound); return;
+	case SCRIPT_SOUND_FRANKIE_PIANO:
+		maxDist = 900.f;
+		m_sQueueSample.m_fSoundIntensity = 30.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_FRANKIE_PIANO;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 127;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_FRANKIE_PIANO);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_PARTY_1_LOOP:
+		maxDist = 6400.f;
+		m_sQueueSample.m_fSoundIntensity = 80.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_PARTY_1;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 127;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_PARTY_1);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_PORN_CINEMA_1_S:
+	case SCRIPT_SOUND_PORN_CINEMA_1_L:
+	case SCRIPT_SOUND_PORN_CINEMA_2_S:
+	case SCRIPT_SOUND_PORN_CINEMA_2_L:
+	case SCRIPT_SOUND_PORN_CINEMA_3_S:
+	case SCRIPT_SOUND_PORN_CINEMA_3_L:
+	case SCRIPT_SOUND_MISTY_SEX_S:
+	case SCRIPT_SOUND_MISTY_SEX_L: ProcessPornCinema(sound); return;
+	case SCRIPT_SOUND_BANK_ALARM_LOOP_S:
+		maxDist = 900.f;
+		m_sQueueSample.m_fSoundIntensity = 30.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_BANK_ALARM;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 90;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_BANK_ALARM);
+		m_sQueueSample.field_16 = 2;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_BANK_ALARM_LOOP_L:
+		maxDist = 6400.f;
+		m_sQueueSample.m_fSoundIntensity = 80.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_BANK_ALARM;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 90;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_BANK_ALARM);
+		m_sQueueSample.field_16 = 2;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_POLICE_BALL_LOOP_S:
+		maxDist = 900.f;
+		m_sQueueSample.m_fSoundIntensity = 30.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_POLICE_BALL;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 127;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_POLICE_BALL);
+		m_sQueueSample.field_16 = 2;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_POLICE_BALL_LOOP_L:
+		maxDist = 6400.f;
+		m_sQueueSample.m_fSoundIntensity = 80.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_POLICE_BALL;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 127;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_POLICE_BALL);
+		m_sQueueSample.field_16 = 2;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_RAVE_LOOP_INDUSTRIAL_S:
+		maxDist = 900.f;
+		m_sQueueSample.m_fSoundIntensity = 30.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_RAVE_INDUSTRIAL;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 127;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_RAVE_INDUSTRIAL);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_RAVE_LOOP_INDUSTRIAL_L:
+		maxDist = 6400.f;
+		m_sQueueSample.m_fSoundIntensity = 80.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_RAVE_INDUSTRIAL;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 127;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_RAVE_INDUSTRIAL);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_POLICE_CELL_BEATING_LOOP_S:
+	case SCRIPT_SOUND_POLICE_CELL_BEATING_LOOP_L:
+		cAudioManager::ProcessPoliceCellBeatingScriptObject(sound);
+		return;
+	case SCRIPT_SOUND_RAVE_1_LOOP_S:
+	case SCRIPT_SOUND_RAVE_2_LOOP_S:
+		maxDist = 900.f;
+		m_sQueueSample.m_fSoundIntensity = 30.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_RAVE_1;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 127;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_RAVE_1_LOOP_L:
+	case SCRIPT_SOUND_RAVE_2_LOOP_L:
+		maxDist = 6400.f;
+		m_sQueueSample.m_fSoundIntensity = 80.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_RAVE_1;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 127;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_RAVE_3_LOOP_S:
+		maxDist = 900.f;
+		m_sQueueSample.m_fSoundIntensity = 30.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_RAVE_2;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 127;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_RAVE_2);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_RAVE_3_LOOP_L:
+		maxDist = 6400.f;
+		m_sQueueSample.m_fSoundIntensity = 80.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_RAVE_2;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 127;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_RAVE_2);
+		m_sQueueSample.field_16 = 3;
+		m_sQueueSample.field_76 = 3;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	case SCRIPT_SOUND_PRETEND_FIRE_LOOP:
+		maxDist = 2500.f;
+		m_sQueueSample.m_fSoundIntensity = 50.0f;
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_FIRE_ENTITY;
+		m_sQueueSample.m_bBankIndex = 0;
+		emittingVolume = 80;
+		m_sQueueSample.m_nFrequency =
+		    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_FIRE_ENTITY);
+		m_sQueueSample.field_16 = 8;
+		m_sQueueSample.field_76 = 10;
+		m_sQueueSample.field_48 = 2.0f;
+		break;
+	default: return;
+	}
+
+	distSquared = GetDistanceSquared(&m_sQueueSample.m_vecPos);
+	if(distSquared < maxDist) {
+		m_sQueueSample.m_fDistance = Sqrt(distSquared);
+		m_sQueueSample.m_bVolume = ComputeVolume(
+		    emittingVolume, m_sQueueSample.m_fSoundIntensity, m_sQueueSample.m_fDistance);
+		if(m_sQueueSample.m_bVolume) {
+			m_sQueueSample.field_4 = 0;
+			m_sQueueSample.m_bIsDistant = 0;
+			m_sQueueSample.m_nLoopCount = 0;
+			m_sQueueSample.field_56 = 0;
+			m_sQueueSample.m_bReverbFlag = 1;
+			m_sQueueSample.m_bEmittingVolume = emittingVolume;
+			m_sQueueSample.m_nLoopStart =
+			    cSampleManager.GetSampleLoopStartOffset(m_sQueueSample.m_nSampleIndex);
+			m_sQueueSample.m_nLoopEnd =
+			    cSampleManager.GetSampleLoopEndOffset(m_sQueueSample.m_nSampleIndex);
+			m_sQueueSample.m_bRequireReflection = 0;
+			AddSampleToRequestedQueue();
+		}
+	}
+}
+
+WRAPPER
+void
+cAudioManager::ProcessPed(CPhysical *)
+{
+	EAXJMP(0x56F450);
+}
+
+void
+cAudioManager::ProcessPhysical(int32 id)
+{
+	CPhysical *entity = (CPhysical *)m_asAudioEntities[id].m_pEntity;
+	if(entity) {
+		switch(entity->m_type & 7) {
+		case ENTITY_TYPE_VEHICLE:
+			ProcessVehicle((CVehicle *)m_asAudioEntities[id].m_pEntity);
+			break;
+		case ENTITY_TYPE_PED:
+			ProcessPed((CPhysical *)m_asAudioEntities[id].m_pEntity);
+			break;
+		default: return;
+		}
+	}
+}
+
+WRAPPER
+void
+cAudioManager::ProcessPlane(void *ptr)
+{
+	EAXJMP(0x56E860);
+}
+
+WRAPPER
+void
+cAudioManager::ProcessPoliceCellBeatingScriptObject(uint8 sound)
+{
+	EAXJMP(0x578190);
+}
+
+void
+cAudioManager::ProcessPornCinema(uint8 sound)
+{
+
+	eAudioSamples sample;
+	uint32 time;
+	int32 rand;
+	float distSquared;
+	float maxDist;
+
+	switch(sound) {
+	case SCRIPT_SOUND_PORN_CINEMA_1_S:
+	case SCRIPT_SOUND_MISTY_SEX_S:
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_PORN_CINEMA_1_BACKGROUND_1;
+		m_sQueueSample.m_bBankIndex = 0;
+		maxDist = 400.f;
+		sample = AUDIO_SAMPLE_PORN_CINEMA_1_SEX_1;
+		m_sQueueSample.m_fSoundIntensity = 20.0f;
+		break;
+	case SCRIPT_SOUND_PORN_CINEMA_1_L:
+	case SCRIPT_SOUND_MISTY_SEX_L:
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_PORN_CINEMA_1_BACKGROUND_1;
+		m_sQueueSample.m_bBankIndex = 0;
+		maxDist = 6400.f;
+		sample = AUDIO_SAMPLE_PORN_CINEMA_1_SEX_1;
+		m_sQueueSample.m_fSoundIntensity = 80.0f;
+		break;
+	case SCRIPT_SOUND_PORN_CINEMA_2_S:
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_PORN_CINEMA_2_BACKGROUND_2;
+		m_sQueueSample.m_bBankIndex = 0;
+		maxDist = 400.f;
+		sample = AUDIO_SAMPLE_PORN_CINEMA_2_SEX_1;
+		m_sQueueSample.m_fSoundIntensity = 20.0f;
+		break;
+	case SCRIPT_SOUND_PORN_CINEMA_2_L:
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_PORN_CINEMA_2_BACKGROUND_2;
+		m_sQueueSample.m_bBankIndex = 0;
+		maxDist = 6400.f;
+		sample = AUDIO_SAMPLE_PORN_CINEMA_2_SEX_1;
+		m_sQueueSample.m_fSoundIntensity = 80.0f;
+		break;
+	case SCRIPT_SOUND_PORN_CINEMA_3_S:
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_PORN_CINEMA_3_BACKGROUND_3;
+		m_sQueueSample.m_bBankIndex = 0;
+		maxDist = 400.f;
+		m_sQueueSample.m_fSoundIntensity = 20.0f;
+		sample = AUDIO_SAMPLE_PORN_CINEMA_3_SEX_1;
+		break;
+	case SCRIPT_SOUND_PORN_CINEMA_3_L:
+		m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_PORN_CINEMA_3_BACKGROUND_3;
+		m_sQueueSample.m_bBankIndex = 0;
+		maxDist = 6400.f;
+		m_sQueueSample.m_fSoundIntensity = 80.0f;
+		sample = AUDIO_SAMPLE_PORN_CINEMA_3_SEX_1;
+		break;
+	default: break;
+	}
+	distSquared = GetDistanceSquared(&m_sQueueSample.m_vecPos);
+	if(distSquared < maxDist) {
+		m_sQueueSample.m_fDistance = sqrt(distSquared);
+		if(sound != SCRIPT_SOUND_MISTY_SEX_S && sound != SCRIPT_SOUND_MISTY_SEX_L) {
+			m_sQueueSample.m_bVolume =
+			    ComputeVolume(maxVolume, m_sQueueSample.m_fSoundIntensity,
+			                  m_sQueueSample.m_fDistance);
+			if(m_sQueueSample.m_bVolume) {
+				m_sQueueSample.m_nFrequency = cSampleManager.GetSampleBaseFrequency(
+				    m_sQueueSample.m_nSampleIndex);
+				m_sQueueSample.field_4 = 0;
+				m_sQueueSample.m_bIsDistant = 0;
+				m_sQueueSample.m_nLoopCount = 0;
+				m_sQueueSample.field_56 = 0;
+				m_sQueueSample.field_16 = 3;
+				m_sQueueSample.field_48 = 2.0f;
+				m_sQueueSample.m_bEmittingVolume = maxVolume;
+				m_sQueueSample.m_nLoopStart =
+				    cSampleManager.GetSampleLoopStartOffset(
+				        m_sQueueSample.m_nSampleIndex);
+				m_sQueueSample.m_nLoopEnd = cSampleManager.GetSampleLoopEndOffset(
+				    m_sQueueSample.m_nSampleIndex);
+				m_sQueueSample.m_bReverbFlag = 1;
+				m_sQueueSample.m_bRequireReflection = 0;
+				AddSampleToRequestedQueue();
+			}
+		}
+
+		time = CTimer::GetTimeInMilliseconds();
+		if(time > audioLogicTimers[0]) {
+			m_sQueueSample.m_bVolume = ComputeVolume(
+			    90u, m_sQueueSample.m_fSoundIntensity, m_sQueueSample.m_fDistance);
+			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_nSampleIndex);
+				m_sQueueSample.m_nFrequency +=
+				    RandomDisplacement(m_sQueueSample.m_nFrequency >> 4);
+				m_sQueueSample.field_4 = rand + 1;
+				m_sQueueSample.m_bIsDistant = 0;
+				m_sQueueSample.m_nLoopCount = 1;
+				m_sQueueSample.field_56 = 1;
+				m_sQueueSample.field_16 = 6;
+				m_sQueueSample.field_48 = 0.0f;
+				m_sQueueSample.m_nLoopStart = 0;
+				m_sQueueSample.m_nLoopEnd = -1;
+				m_sQueueSample.m_bReverbFlag = 1;
+				m_sQueueSample.m_bRequireReflection = 0;
+				AddSampleToRequestedQueue();
+				audioLogicTimers[0] = time + 2000 + m_anRandomTable[3] % 6000u;
+			}
+		}
+	}
+}
+
+WRAPPER
+void
+cAudioManager::ProcessProjectiles()
+{
+	EAXJMP(0x578A80);
+}
+
+void
+cAudioManager::ProcessSawMillScriptObject(uint8 sound)
+{
+	uint32 time;
+	float distSquared;
+	float maxDist;
+
+	switch(sound) {
+	case SCRIPT_SOUND_SAWMILL_LOOP_S:
+	case SCRIPT_SOUND_SAWMILL_LOOP_L:
+		maxDist = 900.f;
+		m_sQueueSample.m_fSoundIntensity = 30.0f;
+		break;
+	default: break;
+	}
+	distSquared = GetDistanceSquared(&m_sQueueSample.m_vecPos);
+	if(distSquared < maxDist) {
+		m_sQueueSample.m_fDistance = sqrt(distSquared);
+		m_sQueueSample.m_bVolume = cAudioManager::ComputeVolume(
+		    30u, m_sQueueSample.m_fSoundIntensity, m_sQueueSample.m_fDistance);
+		if(m_sQueueSample.m_bVolume) {
+			m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_SAWMILL_1;
+			m_sQueueSample.m_bBankIndex = 0;
+			m_sQueueSample.m_nFrequency =
+			    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_SAWMILL_1);
+			m_sQueueSample.field_4 = 0;
+			m_sQueueSample.m_bIsDistant = 0;
+			m_sQueueSample.m_nLoopCount = 0;
+			m_sQueueSample.field_56 = 0;
+			m_sQueueSample.field_16 = 5;
+			m_sQueueSample.field_48 = 2.0f;
+			m_sQueueSample.m_bEmittingVolume = 30;
+			m_sQueueSample.m_nLoopStart =
+			    cSampleManager.GetSampleLoopStartOffset(m_sQueueSample.m_nSampleIndex);
+			m_sQueueSample.m_nLoopEnd =
+			    cSampleManager.GetSampleLoopEndOffset(m_sQueueSample.m_nSampleIndex);
+			m_sQueueSample.m_bReverbFlag = 1;
+			m_sQueueSample.m_bRequireReflection = 0;
+			AddSampleToRequestedQueue();
+		}
+		time = CTimer::GetTimeInMilliseconds();
+		if(time > audioLogicTimers[1]) {
+			m_sQueueSample.m_bVolume = cAudioManager::ComputeVolume(
+			    70u, m_sQueueSample.m_fSoundIntensity, m_sQueueSample.m_fDistance);
+			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_nSampleIndex);
+				m_sQueueSample.field_4 = 1;
+				m_sQueueSample.m_bIsDistant = 0;
+				m_sQueueSample.m_nLoopCount = 1;
+				m_sQueueSample.field_56 = 1;
+				m_sQueueSample.field_16 = 3;
+				m_sQueueSample.field_48 = 2.0f;
+				m_sQueueSample.m_nLoopStart = 0;
+				m_sQueueSample.m_nLoopEnd = -1;
+				m_sQueueSample.m_bReverbFlag = 1;
+				m_sQueueSample.m_bRequireReflection = 0;
+				AddSampleToRequestedQueue();
+				audioLogicTimers[1] = time + 2000 + m_anRandomTable[3] % 4000u;
+			}
+		}
+	}
+}
+
+WRAPPER
+void
+cAudioManager::ProcessScriptObject(int32 id)
+{
+	EAXJMP(0x576070);
+}
+
+void
+cAudioManager::ProcessShopScriptObject(uint8 sound)
+{
+	uint32 time;
+	int32 rand;
+	float distSquared;
+	float maxDist;
+
+	switch(sound) {
+	case SCRIPT_SOUND_SHOP_LOOP_S:
+	case SCRIPT_SOUND_SHOP_LOOP_L:
+		maxDist = 900.f;
+		m_sQueueSample.m_fSoundIntensity = 30.0f;
+		break;
+	default: break;
+	}
+	distSquared = GetDistanceSquared(&m_sQueueSample.m_vecPos);
+	if(distSquared < maxDist) {
+		m_sQueueSample.m_fDistance = sqrt(distSquared);
+		m_sQueueSample.m_bVolume = ComputeVolume(30u, m_sQueueSample.m_fSoundIntensity,
+		                                         m_sQueueSample.m_fDistance);
+		if(m_sQueueSample.m_bVolume) {
+			m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_SHOP_1;
+			m_sQueueSample.m_bBankIndex = 0;
+			m_sQueueSample.m_nFrequency =
+			    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_SHOP_1);
+			m_sQueueSample.field_4 = 0;
+			m_sQueueSample.m_bIsDistant = 0;
+			m_sQueueSample.m_nLoopCount = 0;
+			m_sQueueSample.field_56 = 0;
+			m_sQueueSample.field_16 = 5;
+			m_sQueueSample.field_48 = 2.0f;
+			m_sQueueSample.m_bEmittingVolume = 30;
+			m_sQueueSample.m_nLoopStart =
+			    cSampleManager.GetSampleLoopStartOffset(m_sQueueSample.m_nSampleIndex);
+			m_sQueueSample.m_nLoopEnd =
+			    cSampleManager.GetSampleLoopEndOffset(m_sQueueSample.m_nSampleIndex);
+			m_sQueueSample.m_bReverbFlag = 1;
+			m_sQueueSample.m_bRequireReflection = 0;
+			cAudioManager::AddSampleToRequestedQueue();
+		}
+		time = CTimer::GetTimeInMilliseconds();
+		if(time > audioLogicTimers[2]) {
+			m_sQueueSample.m_bVolume = ComputeVolume(
+			    70u, m_sQueueSample.m_fSoundIntensity, m_sQueueSample.m_fDistance);
+			if(m_sQueueSample.m_bVolume) {
+				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_nSampleIndex);
+				m_sQueueSample.field_4 = rand + 1;
+				m_sQueueSample.m_bIsDistant = 0;
+				m_sQueueSample.m_nLoopCount = 1;
+				m_sQueueSample.field_56 = 1;
+				m_sQueueSample.field_16 = 3;
+				m_sQueueSample.field_48 = 2.0f;
+				m_sQueueSample.m_bEmittingVolume = 70;
+				m_sQueueSample.m_nLoopStart = 0;
+				m_sQueueSample.m_nLoopEnd = -1;
+				m_sQueueSample.m_bReverbFlag = 1;
+				m_sQueueSample.m_bRequireReflection = 0;
+				AddSampleToRequestedQueue();
+				audioLogicTimers[2] = time + 3000 + m_anRandomTable[3] % 7000u;
+			}
+		}
+	}
+}
+
+void
+cAudioManager::ProcessSpecial()
+{
+	if(m_bUserPause) {
+		if(!m_bPreviousUserPause) {
+			MusicManager.ChangeMusicMode(0);
+			cSampleManager.SetEffectsFadeVol(maxVolume);
+			cSampleManager.SetMusicFadeVol(maxVolume);
+		}
+	} else {
+		if(m_bPreviousUserPause) {
+			MusicManager.StopFrontEndTrack();
+			MusicManager.ChangeMusicMode(1u);
+		}
+		CPlayerPed *playerPed = FindPlayerPed();
+		if(playerPed) {
+			const PedState &state = playerPed->m_nPedState;
+			if(state != PED_ENTER_CAR && state != PED_STEAL_CAR &&
+			   !playerPed->bInVehicle)
+				cSampleManager.StopChannel(m_bActiveSamples);
+		}
+	}
+}
+
+#if 1
+WRAPPER
+void
+cAudioManager::ProcessVehicle(CVehicle *)
+{
+	EAXJMP(0x569A00);
+}
+#else
+void
+cAudioManager::ProcessVehicle(CVehicle *)
+{
+	EAXJMP(0x569A00);
+}
+#endif
+
+WRAPPER
+void cAudioManager::ProcessWaterCannon(int32) { EAXJMP(0x575F30); }
+
+WRAPPER
+void
+cAudioManager::ProcessWeather(int32 id)
+{
+	EAXJMP(0x578370);
+}
+
+void
+cAudioManager::ProcessWorkShopScriptObject(uint8 sound)
+{
+	float distSquared;
+	float maxDist;
+
+	switch(sound) {
+	case SCRIPT_SOUND_WORK_SHOP_LOOP_S:
+	case SCRIPT_SOUND_WORK_SHOP_LOOP_L:
+		maxDist = 400.f;
+		m_sQueueSample.m_fSoundIntensity = 20.0;
+		break;
+	default: break;
+	}
+	distSquared = GetDistanceSquared(&m_sQueueSample.m_vecPos);
+	if(distSquared < maxDist) {
+		m_sQueueSample.m_fDistance = sqrt(distSquared);
+		m_sQueueSample.m_bVolume = ComputeVolume(30u, m_sQueueSample.m_fSoundIntensity,
+		                                         m_sQueueSample.m_fDistance);
+		if(m_sQueueSample.m_bVolume) {
+			m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_WORK_SHOP;
+			m_sQueueSample.m_bBankIndex = 0;
+			m_sQueueSample.m_nFrequency =
+			    cSampleManager.GetSampleBaseFrequency(AUDIO_SAMPLE_WORK_SHOP);
+			m_sQueueSample.field_4 = 0;
+			m_sQueueSample.m_bIsDistant = 0;
+			m_sQueueSample.m_nLoopCount = 0;
+			m_sQueueSample.field_56 = 0;
+			m_sQueueSample.field_16 = 5;
+			m_sQueueSample.field_48 = 2.0;
+			m_sQueueSample.m_bEmittingVolume = 30;
+			m_sQueueSample.m_nLoopStart =
+			    cSampleManager.GetSampleLoopStartOffset(m_sQueueSample.m_nSampleIndex);
+			m_sQueueSample.m_nLoopEnd =
+			    cSampleManager.GetSampleLoopEndOffset(m_sQueueSample.m_nSampleIndex);
+			m_sQueueSample.m_bReverbFlag = 1;
+			m_sQueueSample.m_bRequireReflection = 0;
+			AddSampleToRequestedQueue();
+		}
+	}
+}
+
 WRAPPER void
 cAudioManager::Service()
 {
@@ -2960,22 +5617,40 @@ cAudioManager::Service()
 }
 
 STARTPATCHES
-InjectHook(0x57B070, &cAudioManager::AddSampleToRequestedQueue, PATCH_JUMP);
 InjectHook(0x57B210, &cAudioManager::AddDetailsToRequestedOrderList, PATCH_JUMP);
+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(0x580AF0, &cAudioManager::AgeCrimes, PATCH_JUMP);
+
+InjectHook(0x5697A0, &cAudioManager::CalculateDistance, PATCH_JUMP);
+InjectHook(0x57AA10, &cAudioManager::CheckForAnAudioFileOnCD, PATCH_JUMP);
+InjectHook(0x5796A0, &cAudioManager::ClearMissionAudio, PATCH_JUMP);
+InjectHook(0x57C120, &cAudioManager::ClearRequestedQueue, PATCH_JUMP);
+InjectHook(0x57AE00, &cAudioManager::ComputeDopplerEffectedFrequency, PATCH_JUMP);
 InjectHook(0x57ABB0, &cAudioManager::ComputeVolume, PATCH_JUMP);
+InjectHook(0x57A310, &cAudioManager::CreateEntity, PATCH_JUMP);
+
+InjectHook(0x57A830, &cAudioManager::DestroyAllGameCreatedEntities, PATCH_JUMP);
+InjectHook(0x57A400, &cAudioManager::DestroyEntity, PATCH_JUMP);
+InjectHook(0x57F060, &cAudioManager::DoPoliceRadioCrackle, PATCH_JUMP);
+
+InjectHook(0x57C290, &cAudioManager::GenerateIntegerRandomNumberTable, PATCH_JUMP);
+InjectHook(0x569750, &cAudioManager::GetDistanceSquared, PATCH_JUMP);
+InjectHook(0x57AC60, &cAudioManager::TranslateEntity, PATCH_JUMP);
 
 InjectHook(0x57A0E0, &cAudioManager::Initialise, PATCH_JUMP);
 InjectHook(0x569420, &cAudioManager::PostInitialiseGameSpecificSetup, PATCH_JUMP);
-//InjectHook(0x57EAC0, &cAudioManager::InitialisePoliceRadioZones, PATCH_JUMP);
-//InjectHook(0x569650, &cAudioManager::ResetAudioLogicTimers, PATCH_JUMP);
+// InjectHook(0x57EAC0, &cAudioManager::InitialisePoliceRadioZones, PATCH_JUMP);
+// InjectHook(0x569650, &cAudioManager::ResetAudioLogicTimers, PATCH_JUMP);
 InjectHook(0x57A150, &cAudioManager::Terminate, PATCH_JUMP);
 
 InjectHook(0x57F050, &cAudioManager::GetMissionScriptPoliceAudioPlayingStatus, PATCH_JUMP);
 InjectHook(0x5795D0, &cAudioManager::GetMissionAudioLoadingStatus, PATCH_JUMP);
 
 InjectHook(0x57A8A0, &cAudioManager::GetNum3DProvidersAvailable, PATCH_JUMP);
-InjectHook(0x57A8F0, &cAudioManager::AutoDetect3DProviders, PATCH_JUMP);
 InjectHook(0x57A9C0, &cAudioManager::IsMP3RadioChannelAvailable, PATCH_JUMP);
 InjectHook(0x57AA30, &cAudioManager::GetCDAudioDriveLetter, PATCH_JUMP);
 
@@ -2986,20 +5661,20 @@ InjectHook(0x57A790, &cAudioManager::SetMusicFadeVol, PATCH_JUMP);
 
 InjectHook(0x57A9A0, &cAudioManager::SetSpeakerConfig, PATCH_JUMP);
 
-InjectHook(0x56ECF0, &cAudioManager::ProcessJumboFlying, PATCH_JUMP);
 InjectHook(0x569400, &cAudioManager::PreInitialiseGameSpecificSetup, PATCH_JUMP);
 
 InjectHook(0x57F020, &cAudioManager::SetMissionScriptPoliceAudio, PATCH_JUMP);
 
-InjectHook(0x5697A0, &cAudioManager::CalculateDistance, PATCH_JUMP);
-
 InjectHook(0x56C3C0, &cAudioManager::UsesSiren, PATCH_JUMP);
 InjectHook(0x56C3F0, &cAudioManager::UsesSirenSwitching, PATCH_JUMP);
 
 InjectHook(0x579520, &cAudioManager::MissionScriptAudioUsesPoliceChannel, PATCH_JUMP);
 
 InjectHook(0x57A8C0, &cAudioManager::Get3DProviderName, PATCH_JUMP);
-InjectHook(0x56EA10, &cAudioManager::ProcessJumboTaxi, PATCH_JUMP);
+InjectHook(0x56F230, &cAudioManager::SetupJumboFlySound, PATCH_JUMP);
+InjectHook(0x56F310, &cAudioManager::SetupJumboRumbleSound, PATCH_JUMP);
+InjectHook(0x56EF20, &cAudioManager::SetupJumboTaxiSound, PATCH_JUMP);
+InjectHook(0x56F070, &cAudioManager::SetupJumboWhineSound, PATCH_JUMP);
 
 InjectHook(0x579620, &cAudioManager::PlayLoadedMissionAudio, PATCH_JUMP);
 
@@ -3009,22 +5684,12 @@ InjectHook(0x57EFF0, &cAudioManager::ResetPoliceRadio, PATCH_JUMP);
 
 InjectHook(0x57B030, &cAudioManager::InterrogateAudioEntities, PATCH_JUMP);
 
-InjectHook(0x57C120, &cAudioManager::ClearRequestedQueue, PATCH_JUMP);
-// InjectHook(0x580AF0, &cAudioManager::AgeCrimes, PATCH_JUMP);
-
 InjectHook(0x56C600, &cAudioManager::UsesReverseWarning, PATCH_JUMP);
 InjectHook(0x56CAB0, &cAudioManager::HasAirBrakes, PATCH_JUMP);
 
 InjectHook(0x56F410, &cAudioManager::GetJumboTaxiFreq, PATCH_JUMP);
 
-InjectHook(0x5699C0, &cAudioManager::ProcessPhysical, PATCH_JUMP);
-// InjectHook(0x56E860, &cAudioManager::ProcessPlane, PATCH_JUMP);
-
-InjectHook(0x5796A0, &cAudioManager::ClearMissionAudio, PATCH_JUMP);
-// InjectHook(0x569700, &cAudioManager::ProcessReverb, PATCH_JUMP);
-
 InjectHook(0x579650, &cAudioManager::IsMissionAudioSampleFinished, PATCH_JUMP);
-// done
 InjectHook(0x57AF90, &cAudioManager::RandomDisplacement, PATCH_JUMP);
 
 InjectHook(0x57A9E0, &cAudioManager::ReleaseDigitalHandle, PATCH_JUMP);
@@ -3033,19 +5698,18 @@ InjectHook(0x57AA00, &cAudioManager::SetDynamicAcousticModelingStatus, PATCH_JUM
 
 InjectHook(0x57AA50, &cAudioManager::IsAudioInitialised, PATCH_JUMP);
 
-InjectHook(0x57A310, &cAudioManager::CreateEntity, PATCH_JUMP);
-InjectHook(0x57A400, &cAudioManager::DestroyEntity, PATCH_JUMP);
 InjectHook(0x57A4C0, &cAudioManager::SetEntityStatus, PATCH_JUMP);
 
 InjectHook(0x569570, &cAudioManager::PreTerminateGameSpecificShutdown, PATCH_JUMP);
 InjectHook(0x569640, &cAudioManager::PostTerminateGameSpecificShutdown, PATCH_JUMP);
 
-InjectHook(0x57C290, &cAudioManager::GenerateIntegerRandomNumberTable, PATCH_JUMP);
-
 InjectHook(0x56AD10, &cAudioManager::PlayerJustGotInCar, PATCH_JUMP);
 InjectHook(0x56AD20, &cAudioManager::PlayerJustLeftCar, PATCH_JUMP);
 InjectHook(0x570DB0, &cAudioManager::GetPhrase, PATCH_JUMP);
 
+// Get ped sfx stuff
+InjectHook(0x570960, &cAudioManager::GetPedCommentSfx, PATCH_JUMP);
+
 InjectHook(0x570E00, &cAudioManager::GetPlayerTalkSfx, PATCH_JUMP);
 InjectHook(0x570EA0, &cAudioManager::GetCopTalkSfx, PATCH_JUMP);
 InjectHook(0x570F80, &cAudioManager::GetSwatTalkSfx, PATCH_JUMP);
@@ -3122,4 +5786,32 @@ InjectHook(0x575120, &cAudioManager::GetChunkyTalkSfx, PATCH_JUMP);
 
 InjectHook(0x575460, &cAudioManager::GetGenericMaleTalkSfx, PATCH_JUMP);
 InjectHook(0x575510, &cAudioManager::GetGenericFemaleTalkSfx, PATCH_JUMP);
+
+// Process stuff
+// InjectHook(0x57BA60, &cAudioManager::ProcessActiveQueues, PATCH_JUMP);
+InjectHook(0x56C940, &cAudioManager::ProcessAirBrakes, PATCH_JUMP);
+InjectHook(0x577B30, &cAudioManager::ProcessAirportScriptObject, PATCH_JUMP);
+InjectHook(0x579250, &cAudioManager::ProcessBridgeMotor, PATCH_JUMP);
+InjectHook(0x579170, &cAudioManager::ProcessBridgeWarning, PATCH_JUMP);
+InjectHook(0x577CA0, &cAudioManager::ProcessCinemaScriptObject, PATCH_JUMP);
+InjectHook(0x577E50, &cAudioManager::ProcessDocksScriptObject, PATCH_JUMP);
+InjectHook(0x569870, &cAudioManager::ProcessEntity, PATCH_JUMP);
+InjectHook(0x578FD0, &cAudioManager::ProcessFireHydrant, PATCH_JUMP);
+InjectHook(0x5785E0, &cAudioManager::ProcessFrontEnd, PATCH_JUMP);
+InjectHook(0x577FE0, &cAudioManager::ProcessHomeScriptObject, PATCH_JUMP);
+InjectHook(0x56E8F0, &cAudioManager::ProcessJumbo, PATCH_JUMP);
+InjectHook(0x56EA40, &cAudioManager::ProcessJumboAccel, PATCH_JUMP);
+InjectHook(0x56EE40, &cAudioManager::ProcessJumboDecel, PATCH_JUMP);
+InjectHook(0x56ECF0, &cAudioManager::ProcessJumboFlying, PATCH_JUMP);
+InjectHook(0x56ED10, &cAudioManager::ProcessJumboLanding, PATCH_JUMP);
+InjectHook(0x56EC00, &cAudioManager::ProcessJumboTakeOff, PATCH_JUMP);
+InjectHook(0x56EA10, &cAudioManager::ProcessJumboTaxi, PATCH_JUMP);
+InjectHook(0x5777E0, &cAudioManager::ProcessLaunderetteScriptObject, PATCH_JUMP);
+InjectHook(0x576770, &cAudioManager::ProcessLoopingScriptObject, PATCH_JUMP);
+InjectHook(0x5699C0, &cAudioManager::ProcessPhysical, PATCH_JUMP);
+InjectHook(0x577280, &cAudioManager::ProcessPornCinema, PATCH_JUMP);
+InjectHook(0x577630, &cAudioManager::ProcessSawMillScriptObject, PATCH_JUMP);
+InjectHook(0x577970, &cAudioManager::ProcessShopScriptObject, PATCH_JUMP);
+InjectHook(0x5697D0, &cAudioManager::ProcessSpecial, PATCH_JUMP);
+InjectHook(0x577530, &cAudioManager::ProcessWorkShopScriptObject, PATCH_JUMP);
 ENDPATCHES
diff --git a/src/audio/AudioManager.h b/src/audio/AudioManager.h
index 7a2dc9c5..8e8a1d1d 100644
--- a/src/audio/AudioManager.h
+++ b/src/audio/AudioManager.h
@@ -7,48 +7,48 @@
 class tActiveSample
 {
 public:
-	int m_nEntityIndex;
-	int field_4;
-	int m_nSampleIndex;
-	char m_bBankIndex;
-	char m_bIsDistant;
-	char field_14;
-	char field_15;
-	int field_16;
-	int m_nFrequency;
+	int32 m_nEntityIndex;
+	int32 field_4;
+	int32 m_nSampleIndex;
+	uint8 m_bBankIndex;
+	uint8 m_bIsDistant;
+	uint8 field_14;
+	uint8 field_15;
+	int32 field_16;
+	int32 m_nFrequency;
 	uint8 m_bVolume;
-	char field_25;
-	char field_26;
-	char field_27;
+	uint8 field_25;
+	uint8 field_26;
+	uint8 field_27;
 	float m_fDistance;
-	int m_nLoopCount;
-	int m_nLoopStart;
-	int m_nLoopEnd;
+	int32 m_nLoopCount;
+	int32 m_nLoopStart;
+	int32 m_nLoopEnd;
 	uint8 m_bEmittingVolume;
-	char field_45;
-	char field_46;
-	char field_47;
+	uint8 field_45;
+	uint8 field_46;
+	uint8 field_47;
 	float field_48;
 	float m_fSoundIntensity;
-	char field_56;
-	char field_57;
-	char field_58;
-	char field_59;
+	uint8 field_56;
+	uint8 field_57;
+	uint8 field_58;
+	uint8 field_59;
 	CVector m_vecPos;
-	char m_bReverbFlag;
-	char m_bLoopsRemaining;
-	char m_bRequireReflection;
+	uint8 m_bReverbFlag;
+	uint8 m_bLoopsRemaining;
+	uint8 m_bRequireReflection;
 	uint8 m_bOffset;
-	int field_76;
-	char m_bIsProcessed;
-	char m_bLoopEnded;
-	char field_82;
-	char field_83;
-	int calculatedVolume;
-	char field_88;
-	char field_89;
-	char field_90;
-	char field_91;
+	int32 field_76;
+	uint8 m_bIsProcessed;
+	uint8 m_bLoopEnded;
+	uint8 field_82;
+	uint8 field_83;
+	int32 calculatedVolume;
+	uint8 field_88;
+	uint8 field_89;
+	uint8 field_90;
+	uint8 field_91;
 };
 
 static_assert(sizeof(tActiveSample) == 0x5c, "tActiveSample: error");
@@ -77,14 +77,14 @@ class tAudioEntity
 {
 public:
 	eAudioType m_nType;
-	CPhysical *m_pEntity;
+	void *m_pEntity;
 	bool m_bIsUsed;
-	char m_bStatus;
+	uint8 m_bStatus;
 	int16 m_awAudioEvent[4];
-	char gap_18[2];
+	uint8 gap_18[2];
 	float m_afVolume[4];
-	char field_24;
-	char field_25[3];
+	uint8 field_24;
+	uint8 field_25[3];
 };
 
 static_assert(sizeof(tAudioEntity) == 0x28, "tAudioEntity: error");
@@ -96,9 +96,9 @@ public:
 	int field_4;
 	CVector m_vecPos;
 	float m_fDistance;
-	char m_bVolume;
-	char field_25;
-	char gap_26[2];
+	uint8 m_bVolume;
+	uint8 field_25;
+	uint8 gap_26[2];
 };
 
 static_assert(sizeof(tPedComment) == 0x1c, "tPedComment: error");
@@ -107,10 +107,10 @@ class cPedComments
 {
 public:
 	tPedComment m_asPedComments[40];
-	char field_1120[40];
-	char field_1160[2];
-	char field_1162;
-	char gap_1163[1];
+	uint8 field_1120[40];
+	uint8 field_1160[2];
+	uint8 field_1162;
+	uint8 gap_1163[1];
 };
 
 static_assert(sizeof(cPedComments) == 0x48c, "cPedComments: error");
@@ -122,15 +122,15 @@ class cAudioCollision
 public:
 	CEntity *m_pEntity1;
 	CEntity *m_pEntity2;
-	char m_bSurface1;
-	char m_bSurface2;
-	char field_10;
-	char field_11;
+	uint8 m_bSurface1;
+	uint8 m_bSurface2;
+	uint8 field_10;
+	uint8 field_11;
 	float m_fIntensity1;
 	float m_fIntensity2;
 	CVector m_vecPosition;
 	float m_fDistance;
-	int m_nBaseVolume;
+	int32 m_nBaseVolume;
 };
 
 static_assert(sizeof(cAudioCollision) == 0x28, "cAudioCollision: error");
@@ -140,95 +140,132 @@ class cAudioCollisionManager
 public:
 	cAudioCollision m_asCollisions1[10];
 	cAudioCollision m_asCollisions2[10];
-	char m_bIndicesTable[10];
-	char m_bCollisionsInQueue;
-	char gap_811;
+	uint8 m_bIndicesTable[10];
+	uint8 m_bCollisionsInQueue;
+	uint8 gap_811;
 	cAudioCollision m_sQueue;
 };
 
-static_assert(sizeof(cAudioCollisionManager) == 0x354,
-              "cAudioCollisionManager: error");
+static_assert(sizeof(cAudioCollisionManager) == 0x354, "cAudioCollisionManager: error");
 
 class cMissionAudio
 {
 public:
 	CVector m_vecPos;
-	char field_12;
-	char gap_13[3];
+	uint8 field_12;
+	uint8 gap_13[3];
 	int m_nSampleIndex;
-	char m_bLoadingStatus;
-	char m_bPlayStatus;
-	char field_22;
-	char field_23;
+	uint8 m_bLoadingStatus;
+	uint8 m_bPlayStatus;
+	uint8 field_22;
+	uint8 field_23;
 	int field_24;
 	bool m_bIsPlayed;
-	char field_29;
-	char field_30;
-	char field_31;
+	uint8 field_29;
+	uint8 field_30;
+	uint8 field_31;
 };
 
 static_assert(sizeof(cMissionAudio) == 0x20, "cMissionAudio: error");
 
+class cVehicleParams;
+class CPlane;
+class CVehicle;
+class CPed;
+
+struct cAudioScriptObject {
+	int16 m_wSound;
+	char gap_2[2];
+	CVector m_vecPos;
+	int m_nAudioEntityId;
+};
+
+static_assert(sizeof(cAudioScriptObject) == 0x14, "cAudioScriptObject: error");
+
 class cAudioManager
 {
 public:
 	bool m_bIsInitialised;
-	char field_1;
-	char field_2;
-	char m_bActiveSamples;
-	char field_4;
+	uint8 field_1;
+	uint8 field_2;
+	uint8 m_bActiveSamples;
+	uint8 field_4;
 	bool m_bDynamicAcousticModelingStatus;
-	char field_6;
-	char field_7;
-	float field_8;
+	uint8 field_6;
+	uint8 field_7;
+	float speedOfSound;
 	bool m_bTimerJustReset;
-	char field_13;
-	char field_14;
-	char field_15;
-	int m_nTimer;
+	uint8 field_13;
+	uint8 field_14;
+	uint8 field_15;
+	int32 m_nTimer;
 	tActiveSample m_sQueueSample;
 	uint8 m_bActiveSampleQueue;
-	char gap_109[3];
-	tActiveSample m_asSamples[54];
-	char m_abSampleQueueIndexTable[54];
-	char m_bSampleRequestQueuesStatus[2];
+	uint8 gap_109[3];
+	tActiveSample m_asSamples[2][27];
+	uint8 m_abSampleQueueIndexTable[2][27];
+	uint8 m_bSampleRequestQueuesStatus[2];
 	tActiveSample m_asActiveSamples[27];
 	tAudioEntity m_asAudioEntities[200];
-	int m_anAudioEntityIndices[200];
-	int m_nAudioEntitiesTotal;
+	int32 m_anAudioEntityIndices[200];
+	int32 m_nAudioEntitiesTotal;
 	CVector m_avecReflectionsPos[5];
 	float m_afReflectionsDistances[5];
-	int m_anScriptObjectEntityIndices[40];
-	int m_nScriptObjectEntityTotal;
+	int32 m_anScriptObjectEntityIndices[40];
+	int32 m_nScriptObjectEntityTotal;
 	cPedComments m_sPedComments;
-	int m_nFireAudioEntity;
-	int m_nWaterCannonEntity;
-	int m_nPoliceChannelEntity;
-	char gap45B8[444];
-	int m_nFrontEndEntity;
-	int m_nCollisionEntity;
+	int32 m_nFireAudioEntity;
+	int32 m_nWaterCannonEntity;
+	int32 m_nPoliceChannelEntity;
+	uint8 gap45B8[444];
+	int32 m_nFrontEndEntity;
+	int32 m_nCollisionEntity;
 	cAudioCollisionManager m_sCollisionManager;
-	int m_nProjectileEntity;
-	int m_nBridgeEntity;
+	int32 m_nProjectileEntity;
+	int32 m_nBridgeEntity;
 	cMissionAudio m_sMissionAudio;
-	int m_anRandomTable[5];
-	char field_19192;
-	char m_bUserPause;
-	char m_bPreviousUserPause;
-	char field_19195;
-	int m_nTimeOfRecentCrime;
-
-	void AddSampleToRequestedQueue();
-
-	void AddDetailsToRequestedOrderList(uint8 sample);
-	void AddReflectionsToRequestedQueue();
-
-	uint32 ComputeVolume(int emittingVolume, float soundIntensity, float distance);
+	int32 m_anRandomTable[5];
+	uint8 field_19192;
+	uint8 m_bUserPause;
+	uint8 m_bPreviousUserPause;
+	uint8 field_19195;
+	int32 m_nTimeOfRecentCrime;
+
+	void AddDetailsToRequestedOrderList(uint8 sample); /// ok
+	void AddPlayerCarSample(uint8 emittingVolume, int32 freq, uint32 sample, uint8 unk1,
+	                        uint8 unk2, bool notLooping); /// ok
+	void AddReflectionsToRequestedQueue();                /// ok (check value)
+	void AddReleasingSounds();                            // todo (difficult)
+	void AddSampleToRequestedQueue();                     /// ok
+	void AgeCrimes();                                     // todo
+	int8 AutoDetect3DProviders();                         /// ok
+
+	void CalculateDistance(bool *ptr, float dist); /// ok
+	bool CheckForAnAudioFileOnCD();                /// ok
+	void ClearMissionAudio();                      /// ok
+	void ClearRequestedQueue();                    /// ok
+	int32 ComputeDopplerEffectedFrequency(uint32 oldFreq, float position1, float position2,
+	                                      float speedMultiplier);                   /// ok
+	int32 ComputePan(float, CVector *);                                             // todo
+	uint32 ComputeVolume(int emittingVolume, float soundIntensity, float distance); /// ok
+	int32 CreateEntity(int32 type, CPhysical *entity);                              /// ok
+
+	void DestroyAllGameCreatedEntities(); /// ok
+	void DestroyEntity(int32 id);         /// ok
+	void DoPoliceRadioCrackle();          /// ok
+
+	void GenerateIntegerRandomNumberTable(); /// ok
+
+	float GetDistanceSquared(CVector *v); /// ok
+
+	void TranslateEntity(CVector *v1, CVector *v2); /// ok
+
+	// done
 
 	void Initialise();
 	void PostInitialiseGameSpecificSetup();
-	void InitialisePoliceRadioZones();       // @todo
-	void ResetAudioLogicTimers(int32 timer); // @todo
+	void InitialisePoliceRadioZones();       // todo
+	void ResetAudioLogicTimers(int32 timer); // todo
 
 	void Terminate();
 
@@ -236,7 +273,6 @@ public:
 	bool GetMissionAudioLoadingStatus();
 
 	uint8 GetNum3DProvidersAvailable();
-	int8 AutoDetect3DProviders();
 	bool IsMP3RadioChannelAvailable();
 	uint8 GetCDAudioDriveLetter();
 
@@ -247,24 +283,21 @@ public:
 
 	void SetSpeakerConfig(int32 conf);
 
-	void ProcessJumboFlying();
 	bool SetupJumboEngineSound(uint8, int32); // todo
 	void PreInitialiseGameSpecificSetup();
 	void SetMissionScriptPoliceAudio(int32 sfx);
 
-	void CalculateDistance(bool *ptr, float dist);
-
 	bool UsesSiren(int32 model);
 	bool UsesSirenSwitching(int32 model);
 
 	bool MissionScriptAudioUsesPoliceChannel(int32 soundMission);
 
-	uint8 Get3DProviderName(uint8 id);
+	char* Get3DProviderName(uint8 id);
 
-	void ProcessJumboTaxi();
-	bool SetupJumboFlySound(uint8);          // todo
-	bool SetupJumboTaxiSound(uint8);         // todo
-	bool SetupJumboWhineSound(uint8, int32); // todo
+	bool SetupJumboFlySound(uint8 emittingVol);               /// ok
+	bool SetupJumboRumbleSound(uint8 emittingVol);            /// ok
+	bool SetupJumboTaxiSound(uint8 vol);                      /// ok
+	bool SetupJumboWhineSound(uint8 emittingVol, int32 freq); /// ok
 
 	void PlayLoadedMissionAudio();
 
@@ -274,27 +307,14 @@ public:
 
 	void InterrogateAudioEntities();
 
-	void ClearRequestedQueue();
-	//	void AgeCrimes(); //todo
-
 	bool UsesReverseWarning(int32 model);
 	bool HasAirBrakes(int32 model);
 
 	int32 GetJumboTaxiFreq();
 
-	void ProcessPhysical(int32 id);
-	void ProcessVehicle(CPhysical *); // todo
-	void ProcessPed(CPhysical *);     // todo
-	void ProcessPlane(void *);        // todo
-
-	void ClearMissionAudio();
-	//	void ProcessReverb(); // todo
-
 	bool IsMissionAudioSampleFinished();
 
-	void ProcessEntity(int32);
-
-	void InitialisePoliceRadio();
+	void InitialisePoliceRadio(); // todo
 
 	int32 RandomDisplacement(uint32 seed);
 
@@ -304,21 +324,20 @@ public:
 
 	bool IsAudioInitialised() const;
 
-	int32 CreateEntity(int32 type, CPhysical *entity);
-	void DestroyEntity(int32 id);
 	void SetEntityStatus(int32 id, bool status);
 
 	void PreTerminateGameSpecificShutdown();
 	void PostTerminateGameSpecificShutdown();
 
-	void GenerateIntegerRandomNumberTable();
-
 	void PlayerJustGotInCar();
 	void PlayerJustLeftCar();
 
 	void Service();
-	void GetPhrase(uint32 *phrase, uint32 *prevPhrase, uint32 sample,
-	               uint32 maxOffset);
+	void GetPhrase(uint32 *phrase, uint32 *prevPhrase, uint32 sample, uint32 maxOffset);
+
+	void DoJumboVolOffset();
+
+	int32 GetPedCommentSfx(CPed *ped, int32 sound);
 
 	uint32 GetPlayerTalkSfx(int16 sound);
 	uint32 GetCopTalkSfx(int16 sound);
@@ -396,9 +415,74 @@ public:
 
 	uint32 GetGenericMaleTalkSfx(int16 sound);
 	uint32 GetGenericFemaleTalkSfx(int16 sound);
+
+	void ProcessActiveQueues();                              // todo
+	bool ProcessAirBrakes(cVehicleParams *params);           /// ok
+	void ProcessAirportScriptObject(uint8 sound);            /// ok
+	bool ProcessBoatEngine(cVehicleParams *params);          // todo requires CBoat
+	bool ProcessBoatMovingOverWater(cVehicleParams *params); // todo requires CBoat
+	void ProcessBridge();                                    // todo requires CBridge
+	void ProcessBridgeMotor();                               /// ok
+	void ProcessBridgeOneShots();                            // todo requires CBridge
+	void ProcessBridgeWarning();                             /// ok
+	bool ProcessCarBombTick(void *);                         // todo requires CVehicle
+	void ProcessCesna(void *);                               // todo requires CPlane
+	void ProcessCinemaScriptObject(uint8 sound);             /// ok
+	void ProcessCrane();                                     // todo requires CCrane
+	void ProcessDocksScriptObject(uint8 sound);              /// ok
+	//	bool ProcessEngineDamage(void *); //todo requires CVehicle
+	void ProcessEntity(int32 sound);         /// ok
+	void ProcessExplosions(int32 explosion); // todo requires CExplosion
+	void ProcessFireHydrant();               /// ok
+	void ProcessFires(int32 entity);         // todo requires gFireManager
+	void ProcessFrontEnd();                  /// ok
+	void ProcessGarages();                   // todo requires CGarages::aGarages
+	//	bool ProcessHelicopter(void *); // todo requires CVehicle
+	void ProcessHomeScriptObject(uint8 sound);        /// ok
+	void ProcessJumbo(cVehicleParams *);              /// ok
+	void ProcessJumboAccel(CPlane *plane);            /// ok
+	void ProcessJumboDecel(CPlane *plane);            /// ok
+	void ProcessJumboFlying();                        /// ok
+	void ProcessJumboLanding(CPlane *plane);          /// ok
+	void ProcessJumboTakeOff(CPlane *plane);          /// ok
+	void ProcessJumboTaxi();                          /// ok
+	void ProcessLaunderetteScriptObject(uint8 sound); /// ok
+	void ProcessLoopingScriptObject(uint8 sound);     /// ok
+	//	void ProcessMissionAudio();
+	//	void ProcessModelVehicle(void *);
+	//	void ProcessOneShotScriptObject(uint8 sound);
+	void ProcessPed(CPhysical *p); // todo
+	//	void ProcessPedHeadphones(void *);
+	//	void ProcessPedOneShots(void *);
+	void ProcessPhysical(int32 id); /// ok
+	void ProcessPlane(void *);      // todo
+	//	void ProcessPlayersVehicleEngine(void *, void *);
+	void ProcessPoliceCellBeatingScriptObject(uint8 sound); // todo
+	void ProcessPornCinema(uint8 sound);                    /// ok
+	void ProcessProjectiles();                              // todo
+	//	void ProcessRainOnVehicle(void *);
+	//	void ProcessReverb();
+	//	bool ProcessReverseGear(void *);
+	void ProcessSawMillScriptObject(uint8 sound); /// ok
+	void ProcessScriptObject(int32 id);           // todo
+	void ProcessShopScriptObject(uint8 sound);    /// ok
+	void ProcessSpecial();                        /// ok
+	//	bool ProcessTrainNoise(void *);
+	void ProcessVehicle(CVehicle *); // todo
+	//	bool ProcessVehicleDoors(void *);
+	//	bool ProcessVehicleEngine(void *);
+	//	void ProcessVehicleHorn(void *);
+	//	void ProcessVehicleOneShots(void *);
+	//	bool ProcessVehicleReverseWarning(void *);
+	//	bool ProcessVehicleRoadNoise(void *);
+	//	void ProcessVehicleSirenOrAlarm(void *);
+	//	void ProcessVehicleSkidding(void *);
+	void ProcessWaterCannon(int32); // todo
+	void ProcessWeather(int32 id);  // todo
+	//	bool ProcessWetRoadNoise(void *);
+	void ProcessWorkShopScriptObject(uint8 sound); /// ok
 };
 
 static_assert(sizeof(cAudioManager) == 0x4B14, "cAudioManager: error");
 
 extern cAudioManager &AudioManager;
-extern cAudioManager &Players;
diff --git a/src/audio/AudioSamples.h b/src/audio/AudioSamples.h
index 26fffe63..ba7bf7a8 100644
--- a/src/audio/AudioSamples.h
+++ b/src/audio/AudioSamples.h
@@ -3037,4 +3037,132 @@ enum eAudioSamples : uint32 {
 	AUDIO_SAMPLE_AMMUNATION_WELCOME_3 = 3031,
 	TOTAL_AUDIO_SAMPLES = 3032,
 	NO_SAMPLE = 3033,
-};
\ No newline at end of file
+};
+
+enum eScriptSounds : int16
+{
+  SCRIPT_SOUND_0 = 0,
+  SCRIPT_SOUND_1 = 1,
+  SCRIPT_SOUND_2 = 2,
+  SCRIPT_SOUND_3 = 3,
+  SCRIPT_SOUND_PARTY_1_LOOP_S = 4,
+  SCRIPT_SOUND_PARTY_1_LOOP_L = 5,
+  SCRIPT_SOUND_PARTY_2_LOOP_S = 6,
+  SCRIPT_SOUND_PARTY_2_LOOP_L = 7,
+  SCRIPT_SOUND_PARTY_3_LOOP_S = 8,
+  SCRIPT_SOUND_PARTY_3_LOOP_L = 9,
+  SCRIPT_SOUND_PARTY_4_LOOP_S = 10,
+  SCRIPT_SOUND_PARTY_4_LOOP_L = 11,
+  SCRIPT_SOUND_PARTY_5_LOOP_S = 12,
+  SCRIPT_SOUND_PARTY_5_LOOP_L = 13,
+  SCRIPT_SOUND_PARTY_6_LOOP_S = 14,
+  SCRIPT_SOUND_PARTY_6_LOOP_L = 15,
+  SCRIPT_SOUND_PARTY_7_LOOP_S = 16,
+  SCRIPT_SOUND_PARTY_7_LOOP_L = 17,
+  SCRIPT_SOUND_PARTY_8_LOOP_S = 18,
+  SCRIPT_SOUND_PARTY_8_LOOP_L = 19,
+  SCRIPT_SOUND_PARTY_9_LOOP_S = 20,
+  SCRIPT_SOUND_PARTY_9_LOOP_L = 21,
+  SCRIPT_SOUND_PARTY_10_LOOP_S = 22,
+  SCRIPT_SOUND_PARTY_10_LOOP_L = 23,
+  SCRIPT_SOUND_PARTY_11_LOOP_S = 24,
+  SCRIPT_SOUND_PARTY_11_LOOP_L = 25,
+  SCRIPT_SOUND_PARTY_12_LOOP_S = 26,
+  SCRIPT_SOUND_PARTY_12_LOOP_L = 27,
+  SCRIPT_SOUND_PARTY_13_LOOP_S = 28,
+  SCRIPT_SOUND_PARTY_13_LOOP_L = 29,
+  SCRIPT_SOUND_STRIP_CLUB_LOOP_1_S = 30,
+  SCRIPT_SOUND_STRIP_CLUB_LOOP_1_L = 31,
+  SCRIPT_SOUND_STRIP_CLUB_LOOP_2_S = 32,
+  SCRIPT_SOUND_STRIP_CLUB_LOOP_2_L = 33,
+  SCRIPT_SOUND_WORK_SHOP_LOOP_S = 34,
+  SCRIPT_SOUND_WORK_SHOP_LOOP_L = 35,
+  SCRIPT_SOUND_SAWMILL_LOOP_S = 36,
+  SCRIPT_SOUND_SAWMILL_LOOP_L = 37,
+  SCRIPT_SOUND_38 = 38,
+  SCRIPT_SOUND_39 = 39,
+  SCRIPT_SOUND_LAUNDERETTE_LOOP_S = 40,
+  SCRIPT_SOUND_LAUNDERETTE_LOOP_L = 41,
+  SCRIPT_SOUND_CHINATOWN_RESTAURANT_S = 42,
+  SCRIPT_SOUND_CHINATOWN_RESTAURANT_L = 43,
+  SCRIPT_SOUND_CIPRIANI_RESAURANT_S = 44,
+  SCRIPT_SOUND_CIPRIANI_RESAURANT_L = 45,
+  SCRIPT_SOUND_46 = 46,
+  SCRIPT_SOUND_47 = 47,
+  SCRIPT_SOUND_MARCO_BISTRO_S = 48,
+  SCRIPT_SOUND_MARCO_BISTRO_L = 49,
+  SCRIPT_SOUND_AIRPORT_LOOP_S = 50,
+  SCRIPT_SOUND_AIRPORT_LOOP_L = 51,
+  SCRIPT_SOUND_SHOP_LOOP_S = 52,
+  SCRIPT_SOUND_SHOP_LOOP_L = 53,
+  SCRIPT_SOUND_CINEMA_LOOP_S = 54,
+  SCRIPT_SOUND_CINEMA_LOOP_L = 55,
+  SCRIPT_SOUND_DOCKS_LOOP_S = 56,
+  SCRIPT_SOUND_DOCKS_LOOP_L = 57,
+  SCRIPT_SOUND_HOME_LOOP_S = 58,
+  SCRIPT_SOUND_HOME_LOOP_L = 59,
+  SCRIPT_SOUND_FRANKIE_PIANO = 60,
+  SCRIPT_SOUND_PARTY_1_LOOP = 61,
+  SCRIPT_SOUND_PORN_CINEMA_1_S = 62,
+  SCRIPT_SOUND_PORN_CINEMA_1_L = 63,
+  SCRIPT_SOUND_PORN_CINEMA_2_S = 64,
+  SCRIPT_SOUND_PORN_CINEMA_2_L = 65,
+  SCRIPT_SOUND_PORN_CINEMA_3_S = 66,
+  SCRIPT_SOUND_PORN_CINEMA_3_L = 67,
+  SCRIPT_SOUND_BANK_ALARM_LOOP_S = 68,
+  SCRIPT_SOUND_BANK_ALARM_LOOP_L = 69,
+  SCRIPT_SOUND_POLICE_BALL_LOOP_S = 70,
+  SCRIPT_SOUND_POLICE_BALL_LOOP_L = 71,
+  SCRIPT_SOUND_RAVE_LOOP_INDUSTRIAL_S = 72,
+  SCRIPT_SOUND_RAVE_LOOP_INDUSTRIAL_L = 73,
+  SCRIPT_SOUND_74 = 74,
+  SCRIPT_SOUND_75 = 75,
+  SCRIPT_SOUND_POLICE_CELL_BEATING_LOOP_S = 76,
+  SCRIPT_SOUND_POLICE_CELL_BEATING_LOOP_L = 77,
+  SCRIPT_SOUND_INJURED_PED_MALE_OUCH_S = 78,
+  SCRIPT_SOUND_INJURED_PED_MALE_OUCH_L = 79,
+  SCRIPT_SOUND_INJURED_PED_FEMALE_OUCH_S = 80,
+  SCRIPT_SOUND_INJURED_PED_FEMALE_OUCH_L = 81,
+  SCRIPT_SOUND_EVIDENCE_PICKUP = 82,
+  SCRIPT_SOUND_UNLOAD_GOLD = 83,
+  SCRIPT_SOUND_RAVE_1_LOOP_S = 84,
+  SCRIPT_SOUND_RAVE_1_LOOP_L = 85,
+  SCRIPT_SOUND_RAVE_2_LOOP_S = 86,
+  SCRIPT_SOUND_RAVE_2_LOOP_L = 87,
+  SCRIPT_SOUND_RAVE_3_LOOP_S = 88,
+  SCRIPT_SOUND_RAVE_3_LOOP_L = 89,
+  SCRIPT_SOUND_MISTY_SEX_S = 90,
+  SCRIPT_SOUND_MISTY_SEX_L = 91,
+  SCRIPT_SOUND_GATE_START_CLUNK = 92,
+  SCRIPT_SOUND_GATE_STOP_CLUNK = 93,
+  SCRIPT_SOUND_PART_MISSION_COMPLETE = 94,
+  SCRIPT_SOUND_CHUNKY_RUN_SHOUT = 95,
+  SCRIPT_SOUND_SECURITY_GUARD_AWAY_SHOUT = 96,
+  SCRIPT_SOUND_RACE_START_3 = 97,
+  SCRIPT_SOUND_RACE_START_2 = 98,
+  SCRIPT_SOUND_RACE_START_1 = 99,
+  SCRIPT_SOUND_RACE_START_GO = 100,
+  SCRIPT_SOUND_SWAT_PED_SHOUT = 101,
+  SCRIPT_SOUND_PRETEND_FIRE_LOOP = 102,
+  SCRIPT_SOUND_AMMUNATION_CHAT_1 = 103,
+  SCRIPT_SOUND_AMMUNATION_CHAT_2 = 104,
+  SCRIPT_SOUND_AMMUNATION_CHAT_3 = 105,
+  SCRIPT_SOUND_BULLET_HIT_GROUND_1 = 106,
+  SCRIPT_SOUND_BULLET_HIT_GROUND_2 = 107,
+  SCRIPT_SOUND_BULLET_HIT_GROUND_3 = 108,
+  SCRIPT_SOUND_109 = 109,
+  SCRIPT_SOUND_110 = 110,
+  SCRIPT_SOUND_111 = 111,
+  SCRIPT_SOUND_PAYPHONE_RINGING = 112,
+  SCRIPT_SOUND_113 = 113,
+  SCRIPT_SOUND_GLASS_BREAK_L = 114,
+  SCRIPT_SOUND_GLASS_BREAK_S = 115,
+  SCRIPT_SOUND_GLASS_CRACK = 116,
+  SCRIPT_SOUND_GLASS_LIGHT_BREAK = 117,
+  SCRIPT_SOUND_BOX_DESTROYED_1 = 118,
+  SCRIPT_SOUND_BOX_DESTROYED_2 = 119,
+  SCRIPT_SOUND_METAL_COLLISION = 120,
+  SCRIPT_SOUND_TIRE_COLLISION = 121,
+  SCRIPT_SOUND_GUNSHELL_DROP = 122,
+  SCRIPT_SOUND_GUNSHELL_DROP_SOFT = 123,
+};
diff --git a/src/audio/DMAudio.h b/src/audio/DMAudio.h
index b671e260..da20dc31 100644
--- a/src/audio/DMAudio.h
+++ b/src/audio/DMAudio.h
@@ -96,8 +96,8 @@ enum eSound : int16
 	SOUND_RAMPAGE_FAILED = 91,
 	SOUND_RAMPAGE_KILL = 92,
 	SOUND_RAMPAGE_CAR_BLOWN = 93,
-	_SOUND_EVIDENCE_PICKUP = 94,
-	_SOUND_UNLOAD_GOLD = 95,
+	SOUND_EVIDENCE_PICKUP = 94,
+	SOUND_UNLOAD_GOLD = 95,
 	SOUND_PAGER = 96,
 	SOUND_PED_DEATH = 97,
 	SOUND_PED_DAMAGE = 98,
@@ -141,16 +141,16 @@ enum eSound : int16
 	SOUND_INJURED_PED_MALE_OUCH = 136,
 	SOUND_INJURED_PED_FEMALE = 137,
 	SOUND_8A = 138,
-	_SOUND_RACE_START_3 = 139,
-	_SOUND_RACE_START_2 = 140,
-	_SOUND_RACE_START_1 = 141,
-	_SOUND_RACE_START_GO = 142,
+	SOUND_RACE_START_3 = 139,
+	SOUND_RACE_START_2 = 140,
+	SOUND_RACE_START_1 = 141,
+	SOUND_RACE_START_GO = 142,
 	SOUND_SPLASH = 143,
 	SOUND_WATER_FALL = 144,
 	SOUND_SPLATTER = 145,
 	SOUND_CAR_PED_COLLISION = 146,
 	SOUND_CLOCK_TICK = 147,
-	_SOUND_PART_MISSION_COMPLETE = 148,
+	SOUND_PART_MISSION_COMPLETE = 148,
 	SOUND_FRONTEND_MENU_STARTING = 149,
 	SOUND_FRONTEND_MENU_COMPLETED = 150,
 	SOUND_FRONTEND_MENU_DENIED = 151,
diff --git a/src/audio/MusicManager.cpp b/src/audio/MusicManager.cpp
index dcd4ae93..71cc594b 100644
--- a/src/audio/MusicManager.cpp
+++ b/src/audio/MusicManager.cpp
@@ -188,3 +188,17 @@ cMusicManager::Terminate()
 {
 	EAXJMP(0x57D140);
 }
+
+WRAPPER
+void
+cMusicManager::ChangeMusicMode(int32 mode)
+{
+	EAXJMP(0x57D310);
+}
+
+WRAPPER
+void
+cMusicManager::StopFrontEndTrack()
+{
+	EAXJMP(0x57E3D0);
+}
diff --git a/src/audio/MusicManager.h b/src/audio/MusicManager.h
index 944fd16e..6a08882f 100644
--- a/src/audio/MusicManager.h
+++ b/src/audio/MusicManager.h
@@ -267,6 +267,9 @@ public:
 	void Initialise();
 	void Terminate();
 
+	void ChangeMusicMode(int32 mode);
+	void StopFrontEndTrack();
+
 	char *Get3DProviderName(char);
 	bool PlayerInCar();
 	void DisplayRadioStationName();
diff --git a/src/audio/SampleManager.cpp b/src/audio/SampleManager.cpp
index fbeb49ed..b2f0cf35 100644
--- a/src/audio/SampleManager.cpp
+++ b/src/audio/SampleManager.cpp
@@ -1,18 +1,67 @@
+#include "SampleManager.h"
 #include "common.h"
 #include "patcher.h"
-#include "SampleManager.h"
 
 CSampleManager &cSampleManager = *(CSampleManager *)0x7341E0;
 
 uint32 &nNumOfMp3Files = *(uint32 *)0x95CC00;
 uint8 &num3DProvidersAvailable = *(uint8 *)0x734237;
-uint32 *asName3DProviders = (uint32 *)0x734238;
+char **asName3DProviders = (char **)0x734238;
 
-bool CSampleManager::IsMP3RadioChannelAvailable() {
+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
@@ -110,6 +159,13 @@ CSampleManager::GetChannelUsedFlag(int32 id)
 
 WRAPPER
 void
+CSampleManager::StartChannel(int32 id)
+{
+	EAXJMP(0x567B80);
+}
+
+WRAPPER
+void
 CSampleManager::StopChannel(int32 id)
 {
 	EAXJMP(0x567BE0);
diff --git a/src/audio/SampleManager.h b/src/audio/SampleManager.h
index f0245d4e..dc46e7ec 100644
--- a/src/audio/SampleManager.h
+++ b/src/audio/SampleManager.h
@@ -1,5 +1,7 @@
 #pragma once
 
+#include "common.h"
+
 struct tSample {
 	int m_nOffset;
 	unsigned int m_nSize;
@@ -11,6 +13,26 @@ struct tSample {
 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();
@@ -32,6 +54,8 @@ public:
 	void SetSpeakerConfig(uint32 config);
 
 	bool GetChannelUsedFlag(int32 id);
+
+	void StartChannel(int32 id);
 	void StopChannel(int32 id);
 
 	static bool IsMP3RadioChannelAvailable();
@@ -39,6 +63,6 @@ public:
 
 extern uint32 &nNumOfMp3Files;
 extern uint8 &num3DProvidersAvailable;
-extern uint32* asName3DProviders;
+extern char **asName3DProviders;
 
 extern CSampleManager &cSampleManager;
\ No newline at end of file