code:
#include "common.h"

#include "AudioManager.h"
#include "audio_enums.h"

#include "AudioScriptObject.h"
#include "MusicManager.h"
#include "Timer.h"
#include "DMAudio.h"
#include "sampman.h"
#include "Camera.h"
#include "World.h"
#include "Entity.h"

cAudioManager AudioManager;

#define SPEED_OF_SOUND 343.f
#ifdef GTA_PS2
#define TIME_SPENT 40
#else
#define TIME_SPENT 50
#endif

cAudioManager::cAudioManager()
{
	m_bIsInitialised = FALSE;
	m_bIsSurround = TRUE;
	m_fSpeedOfSound = SPEED_OF_SOUND / TIME_SPENT;
	m_nTimeSpent = TIME_SPENT;
	m_nActiveSamples = NUM_CHANNELS_GENERIC;
	m_nActiveQueue = 1;
	ClearRequestedQueue();
	m_nActiveQueue = 0;
	ClearRequestedQueue();
	ClearActiveSamples();
	GenerateIntegerRandomNumberTable();
	m_bDoubleVolume = FALSE;
#ifdef AUDIO_REFLECTIONS
	m_bDynamicAcousticModelingStatus = TRUE;
#endif

	for (uint32 i = 0; i < NUM_AUDIOENTITIES; i++) {
		m_asAudioEntities[i].m_bIsUsed = FALSE;
		m_aAudioEntityOrderList[i] = NUM_AUDIOENTITIES;
	}
	m_nAudioEntitiesCount = 0;
	m_FrameCounter = 0;
	m_bReduceReleasingPriority = FALSE;
	m_bTimerJustReset = FALSE;
	m_nTimer = 0;
}

cAudioManager::~cAudioManager()
{
	if (m_bIsInitialised)
		Terminate();
}

void
cAudioManager::Initialise()
{
	if (!m_bIsInitialised) {
		PreInitialiseGameSpecificSetup();
		m_bIsInitialised = SampleManager.Initialise();
		if (m_bIsInitialised) {
#ifdef EXTERNAL_3D_SOUND
			m_nActiveSamples = SampleManager.GetMaximumSupportedChannels();
			if (m_nActiveSamples <= 1) {
				Terminate();
			} else {
				m_nActiveSamples--;
#else
			{
				m_nActiveSamples = NUM_CHANNELS_GENERIC;
#endif
				PostInitialiseGameSpecificSetup();
				InitialisePoliceRadioZones();
				InitialisePoliceRadio();
				MusicManager.Initialise();
			}
		}
	}
}

void
cAudioManager::Terminate()
{
	if (m_bIsInitialised) {
		MusicManager.Terminate();

		for (uint32 i = 0; i < NUM_AUDIOENTITIES; i++) {
			m_asAudioEntities[i].m_bIsUsed = FALSE;
			m_aAudioEntityOrderList[i] = NUM_AUDIOENTITIES;
		}

		m_nAudioEntitiesCount = 0;
		m_sAudioScriptObjectManager.m_nScriptObjectEntityTotal = 0;
		PreTerminateGameSpecificShutdown();

		for (uint32 i = 0; i < MAX_SFX_BANKS; i++) {
			if (SampleManager.IsSampleBankLoaded(i))
				SampleManager.UnloadSampleBank(i);
		}

		SampleManager.Terminate();

		m_bIsInitialised = FALSE;
		PostTerminateGameSpecificShutdown();
	}
}

void
cAudioManager::Service()
{
	GenerateIntegerRandomNumberTable();
	if (m_bTimerJustReset) {
		ResetAudioLogicTimers(m_nTimer);
		MusicManager.ResetTimers(m_nTimer);
		m_bTimerJustReset = FALSE;
	}
	if (m_bIsInitialised) {
		m_bWasPaused = m_bIsPaused;
		m_bIsPaused = CTimer::GetIsUserPaused();
#ifdef AUDIO_REFLECTIONS
		UpdateReflections();
#endif
		ServiceSoundEffects();
		MusicManager.Service();
	}
}

int32
cAudioManager::CreateEntity(eAudioType type, void *entity)
{
	if (!m_bIsInitialised)
		return AEHANDLE_ERROR_NOAUDIOSYS;
	if (!entity)
		return AEHANDLE_ERROR_NOENTITY;
	if (type >= TOTAL_AUDIO_TYPES)
		return AEHANDLE_ERROR_BADAUDIOTYPE;

#ifdef FIX_BUGS
	// since sound could still play after entity deletion let's make sure we don't override one that is in use
	// find all the free entity IDs that are being used by queued samples
	int32 stillUsedEntities[NUM_CHANNELS_GENERIC * NUM_SOUND_QUEUES];
	uint32 stillUsedEntitiesCount = 0;

	for (uint8 i = 0; i < NUM_SOUND_QUEUES; i++)
		for (uint8 j = 0; j < m_nRequestedCount[i]; j++) {
			tSound &sound = m_aRequestedQueue[i][m_aRequestedOrderList[i][j]];
			if (sound.m_nEntityIndex < 0) continue;
			if (!m_asAudioEntities[sound.m_nEntityIndex].m_bIsUsed) {
				bool found = false;
				for (uint8 k = 0; k < stillUsedEntitiesCount; k++) {
					if (stillUsedEntities[k] == sound.m_nEntityIndex) {
						found = true;
						break;
					}
				}
				if (!found)
					stillUsedEntities[stillUsedEntitiesCount++] = sound.m_nEntityIndex;
			}
		}
#endif

	for (uint32 i = 0; i < NUM_AUDIOENTITIES; i++) {
		if (!m_asAudioEntities[i].m_bIsUsed) {
#ifdef FIX_BUGS
			// skip if ID is still used by queued sample
			bool skip = false;
			for (uint8 j = 0; j < stillUsedEntitiesCount; j++) {
				if (stillUsedEntities[j] == i) {
					//debug("audio entity %i still used, skipping\n", i);
					skip = true;
					break;
				}
			}
			if (skip)
				continue;
#endif

			m_asAudioEntities[i].m_bIsUsed = TRUE;
			m_asAudioEntities[i].m_bStatus = FALSE;
			m_asAudioEntities[i].m_nType = type;
			m_asAudioEntities[i].m_pEntity = entity;
			m_asAudioEntities[i].m_awAudioEvent[0] = SOUND_NO_SOUND;
			m_asAudioEntities[i].m_awAudioEvent[1] = SOUND_NO_SOUND;
			m_asAudioEntities[i].m_awAudioEvent[2] = SOUND_NO_SOUND;
			m_asAudioEntities[i].m_awAudioEvent[3] = SOUND_NO_SOUND;
			m_asAudioEntities[i].m_AudioEvents = 0;
			m_aAudioEntityOrderList[m_nAudioEntitiesCount++] = i;
			return i;
		}
	}
	return AEHANDLE_ERROR_NOFREESLOT;
}

void
cAudioManager::DestroyEntity(int32 id)
{
	if (m_bIsInitialised && id >= 0 && id < NUM_AUDIOENTITIES && m_asAudioEntities[id].m_bIsUsed) {
		m_asAudioEntities[id].m_bIsUsed = FALSE;
		for (uint32 i = 0; i < m_nAudioEntitiesCount; i++) {
			if (id == m_aAudioEntityOrderList[i]) {
				if (i < NUM_AUDIOENTITIES - 1)
					memmove(&m_aAudioEntityOrderList[i], &m_aAudioEntityOrderList[i + 1], sizeof(uint32) * (m_nAudioEntitiesCount - (i + 1)));
				m_aAudioEntityOrderList[--m_nAudioEntitiesCount] = NUM_AUDIOENTITIES;
				return;
			}
		}
	}
}

bool8
cAudioManager::GetEntityStatus(int32 id)
{
	if (m_bIsInitialised && id >= 0 && id < NUM_AUDIOENTITIES && m_asAudioEntities[id].m_bIsUsed)
		return m_asAudioEntities[id].m_bStatus;
	return FALSE;
}

void
cAudioManager::SetEntityStatus(int32 id, bool8 status)
{
	if (m_bIsInitialised && id >= 0 && id < NUM_AUDIOENTITIES && m_asAudioEntities[id].m_bIsUsed)
		m_asAudioEntities[id].m_bStatus = status;
}

void *
cAudioManager::GetEntityPointer(int32 id)
{
	if (m_bIsInitialised && id >= 0 && id < NUM_AUDIOENTITIES && m_asAudioEntities[id].m_bIsUsed)
		return m_asAudioEntities[id].m_pEntity;
	return NULL;
}

static Const uint8 OneShotPriority[] = {
										3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, 5, 5, 3, 5, 2, 2, 1, 1, 3, 1, 3, 3, 1, 1, 1, 4, 4, 3, 1, 1,
										1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 6, 1, 1, 3, 2, 2, 2, 2, 0, 0, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
										1, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 3, 1, 1, 1, 9,
										2, 2, 0, 0, 0, 0, 3, 3, 5, 1, 1, 1, 1, 3, 4, 7, 6, 6, 6, 6, 1, 3, 4, 3, 4, 2, 1, 3, 5, 4, 6, 6, 1, 3,
										1, 1, 1, 0, 0, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
										};

void
cAudioManager::PlayOneShot(int32 index, uint16 sound, float vol)
{
	if (m_bIsInitialised) {
		if (index >= 0 && index < NUM_AUDIOENTITIES) {
			tAudioEntity &entity = m_asAudioEntities[index];
			if (entity.m_bIsUsed) {
				if (sound < SOUND_TOTAL_SOUNDS) {
					if (entity.m_nType == AUDIOTYPE_SCRIPTOBJECT) {
						if (m_sAudioScriptObjectManager.m_nScriptObjectEntityTotal < ARRAY_SIZE(m_sAudioScriptObjectManager.m_anScriptObjectEntityIndices)) {
							entity.m_awAudioEvent[0] = sound;
							entity.m_AudioEvents = 1;
							m_sAudioScriptObjectManager.m_anScriptObjectEntityIndices[m_sAudioScriptObjectManager.m_nScriptObjectEntityTotal++] = index;
						}
					} else {
						int32 i = 0;
						while (TRUE) {
							if (i >= entity.m_AudioEvents) {
								if (entity.m_AudioEvents < NUM_AUDIOENTITY_EVENTS) {
									entity.m_awAudioEvent[i] = sound;
									entity.m_afVolume[i] = vol;
									entity.m_AudioEvents++;
								}
								return;
							}
							if (OneShotPriority[entity.m_awAudioEvent[i]] > OneShotPriority[sound])
								break;
							i++;
						}
						if (i < NUM_AUDIOENTITY_EVENTS - 1) {
							memmove(&entity.m_awAudioEvent[i + 1], &entity.m_awAudioEvent[i], (NUM_AUDIOENTITY_EVENTS - 1 - i) * sizeof(int16));
							memmove(&entity.m_afVolume[i + 1], &entity.m_afVolume[i], (NUM_AUDIOENTITY_EVENTS - 1 - i) * sizeof(float));
						}
						entity.m_awAudioEvent[i] = sound;
						entity.m_afVolume[i] = vol;
						if (entity.m_AudioEvents < NUM_AUDIOENTITY_EVENTS)
							entity.m_AudioEvents++;
					}
				}
			}
		}
	}
}

void
cAudioManager::SetEffectsMasterVolume(uint8 volume)
{
	SampleManager.SetEffectsMasterVolume(volume);
}

void
cAudioManager::SetMusicMasterVolume(uint8 volume)
{
	SampleManager.SetMusicMasterVolume(volume);
}

void
cAudioManager::SetEffectsFadeVol(uint8 volume)
{
	SampleManager.SetEffectsFadeVolume(volume);
}

void
cAudioManager::SetMusicFadeVol(uint8 volume)
{
	SampleManager.SetMusicFadeVolume(volume);
}

void
cAudioManager::SetMonoMode(bool8 mono)
{
	SampleManager.SetMonoMode(mono);
}

void
cAudioManager::ResetTimers(uint32 time)
{
	if (m_bIsInitialised) {
		m_bTimerJustReset = TRUE;
		m_nTimer = time;
		ClearRequestedQueue();
		if (m_nActiveQueue) {
			m_nActiveQueue = 0;
			ClearRequestedQueue();
			m_nActiveQueue = 1;
		} else {
			m_nActiveQueue = 1;
			ClearRequestedQueue();
			m_nActiveQueue = 0;
		}
		ClearActiveSamples();
		ClearMissionAudio();
		SampleManager.StopChannel(CHANNEL_POLICE_RADIO);
		SampleManager.SetEffectsFadeVolume(0);
		SampleManager.SetMusicFadeVolume(0);
		MusicManager.ResetMusicAfterReload();
#ifdef AUDIO_OAL
		SampleManager.Service();
#endif
	}
}

void
cAudioManager::DestroyAllGameCreatedEntities()
{
	cAudioScriptObject *entity;

	if (m_bIsInitialised) {
		for (uint32 i = 0; i < NUM_AUDIOENTITIES; 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_FIREHYDRANT:
					DestroyEntity(i);
					break;
				case AUDIOTYPE_SCRIPTOBJECT:
					entity = (cAudioScriptObject *)m_asAudioEntities[i].m_pEntity;
					if (entity) {
						delete entity;
						m_asAudioEntities[i].m_pEntity = nil;
					}
					DestroyEntity(i);
					break;
				default:
					break;
				}
			}
		}
		m_sAudioScriptObjectManager.m_nScriptObjectEntityTotal = 0;
	}
}

#ifdef GTA_PC

uint8
cAudioManager::GetNum3DProvidersAvailable()
{
#ifdef EXTERNAL_3D_SOUND
	if (m_bIsInitialised)
		return SampleManager.GetNum3DProvidersAvailable();
#endif
	return 0;
}

char *
cAudioManager::Get3DProviderName(uint8 id)
{
#ifndef EXTERNAL_3D_SOUND
	return nil;
#else
	if (!m_bIsInitialised)
		return nil;
#ifdef AUDIO_OAL
	id = Clamp(id, 0, SampleManager.GetNum3DProvidersAvailable() - 1);
#else
	// We don't want that either since it will crash the game, but skipping for now
	if (id >= SampleManager.GetNum3DProvidersAvailable())
		return nil;
#endif
	return SampleManager.Get3DProviderName(id);
#endif
}

int8
cAudioManager::GetCurrent3DProviderIndex()
{
#ifdef EXTERNAL_3D_SOUND
	if (m_bIsInitialised)
		return SampleManager.GetCurrent3DProviderIndex();
#endif

	return -1;
}

int8
cAudioManager::SetCurrent3DProvider(uint8 which)
{
#ifndef EXTERNAL_3D_SOUND
	return -1;
#else
	if (!m_bIsInitialised)
		return -1;
	for (uint8 i = 0; i < m_nActiveSamples + 1; i++)
		SampleManager.StopChannel(i);
	ClearRequestedQueue();
	if (m_nActiveQueue == 0)
		m_nActiveQueue = 1;
	else
		m_nActiveQueue = 0;
	ClearRequestedQueue();
	ClearActiveSamples();
	int8 current = SampleManager.SetCurrent3DProvider(which);
	if (current > 0) {
#ifdef EXTERNAL_3D_SOUND
		m_nActiveSamples = SampleManager.GetMaximumSupportedChannels();
		if (m_nActiveSamples > 1)
			m_nActiveSamples--;
#endif
	}
	return current;
#endif
}

void
cAudioManager::SetSpeakerConfig(int32 conf)
{
#ifdef EXTERNAL_3D_SOUND
	SampleManager.SetSpeakerConfig(conf);
#endif
}

bool8
cAudioManager::IsMP3RadioChannelAvailable()
{
	if (m_bIsInitialised)
		return SampleManager.IsMP3RadioChannelAvailable();

	return FALSE;
}

void
cAudioManager::ReleaseDigitalHandle()
{
	if (m_bIsInitialised)
		SampleManager.ReleaseDigitalHandle();
}

void
cAudioManager::ReacquireDigitalHandle()
{
	if (m_bIsInitialised)
		SampleManager.ReacquireDigitalHandle();
}

#ifdef AUDIO_REFLECTIONS
void
cAudioManager::SetDynamicAcousticModelingStatus(bool8 status)
{
	m_bDynamicAcousticModelingStatus = status;
}
#endif

bool8
cAudioManager::CheckForAnAudioFileOnCD()
{
	return SampleManager.CheckForAnAudioFileOnCD();
}

char
cAudioManager::GetCDAudioDriveLetter()
{
	if (m_bIsInitialised)
		return SampleManager.GetCDAudioDriveLetter();

	return '\0';
}

bool8
cAudioManager::IsAudioInitialised()
{
	return m_bIsInitialised;
}

#endif // GTA_PC

void
cAudioManager::ServiceSoundEffects()
{
#ifdef FIX_BUGS
	if(CTimer::GetLogicalFramesPassed() != 0)
#endif
	m_bReduceReleasingPriority = (m_FrameCounter++ % 5) == 0;
	if (m_bIsPaused && !m_bWasPaused) {
		for (int32 i = 0; i < NUM_CHANNELS; i++)
			SampleManager.StopChannel(i);

		ClearRequestedQueue();
		if (m_nActiveQueue) {
			m_nActiveQueue = 0;
			ClearRequestedQueue();
			m_nActiveQueue = 1;
		} else {
			m_nActiveQueue = 1;
			ClearRequestedQueue();
			m_nActiveQueue = 0;
		}
		ClearActiveSamples();
	}
	m_nActiveQueue = m_nActiveQueue == 1 ? 0 : 1;
	ProcessReverb();
	ProcessSpecial();
	ClearRequestedQueue();
	InterrogateAudioEntities();
	m_sPedComments.Process();
	ServicePoliceRadio();
	ServiceCollisions();
	AddReleasingSounds();
	ProcessMissionAudio();
#ifdef EXTERNAL_3D_SOUND
	AdjustSamplesVolume();
#endif
	ProcessActiveQueues();
#ifdef AUDIO_OAL
	SampleManager.Service();
#endif
	for (int32 i = 0; i < m_sAudioScriptObjectManager.m_nScriptObjectEntityTotal; i++) {
		cAudioScriptObject *object = (cAudioScriptObject *)m_asAudioEntities[m_sAudioScriptObjectManager.m_anScriptObjectEntityIndices[i]].m_pEntity;
		delete object;
		m_asAudioEntities[m_sAudioScriptObjectManager.m_anScriptObjectEntityIndices[i]].m_pEntity = nil;
		DestroyEntity(m_sAudioScriptObjectManager.m_anScriptObjectEntityIndices[i]);
	}
	m_sAudioScriptObjectManager.m_nScriptObjectEntityTotal = 0;
}

uint32
cAudioManager::FL(float f)
{
	return SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex) * f;
}

uint8
cAudioManager::ComputeVolume(uint8 emittingVolume, float maxDistance, float distance)
{
	float minDistance;
	if (maxDistance <= 0.0f)
		return 0;
	minDistance = maxDistance / 5.0f;
	if (minDistance <= distance)
		emittingVolume = sq((maxDistance - minDistance - (distance - minDistance)) / (maxDistance - minDistance)) * emittingVolume;
	return emittingVolume;
}

void
cAudioManager::TranslateEntity(Const CVector *in, CVector *out)
{
	*out = MultiplyInverse(TheCamera.GetMatrix(), *in);
}

int32
cAudioManager::ComputePan(float dist, CVector *vec)
{
	Const static uint8 PanTable[64] = {0,  3,  8,  12, 16, 19, 22, 24, 26, 28, 30, 31, 33, 34, 36, 37, 39, 40, 41, 42, 44, 45, 46, 47, 48, 49, 49, 50, 51, 52, 53, 53,
									   54, 55, 55, 56, 56, 57, 57, 58, 58, 58, 59, 59, 59, 60, 60, 61, 61, 61, 61, 62, 62, 62, 62, 62, 63, 63, 63, 63, 63, 63, 63, 63};

	int32 index = vec->x / (dist / 64.0f);
	index = Min(63, ABS(index));

	if (vec->x > 0.f)
		return Max(20, 63 - (int8)PanTable[index]);
	return Min(107, PanTable[index] + 63);
}

uint32
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 / m_nTimeSpent) * speedMultiplier;
			if (m_fSpeedOfSound > Abs(speedOfSource)) {
				speedOfSource = Clamp2(speedOfSource, 0.0f, 1.5f);
				newFreq = (oldFreq * m_fSpeedOfSound) / (speedOfSource + m_fSpeedOfSound);
			}
		}
	}
	return newFreq;
}

int32
cAudioManager::RandomDisplacement(uint32 seed)
{
	int32 value;

	static bool8 bPos = TRUE;
	static uint32 Adjustment = 0;

	if (seed == 0)
		return 0;

	value = m_anRandomTable[(Adjustment + seed) % 5] % seed;
	Adjustment += value;

	if (value % 2)
		bPos = !bPos;

	if (!bPos)
		value = -value;
	return value;
}

void
cAudioManager::InterrogateAudioEntities()
{
	for (uint32 i = 0; i < m_nAudioEntitiesCount; i++) {
		ProcessEntity(m_aAudioEntityOrderList[i]);
		m_asAudioEntities[m_aAudioEntityOrderList[i]].m_AudioEvents = 0;
	}
}

void
cAudioManager::AddSampleToRequestedQueue()
{
	uint32 finalPriority;
	uint8 sampleIndex;
#ifdef AUDIO_REFLECTIONS
	bool8 bReflections;
#endif

	if (m_sQueueSample.m_nSampleIndex < TOTAL_AUDIO_SAMPLES) {
		finalPriority = m_sQueueSample.m_nPriority * (MAX_VOLUME - m_sQueueSample.m_nVolume);
		sampleIndex = m_nRequestedCount[m_nActiveQueue];
		if (sampleIndex >= m_nActiveSamples) {
			sampleIndex = m_aRequestedOrderList[m_nActiveQueue][m_nActiveSamples - 1];
			if (m_aRequestedQueue[m_nActiveQueue][sampleIndex].m_nFinalPriority <= finalPriority)
				return;
		} else
			m_nRequestedCount[m_nActiveQueue]++;
#if GTA_VERSION < GTA3_PC_10
		if (m_sQueueSample.m_bStatic) {
			if (m_sQueueSample.m_nLoopCount > 0)
				m_sQueueSample.unk = m_nTimeSpent * SampleManager.GetSampleLength(m_sQueueSample.m_nSampleIndex) / m_sQueueSample.m_nFrequency;
			else
				m_sQueueSample.unk = -3;
		}
#endif
		m_sQueueSample.m_nFinalPriority = finalPriority;
		m_sQueueSample.m_bIsPlayingFinished = FALSE;
#ifdef AUDIO_REFLECTIONS
		if (m_sQueueSample.m_bIs2D) {
			m_sQueueSample.m_bReflections = FALSE;
			m_sQueueSample.m_nReflectionDelay = 0;
		}
		if (m_bDynamicAcousticModelingStatus && m_sQueueSample.m_nLoopCount > 0) {
			bReflections = m_sQueueSample.m_bReflections;
		} else {
			bReflections = FALSE;
			m_sQueueSample.m_nReflectionDelay = 0;
		}
		m_sQueueSample.m_bReflections = FALSE;

		if (!m_bDynamicAcousticModelingStatus)
			m_sQueueSample.m_bReverb = FALSE;
#endif

		m_aRequestedQueue[m_nActiveQueue][sampleIndex] = m_sQueueSample;

		AddDetailsToRequestedOrderList(sampleIndex);
#ifdef AUDIO_REFLECTIONS
		if (bReflections)
			AddReflectionsToRequestedQueue();
#endif
	}
}

void
cAudioManager::AddDetailsToRequestedOrderList(uint8 sample)
{
	uint32 i = 0;
	if (sample != 0) {
		for (; i < sample; i++) {
			if (m_aRequestedQueue[m_nActiveQueue][m_aRequestedOrderList[m_nActiveQueue][i]].m_nFinalPriority >
			    m_aRequestedQueue[m_nActiveQueue][sample].m_nFinalPriority)
				break;
		}
		if (i < sample)
			memmove(&m_aRequestedOrderList[m_nActiveQueue][i + 1], &m_aRequestedOrderList[m_nActiveQueue][i], m_nActiveSamples - i - 1);
	}
	m_aRequestedOrderList[m_nActiveQueue][i] = sample;
}

#ifdef AUDIO_REFLECTIONS
void
cAudioManager::AddReflectionsToRequestedQueue()
{
	float reflectionDistance;
	int32 noise;
	uint32 oldCounter = m_sQueueSample.m_nCounter;
	uint8 emittingVolume = (m_sQueueSample.m_nVolume >> 1) + (m_sQueueSample.m_nVolume >> 3);

	for (uint32 i = 0; i < ARRAY_SIZE(m_afReflectionsDistances); i++) {
		reflectionDistance = m_afReflectionsDistances[i];
		if (reflectionDistance > 0.0f && reflectionDistance < 100.0f && reflectionDistance < m_sQueueSample.m_MaxDistance) {
			m_sQueueSample.m_nReflectionDelay = (reflectionDistance * 500.0f / 1029.0f);
			if (m_sQueueSample.m_nReflectionDelay > 5) {
				m_sQueueSample.m_fDistance = m_afReflectionsDistances[i];
				SET_EMITTING_VOLUME(emittingVolume);
				m_sQueueSample.m_nVolume = ComputeVolume(emittingVolume, m_sQueueSample.m_MaxDistance, m_sQueueSample.m_fDistance);
				if (m_sQueueSample.m_nVolume > emittingVolume >> 4) {
					m_sQueueSample.m_nCounter = oldCounter + ((i + 1) << 8);
					if (m_sQueueSample.m_nLoopCount > 0) {
						noise = RandomDisplacement(m_sQueueSample.m_nFrequency >> 5);
						if (noise > 0)
							m_sQueueSample.m_nFrequency -= noise;
						else
							m_sQueueSample.m_nFrequency += noise;
					}
					m_sQueueSample.m_nPriority += 20;
					m_sQueueSample.m_vecPos = m_avecReflectionsPos[i];
					AddSampleToRequestedQueue();
				}
			}
		}
	}
}

void
cAudioManager::UpdateReflections()
{
	CVector camPos;
	CColPoint colpoint;
	CEntity *ent;

	if (m_FrameCounter % 8 == 0) {
		camPos = TheCamera.GetPosition();
		m_avecReflectionsPos[0] = camPos;
		m_avecReflectionsPos[0].y += 50.0f;
		if (CWorld::ProcessLineOfSight(camPos, m_avecReflectionsPos[0], colpoint, ent, true, false, false, true, false, true, true))
			m_afReflectionsDistances[0] = Distance(camPos, colpoint.point);
		else
			m_afReflectionsDistances[0] = 50.0f;
	} else if ((m_FrameCounter + 1) % 8 == 0) {
		camPos = TheCamera.GetPosition();
		m_avecReflectionsPos[1] = camPos;
		m_avecReflectionsPos[1].y -= 50.0f;
		if (CWorld::ProcessLineOfSight(camPos, m_avecReflectionsPos[1], colpoint, ent, true, false, false, true, false, true, true))
			m_afReflectionsDistances[1] = Distance(camPos, colpoint.point);
		else
			m_afReflectionsDistances[1] = 50.0f;
	} else if ((m_FrameCounter + 2) % 8 == 0) {
		camPos = TheCamera.GetPosition();
		m_avecReflectionsPos[2] = camPos;
		m_avecReflectionsPos[2].x -= 50.0f;
		if (CWorld::ProcessLineOfSight(camPos, m_avecReflectionsPos[2], colpoint, ent, true, false, false, true, false, true, true))
			m_afReflectionsDistances[2] = Distance(camPos, colpoint.point);
		else
			m_afReflectionsDistances[2] = 50.0f;
	} else if ((m_FrameCounter + 3) % 8 == 0) {
		camPos = TheCamera.GetPosition();
		m_avecReflectionsPos[3] = camPos;
		m_avecReflectionsPos[3].x += 50.0f;
		if (CWorld::ProcessLineOfSight(camPos, m_avecReflectionsPos[3], colpoint, ent, true, false, false, true, false, true, true))
			m_afReflectionsDistances[3] = Distance(camPos, colpoint.point);
		else
			m_afReflectionsDistances[3] = 50.0f;
	} else if ((m_FrameCounter + 4) % 8 == 0) {
		camPos = TheCamera.GetPosition();
		m_avecReflectionsPos[4] = camPos;
		m_avecReflectionsPos[4].z += 50.0f;
		if (CWorld::ProcessVerticalLine(camPos, m_avecReflectionsPos[4].z, colpoint, ent, true, false, false, false, true, false, nil))
			m_afReflectionsDistances[4] = colpoint.point.z - camPos.z;
		else
			m_afReflectionsDistances[4] = 50.0f;
	}
}
#endif // AUDIO_REFLECTIONS

void
cAudioManager::AddReleasingSounds()
{
	// in case someone would want to increase it
#ifdef FIX_BUGS
	bool8 toProcess[NUM_CHANNELS_GENERIC];
#else
	bool8 toProcess[44];
#endif

	uint8 queue = m_nActiveQueue == 0 ? 1 : 0;

	for (uint8 i = 0; i < m_nRequestedCount[queue]; i++) {
		tSound &sample = m_aRequestedQueue[queue][m_aRequestedOrderList[queue][i]];
		if (sample.m_bIsPlayingFinished)
			continue;

		toProcess[i] = FALSE;
		for (uint8 j = 0; j < m_nRequestedCount[m_nActiveQueue]; j++) {
			if (sample.m_nEntityIndex == m_aRequestedQueue[m_nActiveQueue][m_aRequestedOrderList[m_nActiveQueue][j]].m_nEntityIndex &&
			    sample.m_nCounter == m_aRequestedQueue[m_nActiveQueue][m_aRequestedOrderList[m_nActiveQueue][j]].m_nCounter) {
				toProcess[i] = TRUE;
				break;
			}
		}
		if (!toProcess[i]) {
#ifdef AUDIO_REFLECTIONS
			if (sample.m_nCounter <= 255 || sample.m_nReflectionDelay == 0) // check if not delayed reflection
#endif
			{
#ifdef ATTACH_RELEASING_SOUNDS_TO_ENTITIES
				if (sample.m_nCounter <= 255 && !sample.m_bIs2D) { // check if not reflection and is a 3D sound
					CEntity* entity = (CEntity*)GetEntityPointer(sample.m_nEntityIndex);
					if (entity && m_asAudioEntities[sample.m_nEntityIndex].m_nType == AUDIOTYPE_PHYSICAL) {
						sample.m_vecPos = entity->GetPosition();
						float oldDistance = sample.m_fDistance;
						sample.m_fDistance = Sqrt(GetDistanceSquared(sample.m_vecPos));
						if (sample.m_nSampleIndex >= SAMPLEBANK_PED_START && sample.m_nSampleIndex <= SAMPLEBANK_PED_END) { // check if it's ped comment
							uint8 vol;
							if (CWorld::GetIsLineOfSightClear(TheCamera.GetPosition(), sample.m_vecPos, true, false, false, false, false, false))
								vol = PED_COMMENT_VOLUME;
							else
								vol = PED_COMMENT_VOLUME_BEHIND_WALL;
#ifdef EXTERNAL_3D_SOUND
							sample.m_nEmittingVolume = vol;
#endif
							sample.m_nVolume = ComputeVolume(vol, sample.m_MaxDistance, sample.m_fDistance);
						} else {
							// calculate new volume with changed distance
							float volumeDiff = sq((sample.m_MaxDistance - sample.m_fDistance) / (sample.m_MaxDistance - oldDistance));
							if (volumeDiff > 0.0f) {
								uint8 newVolume = volumeDiff * sample.m_nVolume;
								if (sample.m_nVolumeChange > 0)
									sample.m_nVolumeChange = volumeDiff * sample.m_nVolumeChange;
#if defined(FIX_BUGS) && defined(EXTERNAL_3D_SOUND)
								if (sample.m_nEmittingVolumeChange > 0)
									sample.m_nEmittingVolumeChange = volumeDiff * sample.m_nEmittingVolumeChange;
#endif
								sample.m_nVolume = Min(MAX_VOLUME, newVolume);
							}
						}
						if (sample.m_nVolume == 0)
							sample.m_nFramesToPlay = 0;
					}
				}
#endif
#ifdef FIX_BUGS
				// fixing emitting volume not being lowered and high fps bugs
				if (sample.m_nFramesToPlay <= 0)
					continue;
				if (sample.m_nLoopCount == 0) {
					if (sample.m_nVolumeChange == -1) {
						sample.m_nVolumeChange = sample.m_nVolume / sample.m_nFramesToPlay;
						if (sample.m_nVolumeChange <= 0)
							sample.m_nVolumeChange = 1;
#ifdef EXTERNAL_3D_SOUND
						sample.m_nEmittingVolumeChange = sample.m_nEmittingVolume / sample.m_nFramesToPlay;
						if (sample.m_nEmittingVolumeChange <= 0)
							sample.m_nEmittingVolumeChange = 1;
#endif
					}
					if (sample.m_nVolume <= sample.m_nVolumeChange * CTimer::GetTimeStepFix()) {
						sample.m_nFramesToPlay = 0;
						continue;
					}
					sample.m_nVolume -= sample.m_nVolumeChange * CTimer::GetTimeStepFix();
#ifdef EXTERNAL_3D_SOUND
					if (sample.m_nEmittingVolume <= sample.m_nEmittingVolumeChange * CTimer::GetTimeStepFix()) {
						sample.m_nFramesToPlay = 0;
						continue;
					}
					sample.m_nEmittingVolume -= sample.m_nEmittingVolumeChange * CTimer::GetTimeStepFix();
#endif
				}
				sample.m_nFramesToPlay -= CTimer::GetTimeStepFix();
				if (sample.m_nFramesToPlay < 0)
					sample.m_nFramesToPlay = 0;
#else
				if (sample.m_nFramesToPlay == 0)
					continue;
				if (sample.m_nLoopCount == 0) {
					if (sample.m_nVolumeChange == -1) {
						sample.m_nVolumeChange = sample.m_nVolume / sample.m_nFramesToPlay;
						if (sample.m_nVolumeChange <= 0)
							sample.m_nVolumeChange = 1;
					}
					if (sample.m_nVolume <= sample.m_nVolumeChange) {
						sample.m_nFramesToPlay = 0;
						continue;
					}
					sample.m_nVolume -= sample.m_nVolumeChange;
				}
				sample.m_nFramesToPlay--;
#endif
				if (m_bReduceReleasingPriority) {
					if (sample.m_nPriority < 20)
						sample.m_nPriority++;
				}
				sample.m_bStatic = FALSE;
			}
			memcpy(&m_sQueueSample, &sample, sizeof(tSound));
			AddSampleToRequestedQueue();
		}
	}
}

void
cAudioManager::ProcessActiveQueues()
{
	bool8 flag;
	float position2;
	float position1;

	uint32 samplesPerFrame;
	uint32 samplesToPlay;

#ifdef EXTERNAL_3D_SOUND
	float x;
	float usedX;
	float usedY;
	float usedZ;
#endif

	uint8 vol;
	uint8 emittingVol;
	CVector position;

#ifdef EXTERNAL_3D_SOUND
	#define WORKING_VOLUME_FIELD m_nEmittingVolume
#else
	#define WORKING_VOLUME_FIELD m_nVolume
#endif

#ifdef USE_TIME_SCALE_FOR_AUDIO
	float timeScale = m_bIsPaused ? 1.0f : CTimer::GetTimeScale();
#endif

	for (uint8 i = 0; i < m_nActiveSamples; i++) {
		m_aRequestedQueue[m_nActiveQueue][i].m_bIsBeingPlayed = FALSE;
		m_asActiveSamples[i].m_bIsBeingPlayed = FALSE;
	}

	for (uint8 i = 0; i < m_nRequestedCount[m_nActiveQueue]; i++) {
		tSound &sample = m_aRequestedQueue[m_nActiveQueue][m_aRequestedOrderList[m_nActiveQueue][i]];
		if (sample.m_nSampleIndex != NO_SAMPLE) {
			for (uint8 j = 0; j < m_nActiveSamples; j++) {
				if (sample.m_nEntityIndex == m_asActiveSamples[j].m_nEntityIndex && sample.m_nCounter == m_asActiveSamples[j].m_nCounter &&
				    sample.m_nSampleIndex == m_asActiveSamples[j].m_nSampleIndex) {
					if (sample.m_nLoopCount > 0) {
#if GTA_VERSION >= GTA3_PC_10
						if (m_FrameCounter & 1)
							flag = !!(j & 1);
						else
							flag = !(j & 1);
						if (flag && !SampleManager.GetChannelUsedFlag(j)) {
#else
						if (m_asActiveSamples[j].unk != 0)
							m_asActiveSamples[j].unk--;
						else if (SampleManager.GetChannelUsedFlag(j))
							m_asActiveSamples[j].unk = m_nTimeSpent * SampleManager.GetSampleLength(m_asActiveSamples[j].m_nSampleIndex) / m_asActiveSamples[j].m_nFrequency;
						else {
#endif
							sample.m_bIsPlayingFinished = TRUE;
							m_asActiveSamples[j].m_bIsPlayingFinished = TRUE;
							m_asActiveSamples[j].m_nSampleIndex = NO_SAMPLE;
							m_asActiveSamples[j].m_nEntityIndex = AEHANDLE_NONE;
							continue;
						}
					}
					sample.m_bIsBeingPlayed = TRUE;
					m_asActiveSamples[j].m_bIsBeingPlayed = TRUE;
					sample.m_nVolumeChange = -1;
					if (!sample.m_bStatic) {
						if (sample.m_bIs2D) {
							emittingVol = m_bDoubleVolume ? 2 * Min(63, sample.WORKING_VOLUME_FIELD) : sample.WORKING_VOLUME_FIELD;
#ifdef USE_TIME_SCALE_FOR_AUDIO
							SampleManager.SetChannelFrequency(j, sample.m_nFrequency * timeScale);
#else
							SampleManager.SetChannelFrequency(j, sample.m_nFrequency);
#endif
#ifdef EXTERNAL_3D_SOUND
							SampleManager.SetChannelEmittingVolume(j, emittingVol);
#else
							SampleManager.SetChannelPan(j, sample.m_nPan);
							SampleManager.SetChannelVolume(j, sample.m_nVolume);
#endif
						} else {
							position2 = sample.m_fDistance;
							position1 = m_asActiveSamples[j].m_fDistance;
							m_asActiveSamples[j].m_fDistance = sample.m_fDistance;
							sample.m_nFrequency = ComputeDopplerEffectedFrequency(sample.m_nFrequency, position1, position2, sample.m_fSpeedMultiplier);
							if (sample.m_nFrequency != m_asActiveSamples[j].m_nFrequency) {
								uint32 freq = Clamp2((int32)sample.m_nFrequency, (int32)m_asActiveSamples[j].m_nFrequency, 6000);
								m_asActiveSamples[j].m_nFrequency = freq;
#ifdef USE_TIME_SCALE_FOR_AUDIO
								SampleManager.SetChannelFrequency(j, freq * timeScale);
#else
								SampleManager.SetChannelFrequency(j, freq);
#endif
							}

#ifdef EXTERNAL_3D_SOUND
							if (sample.m_nEmittingVolume != m_asActiveSamples[j].m_nEmittingVolume) {
								vol = Clamp2((int8)sample.m_nEmittingVolume, (int8)m_asActiveSamples[j].m_nEmittingVolume, 10);
								SampleManager.SetChannelEmittingVolume(j, m_bDoubleVolume ? 2 * Min(63, vol) : vol);
								m_asActiveSamples[j].m_nEmittingVolume = vol;
							}
#else
							if (sample.m_nVolume != m_asActiveSamples[j].m_nVolume) {
								vol = Clamp2((int8)sample.m_nVolume, (int8)m_asActiveSamples[j].m_nVolume, 10);
								m_asActiveSamples[j].m_nVolume = vol;
							}
							SampleManager.SetChannelVolume(j, m_bDoubleVolume ? 2 * Min(63, m_asActiveSamples[j].m_nVolume) : m_asActiveSamples[j].m_nVolume);
#endif
							TranslateEntity(&sample.m_vecPos, &position);
#ifdef EXTERNAL_3D_SOUND
							SampleManager.SetChannel3DPosition(j, position.x, position.y, position.z);
							SampleManager.SetChannel3DDistances(j, sample.m_MaxDistance, 0.25f * sample.m_MaxDistance);
#else
							sample.m_nPan = ComputePan(sample.m_fDistance, &position);
							SampleManager.SetChannelPan(j, sample.m_nPan);
#endif
						}
						SampleManager.SetChannelReverbFlag(j, sample.m_bReverb);
						break;
					}
					sample.m_bIsBeingPlayed = FALSE;
					m_asActiveSamples[j].m_bIsBeingPlayed = FALSE;
				}
			}
		}
	}
	for (uint8 i = 0; i < m_nActiveSamples; i++) {
		if (m_asActiveSamples[i].m_nSampleIndex != NO_SAMPLE && !m_asActiveSamples[i].m_bIsBeingPlayed) {
			SampleManager.StopChannel(i);
			m_asActiveSamples[i].m_nSampleIndex = NO_SAMPLE;
			m_asActiveSamples[i].m_nEntityIndex = AEHANDLE_NONE;
		}
	}
	for (uint8 i = 0; i < m_nRequestedCount[m_nActiveQueue]; i++) {
		tSound &sample = m_aRequestedQueue[m_nActiveQueue][m_aRequestedOrderList[m_nActiveQueue][i]];
		if (!sample.m_bIsBeingPlayed && !sample.m_bIsPlayingFinished && m_asAudioEntities[sample.m_nEntityIndex].m_bIsUsed && sample.m_nSampleIndex < NO_SAMPLE) {
#ifdef AUDIO_REFLECTIONS
			if (sample.m_nCounter > 255 && sample.m_nLoopCount > 0 && sample.m_nReflectionDelay > 0) { // check if reflection
				sample.m_nReflectionDelay--;
				sample.m_nFramesToPlay = 1;
			} else
#endif
			{
				for (uint8 j = 0; j < m_nActiveSamples; j++) {
					if (!m_asActiveSamples[j].m_bIsBeingPlayed) {
						if (sample.m_nLoopCount > 0) {
							samplesPerFrame = sample.m_nFrequency / m_nTimeSpent;
							samplesToPlay = sample.m_nLoopCount * SampleManager.GetSampleLength(sample.m_nSampleIndex);
							if (samplesPerFrame == 0)
								continue;
							sample.m_nFramesToPlay = samplesToPlay / samplesPerFrame + 1;
						}
						memcpy(&m_asActiveSamples[j], &sample, sizeof(tSound));
						if (!m_asActiveSamples[j].m_bIs2D) {
							TranslateEntity(&m_asActiveSamples[j].m_vecPos, &position);
#ifndef EXTERNAL_3D_SOUND
							m_asActiveSamples[j].m_nPan = ComputePan(m_asActiveSamples[j].m_fDistance, &position);
#endif
						}
						emittingVol = m_bDoubleVolume ? 2 * Min(63, m_asActiveSamples[j].WORKING_VOLUME_FIELD) : m_asActiveSamples[j].WORKING_VOLUME_FIELD;
#ifdef GTA_PS2
						{
							SampleManager.InitialiseChannel(j, m_asActiveSamples[j].m_nSampleIndex, m_asActiveSamples[j].m_nBankIndex);
#else
						if (SampleManager.InitialiseChannel(j, m_asActiveSamples[j].m_nSampleIndex, m_asActiveSamples[j].m_nBankIndex)) {
#endif
#ifdef USE_TIME_SCALE_FOR_AUDIO
							SampleManager.SetChannelFrequency(j, m_asActiveSamples[j].m_nFrequency * timeScale);
#else
							SampleManager.SetChannelFrequency(j, m_asActiveSamples[j].m_nFrequency);
#endif
#ifdef EXTERNAL_3D_SOUND
							SampleManager.SetChannelEmittingVolume(j, emittingVol);
#else
							SampleManager.SetChannelVolume(j, emittingVol);
							SampleManager.SetChannelPan(j, m_asActiveSamples[j].m_nPan);
#endif
#ifndef GTA_PS2
							SampleManager.SetChannelLoopPoints(j, m_asActiveSamples[j].m_nLoopStart, m_asActiveSamples[j].m_nLoopEnd);
#endif
							SampleManager.SetChannelLoopCount(j, m_asActiveSamples[j].m_nLoopCount);
							SampleManager.SetChannelReverbFlag(j, m_asActiveSamples[j].m_bReverb);
#ifdef EXTERNAL_3D_SOUND
							if (m_asActiveSamples[j].m_bIs2D) {
								uint8 offset = m_asActiveSamples[j].m_nPan;
								if (offset == 63)
									x = 0.f;
								else if (offset >= 63)
									x = (offset - 63) * 1000.0f / 63;
								else
									x = -(63 - offset) * 1000.0f / 63;
								usedX = x;
								usedY = 0.0f;
								usedZ = 0.0f;
								m_asActiveSamples[j].m_MaxDistance = 100000.0f;
							} else {
								usedX = position.x;
								usedY = position.y;
								usedZ = position.z;
							}
							SampleManager.SetChannel3DPosition(j, usedX, usedY, usedZ);
							SampleManager.SetChannel3DDistances(j, m_asActiveSamples[j].m_MaxDistance, 0.25f * m_asActiveSamples[j].m_MaxDistance);
#endif
							SampleManager.StartChannel(j);
						}
						m_asActiveSamples[j].m_bIsBeingPlayed = TRUE;
						sample.m_bIsBeingPlayed = TRUE;
						sample.m_nVolumeChange = -1;
						break;
					}
				}
			}
		}
	}

#ifdef USE_TIME_SCALE_FOR_AUDIO
	for (uint8 i = 0; i < m_nActiveSamples; i++) {
		if (m_asActiveSamples[i].m_nSampleIndex != NO_SAMPLE && m_asActiveSamples[i].m_bIsBeingPlayed)
			SampleManager.SetChannelFrequency(i, m_asActiveSamples[i].m_nFrequency * timeScale);
	}
#endif

	#undef WORKING_VOLUME_FIELD
}

void
cAudioManager::ClearRequestedQueue()
{
	for (uint8 i = 0; i < m_nActiveSamples; i++)
		m_aRequestedOrderList[m_nActiveQueue][i] = m_nActiveSamples;
	m_nRequestedCount[m_nActiveQueue] = 0;
}

void
cAudioManager::ClearActiveSamples()
{
	for (uint8 i = 0; i < m_nActiveSamples; i++) {
		m_asActiveSamples[i].m_nEntityIndex = AEHANDLE_NONE;
		m_asActiveSamples[i].m_nCounter = 0;
		m_asActiveSamples[i].m_nSampleIndex = NO_SAMPLE;
		m_asActiveSamples[i].m_nBankIndex = INVALID_SFX_BANK;
		m_asActiveSamples[i].m_bIs2D = FALSE;
		m_asActiveSamples[i].m_nPriority = 5;
		m_asActiveSamples[i].m_nFrequency = 0;
		m_asActiveSamples[i].m_nVolume = 0;
#ifdef EXTERNAL_3D_SOUND
		m_asActiveSamples[i].m_nEmittingVolume = 0;
#endif
		m_asActiveSamples[i].m_fDistance = 0.0f;
		m_asActiveSamples[i].m_bIsBeingPlayed = FALSE;
		m_asActiveSamples[i].m_bIsPlayingFinished = FALSE;
		m_asActiveSamples[i].m_nLoopCount = 1;
#ifndef GTA_PS2
		m_asActiveSamples[i].m_nLoopStart = 0;
		m_asActiveSamples[i].m_nLoopEnd = -1;
#endif
		m_asActiveSamples[i].m_fSpeedMultiplier = 0.0f;
		m_asActiveSamples[i].m_MaxDistance = 200.0f;
		m_asActiveSamples[i].m_nPan = 63;
		m_asActiveSamples[i].m_bStatic = FALSE;
#if GTA_VERSION < GTA3_PC_10
		m_asActiveSamples[i].unk = -3;
#endif
		m_asActiveSamples[i].m_nFinalPriority = 0;
		m_asActiveSamples[i].m_nFramesToPlay = 0;
		m_asActiveSamples[i].m_nVolumeChange = -1;
		m_asActiveSamples[i].m_vecPos = CVector(0.0f, 0.0f, 0.0f);
		m_asActiveSamples[i].m_bReverb = FALSE;
#ifdef AUDIO_REFLECTIONS
		m_asActiveSamples[i].m_nReflectionDelay = 0;
		m_asActiveSamples[i].m_bReflections = FALSE;
#endif
	}
}

void
cAudioManager::GenerateIntegerRandomNumberTable()
{
	for (uint32 i = 0; i < ARRAY_SIZE(m_anRandomTable); i++)
		m_anRandomTable[i] = myrand();
}

#ifdef GTA_PS2
bool8
cAudioManager::LoadBankIfNecessary(uint8 bank)
{
	if(!SampleManager.IsSampleBankLoaded(bank))
		return SampleManager.LoadSampleBank(bank);
	return FALSE;
}
#endif

#ifdef EXTERNAL_3D_SOUND
void
cAudioManager::AdjustSamplesVolume()
{
	for (uint8 i = 0; i < m_nRequestedCount[m_nActiveQueue]; i++) {
		tSound *pSample = &m_aRequestedQueue[m_nActiveQueue][m_aRequestedOrderList[m_nActiveQueue][i]];

		if (!pSample->m_bIs2D)
			pSample->m_nEmittingVolume = ComputeEmittingVolume(pSample->m_nEmittingVolume, pSample->m_MaxDistance, pSample->m_fDistance);
	}
}

uint8
cAudioManager::ComputeEmittingVolume(uint8 emittingVolume, float maxDistance, float distance)
{
	float minDistance = maxDistance / 4.0f;
	float diffDistance = maxDistance - minDistance;
	if (distance > diffDistance)
		return (minDistance - (distance - diffDistance)) * (float)emittingVolume / minDistance;
	return emittingVolume;
}
#endif

license: mit


code:
#pragma once

#include "audio_enums.h"
#include "AudioCollision.h"
#include "PolRadio.h"

class tSound
{
public:
	int32 m_nEntityIndex;		// audio entity index
#if GTA_VERSION >= GTA3_PC_10
	uint32 m_nCounter;			// I'm not sure what this is but it looks like a virtual counter to determine the same sound in queue
								// Values higher than 255 are used by reflections
#else
	uint8 m_nCounter;
#endif
	uint32 m_nSampleIndex;		// An index of sample from AudioSamples.h
	uint8 m_nBankIndex;			// A sound bank index. IDK what's the point of it here since samples are hardcoded anyway
	bool8 m_bIs2D;				// If TRUE then sound is played in 2D space (such as frontend or police radio)
	uint32 m_nPriority;			// The multiplier for the sound priority (see m_nFinalPriority below). Lesser value means higher priority
	uint32 m_nFrequency;		// Sound frequency, plain and simple
	uint8 m_nVolume;			// Sound volume (0..127), only used as an actual volume without EXTERNAL_3D_SOUND (see m_nEmittingVolume)
	float m_fDistance;			// Distance to camera (useless if m_bIs2D == TRUE)
	uint32 m_nLoopCount;		// 0 - always loop, 1 - don't loop, other values never seen
#ifndef GTA_PS2
	// Loop offsets
	uint32 m_nLoopStart;
	int32 m_nLoopEnd;
#endif
#ifdef EXTERNAL_3D_SOUND
	uint8 m_nEmittingVolume;	// The volume in 3D space, provided to 3D audio engine
#endif
	float m_fSpeedMultiplier;	// Used for doppler effect. 0.0f - unaffected by doppler
#if GTA_VERSION >= GTA3_PC_10
	float m_MaxDistance;		// The maximum distance at which sound could be heard. Minimum distance = MaxDistance / 5 or MaxDistance / 4 in case of emitting volume (useless if m_bIs2D == TRUE)
#else
	uint32 m_MaxDistance;
#endif
	bool8 m_bStatic;			// If TRUE then sound parameters cannot be changed during playback (frequency, position, etc.)
	CVector m_vecPos;			// Position of sound in 3D space. Unused if m_bIs2D == TRUE
	bool8 m_bReverb;			// Toggles reverb effect
#ifdef AUDIO_REFLECTIONS
	uint8 m_nReflectionDelay;	// Number of frames before reflection could be played. This is calculated internally by AudioManager and shouldn't be set by queued sample
	bool8 m_bReflections;		// Add sound reflections
#endif
	uint8 m_nPan;				// Sound panning (0-127). Controls the volume of the playback coming from left and right speaker. Calculated internally unless m_bIs2D==TRUE.
								// 0 =   L 100%  R 0%
								// 63 =  L 100%  R 100%
								// 127 = L 0%    R 100%
#ifndef FIX_BUGS
	uint32 m_nFramesToPlay;		// Number of frames the sound would be played (if it stops being queued).
								// This one is being set by queued sample for looping sounds, otherwise calculated inside AudioManager
#else
	float m_nFramesToPlay;		// Made into float for high fps fix
#endif

	// all fields below are internal to AudioManager calculations and aren't set by queued sample
	bool8 m_bIsBeingPlayed;		// Set to TRUE when the sound was added or changed on current frame to avoid it being overwritten
	bool8 m_bIsPlayingFinished;	// Not sure about the name. Set to TRUE when sampman channel becomes free
#if GTA_VERSION < GTA3_PC_10
	int32 unk;					// (inherited from GTA 2) Only on PS2, used by static non-looped sounds (AFAIK)
								// Looks like it's keeping a number of frames left to play with the purpose of setting m_bIsPlayingFinished=TRUE once value reaches 0
								// Default value is -3 for whatever reason
#endif
	uint32 m_nFinalPriority;	// Actual value used to compare priority, calculated using volume and m_nPriority. Lesser value means higher priority
	int8 m_nVolumeChange;		// How much m_nVolume should reduce per each frame.
#if defined(FIX_BUGS) && defined(EXTERNAL_3D_SOUND)
	int8 m_nEmittingVolumeChange; // same as above but for m_nEmittingVolume
#endif
};

VALIDATE_SIZE(tSound, 92);

class CPhysical;
class CAutomobile;

class tAudioEntity
{
public:
	eAudioType m_nType;
	void *m_pEntity;
	bool8 m_bIsUsed;
	bool8 m_bStatus;
	int16 m_awAudioEvent[NUM_AUDIOENTITY_EVENTS];
	float m_afVolume[NUM_AUDIOENTITY_EVENTS];
	uint8 m_AudioEvents;
};

VALIDATE_SIZE(tAudioEntity, 40);

class tPedComment
{
public:
	uint32 m_nSampleIndex;
	int32 m_nEntityIndex;
	CVector m_vecPos;
	float m_fDistance;
	uint8 m_nVolume;
	int8 m_nLoadingTimeout; // how many iterations we gonna wait until dropping the sample if it's still not loaded (only useful on PS2)
#if defined(EXTERNAL_3D_SOUND) && defined(FIX_BUGS)
	uint8 m_nEmittingVolume;
#endif
};

VALIDATE_SIZE(tPedComment, 28);

class cPedComments
{
public:
	tPedComment m_aPedCommentQueue[NUM_SOUND_QUEUES][NUM_PED_COMMENTS_SLOTS];
	uint8 m_aPedCommentOrderList[NUM_SOUND_QUEUES][NUM_PED_COMMENTS_SLOTS];
	uint8 m_nPedCommentCount[NUM_SOUND_QUEUES];
	uint8 m_nActiveQueue;

	cPedComments()
	{
		for (int i = 0; i < NUM_PED_COMMENTS_SLOTS; i++)
			for (int j = 0; j < NUM_SOUND_QUEUES; j++) {
				m_aPedCommentQueue[j][i].m_nLoadingTimeout = -1;
				m_aPedCommentOrderList[j][i] = NUM_PED_COMMENTS_SLOTS;
			}

		for (int i = 0; i < NUM_SOUND_QUEUES; i++)
			m_nPedCommentCount[i] = 0;
		m_nActiveQueue = 0;
	}
	void Add(tPedComment *com);
	void Process();
};

VALIDATE_SIZE(cPedComments, 1164);

// name made up
class cAudioScriptObjectManager
{
public:
	int32 m_anScriptObjectEntityIndices[NUM_SCRIPT_MAX_ENTITIES];
	int32 m_nScriptObjectEntityTotal;

	cAudioScriptObjectManager() { m_nScriptObjectEntityTotal = 0; }
	~cAudioScriptObjectManager() { m_nScriptObjectEntityTotal = 0; }
};

class cTransmission;
class CEntity;
class CPlane;
class CVehicle;
class CPed;

class cPedParams
{
public:
	bool8 m_bDistanceCalculated;
	float m_fDistance;
	CPed *m_pPed;

	cPedParams()
	{
		m_bDistanceCalculated = false;
		m_fDistance = 0.0f;
		m_pPed = nil;
	}
};

class cVehicleParams
{
public:
	bool8 m_bDistanceCalculated;
	float m_fDistance;
	CVehicle *m_pVehicle;
	cTransmission *m_pTransmission;
	uint32 m_nIndex;
	float m_fVelocityChange;

	cVehicleParams()
	{
		m_bDistanceCalculated = false;
		m_fDistance = 0.0f;
		m_pVehicle = nil;
		m_pTransmission = nil;
		m_nIndex = 0;
		m_fVelocityChange = 0.0f;
	}
};

VALIDATE_SIZE(cVehicleParams, 0x18);

enum {
	/*
	REFLECTION_YMAX = 0, top
	REFLECTION_YMIN = 1, bottom
	REFLECTION_XMIN = 2, left
	REFLECTION_XMAX = 3, right
	REFLECTION_ZMAX = 4,
	*/

	REFLECTION_TOP = 0,
	REFLECTION_BOTTOM,
	REFLECTION_LEFT,
	REFLECTION_RIGHT,
	REFLECTION_UP,
	MAX_REFLECTIONS,
};

enum PLAY_STATUS { PLAY_STATUS_STOPPED = 0, PLAY_STATUS_PLAYING, PLAY_STATUS_FINISHED };
enum LOADING_STATUS { LOADING_STATUS_NOT_LOADED = 0, LOADING_STATUS_LOADED, LOADING_STATUS_LOADING };

class cAudioManager
{
public:
	bool8 m_bIsInitialised;
	bool8 m_bIsSurround; // unused until VC
	bool8 m_bReduceReleasingPriority;
	uint8 m_nActiveSamples;
	bool8 m_bDoubleVolume; // unused
#if GTA_VERSION >= GTA3_PC_10
	bool8 m_bDynamicAcousticModelingStatus;
#endif
	float m_fSpeedOfSound;
	bool8 m_bTimerJustReset;
	uint32 m_nTimer;
	tSound m_sQueueSample;
	uint8 m_nActiveQueue;
	tSound m_aRequestedQueue[NUM_SOUND_QUEUES][NUM_CHANNELS_GENERIC];
	uint8 m_aRequestedOrderList[NUM_SOUND_QUEUES][NUM_CHANNELS_GENERIC];
	uint8 m_nRequestedCount[NUM_SOUND_QUEUES];
	tSound m_asActiveSamples[NUM_CHANNELS_GENERIC];
	tAudioEntity m_asAudioEntities[NUM_AUDIOENTITIES];
	uint32 m_aAudioEntityOrderList[NUM_AUDIOENTITIES];
	uint32 m_nAudioEntitiesCount;
#ifdef AUDIO_REFLECTIONS
	CVector m_avecReflectionsPos[MAX_REFLECTIONS];
	float m_afReflectionsDistances[MAX_REFLECTIONS];
#endif
	cAudioScriptObjectManager m_sAudioScriptObjectManager;
	cPedComments m_sPedComments;
	int32 m_nFireAudioEntity;
	int32 m_nWaterCannonEntity;
	int32 m_nPoliceChannelEntity;
	cPoliceRadioQueue m_sPoliceRadioQueue;
	cAMCrime m_aCrimes[10];
	int32 m_nFrontEndEntity;
	int32 m_nCollisionEntity;
	cAudioCollisionManager m_sCollisionManager;
	int32 m_nProjectileEntity;
	int32 m_nBridgeEntity;

	// Mission audio stuff
	CVector m_vecMissionAudioPosition;
	bool8 m_bIsMissionAudio2D;
	uint32 m_nMissionAudioSampleIndex;
	uint8 m_nMissionAudioLoadingStatus;
	uint8 m_nMissionAudioPlayStatus;
	bool8 m_bIsMissionAudioPlaying;
	int32 m_nMissionAudioFramesToPlay; // possibly unsigned
	bool8 m_bIsMissionAudioAllowedToPlay;

	int32 m_anRandomTable[5];
	uint8 m_nTimeSpent;
	bool8 m_bIsPaused;
	bool8 m_bWasPaused;
	uint32 m_FrameCounter;

	cAudioManager();
	~cAudioManager();

	void Initialise();
	void Terminate();
	void Service();
	int32 CreateEntity(eAudioType type, void *entity);
	void DestroyEntity(int32 id);
	bool8 GetEntityStatus(int32 id);
	void SetEntityStatus(int32 id, bool8 status);
	void *GetEntityPointer(int32 id);
	void PlayOneShot(int32 index, uint16 sound, float vol);
	void SetEffectsMasterVolume(uint8 volume);
	void SetMusicMasterVolume(uint8 volume);
	void SetEffectsFadeVol(uint8 volume);
	void SetMusicFadeVol(uint8 volume);
	void SetMonoMode(bool8 mono);
	void ResetTimers(uint32 time);
	void DestroyAllGameCreatedEntities();

#ifdef GTA_PC
	uint8 GetNum3DProvidersAvailable();
	char *Get3DProviderName(uint8 id);
	int8 GetCurrent3DProviderIndex();
	int8 SetCurrent3DProvider(uint8 which);
	void SetSpeakerConfig(int32 conf);
	bool8 IsMP3RadioChannelAvailable();
	void ReleaseDigitalHandle();
	void ReacquireDigitalHandle();
#ifdef AUDIO_REFLECTIONS
	void SetDynamicAcousticModelingStatus(bool8 status);
#endif
	bool8 CheckForAnAudioFileOnCD();
	char GetCDAudioDriveLetter();
	bool8 IsAudioInitialised();
#endif

	void ServiceSoundEffects();
	uint32 FL(float f); // not used
	uint8 ComputeVolume(uint8 emittingVolume, float maxDistance, float distance);
	void TranslateEntity(Const CVector *v1, CVector *v2);
	int32 ComputePan(float, CVector *);
	uint32 ComputeDopplerEffectedFrequency(uint32 oldFreq, float position1, float position2, float speedMultiplier); // inlined on PS2
	int32 RandomDisplacement(uint32 seed);
	void InterrogateAudioEntities(); // inlined on PS2
	void AddSampleToRequestedQueue();
	void AddDetailsToRequestedOrderList(uint8 sample); // inlined on PS2
#ifdef AUDIO_REFLECTIONS
	void AddReflectionsToRequestedQueue();
	void UpdateReflections();
#endif
	void AddReleasingSounds();
	void ProcessActiveQueues();
	void ClearRequestedQueue(); // inlined on PS2
	void ClearActiveSamples();
	void GenerateIntegerRandomNumberTable(); // inlined on PS2
#ifdef GTA_PS2
	bool8 LoadBankIfNecessary(uint8 bank); // this is used only on PS2 but technically not a platform code
#endif

#ifdef EXTERNAL_3D_SOUND // actually must have been && AUDIO_MSS as well
	void AdjustSamplesVolume();
	uint8 ComputeEmittingVolume(uint8 emittingVolume, float maxDistance, float distance);
#endif

	// audio logic
	void PreInitialiseGameSpecificSetup();
	void PostInitialiseGameSpecificSetup();
	void PreTerminateGameSpecificShutdown();
	void PostTerminateGameSpecificShutdown();
	void ResetAudioLogicTimers(uint32 timer);
	void ProcessReverb();
	float GetDistanceSquared(const CVector &v);
	void CalculateDistance(bool8 &condition, float dist);
	void ProcessSpecial();
	void ProcessEntity(int32 id);
	void ProcessPhysical(int32 id);

	// vehicles
	void ProcessVehicle(CVehicle *vehicle);
	void ProcessRainOnVehicle(cVehicleParams &params);
	bool8 ProcessReverseGear(cVehicleParams &params);
	void ProcessModelCarEngine(cVehicleParams &params);
	bool8 ProcessVehicleRoadNoise(cVehicleParams &params);
	bool8 ProcessWetRoadNoise(cVehicleParams &params);
	bool8 ProcessVehicleEngine(cVehicleParams &params);
	void UpdateGasPedalAudio(CAutomobile *automobile); // inlined on PS2
	void PlayerJustGotInCar();
	void PlayerJustLeftCar();
	void AddPlayerCarSample(uint8 emittingVolume, uint32 freq, uint32 sample, uint8 bank, uint8 counter, bool8 notLooping);
	void ProcessCesna(cVehicleParams &params);
	void ProcessPlayersVehicleEngine(cVehicleParams &params, CAutomobile *automobile);
	bool8 ProcessVehicleSkidding(cVehicleParams &params);
	float GetVehicleDriveWheelSkidValue(uint8 wheel, CAutomobile *automobile, cTransmission *transmission, float velocityChange);
	float GetVehicleNonDriveWheelSkidValue(uint8 wheel, CAutomobile *automobile, cTransmission *transmission, float velocityChange); // inlined on PS2
	bool8 ProcessVehicleHorn(cVehicleParams &params);
	bool8 UsesSiren(uint32 model); // inlined on PS2
	bool8 UsesSirenSwitching(uint32 model); // inlined on PS2
	bool8 ProcessVehicleSirenOrAlarm(cVehicleParams &params);
	bool8 UsesReverseWarning(uint32 model); // inlined on PS2
	bool8 ProcessVehicleReverseWarning(cVehicleParams &params);
	bool8 ProcessVehicleDoors(cVehicleParams &params);
	bool8 ProcessAirBrakes(cVehicleParams &params);
	bool8 HasAirBrakes(uint32 model); // inlined on PS2
	bool8 ProcessEngineDamage(cVehicleParams &params);
	bool8 ProcessCarBombTick(cVehicleParams &params);
	void ProcessVehicleOneShots(cVehicleParams &params);
	bool8 ProcessTrainNoise(cVehicleParams &params);
	bool8 ProcessBoatEngine(cVehicleParams &params);
	bool8 ProcessBoatMovingOverWater(cVehicleParams &params);
	bool8 ProcessHelicopter(cVehicleParams &params);
	void ProcessPlane(cVehicleParams &params); // inlined on PS2
	void ProcessJumbo(cVehicleParams &params);
	void ProcessJumboTaxi(); // inlined on PS2
	void ProcessJumboAccel(CPlane *plane);
	void ProcessJumboTakeOff(CPlane *plane); // inlined on PS2
	void ProcessJumboFlying();               // inlined on PS2
	void ProcessJumboLanding(CPlane *plane); // inlined on PS2
	void ProcessJumboDecel(CPlane *plane);   // inlined on PS2
	bool8 SetupJumboTaxiSound(uint8 vol);
	bool8 SetupJumboWhineSound(uint8 emittingVol, uint32 freq);
	bool8 SetupJumboEngineSound(uint8 vol, uint32 freq);
	bool8 SetupJumboFlySound(uint8 emittingVol);
	bool8 SetupJumboRumbleSound(uint8 emittingVol);
	int32 GetJumboTaxiFreq(); // inlined on PS2

	// peds
	void ProcessPed(CPhysical *ped); // inlined on PS2
	void ProcessPedHeadphones(cPedParams &params);
	void ProcessPedOneShots(cPedParams &params);

	// ped comments
	void SetupPedComments(cPedParams &params, uint16 sound);
	int32 GetPedCommentSfx(CPed *ped, uint16 sound);
	void GetPhrase(uint32 &phrase, uint32 &prevPhrase, uint32 sample, uint32 maxOffset); // inlined on PS2
	uint32 GetPlayerTalkSfx(uint16 sound);                                               // inlined on PS2
	uint32 GetCopTalkSfx(uint16 sound);
	uint32 GetSwatTalkSfx(uint16 sound);
	uint32 GetFBITalkSfx(uint16 sound);
	uint32 GetArmyTalkSfx(uint16 sound);
	uint32 GetMedicTalkSfx(uint16 sound);
	uint32 GetFiremanTalkSfx(uint16 sound); // inlined on PS2
	uint32 GetBusinessMaleOldTalkSfx(uint16 sound);
	uint32 GetBusinessMaleYoungTalkSfx(uint16 sound, uint32 model);
	uint32 GetMafiaTalkSfx(uint16 sound);
	uint32 GetTriadTalkSfx(uint16 sound);
	uint32 GetDiabloTalkSfx(uint16 sound);
	uint32 GetYakuzaTalkSfx(uint16 sound);
	uint32 GetYardieTalkSfx(uint16 sound);
	uint32 GetColumbianTalkSfx(uint16 sound);
	uint32 GetHoodTalkSfx(uint16 sound);
	uint32 GetBlackCriminalTalkSfx(uint16 sound);
	uint32 GetWhiteCriminalTalkSfx(uint16 sound);
	uint32 GetCasualMaleOldTalkSfx(uint16 sound);
	uint32 GetCasualMaleYoungTalkSfx(uint16 sound);
	uint32 GetBlackCasualFemaleTalkSfx(uint16 sound);
	uint32 GetWhiteCasualFemaleTalkSfx(uint16 sound);
	uint32 GetFemaleNo3TalkSfx(uint16 sound);
	uint32 GetWhiteBusinessFemaleTalkSfx(uint16 sound, uint32 model);
	uint32 GetBlackFatFemaleTalkSfx(uint16 sound);
	uint32 GetWhiteFatMaleTalkSfx(uint16 sound);
	uint32 GetBlackFatMaleTalkSfx(uint16 sound);
	uint32 GetWhiteFatFemaleTalkSfx(uint16 sound);
	uint32 GetBlackFemaleProstituteTalkSfx(uint16 sound);
	uint32 GetWhiteFemaleProstituteTalkSfx(uint16 sound);
	uint32 GetBlackProjectMaleTalkSfx(uint16 sound, uint32 model);
	uint32 GetBlackProjectFemaleOldTalkSfx(uint16 sound);
	uint32 GetBlackProjectFemaleYoungTalkSfx(uint16 sound);
	uint32 GetChinatownMaleOldTalkSfx(uint16 sound);
	uint32 GetChinatownMaleYoungTalkSfx(uint16 sound);
	uint32 GetChinatownFemaleOldTalkSfx(uint16 sound);
	uint32 GetChinatownFemaleYoungTalkSfx(uint16 sound);
	uint32 GetLittleItalyMaleTalkSfx(uint16 sound);
	uint32 GetLittleItalyFemaleOldTalkSfx(uint16 sound);
	uint32 GetLittleItalyFemaleYoungTalkSfx(uint16 sound);
	uint32 GetWhiteDockerMaleTalkSfx(uint16 sound);
	uint32 GetBlackDockerMaleTalkSfx(uint16 sound);
	uint32 GetScumMaleTalkSfx(uint16 sound);
	uint32 GetScumFemaleTalkSfx(uint16 sound);
	uint32 GetWhiteWorkerMaleTalkSfx(uint16 sound);
	uint32 GetBlackWorkerMaleTalkSfx(uint16 sound);
	uint32 GetBlackBusinessFemaleTalkSfx(uint16 sound);
	uint32 GetSupermodelMaleTalkSfx(uint16 sound);
	uint32 GetSupermodelFemaleTalkSfx(uint16 sound);
	uint32 GetStewardMaleTalkSfx(uint16 sound);
	uint32 GetStewardFemaleTalkSfx(uint16 sound);
	uint32 GetFanMaleTalkSfx(uint16 sound, uint32 model);
	uint32 GetFanFemaleTalkSfx(uint16 sound);
	uint32 GetHospitalMaleTalkSfx(uint16 sound);
	uint32 GetHospitalFemaleTalkSfx(uint16 sound); // inlined on PS2
	uint32 GetWhiteConstructionWorkerTalkSfx(uint16 sound);
	uint32 GetBlackConstructionWorkerTalkSfx(uint16 sound);
	uint32 GetShopperFemaleTalkSfx(uint16 sound, uint32 model);
	uint32 GetStudentMaleTalkSfx(uint16 sound);
	uint32 GetStudentFemaleTalkSfx(uint16 sound);

	uint32 GetSpecialCharacterTalkSfx(uint32 modelIndex, uint16 sound);
	uint32 GetEightBallTalkSfx(uint16 sound); // inlined on PS2
	uint32 GetSalvatoreTalkSfx(uint16 sound); // inlined on PS2
	uint32 GetMistyTalkSfx(uint16 sound);
	uint32 GetOldJapTalkSfx(uint16 sound); // inlined on PS2
	uint32 GetCatalinaTalkSfx(uint16 sound); // inlined on PS2
	uint32 GetBomberTalkSfx(uint16 sound);   // inlined on PS2
	uint32 GetSecurityGuardTalkSfx(uint16 sound);
	uint32 GetChunkyTalkSfx(uint16 sound); // inlined on PS2

	uint32 GetAsianTaxiDriverTalkSfx(uint16 sound); // inlined on PS2
	uint32 GetPimpTalkSfx(uint16 sound);
	uint32 GetNormalMaleTalkSfx(uint16 sound);
	uint32 GetGenericMaleTalkSfx(uint16 sound);
	uint32 GetGenericFemaleTalkSfx(uint16 sound);

	// particles
	void ProcessExplosions(int32 id);
	void ProcessFires(int32 id);
	void ProcessWaterCannon(int32 id);

	// script objects
	void ProcessScriptObject(int32 id); // inlined on PS2
	void ProcessOneShotScriptObject(uint8 sound);
	void ProcessLoopingScriptObject(uint8 sound);
	void ProcessPornCinema(uint8 sound);
	void ProcessWorkShopScriptObject(uint8 sound);
	void ProcessSawMillScriptObject(uint8 sound);
	void ProcessLaunderetteScriptObject(uint8 sound);
	void ProcessShopScriptObject(uint8 sound);
	void ProcessAirportScriptObject(uint8 sound);
	void ProcessCinemaScriptObject(uint8 sound);
	void ProcessDocksScriptObject(uint8 sound);
	void ProcessHomeScriptObject(uint8 sound);
	void ProcessPoliceCellBeatingScriptObject(uint8 sound);

	// misc
	void ProcessWeather(int32 id);
	void ProcessFrontEnd();
	void ProcessCrane();
	void ProcessProjectiles();
	void ProcessGarages();
	void ProcessFireHydrant();

	// bridge
	void ProcessBridge(); // inlined on PS2
	void ProcessBridgeWarning();
	void ProcessBridgeMotor();
	void ProcessBridgeOneShots();

	// mission audio
	bool8 MissionScriptAudioUsesPoliceChannel(uint32 soundMission);
	void PreloadMissionAudio(Const char *name);
	uint8 GetMissionAudioLoadingStatus();
	void SetMissionAudioLocation(float x, float y, float z);
	void PlayLoadedMissionAudio();
	bool8 IsMissionAudioSampleFinished();
	bool8 IsMissionAudioSamplePlaying() { return m_nMissionAudioPlayStatus == PLAY_STATUS_PLAYING; }
	bool8 ShouldDuckMissionAudio() { return IsMissionAudioSamplePlaying(); }
	void ClearMissionAudio();
	void ProcessMissionAudio();

	// police radio
	void InitialisePoliceRadioZones();
	void InitialisePoliceRadio();
	void ResetPoliceRadio();
	void SetMissionScriptPoliceAudio(uint32 sfx);
	int8 GetMissionScriptPoliceAudioPlayingStatus();
	void DoPoliceRadioCrackle();
	void ServicePoliceRadio();
	void ServicePoliceRadioChannel(uint8 wantedLevel);
	bool8 SetupCrimeReport();
	void SetupSuspectLastSeenReport();
	void ReportCrime(eCrimeType crime, const CVector &pos);
	void PlaySuspectLastSeen(float x, float y, float z);
	void AgeCrimes(); // inlined on PS2

	// collision stuff
	void ReportCollision(CEntity *entity1, CEntity *entity2, uint8 surface1, uint8 surface2, float collisionPower, float intensity2);
	void ServiceCollisions();
	void SetUpOneShotCollisionSound(const cAudioCollision &col);
	void SetUpLoopingCollisionSound(const cAudioCollision &col, uint8 counter);
	uint32 SetLoopingCollisionRequestedSfxFreqAndGetVol(const cAudioCollision &audioCollision);
	float GetCollisionOneShotRatio(uint32 a, float b);
	float GetCollisionLoopingRatio(uint32 a, uint32 b, float c); // not used
	float GetCollisionRatio(float a, float b, float c, float d); // inlined on PS2
};

/*
   Manual loop points are not on PS2 so let's have these macros to avoid massive ifndefs.
   Setting these manually was pointless anyway since they never change from sdt values.
   What were they thinking?
*/
#ifndef GTA_PS2
#define RESET_LOOP_OFFSETS \
	m_sQueueSample.m_nLoopStart = 0; \
	m_sQueueSample.m_nLoopEnd = -1;
#define SET_LOOP_OFFSETS(sample) \
	m_sQueueSample.m_nLoopStart = SampleManager.GetSampleLoopStartOffset(sample); \
	m_sQueueSample.m_nLoopEnd = SampleManager.GetSampleLoopEndOffset(sample);
#else
#define RESET_LOOP_OFFSETS
#define SET_LOOP_OFFSETS(sample)
#endif
#ifdef EXTERNAL_3D_SOUND
#define SET_EMITTING_VOLUME(vol) m_sQueueSample.m_nEmittingVolume = vol
#else
#define SET_EMITTING_VOLUME(vol)
#endif
#ifdef AUDIO_REFLECTIONS
#define SET_SOUND_REFLECTION(b) m_sQueueSample.m_bReflections = b
#else
#define SET_SOUND_REFLECTION(b)
#endif

#if defined(AUDIO_MSS) && !defined(PS2_AUDIO_CHANNELS)
static_assert(sizeof(cAudioManager) == 19220, "cAudioManager: error");
#endif

extern cAudioManager AudioManager;

enum
{
	PED_COMMENT_VOLUME = 127,
	PED_COMMENT_VOLUME_BEHIND_WALL = 31,
	COLLISION_MAX_DIST = 60,
};